HK40092276A - Blockchain-based data processing method, apparatus, device, and readable storage medium - Google Patents

Description

Data processing methods, devices, equipment, and readable storage media based on blockchain.

Technical Field

This application relates to the field of computer technology, and in particular to a data processing method, apparatus, device, and readable storage medium based on blockchain.

Background Technology

A blockchain system is a blockchain network composed of multiple blockchain nodes. Each blockchain node stores the latest on-chain world state corresponding to the blockchain network. That is, after the block with the highest block height in the blockchain is on-chain, the world state is composed of the state data owned by each account in the blockchain network.

In existing blockchain networks, the execution of transactions within a block modifies some state data held by several accounts. Therefore, each time a block is added to the chain, a new, up-to-date world state is generated. During consensus, a new block relies on the up-to-date world state of its parent block to determine its own up-to-date world state. Consequently, existing consensus mechanisms often only allow one block to reach consensus simultaneously. If a consensus mechanism involving multiple blocks simultaneously is adopted, the consistency of the blockchain system's state data often cannot be guaranteed.

Summary of the Invention

This application provides a data processing method, apparatus, device, and readable storage medium that can maintain the world state of multiple blocks to be added to the blockchain and ensure the consistency of the state data of the blockchain system.

One embodiment of this application provides a blockchain-based data processing method, including:

An initial block is generated, and a first world state corresponding to the initial block is created. The first world state has a chain relationship pointing to the second world state corresponding to the parent block of the initial block. The first and second world states exist in the world state chain. If the parent block is the block with the highest block height among the already chained blocks, then the second world state is the consensus root world state. The first world state in the world state chain is the latest on-chain world state. The consensus root world state has a chain relationship pointing to the latest on-chain world state. The latest on-chain world state is used to record the latest world state corresponding to the already chained blocks.

The first world state is updated based on the transactions in the initial block to obtain the target first world state. A clean state tree is then constructed on the target first world state based on the world state chain to obtain the updated target first world state containing the clean current world state tree.

Write the first world state root corresponding to the clean current world state tree into the initial block to obtain the block to be added to the chain. Send the consensus block to the consensus node so that the consensus node can perform consensus processing on the block to be added to the chain based on the first world state root and obtain the consensus result.

If the consensus result is a consensus pass, the block to be added to the blockchain is written into the blockchain. The target first world state is submitted to the latest on-chain world state through the world state chain. The target first world state is determined as the new consensus root world state. The new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission.

One embodiment of this application provides a blockchain-based data processing device, including:

The initialization module is used to generate the initial block.

The state creation module is used to create the first world state corresponding to the initial block. The first world state has a chain relationship pointing to the second world state corresponding to the parent block of the initial block. The first world state and the second world state exist in the world state chain. If the parent block is the block with the highest block height among the already chained blocks, then the second world state is the consensus root world state. The first world state in the world state chain is the latest on-chain world state. The consensus root world state has a chain relationship pointing to the latest on-chain world state. The latest on-chain world state is used to record the latest world state corresponding to the already chained blocks.

The first state update module is used to update the first world state based on the transactions in the initial block to obtain the target first world state.

The second state update module is used to construct a clean state tree for the target first world state based on the world state chain, so as to obtain an updated target first world state containing the clean current world state tree.

The consensus module is used to write the first world state root corresponding to the clean current world state tree into the initial block, obtain the block to be added to the chain, and send the consensus block to the consensus node so that the consensus node can perform consensus processing on the block to be added to the chain based on the first world state root and obtain the consensus result.

The state submission module is used to write the block to be added to the blockchain if the consensus result is a consensus pass result. It submits the target first world state to the latest on-chain world state through the world state chain, and determines the target first world state as the new consensus root world state. The new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission.

The state creation module includes:

A creation unit is used to create the initial world state corresponding to the initial block; the initial world state contains a pointer to the first previous world state and a first tree node cache; the first tree node cache contains a pointer to the first previous tree node cache;

The pointer unit is used to point the first previous world state pointer to the second world state corresponding to the parent block of the initial block, and to point the first previous tree node cache pointer to the second tree node cache contained in the second world state, so as to obtain the first world state corresponding to the initial block.

The first state update module includes:

The transaction retrieval unit is used to sequentially traverse the transactions in the initial block and retrieve the k-th transaction in the initial block; k is a positive integer less than or equal to H; H is the total number of transactions in the initial block;

The transaction state creation unit is used to create the k-th transaction world state corresponding to the k-th transaction; the k-th transaction world state has a chain relationship pointing to the (k-1)-th submitted world state; when k is 1, the (k-1)-th submitted world state is the first world state;

The transaction state update unit is used to execute the kth transaction. During the execution of the kth transaction, the world state of the kth transaction is updated to obtain the updated world state of the kth transaction.

The transaction state submission unit is used to submit the world state of the kth updated transaction to the (k-1)th submission world state if the kth transaction is successfully executed, thus obtaining the kth submission world state.

The world state determination unit is used to take the Hth submitted world state as the target first world state when k equals H.

The k-th transaction world state contains an account state mapping and a set of dirty account addresses;

The transaction status update unit includes:

The execution subunit is used to execute the k-th transaction. During the execution of the k-th transaction, the data to be updated corresponding to the k-th transaction is determined. The data to be updated includes the account address to be updated, the status data key to be updated, and the status data value to be updated.

The account status acquisition subunit is used to obtain the account status corresponding to the account address to be updated based on the k-th transaction world state, and use it as the account status to be updated; the account status to be updated contains the data mapping of the status to be updated and the set of dirty status data keys to be updated;

The first mapping update subunit is used to update the mapping relationship between the state data key to be updated and the state data value to be updated to the state data mapping to be updated, and to insert the state data key to be updated into the dirty state data key set to be updated, so as to obtain the current account status.

The second mapping update unit is used to update the mapping relationship between the account address to be updated and the current account status to the account status mapping contained in the kth transaction world state, and to insert the account address to be updated into the dirty account address set contained in the kth transaction world state to obtain the kth updated transaction world state.

The account status acquisition subunit is specifically used to perform an account status mapping sequence retrieval from the k-th transaction world state to the latest on-chain world state based on the account address to be updated. If an account state with a mapping relationship to the account address to be updated is found during the account status mapping sequence retrieval, the first account state with a mapping relationship to the account address to be updated is taken as the account state to be updated. If no account state with a mapping relationship to the account address to be updated is found during the account status mapping sequence retrieval, the root of the state tree corresponding to the account address to be updated is obtained from the world state tree in the latest on-chain world state, and the account state to be updated is established based on the account address to be updated and the root of the state tree to be updated.

The transaction status submission unit includes:

The address retrieval subunit is used to traverse the set of dirty account addresses contained in the k-th updated transaction world state and sequentially retrieve the j-th account address; j is a positive integer less than or equal to I; I is the total number of account addresses in the set of dirty account addresses contained in the k-th updated transaction world state.

The current account status acquisition subunit is used to obtain the current account status corresponding to the j-th account address from the account status mapping contained in the k-th updated transaction world state;

The previous account state retrieval subunit is used to retrieve the previous account state of the j-th account address based on the (k-1)-th submitted world state.

The world state commit subunit is used to commit the current account state corresponding to the j-th account address to the previous account state of the j-th account address, and to insert the j-th account address into the dirty account address set contained in the (k-1)-th commit world state to obtain the j-th transition commit world state.

The world state determination subunit is used to clear the dirty account address set and account state mapping contained in the k-th update transaction world state when j equals I, and to take the i-th transitional commit world state as the k-th commit world state.

Specifically, the world state commit subunit is used to update the mapping relationship between state data keys and state data values in the state data mapping of the current account state corresponding to the j-th account address to the state data mapping of the previous account state corresponding to the j-th account address; and to insert the state data keys in the state data mapping of the current account state corresponding to the j-th account address into the dirty state data key set of the previous account state corresponding to the j-th account address to obtain the j-th transition commit world state.

The second state update module includes:

The tree query unit is used to perform a world state tree query on the first world state of the target.

The first query processing unit is used to perform full-chain dirty account state submission processing on the target first world state containing the first world state tree if the target first world state contains the first world state tree, so as to obtain the updated target first world state containing the clean current world state tree.

The second query processing unit is used to find the second world state based on the first previous world state pointer if the target first world state does not contain the first world state tree.

The first tree construction unit is used to construct a clean state tree for the second world state based on the world state chain, so as to obtain a clean pre-world state tree.

The second tree construction unit is used to take the root of the previous state tree of the clean previous world state tree as the root of the current state tree.

The second tree construction unit is also used to construct the second world state tree corresponding to the target first world state based on the first tree node cache and the current state tree root, and add the second world state tree to the target first world state to obtain the transition target first world state.

The dirty state submission unit is used to perform full-chain dirty account state submission processing on the transition target first world state to obtain the updated target first world state containing the clean current world state tree.

The dirty state submission unit includes:

The dirty data submission subunit is used to perform full-chain dirty state data submission processing on the first world state of the transition target, and obtain the submitted first world state of the transition target and the full-chain dirty account address set.

The root acquisition subunit is used to obtain the account state root corresponding to each full-chain dirty account address in the full-chain dirty account address set based on the first-world state of the submitted transition target.

The tree update subunit is used to update the second world state tree with each full-chain dirty account address and the account state root corresponding to each full-chain dirty account address to obtain the clean current world state tree.

The tree submission subunit is used to store the updated tree node hash and the association relationship of the updated tree node of the clean current world state tree into the tree node mapping of the tree node cache in the transition target first world state after submission, so as to obtain the updated target first world state containing the clean current world state tree.

The dirty data submission subunit is specifically used to sequentially traverse the world state chain, obtain the set of dirty account addresses contained in the x-th world state, and use it as the x-th target dirty account address set; x is a positive integer less than or equal to Z; Z is the ordinal number of the transition target first world state in the world state chain; traverse the account addresses in the x-th target dirty account address set, and sequentially obtain the m-th account address; m is a positive integer less than or equal to the total number of account addresses in the x-th target dirty account address set; obtain the target current account state and target previous account state corresponding to the m-th account address; and process the m-th account address according to the previous account state of the m-th account address. The current account status of the user address is processed by committing dirty account status data. After the current account status of each dirty account address in the x-th target dirty account address set is processed by committing dirty account status data, the world state after the x-th commit is obtained. The target dirty account address is added to the (x-1)-th on-chain target dirty account address set to obtain the x-th on-chain target dirty account address set. When x is 1, the (x-1)-th on-chain target dirty account address set is an empty set. When x equals Z, the x-th on-chain target dirty account address set is taken as the full chain dirty account address set, and the world state after the x-th commit is taken as the transition target first world state after the commit.

Specifically, the dirty data submission subunit is further used to perform an account state tree query on the current account status of the m-th account address. If the current account status of the m-th account address does not contain an account state tree, or the account state root of the current account status of the m-th account address is not equal to the account state root of the previous account status of the m-th account address, then a specified account state tree is built based on the tree node cache of the current account status of the m-th account address and the account state root of the previous account status of the m-th account address. The account state tree is added to the current account status of the m-th account address, and the account state root of the current account status of the m-th account address is updated to the account state root of the previous account status of the m-th account address to obtain the specified account status. If the current account status of the m-th account address contains an account state tree, and the account state root of the current account status of the m-th account address is equal to the account state root of the previous account status of the m-th account address... If the account state root is determined, the current account state of the m-th account address is taken as the specified account state. If the dirty state data key set of the specified account state is not empty, the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state is obtained from the state data mapping of the specified account state. The dirty state data key and the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state are updated to the account state tree of the specified account state to obtain the specified account state containing the updated account state tree. The account state root of the specified account state containing the updated account state tree is updated to the state tree root of the updated account state tree. The dirty state data key set of the specified account state containing the updated account state tree is cleared. The update tree node hash and the association relationship of the update tree node are stored in the x-th world state.

