A deterministic parallel scheduling method, system, device, and storage medium for blockchain transaction execution.

By performing static analysis on smart contracts to generate read/write set declaration information and constructing a parallel execution plan for transaction dependencies, the throughput and execution efficiency issues of blockchain systems are solved, achieving efficient parallel scheduling and state consistency.

CN123114780APending Publication Date: 2026-11-17BEIJING JIAOTONG UNIV
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611613246.5
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-10-19
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

When processing a large number of smart contract call transactions, existing blockchain systems suffer from throughput limitations due to serial execution methods. Nondeterministic parallel scheduling methods lead to wasted computing resources, while deterministic parallel scheduling methods increase the burden on developers and are difficult to be compatible with existing contracts.

Method used

By performing static analysis on the source code of smart contracts, static read-write set declaration information of contracts is generated, a parallel execution plan for transaction dependencies is constructed to avoid conflicts, and deterministic parallel scheduling is achieved by utilizing the concurrent execution of proposal and verification nodes.

Benefits of technology

It improves the throughput and execution efficiency of the blockchain system, reduces the overhead of transaction rollback and re-execution, and enhances the stability and reliability of the system.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure FT_1
    Figure FT_1
  • Figure FT_2
    Figure FT_2
Patent Text Reader

Abstract

This invention relates to a deterministic parallel scheduling method, system, device, and storage medium for blockchain transaction execution. The method includes: statically analyzing the smart contract source code to identify state read operations, state write operations, state delete operations, and state key construction methods corresponding to the contract interface; generating static read / write set declaration information for the contract and storing it on the blockchain through a system contract; when a user invokes a transaction, generating a conflict factor based on the static read / write set declaration information and transaction parameters stored on the chain, and writing it into the transaction payload; blockchain nodes determining read / write conflict relationships between transactions based on the conflict factor, constructing a directed acyclic graph (DAG) of transaction dependencies, and performing topological grouping based on the DAG to generate a grouped parallel execution plan; proposing nodes executing transactions according to the plan, and verifying nodes performing parallel verification according to the same plan. This invention can determine transaction dependencies in advance without changing the existing smart contract development model, reducing conflict rollback and duplicate execution overhead, and improving the transaction execution efficiency and throughput of the blockchain system.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of blockchain technology, specifically to a deterministic parallel scheduling method, system, device, and storage medium for blockchain transaction execution. Background Technology

[0002] Blockchain technology is a new application model of computer technologies such as distributed computing, P2P networks, cryptography, and consensus mechanisms. Data is combined into blocks in the form of transactions, connected in a chain structure, and consensus is formed in a distributed network. With the widespread application of blockchain technology in fields such as government affairs, finance, supply chain management, and data circulation, the transaction scale that blockchain platforms need to process is constantly increasing, the frequency of smart contract calls is continuously rising, and transaction execution performance is gradually becoming an important factor restricting the throughput and scalability of blockchain systems.

[0003] Early blockchain systems typically employed a serial transaction execution approach. When generating a block, the proposer executes the transactions in the block sequentially according to a predetermined order, generating state transition results. Upon receiving a block, the validator also executes the transactions in the same order to verify the consistency of the state transition results. While this serial execution approach effectively guarantees the consistency and determinism of the blockchain state, it struggles to fully utilize multi-core processor resources. When a block contains a large number of smart contract call transactions, serial execution significantly limits system throughput.

[0004] To improve blockchain transaction processing performance, existing parallel scheduling methods mainly fall into two categories: nondeterministic parallel scheduling and deterministic parallel scheduling. Nondeterministic parallel scheduling executes transactions in parallel, recording the read / write set for each transaction during execution. After execution, it checks for conflicts between transactions based on the read / write set. If a conflict is found, the relevant transactions need to be rolled back and re-executed. Deterministic parallel scheduling, on the other hand, determines the dependencies between transactions before execution, thus avoiding rollbacks due to conflicts after execution. Some blockchain systems require transactions to explicitly declare the state objects they will read or write before submission. The scheduler determines whether there are conflicts between transactions based on the declaration information and executes non-conflicting transactions in parallel. However, the existing two types of methods have at least the following shortcomings: (1) Existing nondeterministic parallel scheduling methods can only obtain the read-write set and determine the conflict after the transaction is actually executed. In high-conflict scenarios, a large number of transaction rollbacks and re-executions are likely to occur, resulting in a waste of computing resources, increased scheduling overhead, and reduced system throughput. (2) Existing deterministic parallel scheduling methods usually require developers to manually declare the transaction read and write status, or require modification of the smart contract programming paradigm, which increases the burden on developers and is difficult to be compatible with a large number of deployed smart contracts and existing business systems.

