WO2021179809A1 - Intelligent contract caching and executing method and apparatus - Google Patents

Abstract

The embodiments of the present description provide an intelligent contract caching method and apparatus. The method is executed when a virtual machine of a blockchain node executes a first transaction, wherein the first transaction is used for calling a first function of a first contract. The method comprises: determining whether a WASM instruction sequence of the first contract is cached in a memory; when it is determined that the WASM instruction sequence of the first contract is cached in the memory, reading the WASM instruction sequence of the first contract from the memory to obtain a WASM instruction sequence of the first function; and on the basis of a data field in the first transaction, interpreting and executing the WASM instruction sequence of the first function.

Description

Method and device for caching and executing smart contract Technical field

One or more embodiments of this specification relate to the field of blockchain technology, and more specifically, to methods and devices for caching and executing smart contracts in a blockchain.

Background technique

Virtual Machine (Virtual Machine) is a complete computer system with complete hardware system functions that is simulated by software and runs in a completely isolated environment. Since the virtual machine can isolate the impact of the underlying hardware platform and operating system on the upper-layer applications, it is very beneficial to the development of the upper-layer applications. There is no need to pay attention to the details of the underlying platform in the upper-level application development process, only the specific business logic. After the development is completed, the virtual machine runs the upper-layer application and is responsible for converting the application code into code suitable for execution on the underlying platform. Specifically, in many scenarios, upper-level applications are written and developed by developers using high-level languages, and then compiled into bytecode by a compiler. Bytecode is an execution program, a binary file composed of a sequence of operation code (op code)-data pairs, which is a kind of intermediate code. Then, the interpreter in the virtual machine interprets and executes the instruction stream represented by the bytecode.

For example, in a blockchain application scenario that supports smart contracts, a virtual machine can be deployed in each node of the blockchain network. Users can write a smart contract in a high-level language, and then compile it into bytecode by a compiler, include the bytecode in the transaction that creates the smart contract, and publish it to the blockchain network, that is, deploy to the blockchain network Of each node. When the smart contract needs to be executed, the virtual machine in each node interprets and executes the bytecode.

With the emergence of the WASM language, more and more blockchains use WASM as the writing language for smart contracts. Correspondingly, the WASM virtual machine is used to execute smart contracts. WASM, or WebAssembly, is a binary instruction format designed for stack virtual machines launched by the W3C community organization, and it is a new platform-independent intermediate bytecode format. The WASM virtual machine is a stack type virtual machine in which the operands of all instructions are placed on the stack, that is, the operands are obtained from the stack for each operation, and the result is pushed onto the stack after the instruction execution ends.

In the application scenario of executing smart contracts through the WASM virtual machine of each node of the blockchain, the execution speed of the contract by the WASM virtual machine interpreter is very important to the performance of the entire system. Therefore, it is hoped that there will be an improved scheme to further improve the efficiency of the WASM virtual machine's execution of smart contracts.

Summary of the invention

The embodiments of this specification aim to provide a more effective solution for caching and executing smart contracts to solve the deficiencies in the prior art.

In order to achieve the above objective, one aspect of this specification provides a smart contract execution method, which is executed when the virtual machine of the blockchain node executes the first transaction, and the first transaction is used to call the first function of the first contract , The method includes: determining whether the WASM instruction sequence of the first contract is cached in the memory; in the case of determining that the WASM instruction sequence of the first contract is cached in the memory, reading the first contract from the memory The WASM instruction sequence of the contract to obtain the WASM instruction sequence of the first function; the WASM instruction sequence of executing the first function is interpreted based on the data field in the first transaction.

In an embodiment, the method further includes, in a case where it is determined that the WASM instruction sequence of the first contract is not cached in the memory, reading the instruction sequence of the first contract from the local storage medium of the node to Obtain the WASM instruction sequence of the first contract; and cache the WASM instruction sequence of the first contract in a memory in association with the identifier of the first contract.

In one embodiment, reading the instruction sequence of the first contract from the node local storage medium to obtain the WASM instruction sequence of the first contract includes reading the first contract's instruction sequence from the node local storage medium. The variable-length-encoded instruction sequence is obtained by decoding the variable-length-encoded instruction sequence of the first contract to obtain the WASM instruction sequence of the first contract.

In one embodiment, the method further includes, after obtaining the WASM instruction sequence of the first contract, preprocessing the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first contract, Wherein, caching the WASM instruction sequence of the first contract in association with the identifier of the first contract in the memory includes: combining the preprocessed WASM instruction sequence of the first contract with the identifier of the first contract Cached in memory associatively.

In an embodiment, preprocessing the WASM instruction sequence of the first contract includes determining the global variable identification range based on the WASM instruction sequence of the first contract; for each of the WASM instruction sequence of the first contract Instruction, parse whether the instruction is a global variable access instruction; in the case of analyzing that the instruction is a global variable access instruction, check whether the global variable identifier included in the instruction is within the scope of the global variable identifier; In the case where the global variable identifiers included in each global variable access instruction of a contract are all within the scope of the global variable identifiers, the WASM instruction sequence of the first contract that has been checked for global variable out-of-bounds checks is obtained.

In one embodiment, preprocessing the WASM instruction sequence of the first contract includes determining whether the WASM instruction sequence includes a predetermined continuous instruction, the predetermined continuous instruction is preset with a corresponding merge instruction, and the The predetermined continuous instruction and its corresponding combined instruction have the same interpretation and execution result; in the case where it is determined that the instruction sequence includes at least one group of predetermined continuous instructions, the groups of predetermined continuous instructions in the instruction sequence are respectively combined into corresponding ones The instructions are merged, thereby obtaining the fused WASM instruction sequence of the first contract.

In one embodiment, the method further includes, after associating the WASM instruction sequence of the first contract with the identifier of the first contract and caching in the memory, based on the data field in the first transaction Explain the WASM instruction sequence that executes the first function.

In one embodiment, caching the WASM instruction sequence of the first contract in association with the identifier of the first contract in the memory includes, and storing the storage address of the WASM instruction sequence of the first contract in the memory with the first The hash value of the contract address of the contract is stored in the memory in association.

Another aspect of this specification provides a smart contract execution method. The method is executed when a virtual machine of a blockchain node executes a first transaction. The first transaction is used to call a first function of the first contract. The method Including: determining whether the WASM instruction sequence of the first function is cached in the memory; in the case of determining that the WASM instruction sequence of the first function is cached in the memory, reading the WASM instruction of the first function from the memory Sequence; interpret the WASM instruction sequence to execute the first function based on the data field in the first transaction.

In one embodiment, the method further includes, in a case where it is determined that the WASM instruction sequence of the first function is not cached in the memory, reading the instruction sequence of the first contract from the local storage medium of the node , To obtain the WASM instruction sequence of the first function; and cache the WASM instruction sequence of the first function in the memory in association with the identifier of the first function.

In one embodiment, caching the WASM instruction sequence of the first function in the memory in association with the identifier of the first function includes, and the storage address of the WASM instruction sequence of the first function in the memory and The hash value of the first data is stored in the memory in association, where the first data is obtained based on the contract address of the first contract and the name of the first function.