The aforementioned data processing device further includes:

The submission module is used to perform full-chain dirty account state submission processing on the latest on-chain world state after submission, so as to obtain a clean latest on-chain world state.

The update module is used to update the tree node database with the tree node hashes and tree nodes contained in the tree node mapping in the clean, latest on-chain world state tree node cache.

The clear module is used to clear the dirty account address set, account state mapping, and tree node mapping in the tree node cache from the latest on-chain world state.

One embodiment of this application provides a computer device, including: a processor, a memory, and a network interface;

The processor is connected to the memory and the network interface. The network interface is used to provide a data communication network element, the memory is used to store a computer program, and the processor is used to call the computer program to execute the method in the embodiments of this application.

One aspect of this application provides a computer-readable storage medium storing a computer program adapted for loading by a processor and executing the methods described in this application.

One aspect of this application provides a computer program product or computer program that includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the method described in this application.

In this embodiment, by constructing a world state chain, it is possible to simultaneously maintain world states at different block heights or different branches of the same block height. That is, each time a new block is created, a world state is created for that new block and added to the world state chain. The first world state in the world state chain is the latest on-chain world state after the transactions in the latest block that has been uploaded to the chain have been executed. The second world state in the world state chain is the consensus root world state that was previously confirmed by consensus. Subsequent world states are the world states corresponding to the blocks that are currently under consensus. The consensus root world state has a chain relationship pointing to the latest on-chain world state. The world state corresponding to the block that is currently under consensus has a chain relationship pointing to the world state corresponding to its parent block. If its parent block is an already on-chain block, then it has a chain relationship pointing to the consensus root world state. Through the chain relationships of each world state, a chain structure of the world state chain is formed. Therefore, it can be guaranteed that no matter how many blocks are reached in consensus at the same time, after the block consensus is passed, its corresponding world state will be submitted to the latest on-chain world state level by level according to the chain structure of the world state chain, ensuring the consistency of the state data of the blockchain system.

Attached Figure Description

To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

Figure 1 is a schematic diagram of the structure of a blockchain node system provided in an embodiment of this application;

Figure 2a is a schematic diagram of a world state provided in an embodiment of this application;

Figure 2b is a schematic diagram of an account status provided in an embodiment of this application;

Figure 2c is a schematic diagram of a world state management scenario provided by an embodiment of this application;

Figure 2d is a schematic diagram of a world state chain provided in an embodiment of this application;

Figure 3 is a flowchart illustrating a data processing method based on blockchain provided in an embodiment of this application;

Figures 4a-4c are schematic diagrams of a data processing scenario based on blockchain provided in the embodiments of this application;

Figure 5 is a flowchart illustrating a transaction-based first-world state update method provided in an embodiment of this application;

Figure 6 is a flowchart illustrating a method for constructing a clean world state tree according to an embodiment of this application;

Figure 7 is a schematic diagram of the structure of a blockchain-based data processing device provided in an embodiment of this application;

Figure 8 is a schematic diagram of the structure of a computer device provided in an embodiment of this application.

Detailed Implementation

The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of this application.

Blockchain is the carrier and organizational method for running blockchain technology. Blockchain technology (BT), also known as distributed ledger technology, is an internet database technology characterized by decentralization and transparency, allowing everyone to participate in database recording. Blockchain technology utilizes a block-chain data structure to verify and store data, distributed node consensus algorithms to generate and update data, cryptography to ensure the security of data transmission and access, and smart contracts composed of automated script code to program and manipulate data—a distributed infrastructure and computing method.

To facilitate understanding, the following will explain blockchain and related concepts:

Blockchain: Blockchain is a new application model of computer technologies such as distributed data storage, peer-to-peer transmission, consensus mechanisms, and encryption algorithms. It is mainly used to organize data in chronological order and encrypt it into a ledger, making it tamper-proof and forgery-proof. It also allows for data verification, storage, and updating. Essentially, a blockchain is a decentralized database where each node stores the same blockchain. The blockchain network can distinguish between consensus nodes and business nodes, with the consensus node responsible for achieving consensus across the entire network. The process of writing transaction data into the ledger in a blockchain network can be described as follows: the client sends transaction data to a business node, which then relays this data among the business nodes in the blockchain network until the consensus node receives it. The consensus node then packages the transaction data into a block and reaches a consensus with other consensus nodes. After consensus is reached, the block containing the transaction data is written into the ledger.

A block is a data packet that carries transaction data (i.e., transaction business) on a blockchain network. It is a data structure that is marked with a timestamp and the hash value of the previous block. The transactions in the block are verified and confirmed by the network's consensus mechanism.

Hash value: Also known as information feature value or characteristic value, a hash value is generated by converting input data of arbitrary length into cryptographic data and producing a fixed output through a hash algorithm. The original input data cannot be retrieved by decrypting the hash value; it is a one-way cryptographic function. In a blockchain, each block (except the initial block) contains the hash value of its predecessor block, which is called the parent block of the current block. The hash value is a core and crucial aspect of blockchain technology, preserving the authenticity of recorded and viewed data, as well as the integrity of the blockchain as a whole.

Transaction: A transaction sent by a blockchain account contains a transaction hash as a unique identifier and includes an account address to identify the blockchain account that sent the transaction.

State snapshot: Represents a snapshot of all state data within a certain range. It is a fixed-length hash value. Whenever any state data changes, the state snapshot changes, which can be used to determine the integrity of all state data.

Account: A blockchain account contains an account address as a unique identifier, a balance as the account's digital assets in the current world state, and each account has some state data. The account contains an account state root as a state snapshot of all its state data.

State data: Data stored in the blockchain of an account, such as how much assets an account has, or other data that smart contracts need to read or update. Each piece of state data is represented in the form of a key-value pair.

On-chain: Each block contains several transactions. The process of inserting a block into the blockchain data structure of each blockchain node after consensus is called on-chain.

World state: A view comprised of the persistent data held by all accounts within the blockchain. Since transaction execution modifies some of the persistent data of several accounts, each transaction within a block generates a new world state after execution. Furthermore, each block's inclusion on the blockchain updates the world state of every blockchain node. Once the same block is included, the world state of every blockchain node must be consistent.

MPT (Merkle Patricia Trie) is a tree-like structure for organizing state data, containing three types of nodes: data nodes, extension nodes, and branch nodes. State data packets contain state data keys and state data values. Data nodes are the leaf nodes of the tree structure, appearing only at the bottom of the MPT, and store the actual state data values. Extension nodes are parent nodes with only one child node, containing a string of arbitrary length representing part of the state data key, and another tree node hash pointing to the child node. Branch nodes can have parent nodes with 1 to 16 child nodes, and have a hash array of 16 capacity, where the 16 positions correspond to hexadecimal 0-9-a-f, and each can potentially serve as a tree node hash pointing to a child node. The tree node hash is the hash value of the child node in the MPT, stored in the parent node.

State Tree: This application embodiment includes an account state tree and a world state tree, both of which use MPT as the data structure for the state data of the organizational blockchain and can provide the following operations:

(1) Query: The state data value can be retrieved from the state tree based on the state data key. This requires providing the state tree with a tree node query source. The tree node query source is a data structure that helps the state tree quickly find tree nodes based on their hashes. Each tree node in the state tree is stored in the database as a key-value pair, with the key being the tree node's hash value and the value being the tree node itself. Therefore, tree nodes can be quickly retrieved from the database based on their hashes. Furthermore, since each parent node in the state tree contains the hashes of all its child nodes, all its child nodes can be derived from the database from the parent node.

(2) Update: The status data value can be updated to the status tree according to the status data key.

(3) Get the root of the state tree: Calculate and get the hash value of the root of the state tree.

(4) Commit: Commit each tree node of the state tree to the tree node update cache. Because each tree node in the state tree is stored in the database as a key-value pair, with the hash value of the tree node as the key and the tree node as the value, a data structure is needed to receive and store key-value pairs with the tree node hash as the key and the tree node as the value when the state tree is committed. This data structure is called the tree node update cache.

Please refer to Figure 1, which is a schematic diagram of a blockchain node system provided in an embodiment of this application. The blockchain node system shown in Figure 1 can correspond to a blockchain network, which may include, but is not limited to, the blockchain network corresponding to a consortium blockchain. A blockchain node system refers to a system used for data sharing between blockchain nodes. This system can include multiple blockchain nodes, specifically blockchain node 10a, blockchain node 10b, blockchain node 10c, blockchain node 10d, ..., blockchain node 10n. Each blockchain node, during normal operation, can receive data sent from the outside world and perform block-on-chain processing based on the received data, and can also send data to the outside world. To ensure data interoperability between blockchain nodes, data connections can exist between each blockchain node. For example, there is a data connection between blockchain node 10a and blockchain node 10b, a data connection between blockchain node 10a and blockchain node 10c, and a data connection between blockchain node 10b and blockchain node 10c.

It is understandable that blockchain nodes can transmit data or blocks through the aforementioned data connections. The blockchain network can establish data connections between blockchain nodes based on node identifiers. Each blockchain node in the network has a corresponding node identifier, and each blockchain node can store the node identifiers of other blockchain nodes that are connected to it. This allows it to broadcast acquired data or generated blocks to other blockchain nodes based on their node identifiers. For example, blockchain node 10a can maintain a node identifier list as shown in Table 1, which stores the node names and node identifiers of other nodes.

Table 1

Node Name Node identifier Node 10a 117.114.151.174 Node 10b 117.116.189.145 Node 10c 117.114.151.183 Node 10d 117.117.125.169 … … Node 10n 117.116.189.125

The node identifier can be an Internet Protocol (IP) address or any other information that can be used to identify a node in a blockchain network. Table 1 uses IP addresses as an example only. For instance, blockchain node 10a can send information (e.g., a block) to blockchain node 10b using node identifier 117.116.189.145, and blockchain node 10b can determine that the information was sent by blockchain node 10a using node identifier 117.114.151.174.

In blockchain, before a block is added to the chain, it must pass consensus among the consensus nodes in the blockchain network. Only after consensus is reached can the block be added to the blockchain. It's understandable that when blockchain is used in scenarios involving government or commercial institutions, not all participating nodes in the blockchain (i.e., the blockchain nodes in the aforementioned blockchain node system) have sufficient resources and necessity to become consensus nodes. For example, in the blockchain node system shown in Figure 1, blockchain nodes 10a, 10b, 10c, and 10d can be considered as consensus nodes. Consensus nodes in the blockchain node system participate in consensus, that is, reaching consensus on blocks (containing a batch of transactions), including generating blocks and voting on blocks; while non-consensus nodes do not participate in consensus but help propagate block and voting messages, and synchronize states with each other.

A blockchain node can contain the following modules:

Transaction pool: Each blockchain node receives transactions sent by users and caches them in the transaction pool. When a blockchain node is selected as a block producer according to the consensus mechanism, the blockchain node will create a new block in memory and package the transactions in the transaction pool into the new block.

Consensus module: Packages transactions to generate candidate blocks, and reaches a consensus among various blockchain nodes based on the consensus mechanism to generate new blocks.

Smart contract container: The consensus mechanism needs to execute each transaction within a block during its execution process. Essentially, it is the process of executing smart contracts within transactions. Executing smart contracts may require reading or updating state data. This module provides the execution environment for smart contract execution.

World State Management: Responsible for maintaining and managing the world state of each block in the consensus mechanism.

Key-value database: Persistently stores data in key-value pairs, allowing for quick lookup of values based on keys. In this invention, it is responsible for persistently storing the data of each block and storing tree nodes. Tree node storage means that the hash value of each tree node in the state tree is the key, and each tree node is the value. Therefore, tree nodes can be quickly looked up based on the tree node hash.