[0005] (3) The existing technology lacks a method that can automatically infer the scope of access to transaction state without changing the existing smart contract development model, and build deterministic dependencies and grouped conflict-free parallel execution plans before transaction execution. Summary of the Invention

[0006] To address the shortcomings of existing technologies, the present invention aims to provide a deterministic parallel scheduling method, system, device, and storage medium for blockchain transaction execution. This scheduling method can automatically infer the state access range of a contract, pre-build transaction dependencies, reduce transaction rollback and re-execution overhead, and support concurrent execution of transaction verification by proposal nodes and verification nodes without altering existing smart contract development models, thereby improving the throughput and block processing efficiency of the blockchain system.

[0007] To achieve the above objectives, the technical solution adopted by the present invention is as follows: A deterministic parallel scheduling method for blockchain transaction execution, characterized by comprising the following steps: Step 1: Parse the smart contract source code using an abstract syntax tree to generate the corresponding static read / write set declaration information of the contract; Specifically, this involves: performing static analysis on the smart contract source code to identify the state read, write, and delete operations corresponding to each contract interface in the smart contract, as well as the state key construction method; generating static read / write set declaration information for the contract; and storing this static read / write set declaration information on the blockchain through a system contract for new deployment, enabling the proposal nodes and verification nodes in the blockchain to obtain unified static read / write set declaration information. Step 2: Register and store the static read / write set declaration information of the contract generated in Step 1 on the blockchain by creating a new system contract for storing the static read / write set, so that the proposal node and the verification node can obtain the unified declaration information; Step 3: Use the declaration information stored on the blockchain in Step 2 to obtain the contract identifier, contract interface and transaction parameters of the user transaction call, generate the corresponding conflict factor and write it into the transaction payload; The conflict factor is used to characterize the state objects that a transaction may access during execution and the access methods thereto; Step 4: The blockchain node reads the conflict factor generated in Step 3 and determines the transaction dependency relationship based on the read-write conflict relationship between transactions: when two transactions access the same or overlapping state objects and at least one transaction contains a write operation or a delete operation, it is determined that the two transactions have a dependency relationship, and a directed acyclic graph of transaction dependencies is constructed based on the dependency relationship between all transactions. Step 5: Based on the directed acyclic graph of transaction dependencies generated in Step 4, perform topological layering and divide the transactions in the blockchain into multiple execution groups according to the transaction dependencies: transactions without dependencies are assigned to the same execution group, and transactions within the same execution group can be executed in parallel; transactions with dependencies are assigned to different execution groups according to the topological order, and different execution groups are executed sequentially according to the topological order; thus generating a grouped parallel execution plan. Step 6: Execute the transactions according to the parallel execution plan obtained in Step 5: The proposing node first reads the parallel execution plan for each group and schedules them according to the order of execution groups: for transactions within the same execution group, the proposing node allocates them to multiple execution threads for parallel execution; for transactions between different execution groups, the proposing node sets an execution waiting relationship, that is, the execution of transactions in the next execution group will only start after all transactions in the current execution group have been completed; this ensures that transactions within the same execution group are processed in parallel, and that different execution groups proceed in the order of dependency, ultimately generating the corresponding read / write sets and state change results; Step 7: The proposing node sends the transaction dependency directed acyclic graph, the grouped parallel execution plan, and the block information to the validating node. The validating node performs transaction verification according to the same grouped parallel execution plan and verifies the consistency of the execution result through the read-write set hash or the state result hash. If the verification result is consistent, the block is confirmed to be valid; otherwise, the block is determined to be invalid.