Another aspect of this specification provides a smart contract execution device that is deployed when a virtual machine of a blockchain node executes a first transaction. The first transaction is used to call a first function of the first contract. The device It includes: a determining unit, configured to determine whether the WASM instruction sequence of the first contract is cached in the memory; a first reading unit, configured to determine that the WASM instruction sequence of the first contract is cached in the memory , Read the WASM instruction sequence of the first contract from the memory to obtain the WASM instruction sequence of the first function; the first execution unit is configured to interpret and execute the command sequence based on the data field in the first transaction Describe the WASM instruction sequence of the first function.

In an embodiment, the device further includes a second reading unit configured to read from the node local storage medium in the case that it is determined that the WASM instruction sequence of the first contract is not cached in the memory Fetch the instruction sequence of the first contract to obtain the WASM instruction sequence of the first contract; the cache unit is configured to cache the WASM instruction sequence of the first contract in association with the identifier of the first contract in the memory .

In one embodiment, the second reading unit is further configured to read the variable-length-encoded instruction sequence of the first contract from the local storage medium of the node, and pass the variable-length-encoded instruction sequence of the first contract. To decode the instruction sequence of the first contract to obtain the WASM instruction sequence of the first contract.

In one embodiment, the device further includes a preprocessing unit configured to, after obtaining the WASM instruction sequence of the first contract, perform preprocessing on the WASM instruction sequence of the first contract to obtain the experience of the first contract. The preprocessed WASM instruction sequence, wherein the cache unit is further configured to cache the preprocessed WASM instruction sequence of the first contract in association with the identifier of the first contract in the memory.

In an embodiment, the preprocessing unit includes a first determining subunit configured to determine the global variable identification range based on the WASM instruction sequence of the first contract; and the parsing subunit is configured to: For each instruction in the WASM instruction sequence of a contract, analyze whether the instruction is a global variable access instruction; the check sub-unit is configured to, in the case that the instruction is analyzed to be a global variable access instruction, check the global variables included in the instruction Whether the variable identifier is within the scope of the global variable identifier; the acquiring subunit is configured to check that the global variable identifiers included in each global variable access instruction of the first contract are all within the scope of the global variable identifier To obtain the WASM instruction sequence of the first contract that has been checked for out-of-bounds global variables.

In one embodiment, the preprocessing unit includes a second determining subunit configured to determine whether the WASM instruction sequence includes a predetermined continuous instruction, and the predetermined continuous instruction is preset with a corresponding merge instruction, And the predetermined continuous instruction and its corresponding merged instruction have the same interpretation execution result; the merge sub-unit is configured to, in the case where it is determined that the instruction sequence includes at least one group of predetermined continuous instructions, combine the instructions in the instruction sequence The groups of predetermined consecutive instructions are respectively merged into corresponding merged instructions, thereby obtaining the instruction-fused WASM instruction sequence of the first contract.

In one embodiment, the device further includes a second execution unit configured to cache the WASM instruction sequence of the first contract in association with the identification of the first contract in the memory, and based on the The data field in the first transaction interprets the WASM instruction sequence for executing the first function.

In an embodiment, the cache unit is further configured to store the storage address of the WASM instruction sequence of the first contract in the memory in association with the hash value of the contract address of the first contract in the memory.

Another aspect of this specification provides a smart contract execution device that is deployed when a virtual machine of a blockchain node executes a first transaction. The first transaction is used to call a first function of the first contract. The device It includes: a determining unit, configured to determine whether a WASM instruction sequence of the first function is cached in the memory; a first reading unit, configured to determine a situation in which the WASM instruction sequence of the first function is cached in the memory , Read the WASM instruction sequence of the first function from the memory; the execution unit is configured to interpret and execute the WASM instruction sequence of the first function based on the data field in the first transaction.

In an embodiment, the device further includes a second reading unit configured to read from the node local storage medium in the case that it is determined that the WASM instruction sequence of the first function is not cached in the memory Fetch the instruction sequence of the first contract to obtain the WASM instruction sequence of the first function; the cache unit is configured to cache the WASM instruction sequence of the first function in association with the identifier of the first function In memory.

In one embodiment, the cache unit is further configured to store the storage address of the WASM instruction sequence of the first function in the memory in association with the hash value of the first data in the memory, wherein the The first data is obtained based on the contract address of the first contract and the name of the first function.

Another aspect of this specification provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed in a computer, the computer is caused to execute any of the above-mentioned methods.

Another aspect of this specification provides a computing device, including a memory and a processor, the memory stores executable code, and when the processor executes the executable code, any one of the above methods is implemented.

In the smart contract caching and execution scheme according to the embodiments of this specification, the virtual machine caches the acquired contract's instruction sequence into the memory when the transaction is executed, so that subsequent transactions can directly read the contract's instruction sequence from the memory, and There is no need to read the instruction sequence from the node storage medium, and there is no need to repeatedly decode the encoded instruction sequence, and there is no need to repeatedly preprocess the instruction sequence, which shortens the execution time of subsequent transactions and improves system performance.

Description of the drawings

By describing the embodiments of this specification in conjunction with the accompanying drawings, the embodiments of this specification can be made clearer:

Figure 1 is a schematic diagram of the process of calling SCORE contract in the blockchain network;

Figure 2 shows a flowchart of a smart contract execution method according to an embodiment of the present specification;

Figure 3 schematically shows an example of a table that records key-value pairs of contracts and addresses;

Figure 4 shows a schematic diagram of caching and executing contract SCORE in a node;

Fig. 5 shows a flowchart of a smart contract caching method according to another embodiment of this specification;

Fig. 6 shows a flowchart of a smart contract caching method according to another embodiment of this specification;

Fig. 7 shows a flowchart of a smart contract execution method according to another embodiment of this specification;

Fig. 8 shows a smart contract execution device 800 according to an embodiment of the present specification;

Fig. 9 shows a smart contract execution device 900 according to another embodiment of the present specification.

Detailed ways

The embodiments of this specification will be described below in conjunction with the drawings.

As those skilled in the art know, the blockchain network includes several nodes, and each node can communicate with each other. In a blockchain such as a consortium chain, a user can send a transaction to any node in the blockchain through the client. The transaction can be an ordinary transfer transaction, or it can be used to create a smart contract or call a smart contract. Suppose that the user Bob of the blockchain wants to issue a smart contract Contract SCORE. The smart contract uses the following formula (1) to calculate the user's reward score s based on the user's consumption amount x and sales amount y in the platform, for example:

S=(x+y*2)*3 (1)

Bob, for example, can write the smart contract in a high-level language such as C++, and then use the compiler to convert the C++ smart contract into the following WASM instruction sequence:

It can be understood that, in order to facilitate reading, the above WASM instruction sequence is displayed in text form. In actual operation, the WASM instruction sequence is expressed in binary format, so that the above function calculation has the following form (here for simplicity, it is expressed in hexadecimal The number shows the binary code):

{20 y

41 02

6c

20 x

6a

41 03

6c}

Then, Bob can publish the transaction used to create the SCORE of the contract to any node in the blockchain through his client, so that each node in the blockchain network can obtain the bytecode of the above smart contract, so that the block Each node of the chain network can deploy the smart contract to the local medium.