It is understood that the above-mentioned data connection is not limited to the connection method. It can be connected directly or indirectly through wired communication, or directly or indirectly through wireless communication, or through other connection methods. This application does not impose any restrictions on this.

It is understood that the data processing method provided in this application embodiment can be executed by a computer device, which includes, but is not limited to, the aforementioned blockchain node (which can be a server or a terminal). The aforementioned server can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms. The aforementioned terminal can be a smartphone, tablet computer, laptop computer, desktop computer, smart speaker, smartwatch, etc., but is not limited to these.

It is understood that the embodiments of this application can be applied to various scenarios, including but not limited to cloud technology, artificial intelligence, smart transportation, and assisted driving.

It is understood that, in the specific embodiments of this application, the status data and other related data involved need to obtain user permission or consent when the above embodiments of this application are applied to specific products or technologies, and the collection, use and processing of related data need to comply with the relevant laws, regulations and standards of relevant countries and regions.

As shown in Figure 1, a block-producing node in a blockchain network, such as blockchain node 10a in the aforementioned blockchain node system, can create a first world state corresponding to the initial block after generating it. This first world state has a chained relationship pointing to the second world state corresponding to the parent block of the initial block. At this time, the first and second world states exist in the world state chain. If the parent block is the block with the highest block height among the already chained blocks, then the second world state is the consensus root world state. The consensus root world state has a chained relationship pointing to the latest chained world state. The latest chained world state is the first world state in the world state chain and is used to record the latest world state corresponding to the already chained blocks. Then, the first world state is updated according to the transactions in the initial block. The process begins by obtaining the target first-world state. Based on the world state chain, a clean state tree is constructed from the target first-world state, resulting in an updated target first-world state containing the clean current world state tree. The first-world state root corresponding to the clean current world state tree is written into the initial block, resulting in a block to be added to the blockchain. The consensus block is then sent to the consensus nodes, enabling them to process the block to be added to the blockchain based on the first-world state root, yielding a consensus result. If the consensus result is successful, the block to be added to the blockchain is written into the blockchain. The updated target first-world state is then submitted level by level to the latest on-chain world state through the world state chain, establishing the updated target first-world state as the new consensus root world state. This new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission.

To better understand the world state management process described above, please refer to Figure 2a. Figure 2a is a schematic diagram of a world state structure provided in an embodiment of this application. As shown in Figure 2a, world state 20 may include a previous world state pointer 201, a dirty account address set 202, an account state mapping 203, a world state tree 204, and a tree node cache 205. The previous world state pointer 201 points to the previous world state of world state 20. The previous world state of world state 20 can be located in memory through the previous world state pointer 201. The previous world state pointer of the latest chained world state is null. The dirty account address set 202 refers to the set of account addresses within world state 20 that have been updated but have not yet been updated to the account state in world state tree 204. The account state mapping 203 is a mapping structure that maps account addresses to account states. In the account state mapping 203, account states can be quickly found based on account addresses. The world state tree 204 is an MPT data structure organized with account addresses as keys and account state roots as values. Here, the account state root refers to the hash value of the root of the account state tree contained in the account state corresponding to the account address. The tree node cache 205 includes a previous tree node cache pointer 2051 and a tree node map 2052. The previous tree node cache pointer 2051 points to the tree node cache of the previous world state of world state 20, and the previous tree node cache pointer of the tree node cache of the latest on-chain world state points to the tree node storage in the key-value database. The tree node map 2052 is a mapping structure from tree node hashes to tree nodes, allowing for fast lookup of tree nodes based on their hashes. Tree node cache 205 serves as the source for querying tree nodes in the world state tree 204 of world state 20 and the account state map 203 for each account state. World state tree 204 and the account state tree for each account state can search for tree nodes in the tree node cache's tree node map based on the tree node hash. If no tree node is found, the previous tree node cache pointer is used to locate it in memory, and the search continues in the previous tree node cache's tree node map based on the tree node hash. If still not found, the search continues backward, and so on, until the previous tree node cache pointer of the foremost tree node cache points to the tree node storage in the key-value database. Then, the search continues in the tree node storage based on the tree node hash. Tree node cache 205 also serves as the update cache for tree nodes in the world state tree 204 of world state 20 and the account state map 203 for each account state. World state tree 204 and the account state tree can be committed, i.e., updated in the tree node cache's tree node map with the tree node hash as the key and the tree node as the value.

Please refer to Figure 2b, which is a schematic diagram of an account state structure provided in an embodiment of this application. As shown in Figure 2b, account state 21 may include account address 211, account state root 212, dirty state data key set 213, state data mapping 214, and account state tree 215. The account address 211 is the unique identifier of the account. The account state root 212 is the root of the account state tree 215, i.e., its hash value. The dirty state data key set 213 refers to the set of keys for state data in account state 21 that have been updated but not yet updated in the account state tree 215. The state data mapping 214 is a mapping structure that maps state data keys to state data values, allowing for quick lookup of state data values based on state data keys. The account state tree 214 is an MPT data structure organized with state data keys as keys and state data values as values.

The method provided in this application embodiment can construct the world state using the structure shown in Figure 2a and the account state using the structure shown in Figure 2b. Then, the constructed account state and world state are managed. For ease of understanding, please also refer to Figure 2c, which is a schematic diagram of a world state management scenario provided in this application embodiment. As shown in Figure 2a, the key-value database 23 of the block-producing node 22 (which can be any blockchain node in the blockchain node system shown in Figure 1, such as blockchain node 10b) stores the blockchain data structure 231 that has been uploaded to the chain. This blockchain data structure 231 contains all the blocks that have been uploaded to the chain. Furthermore, the key-value database 23 also includes a tree node storage 232. In the tree node storage 232, each tree node and its hash value in the account state tree corresponding to each account in the blockchain network and the world state tree corresponding to the latest uploaded world state are stored, using the tree node hash value as the key and the tree node as the value. The latest uploaded world state refers to the world state after the transactions in the latest uploaded block have been executed.

As shown in Figure 2c, the block-producing node can maintain several blocks at different heights undergoing consensus in memory 24, such as block n+1 at height n+1, block (n+2)a at height n+2, and so on. Of course, according to the consensus mechanism, there may also be different block branches at the same height, such as block (n+2)a and block (n+2)b at height n+2, but ultimately only one branch will reach consensus among the blockchain nodes of the blockchain network and complete the on-chain operation, entering the key-value database 21. In addition, memory 21 also maintains different world states, including the latest on-chain world state, the consensus root world state, and the world state corresponding to the blocks currently under consensus. The consensus root world state refers to the world state corresponding to the last block confirmed by consensus; the world state corresponding to the blocks currently under consensus, as the name suggests, is the world state created for each block in consensus, representing the source of query and update cache for state data during and after the execution of transactions within that block. As shown in Figure 2c, the world states corresponding to blocks undergoing consensus all have a chain relationship pointing to the world states corresponding to their parent blocks. A block-producing node can obtain the world state corresponding to its parent block through this chain relationship, and then, based on the chain relationship, can obtain the world state corresponding to the parent block's parent block. For example, the world state (n+2)a corresponding to block (n+2)a has a chain relationship pointing to the world state n+1 corresponding to its parent block n+1. After obtaining the world state (n+2)a corresponding to block (n+2)a, block-producing node 20 can obtain the chain relationship of world state (n+2)a, and then obtain world state n+1 based on this chain relationship. When the parent block of a block undergoing consensus is a block passed in the previous round of consensus, the chain relationship of the world state of this block will point to the consensus root world state. Therefore, the world state of a block undergoing consensus must be created directly or indirectly from the consensus root world state. Within the consensus root world state, there is a chain-like relationship pointing to the latest on-chain world state. It can be understood that after a new block is reached through consensus, the world state corresponding to the new block is determined as the consensus root world state, and the original consensus root world state can be cleared. However, after a new block is added to the chain, only the latest on-chain world state needs to be updated to obtain the new latest on-chain world state; its storage address in memory does not need to be changed.

It can be understood that the chained relationship of world states can be represented by its previous tree world state pointer and previous tree node cache pointer. Each world state points to its previous world state through the previous world state pointer, and points to the tree node cache of the previous world state through the previous tree node cache pointer of the tree node cache. The previous world state pointer of the foremost world state is null, and the previous tree node cache pointer of the tree node cache points to the tree node storage of the key-value database, thus forming a world state chain. For ease of understanding, please refer to Figure 2d, which is a schematic diagram of the structure of a world state chain provided by an embodiment of this application. As shown in Figure 2d, in the world state chain, the first world state is the latest chained world state. The latest chained world state has no previous world state, so the previous world state pointer of the latest chained world state is null. In addition, the previous tree node cache pointer of the latest chained world state cannot point to the tree node cache of the previous world state, but the previous tree node cache pointer of the latest chained world state will point to the tree node storage (for example, the tree node storage 232 shown in Figure 2c above). The second world state in the world state chain is the consensus root world state. The previous world state of the consensus root world state is the most recently added world state, and its tree node cache pointer points to the tree node cache of the most recently added world state. Starting from the third world state, the world state corresponds to the block in the consensus. Its previous world state pointer and tree node cache pointer point to the world state of the parent block and its tree node cache, respectively. Of course, it is also permissible for the previous world state pointers and tree node cache pointers of two different blocks in the consensus to point to the same previous world state and its corresponding tree node cache. In other words, the world state chain can branch after the consensus root world state.

The world state corresponding to a block currently undergoing consensus will eventually be submitted to the latest on-chain world state. Once the block completing consensus, its corresponding world state becomes the new consensus root world state, possessing a chain-like relationship pointing to the latest on-chain world state. To facilitate understanding of the specific process of world state management in this application embodiment, please further refer to Figure 3, which is a flowchart illustrating a blockchain-based data processing method provided in this application embodiment. This method can be executed by a block-producing node (e.g., any blockchain node in the blockchain node system 10 in the embodiment corresponding to Figure 1 above). The following will illustrate this method using the execution of a block-producing node as an example. This blockchain-based data processing method can at least include the following steps S101-S104:

Step S101: Generate an initial block and create the first world state corresponding to the initial block.

Specifically, each blockchain node receives transactions and caches them in a transaction pool. Block-producing nodes are selected in the blockchain network based on a consensus mechanism. When a blockchain node is selected as a block-producing node, it creates a new block in memory. This new block contains the hash value of its parent block. Using the parent block hash value, the parent block can be found. The block-producing node then packages the transactions from the transaction pool into the new block, thus obtaining the initial block. At this point, the block-producing node can create the first-world state corresponding to the initial block. The block-producing node can first obtain the second-world state corresponding to its parent block, and then initialize the world state based on the second-world state of its parent block to obtain the first-world state. It should be noted that if the parent block of the initial block has already been written into the blockchain data structure, then the parent block of the initial block can only be the most recently added block in the blockchain. The second world state corresponding to the parent block is the world state that passed the previous round of consensus. That is, the second world state corresponding to the parent block is the consensus root world state shown in Figure 2c above. If the parent block of the initial block has not yet been written into the blockchain data structure, then the parent block of the initial block should be in consensus. Its corresponding world state is the world state corresponding to the block in consensus shown in Figure 2c above, for example, world state n+1. It is understandable that both the first world state and the second world state are located in the world state chain. The first world state in the world state chain is the latest on-chain world state, which is used to record the latest world state corresponding to the on-chain blocks. The second consensus root world state is the consensus root world state, which has a chain relationship pointing to the latest on-chain world state. In other words, the second world state may be the second world state in the world state chain, or it may be the world state after the second world state. The first world state is located after the second world state in the world state chain.