[0008] Based on the above scheme, step 1 specifically includes: Step 1.1: Obtain the smart contract source code and use it as the object of analysis; Step 1.2 involves performing abstract syntax tree parsing, symbol table construction, and state access analysis on the smart contract to obtain information such as function signature, parameter source, local variable mapping, state access operations, and state key construction method. Step 1.3: Identify state read operations, state write operations, and state delete operations in the smart contract, and infer the state access key pattern; Step 1.4: Generate the corresponding contract access declaration information based on the inferred contract access status; The contract static read / write set declaration information includes at least the contract name, state namespace, state key template, and the relevant read operation set, write operation set, delete operation set, or conservative mutual exclusion flag.

[0009] Based on the above scheme, the specific method for generating the conflict factor in step 3 is as follows: Step 3.1: The user initiates a smart contract call transaction, which includes at least the contract identifier, the contract interface name, and transaction parameters; Step 3.2: Based on the contract identifier and contract interface name, obtain the read operation set, write operation set, delete operation set, and status key template of the corresponding contract interface from the contract static read / write set declaration information stored on the blockchain; Step 3.3: Instantiate the status key template according to the transaction parameters to obtain the status object that the transaction may actually access; Step 3.4 Generate a conflict factor based on the state object and its access method, and write the conflict factor into the transaction payload; The conflict factors include at least the contract name, state namespace, state key or state key pattern, and the relevant set of read operations, set of write operations, set of delete operations, or conservative mutual exclusion flag.

[0010] Based on the above scheme, the process of generating the transaction-dependent directed acyclic graph and the grouped parallel execution plan in step 4 is as follows: Step 4.1: The proposing node obtains the transactions to be packaged from the transaction pool and reads the conflict factor in each transaction payload; Step 4.2: Determine whether there are read-write conflicts, write-write conflicts, or deletion-related conflicts between transactions based on the read operation set, write operation set, and delete operation set of each transaction; Step 4.3: When there is a read-write conflict, write-write conflict, or deletion-related conflict between two transactions, establish a dependency edge according to the order of the two transactions in the block. Step 4.4: Construct a directed acyclic graph of transaction dependencies based on all transactions in the block and their dependent edges.

[0011] Based on the above scheme, the process of the verification nodes performing transaction verification according to the same grouping parallel execution plan in step 7 is as follows: Step 7.1: The verification node receives the transaction dependency directed acyclic graph, the grouped parallel execution plan, and the block information sent by the proposing node; Step 7.2: The verification node executes the transactions in the block according to the grouped parallel execution plan and generates local execution results; Step 7.3: The verification node compares the read-write set hash or state result hash corresponding to the local execution result with the read-write set hash or state result hash corresponding to the proposal node; Step 7.4: If the comparison results are consistent, the block is confirmed to be valid and a state update is submitted; if the comparison results are inconsistent, the block is rejected or a rollback is triggered.

[0012] Based on the above scheme, the rollback is executed as follows: When the static analysis of a smart contract fails, the static read / write set declaration information of the contract is missing, the static read / write set declaration information of the contract is inconsistent with the actual execution result, the state key template cannot be instantiated according to the transaction parameters, the transaction dependency relationship cannot be determined, or the execution results generated by the proposal node and the verification node are inconsistent, the blockchain node will fall back to the serial execution mode or the original transaction execution logic of the blockchain platform to execute or re-execute the transaction.

[0013] A blockchain system that executes the aforementioned deterministic parallel scheduling method for blockchain transaction execution, the blockchain system comprising a client, a proposal node, a verification node, and a system contract for storing static read / write set declaration information of the contract: The client is used to obtain the static read / write set declaration information of the contract stored on the chain based on the contract identifier, contract interface name and transaction parameters in the transaction when the user submits a smart contract call transaction, generate the corresponding conflict factor, and write the conflict factor into the transaction payload. The proposal node is used to obtain transactions to be packaged from the transaction pool, read the conflict factors in each transaction payload, construct a transaction dependency directed acyclic graph based on the state access conflict relationship between transactions, generate a grouped parallel execution plan based on the transaction dependency directed acyclic graph, and execute transactions according to the grouped parallel execution plan. The verification node is used to receive the transaction dependency directed acyclic graph, the grouped parallel execution plan and block information sent by the proposing node, and to perform transaction verification according to the same grouped parallel execution plan; The system contract is used to store the static read / write set declaration information of the smart contract, so that the client, the proposal node and the verification node can obtain the unified static read / write set declaration information of the contract.