In the prior art, after the contract SCORE is deployed at each node, each time a transaction that calls the contract SCORE is executed later, the above-mentioned instruction sequence of the contract SCORE must be obtained from the local medium, and the above-mentioned instruction sequence must be executed sequentially. In the case that the instruction sequence in transaction 1 is an instruction sequence encoded by leb 128, it is also necessary to perform leb 128 decoding after obtaining the instruction sequence of the contract from the medium, and then execute the instruction sequence of the contract sequentially. The process of reading and decoding the contract from the storage medium every time a transaction that calls the contract SCORE is executed greatly increases the transaction execution time.

In order to reduce the transaction execution time, in the embodiment of this specification, in the process of executing the transaction that calls the contract SCORE, the WASM virtual machine obtains the leb 128-encoded instruction sequence of the contract SCORE from the local storage medium, and the coded instruction The sequence is decoded, and the decoded instruction sequence is cached in the memory for subsequent contract calls. Therefore, in the subsequent contract call, on the one hand, the instruction sequence of the contract SCORE can be directly obtained from the memory, without the need to obtain the instruction sequence from the storage medium, thereby reducing the reading time, and on the other hand, eliminating the need for encoding The process of decoding the instruction sequence, thereby greatly reducing the contract execution time.

Figure 1 is a schematic diagram of the process of calling the function calculation in the contract SCORE in the blockchain network 100. The blockchain network 100 includes nodes A to D. The users of the blockchain can connect to any of the nodes A to D through the client. . Assuming that the blockchain user Alice wants to call the function calculation in the contract SCORE, Alice can send, for example, transaction 1 (Tx 1) to node A in the blockchain through her client to make contract calls.