Specifically, a feasible implementation method for creating the first world state corresponding to the initial block is as follows: Create an initial world state corresponding to the initial block, which includes a pointer to the first previous world state and a first tree node cache. The first tree node cache includes a pointer to the first previous tree node cache. Then, point the pointer to the first previous world state to the second world state corresponding to the parent block of the initial block, and point the pointer to the first previous tree node cache to the second tree node cache contained in the second world state, thus obtaining the first world state corresponding to the initial block. It should be noted that the structure of the first world state can still refer to world state 20 shown in Figure 2a above. At this time, the block-producing node only initializes the pointer to the first previous world state and the pointer to the first previous tree node cache of the first world state. The dirty account address set, account state mapping, world state tree, and tree node mapping can be initialized as empty sets first, or added to the first world state later. This embodiment does not impose any restrictions here. However, the following explanation will uniformly assume that the world state is generated according to the world state structure shown in Figure 2a during creation, and an empty set is created by default if there is no corresponding data.

Step S102: Update the first world state according to the transactions in the initial block to obtain the target first world state; construct a clean state tree for the target first world state according to the world state chain to obtain an updated target first world state containing the clean current world state tree.

Specifically, the execution of transactions in the initial block modifies some state data contained in several accounts within the blockchain. Block-producing nodes can progressively execute each transaction in the initial block, determining the state data that needs modification after each transaction's execution, which is then recorded as data to be updated. The first-world state is then updated based on this data, ultimately yielding the target first-world state. At this point, the account state mapping of the target first-world state will contain the account addresses of the accounts that need updating and their updated account states. There is a mapping relationship between the account addresses of the same account and their updated account states. Subsequent block-producing nodes, when accessing the first-world state, can quickly retrieve the updated account state corresponding to that account from the account state mapping based on the account address. Simultaneously, the dirty account address set of the target first-world state will contain the account addresses of accounts whose state data was updated after the transactions in the initial block were executed. With the dirty account address set and account state mapping of the target first-world state, the clean current-world state tree corresponding to the target first-world state can be constructed.

Specifically, at this point, the world state tree in the target first world state is empty, meaning that the world state tree in the target first world state has not yet been constructed. At this time, the block-producing node will find the second world state based on the first previous world state pointer in the target first world state, first obtain the clean world state tree of the second world state as the clean previous world state tree, and then construct the second world state tree corresponding to the target first world state based on the first tree node cache and the current state tree root. The second world state tree is added to the target first world state to obtain the transitional target first world state. The transitional target first world state is then subjected to a full-chain dirty account state commit process to obtain the updated target first world state containing the clean current world state tree.

Step S103: Write the first world state root corresponding to the clean current world state tree into the initial block to obtain the block to be added to the chain. Send the consensus block to the consensus node so that the consensus node can perform consensus processing on the block to be added to the chain based on the first world state root to obtain a consensus result.

Specifically, the first world state root corresponding to the clean current world state tree refers to the hash value of the root of the clean current world state tree. At this time, the first world state root can serve as a state snapshot of the state data contained in all accounts in the blockchain network after the initial block is executed. After the first world state root is written into the initial block, the block-producing node completes the packaging of the block, thus obtaining the block to be added to the chain. Subsequently, the block-producing node will transmit the block to be added to the chain to the consensus node in the blockchain network through the P2P (Peer to Peer) network. Then, the consensus node can first construct the world state corresponding to the block to be added to the chain, and then perform the above steps S102 to S103 on the constructed world state to obtain the clean current world state tree corresponding to the constructed world state. Then, it obtains the hash value of its root as the verification world state root. The consensus node will compare the verification world state root with the first world state root in the block to be added to the chain. If they are the same, the verification passes; if they are different, the verification fails, and the consensus of the block to be added to the chain fails.

Step S104: If the consensus result is a consensus pass result, the block to be added to the blockchain is written into the blockchain. The first world state of the update target is submitted to the latest on-chain world state through the world state chain. The first world state of the update target is determined as the new consensus root world state. The new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission.

Specifically, if the consensus of the block to be added to the blockchain is passed, the block-producing node and other blockchain nodes in the blockchain network will write the block to be added to the blockchain. As mentioned above, after the new block is added to the blockchain, the latest world state will also be updated. At this time, the block-producing node needs to submit the target first world state to be updated to the latest world state in the order of the world state chain. After the submission is completed, the target first world state will be determined as the new consensus root world state. At this time, the pointer of the first previous world state in the new consensus root world state will point from the world state corresponding to its parent block to the latest world state, and the pointer of the first previous tree node cache in the new consensus root world state will also point to the previous tree node cache in the latest world state. For example, in the world state chain shown in Figure 2c above, the block-producing node 22 can submit world state n+1 to the consensus root world state after the consensus of block n+1 is passed, and then submit the submitted consensus root world state to the latest world state to obtain the latest world state after submission. After the submission, world state n+1 will be confirmed as the new consensus root world state. The original chain relationship pointing to the consensus root world state will be updated to point to the latest on-chain world state after the submission. The storage address of the latest on-chain world state after the submission remains the same as the original latest on-chain world state. The latest on-chain world state after the submission is used to represent the world state after the transactions in block n+1 are executed. Optionally, the original consensus root world state can be deleted.

Optionally, after the target first-world state is finally committed to the latest on-chain world state, the block-producing node also needs to commit the committed latest on-chain world state to the tree node storage. Since the tree node storage is a key-value database, it can also be considered as a commit to the tree node database. The specific process can be as follows: perform a full-chain dirty account state commit process on the committed latest on-chain world state to obtain a clean latest on-chain world state; update the tree node hash and tree node contained in the tree node cache in the clean latest on-chain world state to the tree node database; clear the dirty account address set, account state mapping and tree node mapping in the tree node cache of the clean latest on-chain world state.

To facilitate understanding of the above process, please refer to Figures 4a-4c. Figures 4a-4c are schematic diagrams of a data processing scenario based on blockchain provided by an embodiment of this application. As shown in Figure 4a, in block-producing node 40 (which can be block-producing node 22 shown in Figure 2c above), block 41 is the latest block added to the blockchain 42. The latest added world state 400 records a view of the state data corresponding to all accounts in the blockchain network after block 42 is added to the blockchain. At this time, in the latest added world state 400, except for the previous world state pointer which is empty, the dirty account address set, account state mapping, and tree node mapping are all empty sets. The world state tree in the latest added world state 400 is the world state tree corresponding to all state data of the blockchain at this time. The previous tree node cache pointer of the latest added world state 400 points to the tree node storage 43. It can be understood that each tree node in the world state tree of the latest added world state 400 and the tree node hash corresponding to the tree node are stored in the tree node storage 43. In addition, the memory of block-producing node 40 also contains consensus root world state 402. Consensus root world state 402 is actually the world state corresponding to the consensus submission of block 41. Its previous world state is the latest on-chain world state 400. As shown in Figure 4a, the previous world state pointer of consensus root world state 402 points to the latest on-chain world state 400, and the previous tree node cache pointer of consensus root world state 402 points to tree node cache 4005.

For a better explanation of this method, please refer to Figure 4b. Assume that there are no blocks currently in consensus. After receiving the block production command, block production node 40 generates a new block 420 with block 41 as its parent block. The parent hash contained in the new block 420 is the hash value of block 41. Then, block production node 40 packages a portion of the transactions in the transaction pool into the new block 420 in order, thus obtaining the initial block 421. Subsequently, block production node 40 can construct the first world state 402 corresponding to the initial block 421. The first world state in the first world state 402 will point to the second world state corresponding to the parent block of the initial block 421. Since the parent block of the initial block 421 is an on-chain block, its corresponding second world state is actually the consensus root world state 401. Therefore, the first previous world state pointer of the first world state 402 points to the consensus root world state 401, and the first previous tree node cache pointer points to the tree node cache of the consensus root world state 401. At this time, the other components of the first world state 402, such as the dirty account address set and the world state tree, are all empty sets. Then, block-producing node 40 executes the transactions in the initial block 421. During the execution of these transactions, it updates the first-world state 402 to obtain the target first-world state 403. This update involves writing the account address of the account to be updated and the updated account state into the account state mapping of first-world state 402, and adding the account address of the account to be updated to the dirty account address set of first-world state 402. For example, after transaction 1 is executed, the state data of account A will be changed, so the account state of account A will be updated accordingly. Assuming the updated account state is account state A, block-producing node 40 will write the account address A corresponding to account A into the dirty account address set of first-world state 402, and then add the mapping relationship between account address A and account state A to the account state mapping of first-world state 402. After all transactions in the initial block 421 have been executed, the target first-world state 403 is obtained. At this point, the world state tree for the target first-world state 403 has not yet been constructed. Then, block-producing node 40 constructs the target first-world state 403 to perform a clean world state tree construction process, obtaining a clean current-world state tree. Finally, the block-producing node uses the root of the state tree corresponding to the clean current-world state tree as the first-world state root and adds it to the initial block 421, resulting in the block to be added to the blockchain 422. Subsequently, the block-producing node can send the block to be added to the blockchain 422 to the consensus nodes in the blockchain network, allowing the consensus nodes to reach a consensus on the block to be added based on the first-world state root, thus obtaining the consensus result.

Further, please refer to Figure 4c. As shown in Figure 4c, when the consensus result is a consensus pass, the world state corresponding to the block 422 to be added to the chain in the block-producing node 40 is the first world state 404, which contains the clean current world state tree. The block-producing node 40 will gradually submit the first world state 404 to the latest on-chain world state. That is, the first world state 404 will first be submitted to the consensus root world state 401, then the submitted consensus root world state will be submitted to the latest on-chain world state 400, and finally the submitted latest on-chain world state will be submitted to the tree node storage 43. The block 422 to be added to the chain will also be written into the blockchain 42 and become the latest on-chain block. At this time, the first target time state 404 will be used as the new consensus root world state. The block-producing node 40 will point its first previous world state pointer to the latest on-chain world state after submission, and point its first previous tree node cache pointer to the tree node cache of the latest on-chain world state after submission.

Using the method provided in this application embodiment, when updating state data during block execution, it is not necessary to record the old value of the changed state data, and it is not necessary to perform state data rollback operation for failed transactions, thus saving system overhead.

Further, please refer to Figure 5, which is a flowchart illustrating a transaction-based first-world state update method provided in an embodiment of this application. This update method is a feasible implementation of step S102 in the embodiment corresponding to Figure 3, which updates the first-world state based on transactions in the initial block to obtain the target first-world state. This method can also be executed by a block-producing node (e.g., any blockchain node in the blockchain node system 10 in the embodiment corresponding to Figure 1). The following description will use the execution of this method by a block-producing node as an example, wherein the first-world state update method may include at least the following steps S201-S205:

Step S201: Iterate through the transactions in the initial block sequentially to obtain the k-th transaction in the initial block; k is a positive integer less than or equal to H; H is the total number of transactions in the initial block.

Specifically, when the initial block contains multiple transactions, the block-producing node traverses the initial block, sequentially retrieving the first transaction, executing it, and updating the first-world state based on the execution result of the first transaction to obtain the first committed world state. Then, it retrieves the second transaction, executes it, and updates the first committed world state based on the execution result to obtain the second committed world state, and so on, until all transactions in the initial block have been processed, thus obtaining the target first-world state. For ease of understanding, we will use the processing of the k-th transaction as an example.

Step S202: Create the world state of the kth transaction corresponding to the kth transaction; the world state of the kth transaction has a chain relationship pointing to the (k-1)th submitted world state; when k is 1, the (k-1)th submitted world state is the first world state.

Specifically, the block-producing node first creates the world state corresponding to the k-th transaction. For the k-th transaction world state, its previous world state is the (k-1)-th committed world state. The creation of the k-th transaction world state can be referenced from the creation process of the first world state in step S101 above, and will not be repeated here. The k-th transaction world state has a chain relationship pointing to the (k-1)-th committed world state. It can be understood that for the first transaction, its previous world state is the first world state.