[0014] A computer storage medium storing a computer program, characterized in that, when the program is executed by a processor, it implements a deterministic parallel scheduling method for blockchain transaction execution as described above.

[0015] A deterministic parallel scheduling device for blockchain transaction execution, characterized in that the device includes the aforementioned computer storage medium, and the device implements the aforementioned deterministic parallel scheduling method for blockchain transaction execution during operation.

[0016] The deterministic parallel scheduling method, system, device, and storage medium for blockchain transaction execution described in this invention have the following advantages: This invention automatically infers the state access scope of smart contracts through static program analysis, eliminating the need for developers to manually declare read / write sets and improving compatibility with deployed contracts. By generating conflict factors and constructing deterministic dependencies before transaction execution, it avoids conflict detection, transaction rollback, and duplicate execution in non-deterministic parallel execution, improving computational resource utilization. Simultaneously, this invention constructs a directed acyclic graph of transaction dependencies and generates grouped parallel execution plans, enabling non-conflicting transactions to be processed in parallel, thereby improving the throughput and execution efficiency of the blockchain system. Furthermore, by sending dependencies and scheduling plans to verification nodes in advance, it achieves concurrent execution and verification of verification and proposal nodes, shortening the block processing chain. Through on-chain shared contract access declaration information and the introduction of conservative mutual exclusion, topology grouping, and anomaly degradation mechanisms, it achieves efficient parallel scheduling while ensuring transaction execution determinism and state consistency, improving system stability and reliability. Attached Figure Description

[0017] The present invention includes the following figures: Figure 1 A schematic diagram illustrating the process of a deterministic parallel scheduling method, system, device, and storage medium for blockchain transaction execution provided by the present invention; Figure 2 This is a schematic diagram illustrating the contract parsing process in an embodiment of the present invention. Detailed Implementation

[0018] The present invention will be further described in detail below with reference to the accompanying drawings. The following embodiments are used to illustrate the present invention, but are not intended to limit the scope of the invention.

[0019] In this embodiment of the invention, the blockchain platform, taking Chang'an Chain as an example, supports smart contracts written in Go. The following is an example of a business contract written in Go, whose main function is to define an asset and support functions such as transfers and queries. The transfer function receives the sending account, receiving account, and transfer amount as transaction parameters, and reads the balance of the sending account and updates the balances of both the sending and receiving accounts during execution. Since different transfer transactions may access the same account balance status, read-write conflicts may occur between multiple transactions if proper scheduling is not implemented.