Specifically, in transaction 1, the from field can be the address of the caller Alice, and the to field is the contract name and contract address of the aforementioned SCORE contract, indicating the smart contract called by the exchange. In the Data field, it contains the method or function name (calculation) in the contract to be called and the parameter value passed in (Alice's consumption amount x=50 and sales amount y=100).

After Alice publishes transaction 1 to the blockchain, each node can obtain transaction 1, and execute the function calculation in the contract SCORE through the WASM virtual machine, thereby returning the contract execution result. In one case, for example, there is no cached WASM instruction sequence of the contract SCORE in the memory of node A, so that node A obtains the encoded bytecode sequence of the contract SCORE from the local storage medium, and decodes the bytecode sequence , The decoded instruction sequence is cached in the memory, and the decoded instruction sequence is interpreted and executed, so that subsequent transactions that call the contract can directly execute the decoded instruction sequence of the contract. In another case, for example, node D has previously executed other transactions that call SCORE of the contract, so the WASM instruction sequence of the contract SCORE is cached in the local memory, so that node D is executing the transaction of the call contract SCORE At the time, get the instruction sequence of the contract SCORE from the memory, and interpret the instruction sequence of the function calculation in it.

It can be understood that FIG. 1 and the corresponding description are only illustrative, and not restrictive. For example, the blockchain network is not limited to a consortium chain network, but may also be a public chain network, and so on.

The following will describe the above smart contract caching and execution scheme in detail.

Fig. 2 shows a flowchart of a smart contract execution method according to an embodiment of the present specification. The method is executed by a WASM virtual machine of any node of the blockchain, and includes the following steps.

In step S202, it is determined whether the WASM instruction sequence of the SCORE contract is cached in the memory.

This method is executed by a virtual machine in node A or node D in FIG. 1, for example. After receiving the block including the above transaction, the node instantiates a virtual machine relative to transaction 1 to execute transaction 1. In the process of executing transaction 1, the virtual machine needs to obtain the WASM instruction sequence of the contract SCORE to execute the function calculation therein.

There are many ways to determine whether there is a WASM instruction sequence of the contract SCORE cached in the memory.

In one embodiment, the association relationship between the cached contract SCORE and the memory address of the WASM instruction sequence of the storage contract SCORE is recorded in the memory. For example, the contract address hash value of the contract SCORE is compared with the memory of the contract SCORE in the form of a table. The storage addresses are linked, so that by querying the table whether the hash value of the contract address of the contract SCORE is stored, it can be determined whether the WASM instruction sequence of the contract SCORE is cached in the memory.

In an implementation manner, the contract address of the SCORE contract can be searched in the memory to determine whether the WASM instruction sequence of the SCORE contract is cached in the memory.

Step S204, in a case where it is determined that the WASM instruction sequence of the first contract is cached in the memory, read the WASM instruction sequence of the first contract from the memory to obtain the WASM instruction sequence of the first function.

For example, in the case where node D in FIG. 1 determines that the WASM instruction sequence of contract SCORE is cached in the memory, the virtual machine set in node D can directly read the WASM instruction sequence of contract SCORE from the memory. For example, as mentioned above, when the contract address hash value of the contract SCORE stored in the table is queried, according to the table, the contract SCORE stored in the memory associated with the hash value can be read Store the address, so that the WASM instruction sequence of the contract SCORE can be read from the storage address. In another embodiment, after the contract address of the contract SCORE is searched in the memory, for example, the contract address and the contract code can be stored in association with each other in advance, so that the contract address of the contract SCORE can be found after searching The storage address of the WASM instruction sequence of the contract SCORE can be read, so that the WASM instruction sequence of the contract SCORE can be read. After obtaining the WASM instruction sequence of the contract SCORE, the instruction sequence of the function calculation can be read from the instruction sequence. For example, by searching the function name of the function calculation, the WASM of the function calculation can be found in the WASM instruction sequence of the contract SCORE Sequence of instructions.

Step S206: Interpret the WASM instruction sequence for executing the first function based on the data field in the first transaction.

After the WASM instruction sequence of the function calculation is read from the memory, the instruction sequence included in the function calculation in the contract is interpreted and executed based on the data field in the transaction 1, thereby completing the execution of the transaction 1. For example, as mentioned above, the data field of transaction 1 contains the method or function name (calculation) in the contract to be called and the parameter value passed in (Alice's consumption amount x=50 and sales amount y=100), thus Use x=50 and y=100 as the incoming parameters to execute the WASM instruction sequence of the function calculation, so that the value returned by the function is the score value.

Step S208: In the case where it is determined that the WASM instruction sequence of the contract SCORE is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the WASM instruction sequence of the first contract.

For example, when the above node A executes a transaction that calls a function in the contract SCORE (for example, transaction 1), when it is determined that there is no WASM instruction sequence of the contract SCORE in the memory, the pre-deployment can be found from the local storage medium The sequence of instructions for the contract SCORE. The node’s storage medium (for example, hard disk) stores the SCORE instruction sequence of the contract in the form of unstructured key-value pairs. For example, by searching the contract address of the contract SCORE, the contract SCORE can be found in the medium. The storage address. Or, similar to the storage in the memory, the medium stores an association table between the contract address hash value of the contract and the storage address of the contract. By searching the contract SCORE hash value of the contract address from the table, the contract SCORE can be found The storage address in the medium, so that the instruction sequence of the contract SCORE can be read from the medium.

In one embodiment, the instruction sequence of the contract SCORE stored in the storage medium is a WASM instruction sequence, so that the WASM instruction sequence of the contract SCORE can be directly read from the storage medium.

In one embodiment, the instruction sequence of the SCORE contract stored in the storage medium is encoded in a leb 128 variable-length encoding method, so as to reduce the file size and make better use of storage space. Leb 128, or "Little-Endian Base 128", is a variable-length encoding for any signed or unsigned integer. Therefore, an integer encoded with Leb128 will change the number of bytes according to the size of the number. According to the encoding method of leb 128, of the 8 bits (8 bits) of each byte, the lower 7 bits are the valid data part, and the highest bit is used to indicate whether the current byte is the last byte, and 1 means the last byte. Byte, 0 means it is not the last byte, that is, the subsequent bytes need to be continued. In this way, different numbers of bytes can be used to encode integers of different sizes.

Correspondingly, for the leb-encoded instruction sequence, when decoding the data, each byte is first restored to 8 bits, and the highest bit is used to determine whether to follow the following bytes to jointly form the target data. Therefore, if the instruction sequence is parsed and decoded, an instruction of variable length will be obtained. In order to store these instructions, variable-length instructions can be converted into memory-aligned fixed-length instructions. In this way, the WASM instruction sequence of the contract SCORE can be obtained.

In step S210, the WASM instruction sequence of the first contract and the identification of the first contract are cached in the memory in association with each other.

In an implementation manner, node A may allocate a starting address for storing the WASM instruction sequence in its memory, so that the virtual machine 1 set in node A stores the instruction sequence from the starting address. In the memory, and record the contract SCORE corresponding to the starting address in the predetermined table in the memory. The table records key-value pairs, for example, the key is, for example, the hash value of the contract address of the contract SCORE, and the value is the starting address. It is understandable that although it is described here that the hash value of the contract address of the contract SCORE is recorded in the predetermined table to identify the contract SCORE, the embodiment of this specification is not limited to this, as long as the identifier that can uniquely identify the contract SCORE is recorded in the predetermined table, For example, the contract address of the contract SCORE can also be recorded in the reservation form to identify the contract SCORE.

Fig. 3 schematically shows an example of a table for recording contract identification and address key-value pairs. As shown in Figure 3, the upper row of the table records the hash value of the contract address of each contract, and the lower row records the storage starting address of the corresponding contract in the memory. For example, the hash value of the contract address of the contract SCORE is "21c...", and the corresponding memory storage address is 300.

Therefore, by performing this cache, when node A subsequently executes other transactions that call the contract SCORE, it can find the contract address hash value "21c..." of the contract SCORE from the predetermined table in its memory, so as to obtain the contract SCORE status The storage address 300 in the memory, by accessing the address 300 in the memory, the WASM instruction sequence of the contract SCORE can be directly read, thereby speeding up the contract execution time.

In one embodiment, node A can allocate the starting address for storing the WASM instruction sequence in its memory, so that the virtual machine 1 starts the instruction sequence together with the contract address of the contract SCORE from the starting address Stored in memory. Therefore, when the contract SCORE is subsequently called, the contract SCORE can be found by searching the contract address of the contract SCORE.

After node A performs the above-mentioned caching, the above-mentioned step S206 can be performed, that is, the virtual machine 1 in node A can interpret and execute the sequence of instructions included in the function calculation in the contract SCORE based on the data field in transaction 1, so as to complete the transaction 1 Implementation.

Figure 4 shows a schematic diagram of caching and executing contract SCORE in node A. In node A, a memory 41, a CPU 42 and a storage medium 43 are included. When the transaction 1 in the transaction queue in the memory 41 that calls the function in the SCORE contract is executed, the virtual machine 1 is instantiated by the CPU 42 to execute the transaction 1. The virtual machine 1 first determines whether the WASM instruction sequence of the contract SCORE is cached in the memory 41. When it is determined that the instruction sequence is not cached in the memory 41, the virtual machine 1 obtains the leb 128-encoded instruction of the contract SCORE from the medium 43. Sequence, the encoded instruction sequence is decoded by leb 128 (not shown), and the decoded instruction sequence is cached in the memory 41, and then the corresponding function in the contract SCORE is interpreted and executed based on the function parameters in the data field of transaction 1. After the transaction 1 is executed, when the transaction 2 in the transaction queue that calls a function in the SCORE contract is executed, the virtual machine 2 is instantiated by the CPU 42 to execute the transaction 2. Similarly, the virtual machine 2 first determines whether the WASM instruction sequence of the contract SCORE is cached in the memory 41. When it is determined that the instruction sequence is cached in the memory, the WASM instruction sequence is read and based on the data field of transaction 2. The function parameter executes the WASM instruction sequence of the corresponding function. Therefore, after the WASM instruction sequence of the contract SCORE is cached when transaction 1 is executed, it is no longer necessary to read the contract SCORE from the medium 43 when executing other transactions that call functions in the contract SCORE, and there is no need to repeat leb 128 decoding. , Thereby shortening the execution time of subsequent transactions and improving system performance.

Figure 5 shows a flow chart of a smart contract caching method according to another embodiment of this specification. The method is executed when a virtual machine of any node in the blockchain executes a transaction for calling a function in the contract SCORE. The method includes Steps S502 to S510.

In step S502, it is determined whether the WASM instruction sequence of the contract SCORE is cached in the memory.

In step S504, in the case where it is determined that there is no WASM instruction sequence of the contract SCORE cached in the memory, the instruction sequence of the contract SCORE is read from the local storage medium of the node to obtain the WASM instruction sequence of the contract SCORE.

For steps S502 and S504, reference may be made to the above description of steps S202 and S204, which will not be described in detail here.

Step S506: Determine whether the WASM instruction sequence includes a predetermined continuous instruction, the predetermined continuous instruction is preset with a corresponding combined instruction, and the predetermined continuous instruction and its corresponding combined instruction have the same interpretation execution result.

The predetermined continuous instruction is a number of predetermined continuous instructions that can be combined. For such predetermined continuous instructions, a corresponding combined instruction and a machine code corresponding to the combined instruction have been set in advance, and the machine code is executing After that, the corresponding consecutive instructions have the same execution result.

For example, for the instruction sequence of the above function calculation, a combined instruction “i32.mul y, const 2” can be preset relative to the continuous instruction “get_local y/i32.const 2/i32.mul”. Similarly, the combined instruction actually The middle is a binary code, and a binary code that is not used in the WASM instruction set can be selected to represent the combined instruction. At the same time, in the interpreter of the virtual machine, a machine code (machine code) corresponding to the combined instruction is preset, and the corresponding operation of the machine code is to obtain the value of parameter y, and compare the value of parameter y with 2. Multiply and push the product into the stack, where the value of the parameter y can be obtained from the data in the transaction that calls the SCORE contract. It can be seen that the operation result of the machine code corresponding to the combined instruction is the same as the execution result of the machine code corresponding to the three consecutive instructions, and the product of the value of the parameter y and 2 is pushed onto the stack.

In addition, a combined instruction "i32.add x" can be preset relative to the continuous instruction "get_local x/i32.add", and at the same time, the machine code corresponding to the combined instruction is preset in the interpreter of the virtual machine , The corresponding operation of this machine code is to pop the latest value from the stack, get the value of parameter x, add the popped value to the value of parameter x, and push the result of the addition into the stack, where Get the value of x from the transaction data of the call contract SCORE. It can be seen that the operation result of the machine code corresponding to the combined instruction is the same as the execution result of the machine code corresponding to the two consecutive instructions, both of which are the result of adding the product and the value of the parameter x to the stack.

In addition, a combined instruction “i32.mul const 3” can be preset relative to the continuous instruction “i32.const 3/i32.mul”, and at the same time, the virtual machine interpreter is preset to correspond to the combined instruction The machine code corresponding to the machine code is to pop the latest value from the stack, multiply the popped value by 3, and push the product into the stack. It can be seen that the operation result of the machine code corresponding to the combined instruction is the same as the execution result of the machine code corresponding to the two consecutive instructions. Both the result of the above addition and the product of 3 are pushed into the stack, and the final push is The value in the stack is the return value of the function.

As can be seen from the above example, in the predetermined consecutive instructions, each instruction has a certain correlation. For example, for the continuous instruction "get_local y/i32.const 2/i32.mul", the last instruction i32.mul will use the obtained value (y) or immediate value (ie constant 2) of the previous two instructions.

Step S508: In a case where it is determined that the instruction sequence includes at least one group of predetermined continuous instructions, the groups of predetermined continuous instructions in the instruction sequence are respectively merged into corresponding merged instructions, so as to obtain the final instruction of the contract SCORE. Converged WASM instruction sequence.

For example, in the above step S506, it has been determined that the instruction sequence includes three sets of predetermined consecutive instructions, so that the three sets of instructions can be merged into corresponding merged instructions respectively, that is, the merged WASM instruction sequence is:

{i32.mul y const 2

i32.add x

i32.mul const 3

}.

In step S510, the WASM instruction sequence of the contract SCORE, which is fused with instructions, is cached in the memory in association with the contract SCORE identifier.

For this step, reference may be made to the above description of step S206, which will not be repeated here.

After executing transaction 1 to cache the instruction sequence of the contract SCORE that is fused with instructions, it is no longer necessary to read the contract SCORE from the storage medium when executing the transaction that calls the function in the contract SCORE, and there is no need to repeat leb 128 Decoding does not require repeated instruction fusion, thereby shortening the execution time of subsequent transactions and improving system performance. By executing the WASM instruction sequence of instruction fusion, the execution time of the transaction can be further reduced.

Fig. 6 shows a flowchart of a smart contract caching method according to another embodiment of the present specification. The method is executed when a virtual machine of any node in the blockchain executes a transaction for calling a function in the contract SCORE2. The method includes Steps S602 to S612.

Step S602: Determine whether the WASM instruction sequence of the contract SCORE2 is cached in the memory.

Step S604, in the case that it is determined that the WASM instruction sequence of the contract SCORE2 is not cached in the memory, read the instruction sequence of the contract SCORE2 from the local storage medium of the node to obtain the WASM instruction sequence of the contract SCORE2.

For steps S602 and S604, reference may be made to the above description of steps S202 and S204, which will not be described in detail here.

Assume that the WASM instruction sequence of the contract SCORE2 obtained is:

Step S606: Determine the global variable identification range based on the WASM instruction sequence of the contract SCORE2.

Refer to the WASM instruction sequence of the aforementioned contract SCORE2, after the virtual machine obtains the instruction sequence, by reading each instruction one by one, it can know how many global variables are included in the instruction sequence, that is, global variables 0 to 7, a total of 8 global variables , So the variable subscripts assigned to these global variables are 0-7 respectively, that is, the global variable identification range is 0-7.

Step S608: For each instruction in the WASM instruction sequence of the contract SCORE2, analyze whether the instruction is a global variable access instruction.

For example, when parsed to "get_global 0" in line 4 of contract SCORE2, it can be parsed that the instruction is a global variable read instruction. Global variable access instructions are not limited to global variable read instructions, but also include global variable write instructions, for example, "set_global 1".

Step S610, in the case where the instruction is resolved to be a global variable access instruction, check whether the global variable identifier included in the instruction is within the scope of the global variable identifier.

For example, for the global variable read command get_global 0 in the contract SCORE2, it is to check whether the variable subscript "0" is within the range 0-7 of the global variable identification. Obviously, 0 is within the range 0-7.

Assuming that in addition to the above global variable read instruction, the contract SCORE2 also includes the global variable write instruction "set_global 10". Obviously, the variable subscript "10" in this instruction exceeds the global variable identification range 0-7 obtained by the virtual machine. Therefore, the variable index of the global variable write instruction is out of bounds, that is, the contract SCORE2 includes an incorrect instruction. In this case, the execution of the transaction will be withdrawn.

Step S612, when checking that the contract SCORE2 does not include a global variable access instruction, or checking that the global variable identifiers included in each global variable access instruction of the contract SCORE2 are all within the scope of the global variable identifiers In the above, the WASM instruction sequence of the contract SCORE2 that has passed the cross-border check is cached in the memory in association with the identifier of the contract SCORE2.

After the execution of the transaction, the cache of the instruction sequence of the contract SCORE2 that has passed the cross-border check, subsequent transactions that call the function in the contract SCORE2 no longer need to read the contract SCORE2 from the storage medium, and there is no need to repeat the leb 128 decoding, there is no need to repeat the out-of-bounds check, which shortens the execution time of subsequent transactions and improves the system performance. By performing the out-of-bounds check on the WASM instruction sequence in the static analysis stage in the virtual machine, the WASM instruction is executed in the interpretation During the sequence, the program execution time can be greatly reduced and the program execution speed can be accelerated.

The methods shown in Figures 5 and 6 are just two examples of preprocessing the WASM instruction sequence of the contract before caching the contract. In practice, before caching, various requirements can be performed on the WASM instruction sequence of the contract according to specific scenarios. The preprocessing is not listed here.

Fig. 7 shows a flow chart of a smart contract execution method according to another embodiment of this specification. The method is executed when the virtual machine of the blockchain node executes the first transaction, and the first transaction is used to call the first contract. The method includes steps S702 to S706.

Step S702: Determine whether the WASM instruction sequence of the first function is cached in the memory.

In one embodiment, the correlation between the function calculation of the cached contract SCORE and the memory storage address of the WASM instruction sequence storing the function calculation is recorded in the memory, for example, the contract address of the contract SCORE and the function calculation are included in the form of a table. The hash value of the data of the function name is associated with the memory storage address of the function calculation. Thus, by querying whether the hash value corresponding to the function calculation is stored in the table, it can be determined whether the WASM of the function calculation is cached in the memory Sequence of instructions.

In one embodiment, the contract address of the contract SCORE can be searched in the memory to determine whether the WASM instruction sequence of the contract SCORE is cached in the memory, so as to determine whether the WASM instruction sequence of the function calculation is cached.

Step S704, in the case where it is determined that the WASM instruction sequence of the first function is cached in the memory, read the WASM instruction sequence of the first function from the memory.

In one embodiment, as described above, after the hash value corresponding to the function calculation is queried in the table, according to the table, the function calculation stored in association with the hash value can be read. The storage address in the memory, from which the WASM instruction sequence of the function calculation can be read from the storage address.

In another embodiment, after the contract address of the contract SCORE is searched in the memory, for example, the contract address and the contract code can be stored in association with each other in advance, so that the contract address of the contract SCORE can be found after searching The storage address of the WASM instruction sequence of the contract SCORE, by searching the name of the function calculation from the storage address, the WASM instruction sequence of the function calculation can be read.

Step S706: Interpret the WASM instruction sequence for executing the first function based on the data field in the first transaction.

For this step, reference may be made to the above description of step S206, which will not be described in detail here.

Step S708, in the case where it is determined that the WASM instruction sequence of the first function is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the WASM of the first function Sequence of instructions.

For reading the instruction sequence of the first contract from the local storage medium of the node, reference may be made to the above description of step S208, which will not be described in detail here. After obtaining the instruction sequence of the first contract, the WASM instruction sequence of each function in the contract can be obtained. For example, the first contract includes not only the WASM instruction sequence of the above function calculation, but may also include the WASM instruction sequence of the function calculation2. For example, the function calculation is used to calculate the scores of users in the platform, and the function calculation2 is used to calculate the scores of merchants in the platform. They may have different calculation formulas and thus different WASM instruction sequences. In the process of executing a transaction, part of the transaction calls the function calculation to calculate the user's score, and part of the transaction calls the function calculation2 to calculate the merchant's score. Therefore, after obtaining the WASM instruction sequence of the contract SCORE, the WASM instruction sequence of each function included in it can be obtained to cache these functions in the memory for the transaction to call.

Step S710: Cache the WASM instruction sequence of the first function in the memory in association with the identifier of the first function.

In an embodiment, the storage address of the WASM instruction sequence of the first function in the memory is stored in the memory in association with the hash value of the first data, wherein the first data is based on the first contract's Get the contract address and the name of the first function. For example, the first data is obtained by splicing the contract address of the first contract and the name of the first function together, or calculating the contract address of the first contract and the name of the first function based on a predetermined formula, etc. . Specifically, the above-mentioned association relationship may be stored in a table similar to the table shown in FIG. 3, the table for example records key-value pairs, the key is, for example, the hash value of the first data, and the value is the start address.

In one embodiment, the node may store the WASM instruction sequence of the contract SCORE and the contract address of the contract SCORE into the memory starting from the starting address. Therefore, when the function calculation is subsequently called, the WASM instruction sequence of the function calculation can be found by searching the contract address of the contract SCORE and the function name of the function calculation.

In the case that the contract SCORE includes multiple functions, for example, it also includes the function calculation2. For the function calculation2, the same processing as the function calculation is also performed, so that subsequent transactions that call the function calculation2 can be directly read from the memory to the WASM of the function calculation2 Sequence of instructions.

Fig. 8 shows a smart contract execution device 800 according to an embodiment of the present specification. The device is deployed when a virtual machine of a blockchain node executes a first transaction, and the first transaction is used to call the first contract of the first contract. A function, the device includes the following units.

The determining unit 81 is configured to determine whether the WASM instruction sequence of the first contract is cached in the memory.

The first reading unit 82 is configured to, when it is determined that the WASM instruction sequence of the first contract is cached in the memory, read the WASM instruction sequence of the first contract from the memory to obtain the first The WASM instruction sequence of the function.

The first execution unit 83 is configured to interpret and execute the WASM instruction sequence of the first function based on the data field in the first transaction.

In an embodiment, the device further includes a second reading unit 84 configured to, in a case where it is determined that the WASM instruction sequence of the first contract is not cached in the memory, from the node local storage medium Read the instruction sequence of the first contract to obtain the WASM instruction sequence of the first contract.

The cache unit 85 is configured to cache the WASM instruction sequence of the first contract in the memory in association with the identifier of the first contract.

In one embodiment, the second reading unit 84 is further configured to read the variable-length-encoded instruction sequence of the first contract from the local storage medium of the node, and pass the variable-length-encoded instruction sequence of the first contract. The encoded instruction sequence is decoded to obtain the WASM instruction sequence of the first contract.

In an embodiment, the device 800 further includes a preprocessing unit 86 configured to, after obtaining the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the first contract The pre-processed WASM instruction sequence of the first contract, wherein the cache unit 85 is further configured to cache the pre-processed WASM instruction sequence of the first contract in the memory in association with the identifier of the first contract.

In one embodiment, the preprocessing unit 86 includes a first determining subunit 861 configured to determine a global variable identification range based on the WASM instruction sequence of the first contract; and a parsing subunit 862 configured to Each instruction in the WASM instruction sequence of the first contract analyzes whether the instruction is a global variable access instruction; the checking subunit 863 is configured to check the Whether the global variable identifier included in the instruction is within the scope of the global variable identifier; the obtaining subunit 864 is configured to check that the global variable identifiers included in each global variable access instruction of the first contract are all in the global variable identifier In the case of being within the range, obtain the WASM instruction sequence of the first contract that has been checked for out-of-bounds global variables.

In one embodiment, the preprocessing unit includes a second determining subunit 865 configured to determine whether the WASM instruction sequence includes a predetermined continuous instruction, and the predetermined continuous instruction is preset with a corresponding merge instruction , And the predetermined continuous instruction and its corresponding merged instruction have the same interpretation execution result; the merge subunit 866 is configured to, in the case where it is determined that the instruction sequence includes at least one set of predetermined continuous instructions, combine the instruction sequence The groups of predetermined consecutive instructions in the, respectively, are merged into corresponding merged instructions, so as to obtain the instruction-fused WASM instruction sequence of the first contract.

In one embodiment, the device 800 further includes a second execution unit 87 configured to, after associating the WASM instruction sequence of the first contract with the identifier of the first contract and caching in the memory, Interpret the WASM instruction sequence for executing the first function based on the data field in the first transaction.

In one embodiment, the cache unit 85 is further configured to store the storage address of the WASM instruction sequence of the first contract in the memory in association with the hash value of the contract address of the first contract in the memory.

FIG. 9 shows a smart contract execution device 900 according to another embodiment of this specification. The device is deployed when a virtual machine of a blockchain node executes a first transaction, and the first transaction is used to call the first contract. The first function, the device includes: a determining unit 91 configured to determine whether the WASM instruction sequence of the first function is cached in the memory; the first reading unit 92 is configured to cache the In the case of the WASM instruction sequence of the first function, read the WASM instruction sequence of the first function from the memory; the execution unit 93 is configured to execute the first function based on the interpretation of the data field in the first transaction The WASM instruction sequence.

In one embodiment, the device further includes a second reading unit 94 configured to, in a case where it is determined that the WASM instruction sequence of the first function is not cached in the memory, from the local storage medium of the node Read the instruction sequence of the first contract to obtain the WASM instruction sequence of the first function; the cache unit 95 is configured to associate the WASM instruction sequence of the first function with the identifier of the first function Cached in memory.

In one embodiment, the caching unit 95 is further configured to store the storage address of the WASM instruction sequence of the first function in the memory and the hash value of the first data in the memory in association with each other. The first data is obtained based on the contract address of the first contract and the name of the first function.

Another aspect of this specification provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed in a computer, the computer is caused to execute any of the above-mentioned methods.

Another aspect of this specification provides a computing device, including a memory and a processor, the memory stores executable code, and when the processor executes the executable code, any one of the above methods is implemented.

In the smart contract caching and execution scheme according to the embodiments of this specification, the virtual machine caches the acquired contract's instruction sequence into the memory when the transaction is executed, so that subsequent transactions can directly read the contract's instruction sequence from the memory, and There is no need to read the instruction sequence from the storage medium, and there is no need to repeatedly decode the encoded instruction sequence. In addition, there is no need to repeatedly preprocess the contract instruction sequence when executing the transaction that calls the contract, which shortens subsequent transactions. The execution time has improved system performance.

It needs to be understood that the descriptions of "first", "second", etc. in this article are only used to distinguish similar concepts for the sake of simplicity of description, and do not have other limiting effects.

The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other, and each embodiment focuses on the difference from other embodiments. In particular, as for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and for related parts, please refer to the part of the description of the method embodiment.

The foregoing describes specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps described in the claims can be performed in a different order than in the embodiments and still achieve desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or sequential order shown in order to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

Those of ordinary skill in the art should be further aware that the units and algorithm steps of the examples described in the embodiments disclosed herein can be implemented by electronic hardware, computer software or a combination of the two, in order to clearly illustrate the hardware For the interchangeability with software, the composition and steps of each example have been described generally in terms of function in the above description. Whether these functions are executed by hardware or software depends on the specific application and design constraint conditions of the technical solution. A person of ordinary skill in the art can use different methods for each specific application to implement the described functions, but such implementation should not be considered beyond the scope of the present application. Among them, the software module can be placed in random access memory (RAM), memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, register, hard disk, removable disk, CD-ROM, or technical fields Any other form of storage medium known within.

The specific embodiments described above further describe the purpose, technical solutions and beneficial effects of the present invention in detail. It should be understood that the above are only specific embodiments of the present invention, and are not intended to limit the scope of the present invention. The scope of protection, any modification, equivalent replacement, improvement, etc., made within the spirit and principle of the present invention shall be included in the scope of protection of the present invention.

Claims (18)

1. A smart contract execution method, the method is executed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the method includes:

   Determining whether the WASM instruction sequence of the first contract is cached in the memory;

   In the case of determining that the WASM instruction sequence of the first contract is cached in the memory, read the WASM instruction sequence of the first contract from the memory to obtain the WASM instruction sequence of the first function; A data field in a transaction interprets the WASM instruction sequence for executing the first function;

   In the case of determining that the WASM instruction sequence of the first contract is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the WASM instruction sequence of the first contract; After the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first contract; The WASM instruction sequence is cached in the memory in association with the identifier of the first contract;

   Wherein, preprocessing the WASM instruction sequence of the first contract includes:

   Determining the global variable identification range based on the WASM instruction sequence of the first contract;

   For each instruction in the WASM instruction sequence of the first contract, analyze whether the instruction is a global variable access instruction;

   In the case where the instruction is resolved to be a global variable access instruction, checking whether the global variable identifier included in the instruction is within the scope of the global variable identifier;

   In the case where it is checked that the global variable identifiers included in each global variable access instruction of the first contract are all within the scope of the global variable identifiers, obtain the WASM instruction sequence of the first contract that has been checked for out-of-bounds global variables.
2. A smart contract execution method, the method is executed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the method includes:

   Determining whether the WASM instruction sequence of the first contract is cached in the memory;

   In the case of determining that the WASM instruction sequence of the first contract is cached in the memory, read the WASM instruction sequence of the first contract from the memory to obtain the WASM instruction sequence of the first function; A data field in a transaction interprets the WASM instruction sequence for executing the first function;

   In the case of determining that the WASM instruction sequence of the first contract is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the WASM instruction sequence of the first contract; After the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first contract; The WASM instruction sequence is cached in the memory in association with the identifier of the first contract;

   Wherein, preprocessing the WASM instruction sequence of the first contract includes:

   Determining whether a predetermined continuous instruction is included in the WASM instruction sequence, the predetermined continuous instruction is preset with a corresponding combined instruction, and the predetermined continuous instruction and its corresponding combined instruction have the same interpretation execution result;

   In the case where it is determined that the instruction sequence includes at least one group of predetermined continuous instructions, each group of predetermined continuous instructions in the instruction sequence is respectively merged into corresponding merged instructions, so as to obtain the instruction-fused instruction of the first contract WASM instruction sequence.
3. The method according to claim 1 or 2, wherein reading the instruction sequence of the first contract from the node local storage medium to obtain the WASM instruction sequence of the first contract comprises: reading from the node local storage medium Take the variable-length-encoded instruction sequence of the first contract, and obtain the WASM instruction sequence of the first contract by decoding the variable-length-encoded instruction sequence of the first contract.
4. The method according to claim 1 or 2, further comprising, after associating the preprocessed WASM instruction sequence of the first contract with the identification of the first contract and caching in the memory, based on the first The data field in the transaction interprets the WASM instruction sequence for executing the first function.
5. The method according to claim 1 or 2, wherein the pre-processed WASM instruction sequence of the first contract and the identification of the first contract are cached in memory in association with the method comprising: The storage address of the preprocessed WASM instruction sequence in the memory is stored in the memory in association with the hash value of the contract address of the first contract.
6. A smart contract execution method, the method is executed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the method includes:

   Determining whether the WASM instruction sequence of the first function is cached in the memory;

   In the case of determining that the WASM instruction sequence of the first function is cached in the memory, read the WASM instruction sequence of the first function from the memory; interpret and execute the first function based on the data field in the first transaction. The WASM instruction sequence of the function;

   In a case where it is determined that the WASM instruction sequence of the first function is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the WASM instruction sequence of the first function; After acquiring the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first function; The processed WASM instruction sequence is cached in the memory in association with the identifier of the first function;

   Wherein, preprocessing the WASM instruction sequence of the first contract includes:

   Determining the global variable identification range based on the WASM instruction sequence of the first contract;

   For each instruction in the WASM instruction sequence of the first contract, analyze whether the instruction is a global variable access instruction;

   In the case where the instruction is resolved to be a global variable access instruction, checking whether the global variable identifier included in the instruction is within the scope of the global variable identifier;

   In the case where it is checked that the global variable identifiers included in each global variable access instruction of the first contract are all within the scope of the global variable identifiers, obtain the WASM instruction sequence of the first contract that has been checked for out-of-bounds global variables.
7. A smart contract execution method, the method is executed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the method includes:

   Determining whether the WASM instruction sequence of the first function is cached in the memory;

   In the case of determining that the WASM instruction sequence of the first function is cached in the memory, read the WASM instruction sequence of the first function from the memory; interpret and execute the first function based on the data field in the first transaction. The WASM instruction sequence of the function;

   In a case where it is determined that the WASM instruction sequence of the first function is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the WASM instruction sequence of the first function; After acquiring the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first function; The processed WASM instruction sequence is cached in the memory in association with the identifier of the first function;

   Wherein, preprocessing the WASM instruction sequence of the first contract includes:

   Determining whether a predetermined continuous instruction is included in the WASM instruction sequence, the predetermined continuous instruction is preset with a corresponding combined instruction, and the predetermined continuous instruction and its corresponding combined instruction have the same interpretation execution result;

   In the case where it is determined that the instruction sequence includes at least one group of predetermined continuous instructions, each group of predetermined continuous instructions in the instruction sequence is respectively merged into corresponding merged instructions, so as to obtain the instruction-fused instruction of the first contract WASM instruction sequence.
8. The method according to claim 6 or 7, wherein caching the preprocessed WASM instruction sequence of the first function in association with the identifier of the first function in the memory comprises: The storage address of the preprocessed WASM instruction sequence in the memory is stored in the memory in association with the hash value of the first data, where the first data is obtained based on the contract address of the first contract and the name of the first function.
9. A smart contract execution device, the device is deployed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the device includes:

   The determining unit is configured to determine whether the WASM instruction sequence of the first contract is cached in the memory;

   The first reading unit is configured to, when it is determined that the WASM instruction sequence of the first contract is cached in the memory, read the WASM instruction sequence of the first contract from the memory to obtain the first function The WASM instruction sequence;

   The first execution unit is configured to interpret and execute the WASM instruction sequence of the first function based on the data field in the first transaction;

   The second reading unit is configured to, in a case where it is determined that the WASM instruction sequence of the first contract is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the first contract. A WASM command sequence of the contract;

   The preprocessing unit is configured to, after obtaining the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first contract;

   A cache unit configured to cache the preprocessed WASM instruction sequence of the first contract in association with the identifier of the first contract in the memory;

   Wherein, the preprocessing unit includes:

   The first determining subunit is configured to determine the global variable identification range based on the WASM instruction sequence of the first contract;

   The parsing subunit is configured to, for each instruction in the WASM instruction sequence of the first contract, analyze whether the instruction is a global variable access instruction;

   The checking subunit is configured to check whether the global variable identifier included in the instruction is within the scope of the global variable identifier when the instruction is parsed as a global variable access instruction;

   The obtaining sub-unit is configured to obtain the global variable out-of-bounds of the first contract when it is checked that the global variable identifiers included in each global variable access instruction of the first contract are all within the scope of the global variable identifiers Check the sequence of WASM instructions.
10. A smart contract execution device, the device is deployed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the device includes:

    The determining unit is configured to determine whether the WASM instruction sequence of the first contract is cached in the memory;

    The first reading unit is configured to, when it is determined that the WASM instruction sequence of the first contract is cached in the memory, read the WASM instruction sequence of the first contract from the memory to obtain the first function The WASM instruction sequence;

    The first execution unit is configured to interpret and execute the WASM instruction sequence of the first function based on the data field in the first transaction;

    The second reading unit is configured to, in a case where it is determined that the WASM instruction sequence of the first contract is not cached in the memory, read the instruction sequence of the first contract from the local storage medium of the node to obtain the first contract. A WASM command sequence of the contract;

    The preprocessing unit is configured to, after obtaining the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first contract;

    A cache unit configured to cache the preprocessed WASM instruction sequence of the first contract in association with the identifier of the first contract in the memory;

    Wherein, the preprocessing unit includes:

    The second determining subunit is configured to determine whether a predetermined continuous instruction is included in the WASM instruction sequence, the predetermined continuous instruction is preset with a corresponding merge instruction, and the predetermined continuous instruction and its corresponding merge instruction have the same Interpret the results of the implementation;

    The merging subunit is configured to, in a case where it is determined that the instruction sequence includes at least one set of predetermined continuous instructions, merge each set of predetermined continuous instructions in the instruction sequence into corresponding merged instructions, thereby obtaining the first set of continuous instructions. A sequence of WASM instructions fused with instructions for a contract.
11. The device according to claim 9 or 10, wherein the second reading unit is further configured to read the variable-length-encoded instruction sequence of the first contract from the local storage medium of the node, and pass the first contract The variable-length-encoded instruction sequence is decoded to obtain the WASM instruction sequence of the first contract.
12. The device according to claim 9 or 10, further comprising a second execution unit configured to cache the pre-processed WASM instruction sequence of the first contract in association with the identification of the first contract in a memory After processing, the WASM instruction sequence for executing the first function is interpreted based on the data field in the first transaction.
13. The device according to claim 9 or 10, wherein the caching unit is further configured to combine the storage address of the pre-processed WASM instruction sequence of the first contract in the memory with the hash of the contract address of the first contract. Hope values are stored in memory associatively.
14. A smart contract execution device, the device is deployed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the device includes:

    The determining unit is configured to determine whether the WASM instruction sequence of the first function is cached in the memory;

    The first reading unit is configured to read the WASM instruction sequence of the first function from the memory when it is determined that the WASM instruction sequence of the first function is cached in the memory;

    The execution unit is configured to interpret and execute the WASM instruction sequence of the first function based on the data field in the first transaction;

    The second reading unit is configured to read the instruction sequence of the first contract from the local storage medium of the node in the case where it is determined that the WASM instruction sequence of the first function is not cached in the memory to obtain all The WASM instruction sequence of the first function;

    The preprocessing unit is configured to, after obtaining the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first function;

    A cache unit configured to cache the preprocessed WASM instruction sequence of the first function in association with the identifier of the first function in the memory;

    Wherein, the preprocessing unit includes:

    The first determining subunit is configured to determine the global variable identification range based on the WASM instruction sequence of the first contract;

    The parsing subunit is configured to, for each instruction in the WASM instruction sequence of the first contract, analyze whether the instruction is a global variable access instruction;

    The checking subunit is configured to check whether the global variable identifier included in the instruction is within the scope of the global variable identifier when the instruction is parsed as a global variable access instruction;

    The obtaining sub-unit is configured to obtain the global variable out-of-bounds of the first contract when it is checked that the global variable identifiers included in each global variable access instruction of the first contract are all within the scope of the global variable identifiers Check the sequence of WASM instructions.
15. A smart contract execution device, the device is deployed when a virtual machine of a blockchain node executes a first transaction, the first transaction is used to call a first function of the first contract, and the device includes:

    The determining unit is configured to determine whether the WASM instruction sequence of the first function is cached in the memory;

    The first reading unit is configured to read the WASM instruction sequence of the first function from the memory when it is determined that the WASM instruction sequence of the first function is cached in the memory;

    The execution unit is configured to interpret and execute the WASM instruction sequence of the first function based on the data field in the first transaction;

    The second reading unit is configured to read the instruction sequence of the first contract from the local storage medium of the node in the case where it is determined that the WASM instruction sequence of the first function is not cached in the memory to obtain all The WASM instruction sequence of the first function;

    The preprocessing unit is configured to, after obtaining the WASM instruction sequence of the first contract, preprocess the WASM instruction sequence of the first contract to obtain the preprocessed WASM instruction sequence of the first function;

    A cache unit configured to cache the preprocessed WASM instruction sequence of the first function in association with the identifier of the first function in the memory;

    Wherein, the preprocessing unit includes:

    The second determining subunit is configured to determine whether a predetermined continuous instruction is included in the WASM instruction sequence, the predetermined continuous instruction is preset with a corresponding merge instruction, and the predetermined continuous instruction and its corresponding merge instruction have the same Interpret the results of the implementation;

    The merging subunit is configured to, in a case where it is determined that the instruction sequence includes at least one set of predetermined continuous instructions, merge each set of predetermined continuous instructions in the instruction sequence into corresponding merged instructions, thereby obtaining the first set of continuous instructions. A sequence of WASM instructions fused with instructions for a contract.
16. The device according to claim 14 or 15, wherein the cache unit is further configured to associate the storage address of the preprocessed WASM instruction sequence of the first function in the memory with the hash value of the first data The first data is obtained based on the contract address of the first contract and the name of the first function.
17. A computer-readable storage medium having a computer program stored thereon, and when the computer program is executed in a computer, the computer is caused to execute the method of any one of claims 1-8.
18. A computing device, comprising a memory and a processor, the memory is stored with executable code, and when the processor executes the executable code, the method according to any one of claims 1-8 is implemented.

Images