Step S203: Execute the k-th transaction. During the execution of the k-th transaction, perform state update processing on the world state of the k-th transaction to obtain the world state of the k-th updated transaction.

Specifically, as shown in Figure 2b above, the account state structure can contain an account state mapping and a set of dirty account addresses, except that both the account state mapping and the dirty account address set are empty at this point. During the execution of the k-th transaction, when the block-producing node executes the smart contract within the transaction, it may need to read or update the state data of a certain account. At this time, the block-producing node will determine the data to be queried or the data to be updated. The data to be queried may contain the account address to be queried and the state data key to be queried; the data to be updated may contain the account address to be updated, the state data key to be updated, and the state data value to be updated. Then, the block-producing node can either update the k-th transaction world state based on the data to be updated, or query the k-th transaction world state based on the data to be queried.

Specifically, a feasible implementation process for executing the k-th transaction and updating the world state of the k-th transaction during the execution of the k-th transaction to obtain the k-th updated transaction world state is as follows: Execute the k-th transaction; during the execution of the k-th transaction, determine the data to be updated corresponding to the k-th transaction, namely the account address to be updated, the state data key to be updated, and the state data value to be updated, as mentioned above; then, obtain the account state corresponding to the account address to be updated based on the world state of the k-th transaction, and use it as the account state to be updated; update the mapping relationship between the state data key and the state data value to be updated in the state data mapping to be updated; insert the state data key to be updated into the dirty state data key set to be updated to obtain the current account state; update the mapping relationship between the account address to be updated and the current account state to the account state mapping contained in the k-th transaction world state; insert the account address to be updated into the dirty account address set contained in the k-th transaction world state to obtain the k-th updated transaction world state.

Specifically, a feasible implementation process for obtaining the account state corresponding to the account address to be updated based on the k-th transaction world state is as follows: Based on the account address to be updated, perform an account state mapping sequence retrieval from the k-th transaction world state to the latest on-chain world state; if an account state with a mapping relationship to the account address to be updated is found during the account state mapping sequence retrieval, then the first retrieved account state with a mapping relationship to the account address to be updated is taken as the account state to be updated; if no account state with a mapping relationship to the account address to be updated is found during the account state mapping sequence retrieval, then obtain the root of the state tree corresponding to the account address to be updated based on the world state tree in the latest on-chain world state, and establish the account state to be updated based on the account address to be updated and the root of the state tree to be updated. Specifically, the block-producing node can obtain the account state to be updated based on the k-th transaction world state as follows: First, it checks the account state mapping of the k-th transaction world state to see if there is an account state that is mapped to the account address to be updated. If it exists, it takes that account state as the account state to be updated and stops subsequent queries. If it does not exist, it obtains the previous world state of the k-th transaction world state (i.e., the (k-1)-th commit world state) based on the previous world state pointer of the k-th transaction world state. Then, the block-producing node continues to check the account state mapping of the (k-1)-th commit world state to see if there is an account state that is mapped to the account address to be updated. If it exists, it obtains it directly and stops subsequent queries. If it does not exist... The process continues to retrieve the previous world state, and so on, until the block-producing node finds the account state mapping of the latest on-chain world state. If there is no account state in the account state mapping of the latest on-chain world state that has a mapping relationship with the account address to be updated, as mentioned above, the latest on-chain world state has no previous world state. At this time, the block-producing node can retrieve the account state root corresponding to the address to be updated from the world state tree of the latest on-chain world state based on the account address to be updated. Then, it creates a new account state in memory, initializes the account address of the new account state to the account address to be updated, initializes the account state root of the new account state to the retrieved account state root, and then uses the initialized new account state as the account state to be updated.

Specifically, a feasible implementation process for querying the world state of the k-th transaction during its execution is as follows: During the execution of the k-th transaction, determine the data to be queried corresponding to the k-th transaction, namely the aforementioned account address and status data key. Then, search the account status mapping of the k-th transaction world state based on the account address. If the account status corresponding to the account address is found, continue searching among the retrieved account statuses based on the status data key. If the status data value corresponding to the status data key is found, return that status data value as the result and do not perform further searches. If the status data value corresponding to the status data key is not found, or if the account status corresponding to the account address is not found in the account status mapping of the k-th transaction world state, determine whether a previous world state exists based on the previous world state pointer of the k-th transaction world state. If the pointer to the previous world state of the k-th transaction world state exists, the k-th transaction world state (i.e., the (k-1)-th submitted world state) is obtained based on the pointer. Then, the (k-1)-th submitted world state is searched using the address to be queried and the data key of the state to be queried. If the state data value corresponding to the data key of the state to be queried is found in the (k-1)-th submitted world state, the subsequent search stops. If the state data value corresponding to the data key of the state to be queried is not found in the (k-1)-th submitted world state, the pointer to the previous world state of the (k-1)-th submitted world state is used to determine if a previous world state exists. This process continues until the latest on-chain world state is reached. If the state data value corresponding to the data key of the state to be queried is still not found in the account state mapping of the latest on-chain world state, the root account state corresponding to the address to be updated is retrieved from the world state tree of the latest on-chain world state. A new account state is then created in memory, and the account address of the new account state is initialized to the address to be updated. The root account state of the new account state is initialized to the retrieved root account state. The initialized new account state is then used as the account state to be queried. If the root of the account state to be queried is empty, then the state data value corresponding to the data key of the account state to be queried is determined to be empty, and subsequent retrieval stops. If the root of the account state to be queried is not empty, but the account state tree of the account state to be queried is empty, then the tree node cache of the latest on-chain world state is used as the source of the tree node query, and the root of the account state to be queried is used as the root of the state tree. A new account state tree is created in memory and added to the account state to be queried; then, the state data value is retrieved from the account state tree of the account state to be queried based on the data key of the account state to be queried, and the retrieval ends.

Step S204: If the kth transaction is successfully executed, the world state of the kth update transaction is submitted to the (k-1)th submission world state to obtain the kth submission world state.

Specifically, if the k-th transaction is successfully executed, the k-th update transaction world state is submitted to the (k-1)-th commit world state to obtain the k-th commit world state. A feasible implementation process is as follows: traverse the account addresses in the dirty account address set contained in the k-th update transaction world state, and sequentially obtain the j-th account address; j is a positive integer less than or equal to I; I is the total number of account addresses in the dirty account address set contained in the k-th update transaction world state; obtain the current account state corresponding to the j-th account address from the account state mapping contained in the k-th update transaction world state; obtain the previous account state of the j-th account address according to the (k-1)-th commit world state; submit the current account state corresponding to the j-th account address to the previous account state of the j-th account address, insert the j-th account address into the dirty account address set contained in the (k-1)-th commit world state, and obtain the j-th transitional commit world state; when j equals I, clear the dirty account address set and account state mapping contained in the k-th update transaction world state, and take the I-th transitional commit world state as the k-th commit world state. The process of obtaining the previous account state of the j-th account address based on the (k-1)-th committed world state can be described as follows: Search the account state mapping in the (k-1)-th committed world state based on the j-th account address. If an account state with a mapping relationship to the j-th account address is found, it is used as a reference account state. Then, a new account state is created in memory, and the account address and account state root of the newly created account state are initialized based on the account address and account state root of the reference account state. This newly created account state is then used as the previous account state of the j-th account address. If no account state with a mapping relationship to the j-th account address is found... The process continues to search for the account state mapping of the previous world state submitted at the (k-1)th world state. If the search continues until the latest on-chain world state's account state mapping is found, and no account state with a mapping relationship to the j-th account address is found, the search is performed in the world state tree of the latest on-chain world state to obtain the account state root corresponding to the j-th account address. Then, a new account state is created in memory, and the account address and account state root of the newly created account state are initialized based on the j-th account address and the account state root obtained from the world state tree. The newly created account state is then used as the previous account state of the j-th account address.

Specifically, a feasible implementation of submitting the current account state corresponding to the j-th account address to the previous account state of the j-th account address, and inserting the j-th account address into the dirty account address set contained in the (k-1)-th submitted world state to obtain the j-th transitional submitted world state is as follows: update the mapping relationship between state data keys and state data values in the state data mapping contained in the current account state corresponding to the j-th account address to the state data mapping contained in the previous account state of the j-th account address; insert the state data keys in the state data mapping contained in the current account state corresponding to the j-th account address into the dirty state data key set contained in the previous account state of the j-th account address to obtain the j-th transitional submitted world state.

Step S205: When k equals H, the Hth submitted world state is taken as the target first world state.

Specifically, the target first-world state will contain the account addresses that need to be updated after all transactions in the initial block have been executed, as well as the account status after the update of the account addresses. The dirty account address set of the target first-world state will contain all account addresses that need to be updated.

Further, please refer to Figure 6, which is a flowchart illustrating a clean world state tree construction method provided in this application embodiment. This clean world state tree construction method is a feasible implementation of step S102 in the embodiment corresponding to Figure 3 above, which involves constructing a clean state tree from the target first world state based on the world state chain to obtain an updated target first world state containing the clean current world state tree. This method can also be executed by a block-producing node (e.g., any blockchain node in the blockchain node system 10 in the embodiment corresponding to Figure 1 above). The following description will use the execution of this method by a block-producing node as an example, where the clean world state tree construction method can include at least the following steps S301-S306:

Step S301: Perform a world state tree query on the target first world state.

Specifically, a clean world state tree can be constructed for each world state managed by the block-producing node. This clean world state tree construction method applies to all world states. However, some world states may already contain a world state tree. Therefore, in this clean world state tree construction method, it is necessary to first determine whether the world state for which a clean world state tree needs to be constructed already contains a world state tree. When the block-producing node performs clean world state tree construction for the target first world state, the block-producing node will perform a world state tree lookup for the target first world state.

Step S302: If the target first world state contains a first world state tree, then perform a full-chain dirty account state submission process on the target first world state containing the first world state tree to obtain an updated target first world state containing a clean current world state tree.

Specifically, if the target first-world state contains a first-world state tree, the block-producing node will directly perform a full-chain dirty account state commit on the target first-world state containing the first-world state tree, resulting in an updated target first-world state containing a clean current-world state tree. This commit process can be referred to in step S306 below, which will not be described in detail here.

Step S303: If the target first world state does not contain the first world state tree, then the second world state is searched according to the first previous world state pointer.

Specifically, if the target first-world state does not contain a first-world state tree, the block-producing node can query backwards through the world state chain, relying on the clean world states of previous world states in the world state chain to construct the second-world state tree of the target first-world state. First, the block-producing node will obtain the previous world state of the target first-world state, which is the second-world state, based on the pointer to the first previous world state. Then, it will obtain the clean current world state tree corresponding to the second world state and use it as the clean previous world state tree.

Step S304: Construct a clean state tree for the second world state according to the world state chain to obtain a clean pre-world state tree, and take the root of the pre-world state tree of the clean pre-world state tree as the root of the current state tree.

Specifically, the block-producing node constructs a clean state tree for the second world state, that is, it performs steps S301-S306 on the second world state to obtain a clean current world state tree corresponding to the second world state, and then uses this as the clean previous world state tree of the target first world state. Then, the block-producing node uses the root of the previous state tree of the clean previous world state tree as the root of the current state tree.

Step S305: Construct a second world state tree corresponding to the target first world state based on the first tree node cache and the current state tree root, and add the second world state tree to the target first world state to obtain the transition target first world state.

Specifically, the block-producing node caches the first tree node as the source of tree node queries, and then constructs the second world state tree corresponding to the target first world state based on the current state tree root. At this time, the updated account state corresponding to the account address in the dirty account address set of the target first world state has not yet been committed, so it needs to be committed in order to obtain a clean second world state tree, that is, a clean current world state tree.

Step S306: Perform full-chain dirty account state submission processing on the transition target first world state to obtain an updated target first world state containing a clean current world state tree.