[0020] The code for the business contract instance is as follows: func (c ERC20Contract) InvokeContract(method string)protogo.Response { args := sdk.Instance.GetArgs() if len(method) == 0 { return sdk.Error("method of param should not be empty") } switch method { case "totalSupply": return c.totalSupply() case "balanceOf": account := string(args["account"]) if len(account) == 0 { return sdk.Error("Param account should not be empty") } return c.balanceOf(account) case "transfer": / , spender, err := sdk.Instance.Sender() if err != nil { return sdk.Error(fmt.Sprintf("Get sender addressfailed, err:%s", err)) } / spender := string(args["spender"]) / / get spender from param to := string(args["to"]) amountStr := string(args["amount"]) amount, ok := safemath.ParseSafeUint256(amountStr) if !ok { return sdk.Error("Parse amount failed") } return c.transfer(spender, to, amount)

[0021] Step 1: Perform static analysis on the smart contract to generate contract access declaration information. The analysis process is as follows: Figure 2 As shown. The Chang'an Chain node obtains the Go contract source code and parses it into an abstract syntax tree. By identifying the state read operations, state write operations, and state key construction methods in the contract, it extracts the state access rules corresponding to each contract interface, generates contract access declaration information, and stores it on the chain using the system contract. Taking the asset transfer contract as an example, assuming that the input parameters of the transfer interface Transfer include the transfer-out account from, the transfer-in account to, and the transfer amount amount. Static analysis results show that the Transfer interface needs to read the balance of the transfer-out account and write the balance of the transfer-out account and the balance of the transfer-in account. Therefore, the generated contract access declaration information can be represented as follows: the set of read operations is balance:{from}, the set of write operations is balance:{from} and balance:{to}, and the set of delete operations is empty. Among them, balance:{from} and balance:{to} represent the state key template formed by concatenating the fixed prefix balance and the transaction parameters. If the parsing result is incorrect or the parsing fails, step 7 is executed; Step 2: Generate conflict factors based on transaction parameters. When a user initiates a smart contract call transaction, the client obtains the corresponding contract access declaration information based on the contract address and method name in the transaction, and generates conflict factors by instantiating the state access key in conjunction with the actual input parameters.

[0022] For example, the system contract stores the contract access declaration information for the Transfer interface of the asset transfer contract, where the read operation set is balance:{from}, and the write operation set is balance:{from} and balance:{to}. When a user submits a transaction to transfer 100 assets from account A to account B, the input parameters for this transaction are from=A, to=B, and amount=100. The client instantiates balance:{from} as balance and balance:{to} as balance based on the actual parameters, thereby generating the conflict factor for this transaction.

[0023] The conflict factor can be represented as follows: the contract interface is Transfer, the read set is {balance}, the write set is {balance, balance}, and the delete set is empty. Here, balance represents the balance status of account A, and balance represents the balance status of account B. The client then writes the conflict factor into the payload and sends the transaction to the blockchain network for use by subsequent proposing nodes when building transaction dependencies.

[0024] Step 3: Construct transaction dependencies based on conflict factors. The proposing node retrieves transactions to be packaged from the transaction pool and determines whether there are state conflicts between transactions based on the access sets corresponding to each transaction. When two transactions access the same state object and at least one transaction involves a write operation, a dependency relationship is determined between the two transactions, and dependency edges are established according to the transaction order in the block, thus constructing a transaction dependency DAG. For example, a block contains five transactions t1(A,B), t2(A,C), t3(B,D), t4(C,E), and t5(D,F), where parentheses represent the account states involved in the transactions. Since t1 and t2 both access account A, t1 and t3 both access account B, t2 and t4 both access account C, and t3 and t5 both access account D, corresponding dependencies are established, and a transaction dependency DAG is generated. Step 4: Generate a group scheduling plan based on the transaction dependency DAG and simultaneously send the group scheduling plan to the verification nodes. The scheduler performs topological layering on the transaction dependency DAG, grouping transactions without dependencies into the same execution group. Taking the above transactions as an example, we can obtain the first execution group G1={t1}, the second execution group G2={t2,t3}, and the third execution group G3={t4,t5}. Transactions within the same execution group can be executed in parallel, while transactions in different execution groups are executed sequentially according to the topological order. Step 5: The proposing node executes transactions according to the group scheduling plan. Based on the generated group scheduling plan, transactions within the same execution group are distributed to multiple threads for parallel execution. Once all transactions in the current execution group have been executed, the next execution group is executed, until all transactions in the block have been completed. Step 6: Verification nodes synchronously execute verification according to the group scheduling plan. After receiving the group scheduling plan, verification nodes do not need to wait for the proposing node to complete all transaction processing. Instead, they perform transaction execution and verification processes in parallel with the proposing node and generate local execution result hashes according to the same scheduling plan. After the proposing node and verification nodes have completed transaction execution, the verification node compares its generated execution result hash with the execution result hash corresponding to the proposing node. If they match, the block is confirmed as valid, and a state update is submitted; if the results do not match, the block is rejected, and step 7 is executed. Step 7: When the Go contract parsing result is incorrect or the execution result hashes generated by the proposal node and the verification node are inconsistent, the transaction in the block is re-executed by reverting to the original nondeterministic execution logic of the Chang'an Chain.

[0025] Through the above steps, this invention utilizes static analysis of smart contracts to automatically infer transaction read / write sets, constructing deterministic dependencies and parallel execution plans before transaction execution, thus avoiding the significant rollback and re-execution overhead of non-deterministic parallel scheduling. Simultaneously, proposal nodes and verification nodes can concurrently execute transaction verification based on the same scheduling plan, thereby improving the overall throughput and execution efficiency of the blockchain system.

[0026] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit them. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope defined by the claims of the present invention.

[0027] The contents not described in detail in this specification are existing technologies known to those skilled in the art.

Claims

1. A deterministic parallel scheduling method for blockchain transaction execution, characterized in that, Includes the following steps: Step 1: Parse the smart contract source code using an abstract syntax tree to generate the corresponding static read / write set declaration information of the contract; Step 2: Register and store the static read / write set declaration information of the contract generated in Step 1 on the blockchain by creating a new system contract for storing the static read / write set, so that the proposal node and the verification node can obtain the unified declaration information; Step 3: Use the declaration information stored on the blockchain in Step 2 to obtain the contract identifier, contract interface and transaction parameters of the user transaction call, generate the corresponding conflict factor and write it into the transaction payload; The conflict factor is used to characterize the state objects that a transaction may access during execution and the access methods thereto; Step 4: The blockchain node reads the conflict factor generated in Step 3 and determines the transaction dependency relationship based on the read-write conflict relationship between transactions: when two transactions access the same or overlapping state objects and at least one transaction contains a write operation or a delete operation, it is determined that the two transactions have a dependency relationship, and a directed acyclic graph of transaction dependencies is constructed based on the dependency relationship between all transactions. Step 5: Based on the directed acyclic graph of transaction dependencies generated in Step 4, perform topological layering and divide the transactions in the blockchain into multiple execution groups according to the transaction dependencies: transactions without dependencies are assigned to the same execution group, and transactions within the same execution group can be executed in parallel; transactions with dependencies are assigned to different execution groups according to the topological order, and different execution groups are executed sequentially according to the topological order; thus generating a grouped parallel execution plan. Step 6: Execute the transactions according to the parallel execution plan obtained in Step 5: The proposing node first reads the parallel execution plan for the groups and schedules them according to the order of the execution groups: for transactions within the same execution group, the proposing node assigns them to multiple execution threads for parallel execution; for transactions between different execution groups, the proposing node sets an execution waiting relationship, that is, the execution of transactions in the next execution group will only start after all transactions in the current execution group have been completed. This ensures that transactions within the same execution group are processed in parallel, while different execution groups proceed sequentially according to their dependencies, ultimately generating the corresponding read / write sets and state change results. Step 7: The proposing node sends the transaction dependency directed acyclic graph, the grouped parallel execution plan, and the block information to the validating node. The validating node performs transaction verification according to the same grouped parallel execution plan and verifies the consistency of the execution result through the read-write set hash or the state result hash. If the verification results are consistent, the block is confirmed to be valid; otherwise, the block is determined to be invalid.

2. The deterministic parallel scheduling method for blockchain transaction execution as described in claim 1, characterized in that, Step 1 specifically involves: Step 1.1: Obtain the smart contract source code and use it as the object of analysis; Step 1.2 involves performing abstract syntax tree parsing, symbol table construction, and state access analysis on the smart contract to obtain information such as function signature, parameter source, local variable mapping, state access operations, and state key construction method. Step 1.3: Identify state read operations, state write operations, and state delete operations in the smart contract, and infer the state access key pattern; Step 1.4: Generate the corresponding contract access declaration information based on the inferred contract access status; The static read / write set declaration information of the contract includes at least the contract identifier, contract interface name, state namespace, state key template, read operation set, write operation set, delete operation set, and conservative mutual exclusion flag.

3. The deterministic parallel scheduling method for blockchain transaction execution as described in claim 1, characterized in that, The specific method for generating the conflict factor in step 3 is as follows: Step 3.1: The user initiates a smart contract call transaction, which includes at least the contract identifier, the contract interface name, and transaction parameters; Step 3.2: Based on the contract identifier and contract interface name, obtain the read operation set, write operation set, delete operation set, and status key template of the corresponding contract interface from the contract static read / write set declaration information stored on the blockchain; Step 3.3: Instantiate the status key template according to the transaction parameters to obtain the status object that the transaction may actually access; Step 3.4 Generate a conflict factor based on the state object and its access method, and write the conflict factor into the transaction payload; The conflict factors include at least the contract identifier, contract interface name, state namespace, state key or state key pattern, read operation set, write operation set, delete operation set, and conservative mutual exclusion flag.

4. The deterministic parallel scheduling method for blockchain transaction execution as described in claim 1, characterized in that, The process of generating the transaction-dependent directed acyclic graph and the grouped parallel execution plan in step 4 is as follows: Step 4.1: The proposing node obtains the transactions to be packaged from the transaction pool and reads the conflict factor in each transaction payload; Step 4.2: Determine whether there are read-write conflicts, write-write conflicts, or deletion-related conflicts between transactions based on the read operation set, write operation set, and delete operation set of each transaction; Step 4.3: When there is a read-write conflict, write-write conflict, or deletion-related conflict between two transactions, establish a dependency edge according to the order of the two transactions in the block. Step 4.4: Construct a directed acyclic graph of transaction dependencies based on all transactions in the block and their dependent edges.

5. The deterministic parallel scheduling method for blockchain transaction execution as described in claim 1, characterized in that, The process of the verification nodes performing transaction verification according to the same grouping parallel execution plan in step 7 is as follows: Step 7.1: The verification node receives the transaction dependency directed acyclic graph, the grouped parallel execution plan, and the block information sent by the proposing node; Step 7.2: The verification node executes the transactions in the block according to the grouped parallel execution plan and generates local execution results; Step 7.3: The verification node compares the read-write set hash or state result hash corresponding to the local execution result with the read-write set hash or state result hash corresponding to the proposal node; Step 7.4: If the comparison results are consistent, the block is confirmed to be valid and a state update is submitted; if the comparison results are inconsistent, the block is rejected or a rollback is triggered.

6. The deterministic parallel scheduling method for blockchain transaction execution as described in claim 5, characterized in that, The rollback is executed as follows: When the static analysis of a smart contract fails, the static read / write set declaration information of the contract is missing, the static read / write set declaration information of the contract is inconsistent with the actual execution result, the state key template cannot be instantiated according to the transaction parameters, the transaction dependency relationship cannot be determined, or the execution results generated by the proposal node and the verification node are inconsistent, the blockchain node will fall back to the serial execution mode or the original transaction execution logic of the blockchain platform to execute or re-execute the transaction.

7. A blockchain system that performs the method of any one of claims 1-6, the blockchain system comprising a client, a proposal node, a verification node, and a system contract for storing static read-write set declaration information of a contract: The client is used to obtain the static read / write set declaration information of the contract stored on the chain based on the contract identifier, contract interface name and transaction parameters in the transaction when the user submits a smart contract call transaction, generate the corresponding conflict factor, and write the conflict factor into the transaction payload. The proposal node is used to obtain transactions to be packaged from the transaction pool, read the conflict factors in each transaction payload, construct a transaction dependency directed acyclic graph based on the state access conflict relationship between transactions, generate a grouped parallel execution plan based on the transaction dependency directed acyclic graph, and execute transactions according to the grouped parallel execution plan. The verification node is used to receive the transaction dependency directed acyclic graph, the grouped parallel execution plan and block information sent by the proposing node, and to perform transaction verification according to the same grouped parallel execution plan; The system contract is used to store the static read / write set declaration information of the smart contract, so that the client, the proposal node and the verification node can obtain the unified static read / write set declaration information of the contract.

8. A computer storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the method as described in any one of claims 1-6.

9. A deterministic parallel scheduling device for blockchain transaction execution, characterized in that, The device includes the computer storage medium of claim 8, and the device, when in operation, implements the method of any one of claims 1-6.