Specifically, regardless of whether the first-world state tree or the second-world state tree corresponding to the target first-world state is obtained, the block-producing node will perform a full-chain dirty account state commit process. Taking a transitional target first-world state containing a second-world state tree as an example, the block-producing node will sequentially traverse the world state chain to obtain the set of dirty account addresses contained in the x-th world state, which will be used as the x-th target dirty account address set; x is a positive integer less than or equal to Z; Z is the ordinal number of the transitional target first-world state in the world state chain; it will traverse the account addresses in the x-th target dirty account address set to sequentially obtain the m-th account address; m is a positive integer less than or equal to the total number of account addresses in the x-th target dirty account address set; it will obtain the target current account state and the target previous account state corresponding to the m-th account address; and based on the previous account of the m-th account address... The state performs dirty state data submission processing on the current account state of the m-th account address; after the current account state of each dirty account address in the x-th target dirty account address set has been submitted, the world state after the x-th submission is obtained; the target dirty account address is added to the (x-1)-th on-chain target dirty account address set, resulting in the x-th on-chain target dirty account address set; when x is 1, the (x-1)-th on-chain target dirty account address set is an empty set; when x equals Z, the x-th on-chain target dirty account address set is taken as the full chain dirty account address set, and the world state after the x-th submission is taken as the transition target first world state after submission.

Specifically, a feasible implementation process for submitting dirty account state data for the current account state of the m-th account address based on the previous account state of the m-th account address is as follows: Perform an account state tree query on the current account state of the m-th account address; if the current account state of the m-th account address does not contain an account state tree, or the account state root of the current account state of the m-th account address is not equal to the account state root of the previous account state of the m-th account address, then establish a specified account state tree based on the tree node cache of the current account state of the m-th account address and the account state root of the previous account state of the m-th account address, add the account state tree to the current account state of the m-th account address, and update the account state root of the current account state of the m-th account address to the account state root of the previous account state of the m-th account address to obtain the specified account state; if the current account state of the m-th account address contains an account state tree, and the current account state of the m-th account address... If the account state root is equal to the account state root of the previous account state of the m-th account address, then the current account state of the m-th account address is taken as the specified account state. If the dirty state data key set of the specified account state is not empty, then the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state is obtained from the state data mapping of the specified account state. The dirty state data key in the dirty state data key set of the specified account state and the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state are updated to the account state tree of the specified account state to obtain the specified account state containing the updated account state tree. The account state root of the specified account state containing the updated account state tree is updated to the state tree root of the updated account state tree. The dirty state data key set of the specified account state containing the updated account state tree is cleared. The update tree node hash and the association relationship of the update tree node are stored in the x-th world state.

Specifically, the actual implementation of the above process can be as follows: the block-producing node can take the transition target first-world state as the current world state, and then execute the method of "submitting the state data of the entire chain dirty accounts" for the current world state. The specific steps of this method are: determine whether there is a previous world state based on the previous world state pointer of the current world state. If there is a previous world state, then take the previous world state as the current world state and continue to execute the method of "submitting the state data of the entire chain dirty accounts", and take the obtained set of the entire chain dirty account addresses as the initial set of the entire chain dirty account addresses; if there is no previous world state, then create an empty initial set of the entire chain dirty account addresses in memory. After obtaining the initial set of dirty account addresses across the entire chain, the block-producing node can traverse the set of dirty account addresses in the current world state. For each account address, the following operations are performed: The account state is retrieved from the account state mapping based on the account address and used as the current account state; the existence of a previous world state is determined based on the previous world state pointer of the current world state. If a previous world state exists, it is retrieved from the previous world state based on the account address; otherwise, the current account state is used as the previous account state; the root of the previous account state is used as the root of the previous account state, and the current account state is used as the specified account state to execute the "submit state data for a single account" method based on the tree node cache of the current world state; then, the account address is inserted into the set of dirty account addresses for processing the entire chain; after all account addresses in the dirty account address set have completed the above operations, the set of dirty account addresses across the entire chain and the first world state after submission are obtained.

Specifically, the steps for executing the "Submit Single Account State Data" method, which uses the account state root of the previous account state as the previous account state root and the current account state as the specified account state based on the current world state tree node cache, are as follows: If the account state tree of the specified account state is not empty and the account state root of the specified account state is equal to the previous account state root, skip this step; otherwise, use the tree node cache as the tree node query source, the previous account state root as the state tree root, create a new account state tree in memory, add it to the specified account state, update the account state root of the specified account state to the previous account state root, and continue with the following steps; if the dirty state data key set of the specified account state... If the set of dirty state data keys for the specified account state is empty, return and end the process. If the set of dirty state data keys for the specified account state is not empty, continue with the following steps: Traverse the set of dirty state data keys for the specified account state, retrieve the state data value from the state data mapping for the specified account state based on each state data key, update each pair of state data keys and state data values to the account state tree for the specified account state, and continue with the following steps: Use the tree node cache as the tree node update cache, commit the account state tree for the specified account state, and continue with the following steps: Obtain the state root of the account state tree for the specified account state and update the account state root for the specified account state; Clear the set of dirty state data keys for the specified account state.

The method provided in this application, by constructing a world state chain, simultaneously maintains the world state at different block heights or different branches at the same block height, is compatible with consensus mechanisms requiring simultaneous consensus across multiple blocks, and can guarantee the consistency of state data in the blockchain system.

Please refer to Figure 7, which is a schematic diagram of the structure of a blockchain-based data processing device provided in an embodiment of this application. The data processing device can be a computer program (including program code) running on a computer device; for example, the data processing device is an application software. The device can be used to execute the corresponding steps in the data processing method provided in the embodiment of this application. As shown in Figure 7, the data processing device 1 may include: an initialization module 11, a state creation module 12, a first state update module 13, a second state update module 14, a consensus module 15, and a state submission module 16.

Initialization module 11 is used to generate the initial block;

The state creation module 12 is used to create the first world state corresponding to the initial block; the first world state has a chain relationship pointing to the second world state corresponding to the parent block of the initial block; the first world state and the second world state exist in the world state chain; if the parent block is the block with the largest block height among the already chained blocks, then the second world state is the consensus root world state; the first world state in the world state chain is the latest on-chain world state; the consensus root world state has a chain relationship pointing to the latest on-chain world state; the latest on-chain world state is used to record the latest world state corresponding to the already chained blocks;

The first state update module 13 is used to update the first world state based on the transactions in the initial block to obtain the target first world state.

The second state update module 14 is used to construct a clean state tree for the target first world state according to the world state chain, so as to obtain an updated target first world state containing the clean current world state tree.

Consensus module 15 is used to write the first world state root corresponding to the clean current world state tree into the initial block, obtain the block to be added to the chain, and send the consensus block to the consensus node so that the consensus node can perform consensus processing on the block to be added to the chain based on the first world state root and obtain the consensus result.

The state submission module 16 is used to write the block to be added to the blockchain if the consensus result is a consensus pass result. It submits the target first world state to the latest on-chain world state through the world state chain, and determines the target first world state as the new consensus root world state. The new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission.

The specific implementation methods of the initialization module 11, the state creation module 12, the first state update module 13, the second state update module 14, the consensus module 15, and the state submission module 16 can be found in the description of steps S101-S104 in the embodiment corresponding to Figure 3 above, and will not be repeated here.

The state creation module 12 includes a creation unit 121 and a pointing unit 122.

Creation unit 121 is used to create the initial world state corresponding to the initial block; the initial world state contains a pointer to the first previous world state and a first tree node cache; the first tree node cache contains a pointer to the first previous tree node cache;

Pointer unit 122 is used to point the first previous world state pointer to the second world state corresponding to the parent block of the initial block, and to point the first previous tree node cache pointer to the second tree node cache contained in the second world state, so as to obtain the first world state corresponding to the initial block.

The specific implementation of the creation unit 121 and the pointing unit 122 can be found in the description of step S101 in the embodiment corresponding to Figure 3 above, and will not be repeated here.

The first state update module 13 includes: a first transaction acquisition unit 131, a transaction state creation unit 132, a transaction state update unit 133, a transaction state submission unit 134, and a world state determination unit 135.

The first transaction acquisition unit 131 is used to sequentially traverse the transactions in the initial block and acquire the k-th transaction in the initial block; k is a positive integer less than or equal to H; H is the total number of transactions in the initial block;

The transaction state creation unit 132 is used to create the k-th transaction world state corresponding to the k-th transaction; the k-th transaction world state has a chain relationship pointing to the (k-1)-th submitted world state; when k is 1, the (k-1)-th submitted world state is the first world state;

The transaction state update unit 133 is used to execute the kth transaction. During the execution of the kth transaction, the world state of the kth transaction is updated to obtain the updated world state of the kth transaction.

The transaction status submission unit 134 is used to submit the world state of the kth updated transaction to the (k-1)th submission world state if the kth transaction is successfully executed, thus obtaining the kth submission world state.

World state determination unit 135 is used to take the Hth submitted world state as the target first world state when k equals H.

The specific implementation methods of the first transaction acquisition unit 131, transaction status creation unit 132, transaction status update unit 133, transaction status submission unit 134 and world status determination unit 135 can be found in the description of steps S201-S205 in the embodiment corresponding to Figure 5 above, and will not be repeated here.

The k-th transaction world state contains an account state mapping and a set of dirty account addresses;

The transaction status update unit 133 includes: an execution subunit 1331, an account status acquisition subunit 1332, a first mapping update subunit 1333, and a second mapping update unit 1334.

Execution subunit 1331 is used to execute the k-th transaction. During the execution of the k-th transaction, the data to be updated corresponding to the k-th transaction is determined. The data to be updated includes the account address to be updated, the status data key to be updated, and the status data value to be updated.

The account status acquisition subunit 1332 is used to obtain the account status corresponding to the account address to be updated based on the k-th transaction world status, and use it as the account status to be updated; the account status to be updated contains the data mapping of the status to be updated and the set of dirty status data keys to be updated;

The first mapping update subunit 1333 is used to update the mapping relationship between the state data key to be updated and the state data value to be updated to the state data mapping to be updated, and to insert the state data key to be updated into the dirty state data key set to be updated to obtain the current account status.

The second mapping update unit 1334 is used to update the mapping relationship between the account address to be updated and the current account status to the account status mapping contained in the kth transaction world state, and insert the account address to be updated into the dirty account address set contained in the kth transaction world state to obtain the kth updated transaction world state.

The account state acquisition subunit 1332 is specifically used to perform an account state mapping order retrieval from the k-th transaction world state to the latest on-chain world state based on the account address to be updated. If an account state with a mapping relationship to the account address to be updated is found during the account state mapping order retrieval process, the first account state with a mapping relationship to the account address to be updated is taken as the account state to be updated. If no account state with a mapping relationship to the account address to be updated is found during the account state mapping order retrieval process, the root of the state tree corresponding to the account address to be updated is obtained according to the world state tree in the latest on-chain world state, and the account state to be updated is established based on the account address to be updated and the root of the state tree to be updated.

The specific implementation methods of the execution subunit 1331, the account status acquisition subunit 1332, the first mapping update subunit 1333, and the second mapping update unit 1334 can be found in the description of step S203 in the embodiment corresponding to Figure 5 above, and will not be repeated here.

The transaction status submission unit 134 includes: address acquisition subunit 1341, current account status acquisition subunit 1342, previous account status acquisition subunit 1343, world status submission subunit 1344, and world status determination subunit 1345.

Address acquisition subunit 1341 is used to traverse the set of dirty account addresses contained in the k-th updated transaction world state and sequentially acquire the j-th account address; j is a positive integer less than or equal to I; I is the total number of account addresses in the set of dirty account addresses contained in the k-th updated transaction world state.

The current account status acquisition subunit 1342 is used to obtain the current account status corresponding to the j-th account address from the account status mapping contained in the k-th updated transaction world state;

The previous account status acquisition subunit 1343 is used to obtain the previous account status of the j-th account address based on the (k-1)-th submitted world status;

The world state commit subunit 1344 is used to commit the current account state corresponding to the j-th account address to the previous account state of the j-th account address, and insert the j-th account address into the dirty account address set contained in the (k-1)-th commit world state to obtain the j-th transition commit world state.

The world state determination subunit 1345 is used to clear the dirty account address set and account state mapping contained in the k-th update transaction world state when j equals I, and take the i-th transitional commit world state as the k-th commit world state.

Specifically, the world state commit subunit 1345 is used to update the mapping relationship between state data keys and state data values in the state data mapping of the current account state corresponding to the j-th account address to the state data mapping of the previous account state corresponding to the j-th account address; and to insert the state data keys in the state data mapping of the current account state corresponding to the j-th account address into the dirty state data key set of the previous account state corresponding to the j-th account address to obtain the j-th transition commit world state.

The specific implementation methods of address acquisition subunit 1341, current account status acquisition subunit 1342, previous account status acquisition subunit 1343, world status submission subunit 1344, and world status determination subunit 1345 can be found in the description of step S204 in the embodiment corresponding to Figure 5 above, and will not be repeated here.

The second state update module 14 includes: a tree query unit 141, a first query processing unit 142, a second query processing unit 143, a first tree construction unit 144, and a second tree construction unit 145.

Tree query unit 141 is used to perform world state tree query on the first world state of the target;

The first query processing unit 142 is used to perform full-chain dirty account state submission processing on the target first world state containing the first world state tree if the target first world state contains the first world state tree, so as to obtain the updated target first world state containing the clean current world state tree.

The second query processing unit 143 is used to search for the second world state based on the first previous world state pointer if the target first world state does not contain the first world state tree.

The first tree construction unit 144 is used to construct a clean state tree for the second world state according to the world state chain, so as to obtain a clean pre-world state tree.

The second tree construction unit 145 is used to take the root of the previous state tree of the clean previous world state tree as the root of the current state tree.

The second tree construction unit 145 is also used to construct the second world state tree corresponding to the target first world state based on the first tree node cache and the current state tree root, and add the second world state tree to the target first world state to obtain the transition target first world state.

The dirty state submission unit 146 is used to perform full-chain dirty account state submission processing on the transition target first world state to obtain the updated target first world state containing the clean current world state tree.

The specific implementation methods of the tree query unit 141, the first query processing unit 142, the second query processing unit 143, the first tree construction unit 144, and the second tree construction unit 145 can be found in the description of steps S301-S306 in the embodiment corresponding to Figure 6 above, and will not be repeated here.

The dirty state submission unit 146 includes: a dirty data submission subunit 1461, a root acquisition subunit 1462, a tree update subunit 1463, and a tree submission subunit 1464.

Dirty data submission subunit 1461 is used to perform full-chain dirty state data submission processing on the first world state of the transition target, and obtain the submitted first world state of the transition target and the full-chain dirty account address set.

The root acquisition subunit 1462 is used to obtain the account state root corresponding to each full-chain dirty account address in the full-chain dirty account address set according to the first-world state of the transition target after submission.

Tree update subunit 1463 is used to update the second world state tree with each full-chain dirty account address and the account state root corresponding to each full-chain dirty account address to obtain a clean current world state tree.

Tree submission subunit 1464 is used to store the updated tree node hash and the association relationship of the updated tree node of the clean current world state tree into the tree node mapping of the tree node cache in the transition target first world state after submission, so as to obtain the updated target first world state containing the clean current world state tree.

The dirty data submission subunit 1461 is specifically used to sequentially traverse the world state chain, obtain the set of dirty account addresses contained in the x-th world state as the x-th target dirty account address set; x is a positive integer less than or equal to Z; Z is the ordinal number of the transition target first world state in the world state chain; traverse the account addresses in the x-th target dirty account address set, and sequentially obtain the m-th account address; m is a positive integer less than or equal to the total number of account addresses in the x-th target dirty account address set; obtain the target current account state and target previous account state corresponding to the m-th account address; and adjust the m-th account address according to the previous account state of the m-th account address. The current account status of each account address is processed by committing dirty state data. After the current account status of each dirty account address in the x-th target dirty account address set is processed by committing dirty state data, the world state after the x-th commit is obtained. The target dirty account address is added to the (x-1)-th on-chain target dirty account address set to obtain the x-th on-chain target dirty account address set. When x is 1, the (x-1)-th on-chain target dirty account address set is an empty set. When x equals Z, the x-th on-chain target dirty account address set is taken as the full chain dirty account address set, and the world state after the x-th commit is taken as the transition target first world state after the commit.

Specifically, the dirty data submission subunit 1461 is further used to perform an account state tree query on the current account state of the m-th account address. If the current account state of the m-th account address does not contain an account state tree, or the account state root of the current account state of the m-th account address is not equal to the account state root of the previous account state of the m-th account address, then a specified account state tree is established based on the tree node cache of the current account state of the m-th account address and the account state root of the previous account state of the m-th account address. The account state tree is added to the current account state of the m-th account address, and the account state root of the current account state of the m-th account address is updated to the account state root of the previous account state of the m-th account address to obtain the specified account state. If the current account state of the m-th account address contains an account state tree, and the account state root of the current account state of the m-th account address is equal to the account state root of the previous account state of the m-th account address, then... If the m-th account address is the root of the account state, then the current account state of the m-th account address is taken as the specified account state. If the dirty state data key set of the specified account state is not empty, then the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state is obtained from the state data mapping of the specified account state. The dirty state data key in the dirty state data key set of the specified account state and the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state are updated to the account state tree of the specified account state to obtain the specified account state containing the updated account state tree. The account state root of the specified account state containing the updated account state tree is updated to the state tree root of the updated account state tree. The dirty state data key set of the specified account state containing the updated account state tree is cleared. The update tree node hash and the association relationship of the update tree node are stored in the x-th world state.

The specific implementation methods of the dirty data submission subunit 1461, root acquisition subunit 1462, tree update subunit 1463 and tree submission subunit 1464 can be found in the description of step S306 in the embodiment corresponding to Figure 3 above, and will not be repeated here.

The data processing device 1 mentioned above also includes: a submission module 17, an update module 18, and a clear module 19.

Submission module 17 is used to perform full-chain dirty account state submission processing on the latest on-chain world state after submission, so as to obtain a clean latest on-chain world state.

Update module 18 is used to update the tree node database with the tree node hash and tree node contained in the tree node mapping in the clean and latest on-chain world state tree node cache;

The Clear Module 19 is used to clear the dirty account address set, account state mapping, and tree node mapping in the tree node cache in the latest on-chain world state.

The specific implementation methods of the submission module 17, update module 18 and clear module 19 can be found in the optional descriptions in the embodiments corresponding to Figure 3 above, and will not be repeated here.

Please refer to Figure 8, which is a schematic diagram of the structure of a computer device provided in an embodiment of this application. As shown in Figure 8, the data processing device 1 in the embodiment corresponding to Figure 7 can be applied to a computer device 1000. The computer device 1000 may include: a processor 1001, a network interface 1004, and a memory 1005. In addition, the computer device 1000 may also include: a user interface 1003, and at least one communication bus 1002. The communication bus 1002 is used to realize the connection and communication between these components. The user interface 1003 may include a display screen and a keyboard. Optionally, the user interface 1003 may also include a standard wired interface and a wireless interface. The network interface 1004 may optionally include a standard wired interface and a wireless interface (such as a Wi-Fi interface). The memory 1005 may be a high-speed RAM memory or a non-volatile memory, such as at least one disk storage device. Optionally, the memory 1005 may also be at least one storage device located away from the aforementioned processor 1001. As shown in Figure 8, the memory 1005, which is a computer-readable storage medium, may include an operating system, a network communication module, a user interface module, and a device control application program.

In the computer device 1000 shown in Figure 8, the network interface 1004 provides network communication elements; the user interface 1003 is mainly used to provide an input interface for the user; and the processor 1001 can be used to call the device control application stored in the memory 1005 to achieve:

An initial block is generated, and a first world state corresponding to the initial block is created. The first world state has a chain relationship pointing to the second world state corresponding to the parent block of the initial block. The first and second world states exist in the world state chain. If the parent block is the block with the highest block height among the already chained blocks, then the second world state is the consensus root world state. The first world state in the world state chain is the latest on-chain world state. The consensus root world state has a chain relationship pointing to the latest on-chain world state. The latest on-chain world state is used to record the latest world state corresponding to the already chained blocks.

The first world state is updated based on the transactions in the initial block to obtain the target first world state. A clean state tree is then constructed on the target first world state based on the world state chain to obtain the updated target first world state containing the clean current world state tree.

Write the first world state root corresponding to the clean current world state tree into the initial block to obtain the block to be added to the chain. Send the consensus block to the consensus node so that the consensus node can perform consensus processing on the block to be added to the chain based on the first world state root and obtain the consensus result.

If the consensus result is a consensus pass, the block to be added to the blockchain is written into the blockchain. The target first world state is submitted to the latest on-chain world state through the world state chain. The target first world state is determined as the new consensus root world state. The new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission.

It should be understood that the computer device 1000 described in the embodiments of this application can execute the data processing method described in any of the embodiments corresponding to Figure 3 above, and will not be repeated here. In addition, the beneficial effects of using the same method will also not be repeated.

Furthermore, it should be noted that this application also provides a computer-readable storage medium storing a computer program executed by the aforementioned data processing apparatus 1. This computer program includes program instructions, which, when executed by the processor, can perform the data processing method described in any of the embodiments corresponding to FIG3 above. Therefore, further details will not be repeated here. Additionally, the beneficial effects of using the same method will also not be repeated. For technical details not disclosed in the embodiments of the computer-readable storage medium involved in this application, please refer to the description of the method embodiments of this application.

The aforementioned computer-readable storage medium can be an internal storage unit of the data processing apparatus or computer device provided in any of the foregoing embodiments, such as a hard disk or memory of the computer device. The computer-readable storage medium can also be an external storage device of the computer device, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., provided on the computer device. Furthermore, the computer-readable storage medium can include both internal and external storage units of the computer device. The computer-readable storage medium is used to store the computer program and other programs and data required by the computer device. The computer-readable storage medium can also be used to temporarily store data that has been output or will be output.

Furthermore, it should be noted that this application also provides a computer program product or computer program, which includes computer instructions stored in a computer-readable storage medium. The processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the method provided in any of the preceding corresponding embodiments.

The terms "first," "second," etc., in the specification, claims, and drawings of this application are used to distinguish different objects, not to describe a specific order. Furthermore, the term "comprising," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, apparatus, product, or device that includes a series of steps or units is not limited to the listed steps or modules, but may optionally include steps or modules not listed, or may optionally include other step units inherent to these processes, methods, apparatuses, products, or devices.

Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the composition and steps of each example have been generally described in the foregoing description as a network element. Whether these network elements are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can implement the described network elements using different methods for each specific application, but such implementation should not be considered beyond the scope of this application.

The above-disclosed embodiments are merely preferred embodiments of this application and should not be construed as limiting the scope of this application. Therefore, any equivalent variations made in accordance with the claims of this application shall still fall within the scope of this application.

Claims (16)

1. A data processing method based on blockchain, characterized in that it includes: An initial block is generated, and a first world state corresponding to the initial block is created. The first world state has a chain relationship pointing to the second world state corresponding to the parent block of the initial block. The first world state and the second world state exist in the world state chain. If the parent block is the block with the highest block height among the already chained blocks, then the second world state is the consensus root world state. The first world state in the world state chain is the latest on-chain world state. The consensus root world state has a chain relationship pointing to the latest on-chain world state. The latest on-chain world state is used to record the latest world state corresponding to the already chained block. The first world state is updated according to the transactions in the initial block to obtain the target first world state. A clean state tree is constructed on the target first world state according to the world state chain to obtain the updated target first world state containing the clean current world state tree. Write the first world state root corresponding to the clean current world state tree into the initial block to obtain the block to be added to the chain. Send the block to be added to the chain to the consensus node so that the consensus node performs consensus processing on the block to be added to the chain based on the first world state root to obtain a consensus result. If the consensus result is a consensus pass, the block to be added to the blockchain is written into the blockchain. The target world state is submitted to the latest on-chain world state through the world state chain. The target world state is determined as the new consensus root world state. The new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission. 2. The method according to claim 1, wherein creating the first world state corresponding to the initial block includes: Create the initial world state corresponding to the initial block; the initial world state includes a first previous world state pointer and a first tree node cache; the first tree node cache includes a first previous tree node cache pointer; The first previous world state pointer is set to the second world state corresponding to the parent block of the initial block, and the first previous tree node cache pointer is set to the second tree node cache contained in the second world state, so as to obtain the first world state corresponding to the initial block. 3. The method according to claim 1, wherein updating the first world state based on the transactions in the initial block to obtain the target first world state comprises: The transactions in the initial block are sequentially traversed to obtain the k-th transaction in the initial block; k is a positive integer less than or equal to H; H is the total number of transactions in the initial block; Create the world state of the kth transaction corresponding to the kth transaction; the kth transaction world state has a chain relationship pointing to the (k-1)th submitted world state; when k is 1, the (k-1)th submitted world state is the first world state; Execute the k-th transaction, and during the execution of the k-th transaction, perform state update processing on the world state of the k-th transaction to obtain the updated world state of the k-th transaction; If the kth transaction is executed successfully, the world state of the kth update transaction is submitted to the (k-1)th submitted world state to obtain the kth submitted world state; When k equals H, the Hth submitted world state is taken as the target first world state. 4. The method according to claim 3, wherein the kth transaction world state includes an account state mapping and a set of dirty account addresses; The execution of the k-th transaction involves updating the world state of the k-th transaction during the execution process to obtain the updated world state of the k-th transaction, including: Execute the k-th transaction, and during the execution of the k-th transaction, determine the data to be updated corresponding to the k-th transaction; the data to be updated includes the account address to be updated, the status data key to be updated, and the status data value to be updated; The account status corresponding to the account address to be updated is obtained based on the kth transaction world state, and is used as the account status to be updated; the account status to be updated includes the data mapping of the status to be updated and the set of dirty state data keys to be updated; The mapping relationship between the state data key to be updated and the state data value to be updated is updated to the state data mapping to be updated, and the state data key to be updated is inserted into the dirty state data key set to be updated to obtain the current account status. The mapping relationship between the account address to be updated and the current account status is updated to the account status mapping contained in the k-th transaction world state. The account address to be updated is inserted into the dirty account address set contained in the k-th transaction world state to obtain the k-th updated transaction world state. 5. The method according to claim 4, wherein obtaining the account status corresponding to the account address to be updated based on the kth transaction world state, as the account status to be updated, includes: Based on the account address to be updated, perform an account state mapping sequence retrieval from the kth transaction world state to the latest on-chain world state; If an account status that is mapped to the address of the account to be updated is found during the account status mapping order retrieval process, the first account status that is mapped to the address of the account to be updated will be taken as the account status to be updated. If no account state with a mapping relationship to the account address to be updated is found during the account state mapping sequence retrieval process, then the root of the state tree corresponding to the account address to be updated is obtained according to the world state tree in the latest on-chain world state, and the account state to be updated is established according to the account address to be updated and the root of the state tree to be updated. 6. The method according to claim 4, characterized in that, if the k-th transaction is successfully executed, the step of submitting the k-th updated transaction world state to the (k-1)-th submitted world state to obtain the k-th submitted world state includes: Iterate through the set of dirty account addresses contained in the k-th updated transaction world state, and sequentially obtain the j-th account address; j is a positive integer less than or equal to I; I is the total number of account addresses in the set of dirty account addresses contained in the k-th updated transaction world state. Obtain the current account status corresponding to the j-th account address from the account status mapping contained in the k-th updated transaction world state; The previous account state of the j-th account address is obtained based on the (k-1)-th submitted world state; Submit the current account state corresponding to the j-th account address to the previous account state of the j-th account address, insert the j-th account address into the dirty account address set contained in the (k-1)-th submitted world state, and obtain the j-th transitional submitted world state; When j equals I, clear the dirty account address set and account state mapping contained in the kth updated transaction world state, and take the i-th transitional commit world state as the kth commit world state. 7. The method according to claim 6, characterized in that, the step of submitting the current account state corresponding to the j-th account address to the previous account state of the j-th account address, and inserting the j-th account address into the dirty account address set included in the (k-1)-th submitted world state to obtain the j-th transitional submitted world state, includes: Update the mapping relationship between the status data key and the status data value in the status data mapping of the current account status corresponding to the j-th account address to the status data mapping of the previous account status of the j-th account address; Insert the state data key from the state data mapping of the current account state corresponding to the j-th account address into the dirty state data key set of the previous account state of the j-th account address to obtain the j-th transitional commit world state. 8. The method according to claim 2, characterized in that, the step of constructing a clean state tree for the target first world state based on the world state chain to obtain an updated target first world state includes: Perform a world state tree query on the first world state of the target; If the target first world state contains a first world state tree, then the target first world state containing the first world state tree is subjected to full-chain dirty account state submission processing to obtain an updated target first world state containing a clean current world state tree. If the target first world state does not contain the first world state tree, then the second world state is found according to the first previous world state pointer; Based on the world state chain, a clean state tree is constructed for the second world state to obtain a clean pre-world state tree; The root of the clean former world state tree is taken as the root of the current state tree. Construct a second world state tree corresponding to the target first world state based on the first tree node cache and the current state tree root, and add the second world state tree to the target first world state to obtain the transition target first world state; The transition target first world state is subjected to full-chain dirty account state submission processing to obtain an updated target first world state containing a clean current world state tree. 9. The method according to claim 8, characterized in that, the step of performing a full-chain dirty account state commit process on the transition target first world state to obtain an updated target first world state containing a clean current world state tree includes: The first world state of the transition target is processed by submitting full-chain dirty state data to obtain the submitted first world state of the transition target and the set of full-chain dirty account addresses. Based on the first world state of the submitted transition target, obtain the account state root corresponding to each full-chain dirty account address in the full-chain dirty account address set; Update the second world state tree with each full-chain dirty account address and the account state root corresponding to each full-chain dirty account address to obtain the clean current world state tree; The hash of the updated tree node of the clean current world state tree and the association relationship of the updated tree node are stored in the tree node mapping of the tree node cache in the first world state of the transition target after submission, so as to obtain the first world state of the updated target containing the clean current world state tree. 10. The method according to claim 9, characterized in that, the step of performing full-chain dirty state data submission processing on the first world state of the transition target to obtain the submitted first world state of the transition target and the full-chain dirty account address set includes: The world state chain is traversed sequentially to obtain the set of dirty account addresses contained in the x-th world state, which is used as the x-th target dirty account address set; x is a positive integer less than or equal to Z; Z is the ordinal number of the transition target first world state in the world state chain; Traverse the account addresses in the x-th target dirty account address set, and sequentially obtain the m-th account address; m is a positive integer less than or equal to the total number of account addresses in the x-th target dirty account address set; Obtain the current target account status and the previous target account status corresponding to the m-th account address; Based on the previous account status of the m-th account address, the current account status of the m-th account address is processed by submitting dirty account status data. After the current account status of each dirty account address in the x-th target dirty account address set is processed by submitting the dirty account status data, the world state after the x-th submission is obtained. The target dirty account address is added to the (x-1)th on-chain target dirty account address set to obtain the xth on-chain target dirty account address set; when x is 1, the (x-1)th on-chain target dirty account address set is an empty set; When x equals Z, the set of dirty account addresses of the xth on-chain target is taken as the set of dirty account addresses of the entire chain, and the world state after the xth commit is taken as the first world state of the transition target after the commit. 11. The method according to claim 10, characterized in that, the step of performing dirty account status data submission processing on the current account status of the m-th account address based on the previous account status of the m-th account address includes: Perform an account status tree query on the current account status of the m-th account address; If the current account status of the m-th account address does not contain an account status tree, or the account status root of the current account status of the m-th account address is not equal to the account status root of the previous account status of the m-th account address, then a specified account status tree is established based on the tree node cache of the current account status of the m-th account address and the account status root of the previous account status of the m-th account address. The account status tree is added to the current account status of the m-th account address, and the account status root of the current account status of the m-th account address is updated to the account status root of the previous account status of the m-th account address to obtain the specified account status. If the current account status of the m-th account address contains an account status tree, and the account status root of the current account status of the m-th account address is equal to the account status root of the previous account status of the m-th account address, then the current account status of the m-th account address is taken as the specified account status. If the dirty state data key set of the specified account state is not empty, then obtain the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state from the state data mapping of the specified account state, update the account state tree of the specified account state with the dirty state data key in the dirty state data key set of the specified account state and the state data value corresponding to the dirty state data key in the dirty state data key set of the specified account state, and obtain the specified account state containing the updated account state tree; Update the account state root containing the specified account state of the updated account state tree to the state tree root of the updated account state tree; Clear the dirty state data key set containing the state of the specified account that updates the account state tree; Store the hash of the updated tree node and the association relationship of the updated tree node in the xth world state. 12. The method according to claim 11, characterized in that it further comprises: The latest on-chain world state after submission is processed by submitting the dirty account state of the entire chain to obtain a clean latest on-chain world state. Update the tree node database with the tree node hash and tree node contained in the tree node cache of the clean latest on-chain world state; Clear the set of dirty account addresses, account state mappings, and tree node mappings in the clean, latest on-chain world state. 13. A blockchain-based data processing device, characterized in that it comprises: The initialization module is used to generate the initial block. A state creation module is used to create a first world state corresponding to the initial block; the first world state has a chained relationship pointing to the second world state corresponding to the parent block of the initial block; the first world state and the second world state exist in a world state chain; if the parent block is the block with the highest block height among the already chained blocks, then the second world state is the consensus root world state; the first world state in the world state chain is the latest on-chain world state; the consensus root world state has a chained relationship pointing to the latest on-chain world state; the latest on-chain world state is used to record the latest world state corresponding to the already chained block; The first state update module is used to update the first world state according to the transactions in the initial block to obtain the target first world state. The second state update module is used to construct a clean state tree for the target first world state according to the world state chain, so as to obtain an updated target first world state containing the clean current world state tree. The consensus module is used to write the first world state root corresponding to the clean current world state tree into the initial block to obtain the block to be added to the chain, and send the block to be added to the chain to the consensus node so that the consensus node performs consensus processing on the block to be added to the chain based on the first world state root to obtain a consensus result. The state submission module is used to write the block to be added to the blockchain if the consensus result is a consensus pass result, and to submit the target first world state to the latest on-chain world state through the world state chain, and to determine the target first world state as the new consensus root world state. The new consensus root world state has a chain relationship pointing to the latest on-chain world state after submission. 14. A computer device, characterized in that it comprises: a processor, a memory, and a network interface; The processor is connected to the memory and the network interface, wherein the network interface is used to provide data communication functions, the memory is used to store program code, and the processor is used to call the program code to execute the method according to any one of claims 1-12. 15. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program adapted to be loaded by a processor and to execute the method according to any one of claims 1-12. 16. A computer program product comprising a computer program/instructions, characterized in that, when the computer program/instructions are executed by a processor, they can perform the method described in any one of claims 1-12.