WO2022140947A1

WO2022140947A1 - Smart contract deployment method and apparatus, smart contract execution method and apparatus, and terminal device

Info

Publication number: WO2022140947A1
Application number: PCT/CN2020/140281
Authority: WO
Inventors: 邱炜伟; 李伟; 黄方蕾; 张珂杰; 何奇
Original assignee: 杭州趣链科技有限公司
Priority date: 2020-12-28
Filing date: 2020-12-28
Publication date: 2022-07-07

Abstract

A smart contract deployment method and apparatus, a smart contract execution method and apparatus, a terminal device, and a storage medium. The deployment method comprises: when a request instruction for deploying a smart contract is received, reading a bytecode instruction in the smart contract in sequence (S101); when the read bytecode instruction in the smart contract is a boundary instruction, calculating first consumption of a program block corresponding to the boundary instruction, wherein the boundary instruction comprises a start instruction and an end instruction that indicate that the bytecode instruction is a branch execution instruction or a loop execution instruction (S102); associating the first consumption with a preset instruction to obtain an execution consumption calculation bytecode of the program block corresponding to the boundary instruction (S103); and storing the execution consumption calculation bytecode in association with the boundary instruction, so that the execution consumption calculation bytecode is executed in the process of executing the boundary instruction of the smart contract to obtain first execution consumption of the program block corresponding to the boundary instruction (S104). According to the method, in the execution process of the smart contract, first execution consumption is calculated directly according to the execution consumption calculation bytecode associated with the first consumption in the deployment stage, and resource consumption can be quickly and efficiently measured.

Description

Deployment method, execution method, device and terminal device of smart contract

technical field

The present application belongs to the field of computer technology, and in particular, relates to a deployment method, execution method, device and terminal equipment of a smart contract.

Background technique

With the rapid development of computer technology, smart contracts have been used more and more. Smart contracts are event-driven, stateful, run on a replicated and shareable ledger, and can keep assets on the ledger. The program, that is, a smart contract is a programmed contract that is automatically executed when preset conditions are met, such as smart contracts that can be deployed in a blockchain system.

Usually in the process of executing a smart contract, the bytecode of the smart contract can be loaded and run by a virtual machine. When executing the bytecode of the smart contract, there will be execution consumption (ie gas). Gas is the computing resource required to provide computing power for the smart contract. The current measurement method for the execution consumption of the bytecode of the smart contract is inefficient.

technical problem

One of the purposes of the embodiments of the present application is to provide a smart contract deployment method, execution method, device, terminal device and storage medium, aiming to solve the low efficiency of the existing measurement method for the execution consumption of the bytecode of the smart contract The problem.

technical solutions

In order to solve the above-mentioned technical problems, the technical solutions adopted in the embodiments of the present application are:

In a first aspect, an embodiment of the present application provides a method for deploying a smart contract, including:

When receiving the request instruction for deploying the smart contract, read the bytecode instructions in the smart contract in sequence;

When the read bytecode instruction in the smart contract is a boundary instruction, calculate the first consumption of the program block corresponding to the boundary instruction; wherein, the boundary instruction includes indicating that the bytecode instruction is a branch execution instruction or a loop Execute the start command and end command of the command;

Associating the first consumption with a preset instruction to obtain the execution consumption calculation bytecode of the program block corresponding to the boundary instruction;

storing the execution consumption calculation bytecode in association with the boundary instruction, so that in the process of executing the boundary instruction, the smart contract executes the execution consumption calculation bytecode to obtain a program corresponding to the boundary instruction the first execution consumption of the block;

When all bytecode instructions in the smart contract are read, it is determined that the bytecode instructions of the smart contract have been processed.

In one embodiment, when the read bytecode instruction in the smart contract is a boundary instruction, calculating the first consumption of the program block corresponding to the boundary instruction includes:

When the read bytecode instruction in the smart contract is a boundary instruction, the execution consumption of each instruction in the program block corresponding to the boundary instruction is accumulated to obtain the first consumption.

In one embodiment, the execution consumption calculation bytecode is stored in association with the boundary instruction, so that the smart contract executes the execution consumption calculation bytecode in the process of executing the boundary instruction Obtaining the first execution consumption of the program block corresponding to the boundary instruction includes: storing the execution consumption calculation bytecode in association with the boundary instruction, so that during the execution process of the smart contract, every time it detects that the execution starts When the boundary instruction is executed once, the first consumption associated with the boundary instruction is accumulated to the first execution consumption, so as to update the first execution consumption;

Wherein, the first consumption is the consumption required for one execution of the boundary instruction calculated and stored when the smart contract is deployed, and the first execution consumption is the consumption according to the boundary instruction when the smart contract is executed The number of executions of and the total execution consumption of the program block corresponding to the boundary instruction of the first consumption calculation.

In a second aspect, the embodiments of the present application provide a method for executing a smart contract, including:

When receiving a request instruction to execute a deployed smart contract, obtain the instruction consumption threshold;

When the currently executed bytecode instruction is a boundary instruction, the execution consumption associated with the boundary instruction is executed to calculate the bytecode, and the first execution consumption of the program block corresponding to the boundary instruction is obtained; wherein, the boundary instruction includes a pointer The section code instruction is the start instruction and the end instruction of the branch execution instruction or the loop execution instruction, and the execution consumption calculation bytecode is a preset instruction that associates the first consumption of the program block corresponding to the boundary instruction with the calculation during the smart contract deployment process the resulting executable program;

Obtain the second execution consumption, accumulate the second execution consumption and the first execution consumption, and obtain the third execution consumption; wherein, the second execution consumption is all bytecode instructions that have been executed before the current boundary instruction The total execution cost of ;

When it is detected that the third execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited.

In one embodiment, the execution of the execution consumption associated with the boundary instruction is performed to calculate the bytecode, and the first execution consumption of the program block corresponding to the boundary instruction is obtained, including:

In the process of calculating the bytecode of execution consumption associated with the boundary instruction, each time it is detected that the boundary instruction starts to be executed once, the first consumption associated with the boundary instruction is accumulated once to the first execution consumption, to update the first execution consumption;

In one embodiment, the executing method further includes:

When the currently executed bytecode instruction is a sequential execution instruction, obtain the fourth execution consumption of the sequential execution instruction;

Obtain the fifth execution consumption, and accumulate the fifth execution consumption and the fourth execution consumption to obtain the sixth execution consumption; wherein, the fifth execution consumption is all bytecodes that have been executed before the current sequential execution instruction The total execution cost of the instruction;

When it is detected that the sixth execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited.

In a third aspect, the embodiments of the present application provide a smart contract deployment device, including:

a receiving module, configured to read bytecode instructions in the smart contract in sequence when receiving the request instruction for deploying the smart contract;

A calculation module, configured to calculate the first consumption of the program block corresponding to the boundary instruction when the bytecode instruction in the read smart contract is a boundary instruction; wherein the boundary instruction includes indicating that the bytecode instruction is The start and end instructions of branch execution instructions or loop execution instructions;

obtaining module, for associating the first consumption with a preset instruction to obtain the execution consumption calculation bytecode of the program block corresponding to the boundary instruction;

an association module, configured to associate the execution consumption calculation bytecode with the boundary instruction for storage, so that in the process of executing the boundary instruction, the smart contract executes the execution consumption calculation bytecode to obtain all the first execution consumption of the program block corresponding to the boundary instruction;

The processing completion module is configured to determine that the bytecode instructions of the smart contract have been processed when all bytecode instructions in the smart contract are read.

In a fourth aspect, an embodiment of the present application provides a device for executing a smart contract, including:

a first obtaining module, configured to obtain a command consumption threshold when receiving a request command for executing the deployed smart contract;

a calculation module, configured to execute the execution consumption calculation bytecode associated with the boundary instruction when the currently executed bytecode instruction is a boundary instruction, and obtain the first execution consumption of the program block corresponding to the boundary instruction; wherein, the The boundary instruction includes a start instruction and an end instruction indicating that the bytecode instruction is a branch execution instruction or a loop execution instruction. The executable program obtained by consuming the associated preset instruction;

The second obtaining module is configured to obtain the second execution consumption, and accumulate the second execution consumption and the first execution consumption to obtain the third execution consumption; wherein, the second execution consumption is the value that has been executed before the current boundary instruction. The total execution cost of all bytecode instructions executed;

The first exit module is configured to exit the execution of the smart contract when it is detected that the third execution consumption is greater than the instruction consumption threshold.

In a fifth aspect, an embodiment of the present application provides a terminal device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, when the processor executes the computer program The steps of implementing the smart contract deployment method of the first aspect above; or the steps of implementing the smart contract execution method of the second aspect when the processor executes the computer program.

In a sixth aspect, an embodiment of the present application provides a computer-readable storage medium, where a computer program is stored in the computer-readable storage medium, and when the computer program is executed by a processor, the method for deploying a smart contract according to the first aspect is implemented. steps; or the steps of implementing the smart contract execution method of the second aspect above when the above computer program is executed by the processor.

In a seventh aspect, an embodiment of the present application provides a computer program product that, when the computer program product runs on an electronic device, causes the electronic device to execute the steps of the smart contract deployment method of the above-mentioned first aspect; Execute the steps of the smart contract execution method of the second aspect above.

beneficial effect

Compared with the prior art, the first aspect of the embodiments of the present application has the following beneficial effects: in the deployment process of the smart contract, if the read bytecode instruction is a boundary instruction, the first consumption of the boundary instruction is calculated, and the first consumption of the boundary instruction is calculated. Obtaining the execution consumption calculation bytecode of the program block corresponding to the boundary instruction by consuming the associated preset instruction, and storing the execution consumption calculation bytecode in association with the boundary instruction, so that in the execution process of the smart contract, directly according to the In the deployment phase, the execution consumption of the first consumption is associated with the bytecode calculation of the first execution consumption, and there is no need to calculate the instructions in the program block corresponding to the boundary instruction one by one, and the resource consumption can be measured quickly and efficiently.

Compared with the prior art, the second aspect of the embodiment of the present application has the following beneficial effects: during the execution of the smart contract, when the executed bytecode is a boundary instruction, the bytecode is calculated according to the execution consumption associated with the boundary instruction , calculate the first execution consumption of the program block corresponding to the boundary instruction; since the execution consumption calculation bytecode is an executable obtained by correlating the first consumption of the program block corresponding to the boundary instruction with the preset instruction in the smart contract deployment process The program directly calculates the bytecode according to the execution consumption, obtains the first execution consumption of the program block corresponding to the boundary instruction, does not need to calculate the instructions in the program block corresponding to the boundary instruction one by one, and can quickly and efficiently measure the resource consumption . And obtain the second execution consumption, accumulate the second execution consumption and the first execution consumption, and obtain the third execution consumption; wherein, the second execution consumption is all bytecodes that have been executed before the current boundary instruction The total execution consumption of the instruction; when it is detected that the third execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is terminated, and the execution of the smart contract can be quit when the third execution consumption is greater than the instruction consumption threshold, Thus, the execution stability of smart contracts can be improved.

Description of drawings

In order to illustrate the technical solutions in the embodiments of the present application more clearly, the following briefly introduces the accompanying drawings that are used in the description of the embodiments or exemplary technologies. Obviously, the drawings in the following description are only for the present application. In some embodiments, for those of ordinary skill in the art, other drawings can also be obtained according to these drawings without any creative effort.

1 is a schematic flowchart of a method for deploying a smart contract provided in Embodiment 1 of the present application;

2 is a schematic flowchart of a method for executing a smart contract provided in Embodiment 2 of the present application;

3 is a schematic flowchart of a method for executing a smart contract provided in Embodiment 2 of the present application;

4 is a schematic flowchart of a smart contract deployment device provided in Embodiment 3 of the present application;

5 is a schematic flowchart of a smart contract execution device provided in Embodiment 4 of the present application;

FIG. 6 is a schematic structural diagram of a terminal device provided in Embodiment 5 of the present application.

Embodiments of the present invention

In the following description, for the purpose of illustration rather than limitation, specific details such as a specific system structure and technology are set forth in order to provide a thorough understanding of the embodiments of the present application. However, it will be apparent to those skilled in the art that the present application may be practiced in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, devices, circuits, and methods are omitted so as not to obscure the description of the present application with unnecessary detail.

The smart contract deployment method provided by the embodiments of this application can be applied to a blockchain node in a blockchain network, and the blockchain node can be a server, a tablet computer, a wearable device, a vehicle-mounted device, an augmented reality , AR)/virtual reality (VR) devices, laptops, ultra-mobile personal computers computer, UMPC), netbooks, personal digital assistants (personal digital assistants) assistant, PDA), mobile phone, or other various terminal devices capable of data processing. The embodiments of the present application do not limit any specific types of devices.

In order to illustrate the technical solutions described in this application, the following examples are used to illustrate.

Example 1

Referring to FIG. 1, a method for deploying a smart contract provided by an embodiment of the present application includes:

Step S101, when receiving a request instruction for deploying the smart contract, read bytecode instructions in the smart contract in sequence.

Specifically, the request instruction for deploying the smart contract includes a plurality of bytecode instructions for executing the smart contract. When the request instruction for deploying the smart contract is received, the bytecode instructions in the smart contract are sequentially read. For processing, the bytecode instruction may be a wasm bytecode instruction.

Step S102, when the read bytecode instruction in the smart contract is a boundary instruction, calculate the first consumption of the program block corresponding to the boundary instruction; wherein, the boundary instruction includes indicating that the bytecode instruction is branch execution The start and end instructions of an instruction or a cyclic execution instruction.

Specifically, when the read bytecode instruction in the smart contract is a boundary instruction, the boundary instruction may be a branch execution instruction or a loop execution instruction, and the start instruction and the end instruction of the boundary instruction will include multiple instructions , that is, the boundary instruction will correspond to a program block, so in the process of deploying the smart contract, the execution consumption of all instructions in the program block corresponding to the boundary instruction can be calculated, and the cost of all instructions in the program block corresponding to the boundary instruction can be calculated. The execution cost is called the first cost.

In one embodiment, when the bytecode instruction in the smart contract being read is a boundary instruction, calculating the first consumption of the program block corresponding to the boundary instruction includes: When the bytecode instruction in the smart contract is a boundary instruction, the execution consumption of each instruction in the program block corresponding to the boundary instruction is accumulated to obtain the first consumption.

Specifically, when the read bytecode instruction in the smart contract is a boundary instruction, calculating the first consumption of the program block corresponding to the boundary instruction may be: when calculating a single execution of the boundary instruction, the The boundary instructions are accumulated corresponding to the execution consumption of each instruction in the program block to obtain the first consumption. The execution consumption of each instruction may be calculated according to the size of the bytecode occupied by the corresponding instruction.

Step S103 , associate the first consumption with a preset instruction to obtain the execution consumption calculation bytecode of the program block corresponding to the boundary instruction.

Specifically, the preset instruction is a program preset for calculating the execution consumption of the program segment corresponding to the boundary instruction during the execution stage of the smart contract. The program needs to obtain the first consumption required for executing the current boundary instruction once, so the The first consumption is associated with a preset instruction, and a corresponding execution consumption calculation bytecode is generated.

Step S104, storing the execution consumption calculation bytecode in association with the boundary instruction, so that the smart contract executes the execution consumption calculation bytecode to obtain the boundary in the process of executing the boundary instruction The instruction corresponds to the first execution cost of the program block.

Specifically, the execution consumption calculation bytecode is stored in association with the boundary instruction, so that each time the smart contract executes the boundary instruction, it first calculates the first execution by executing the execution consumption bytecode associated with the boundary instruction. consume. For example, storing the execution consumption calculation bytecode in association with the boundary instruction may be inserting the execution consumption calculation bytecode into a preset position before the boundary instruction, and the preset position may be the boundary instruction and the boundary instruction. The position in the middle of the previous instruction of the boundary instruction allows the smart contract to calculate the first execution consumption by executing the corresponding execution consumption bytecode each time the boundary instruction is executed. The execution consumption calculation bytecode can be executed in the smart contract execution process, when the currently executed bytecode instruction is a boundary instruction, execute the execution consumption calculation bytecode associated with the boundary instruction, and obtain the program block corresponding to the boundary instruction The first execution consumes. The specific process of executing the execution consumption calculation bytecode associated with the boundary instruction may be in the process of executing the execution consumption calculation bytecode associated with the boundary instruction, every time it is detected that the boundary instruction starts to be executed once, the boundary instruction is executed. The first consumption associated with the instruction is accumulated once to the first execution consumption to update the first execution consumption, the first consumption represents the consumption required for executing the boundary instruction once, and the first execution consumption is when executing the smart contract, The total execution consumption of the program block corresponding to the boundary instruction is calculated according to the current execution times of the boundary instruction and the first consumption. Therefore, when the smart contract executes the boundary instruction, the execution consumption calculation bytecode can be executed first, and the first execution consumption required by the boundary instruction can be calculated by executing the consumption calculation bytecode.

In an application scenario, for example, the step implemented by the execution consumption calculation bytecode is to first obtain the single execution consumption of the boundary instruction (that is, the above-mentioned first consumption to be associated, the first consumption of different boundary instructions may be different) Therefore, it is necessary to calculate the first consumption of the program block corresponding to the boundary instruction when the bytecode instruction in the read smart contract is a boundary instruction), according to the single execution consumption of the boundary instruction and the current boundary instruction The execution times of , the total current execution consumption of the boundary instruction (ie the first execution consumption) can be calculated.

In one embodiment, the execution consumption calculation bytecode may be an executable program implemented by a wasm bytecode program, and the wasm bytecode program may specifically be implemented by a stack program.

Specifically, wasm (web assembly) bytecode is a target language developed for browsers. It is independent of various hardware architectures and has high portability and efficient network distribution efficiency. Wasm bytecode has been used by major mainstream Supported by browsers, the target bytecode of the smart contract can be in the form of wasm bytecode, and an independent wasm virtual machine is used to execute the program code of the smart contract. Using wasm bytecode to represent and execute smart contract program code, because its binary format has high compactness, it can greatly reduce the size of the object code file and improve the network distribution efficiency of the application. In addition, the runtime efficiency of wasm bytecode can be close to the efficiency of native machine code, and wasm can provide compilation targets for types of languages such as C/C++ and Rust, so that applications written in these languages can run in the browser.

In a specific application scenario, for example, the step of implementing the execution consumption calculation bytecode through a stack code program may be: first, by presetting the first internal instruction (for example, through the instruction "EnvGet"), obtaining from the current execution environment Variable A (this variable can be understood as the total execution consumption of the program block corresponding to the first N minus 1 execution of the boundary instruction when the current boundary instruction is executed for the Nth time), and the variable A is first pushed into the pre-built stack; Preset the first wasm standard instruction (such as through the instruction "I64Const") to push the constant B (this constant can be understood as the first consumption of the above acquisition) into the stack; then according to the preset second wasm standard instruction (such as through the instruction "I64Add" implementation) pops two numbers from the stack and adds the result and pushes the result into the stack. At this time, there are variable A and constant B in the stack, so the two numbers popped from the stack are variable A and constant B. The variable A and the constant B are added and the result is pushed onto the stack; finally, a value is popped from the stack and written back to the environment variable by a preset second internal instruction (such as through the instruction "EnvPet") and written back to the environment variable. The value is the result of adding the variable A and the constant B, and the result of adding the variable A and the constant B is written back to the environment variable, so as to realize that every time it is detected that the boundary instruction starts to be executed once, the boundary instruction is associated with the The first consumption is accumulated once to the first execution consumption to update the first execution consumption.

In one embodiment, when the bytecode instruction in the smart contract is read as a sequential execution instruction, the execution consumption of the sequential execution instruction is calculated, which is called the fourth execution consumption, and the fourth execution consumption is combined with the sequential execution instruction. Associative storage, so that during the execution of the smart contract, when the executed bytecode instruction is a sequential execution instruction, the fourth execution consumption of the sequential execution instruction is directly obtained, the fifth execution consumption is obtained, and the fifth execution consumption is obtained. The consumption is accumulated with the fourth execution consumption to obtain the sixth execution consumption; wherein, the fifth execution consumption is the total execution consumption of all bytecode instructions that have been executed before the current sequential execution instruction; 6. When the execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is terminated, and the instruction consumption threshold indicates that the execution of the corresponding smart contract limits the execution consumption.

Step S105, when all bytecode instructions in the smart contract are read, it is determined that the bytecode instructions of the smart contract have been processed.

Specifically, when all the bytecode instructions in the smart contract are read and the corresponding processing is performed through the above steps S101 to S104, it is determined that the bytecode instructions of the smart contract have been processed, so that the smart contract provided by this application can be processed. The execution method of the contract executes the smart contract deployed using the above deployment method.

During the deployment process of the smart contract in the embodiment of the present application, if the read bytecode instruction is a boundary instruction, the first consumption of the boundary instruction is calculated, and the first consumption is associated with the preset instruction to obtain the execution consumption of the program block corresponding to the boundary instruction. Calculate the bytecode, and associate the execution consumption calculation bytecode with the boundary instruction for storage, so that in the execution process of the smart contract, the execution consumption calculation bytecode calculation is directly associated with the first consumption in the deployment stage. The first execution consumption does not need to calculate the instructions in the program block corresponding to the boundary instruction one by one, which can quickly and efficiently measure the resource consumption.

Embodiment 2

The smart contract execution method provided in the embodiment of the present application can be applied to a terminal device in which a smart contract is deployed through the smart contract deployment method in Embodiment 1.

Referring to FIG. 2, a method for executing a smart contract provided by an embodiment of the present application includes:

Step S201, when a request instruction for executing the deployed smart contract is received, obtain an instruction consumption threshold.

Specifically, the above-mentioned deployed smart contract is a smart contract deployed by the deployment method in Embodiment 1, and the request instruction to execute the deployed smart contract includes an instruction consumption threshold, and the instruction consumption threshold is a limit indicating the execution of the corresponding smart contract Execute consumption.

Step S202, when the currently executed bytecode instruction is a boundary instruction, execute the execution consumption calculation bytecode associated with the boundary instruction, and obtain the first execution consumption of the program block corresponding to the boundary instruction.

The boundary instruction includes a start instruction and an end instruction indicating that the bytecode instruction is a branch execution instruction or a loop execution instruction, and the execution consumption calculation bytecode is a program corresponding to the boundary instruction that will be calculated during the smart contract deployment process The first consumption of the block is associated with the executable program obtained by the preset instruction.

In one embodiment, executing the execution consumption calculation bytecode associated with the boundary instruction, and obtaining the first execution consumption of the program block corresponding to the boundary instruction, includes: executing the execution consumption calculation word associated with the boundary instruction In the process of saving the code, each time it is detected that the boundary instruction starts to be executed once, the first consumption associated with the boundary instruction is accumulated once to the first execution consumption, so as to update the first execution consumption;

Wherein, the first consumption is the consumption required to execute the boundary instruction calculated and stored when the smart contract is deployed, and when the currently executed bytecode instruction is the boundary instruction, the first execution consumption is When executing the smart contract, the total execution consumption of the program block corresponding to the boundary instruction is calculated according to the execution times of the boundary instruction and the first consumption.

Specifically, the above-mentioned step S202 is the same, corresponding or similar to the above-mentioned steps S102 to S104. For details, please refer to the relevant descriptions of the steps S102 to S104, which will not be repeated here.

Step S203, obtaining the second execution consumption, accumulating the second execution consumption and the first execution consumption to obtain the third execution consumption; wherein, the second execution consumption is all words executed before the current boundary instruction Total execution cost of section code instructions.

Specifically, during the execution of the smart contract, the total execution consumption of the executed bytecode instructions is continuously accumulated, and when the currently executed bytecode instruction is a boundary instruction, the first execution consumption of the boundary instruction is calculated first, and the The total execution consumption of all bytecode instructions executed before the current boundary instruction (called the third execution consumption) is added to the first execution to measure whether the execution consumption of continuing to execute the boundary instruction will be greater than the instruction consumption threshold .

Step S204, when it is detected that the third execution consumption is greater than the instruction consumption threshold, exit the execution of the smart contract.

Specifically, when it is detected that the third execution consumption is greater than the instruction consumption threshold, it means that the execution consumption of continuing to execute the boundary instruction will be greater than the instruction consumption threshold, so the execution of the smart contract is directly exited.

In one embodiment, referring to FIG. 3, the execution method further includes:

Step S301, when the currently executed bytecode instruction is a sequential execution instruction, obtain the fourth execution consumption of the sequential execution instruction.

Specifically, when the bytecode instruction executed to the smart contract is a sequential execution instruction, the execution consumption of the sequential instruction is obtained first, which is called the fourth execution consumption. The fourth execution cost may be, in the process of smart contract deployment, when the bytecode instruction in the smart contract is read as a sequential execution instruction, the fourth execution cost of the sequential execution instruction is calculated, and the fourth execution cost is compared with the sequence. The execution instructions are stored associatively, so the fourth execution consumption can be directly obtained during the execution of the smart contract; or the fourth execution consumption can also be in the process of executing the smart contract, and the currently executed bytecode instruction is a sequential execution instruction , the fourth execution consumption is obtained by calculating according to the size of the bytecode occupied by the sequentially executed instructions.

Step S302, obtaining the fifth execution consumption, and accumulating the fifth execution consumption and the fourth execution consumption to obtain the sixth execution consumption; wherein, the fifth execution consumption is all the executed instructions before the current sequential execution instruction. Total execution cost of bytecode instructions.

Specifically, during the execution of the smart contract, the total execution consumption of the executed bytecode instructions is continuously accumulated, and when the currently executed bytecode instruction is a sequential execution instruction, the fourth execution consumption of the sequential execution instruction is obtained first, and The total execution cost of all bytecode instructions executed before the current sequential execution instruction (called the fifth execution cost) is added to the fourth execution cost to measure whether the execution cost of continuing the sequential execution of the instruction will be Greater than the instruction consumption threshold.

Step S303, when it is detected that the sixth execution consumption is greater than the instruction consumption threshold, exit the execution of the smart contract.

Specifically, when it is detected that the sixth execution consumption is greater than the instruction consumption threshold, it means that the execution consumption of continuing to execute the sequential execution instructions will be greater than the instruction consumption threshold, so the execution of the smart contract is directly exited.

In a specific application, when it is detected that the third execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited, and when it is detected that the sixth execution consumption is greater than the instruction consumption threshold, the execution is exited The smart contract can be specifically implemented through a stack code program: for example, by presetting the third internal instruction (such as through the instruction "EnvGet"), the variable C is obtained from the current execution environment (the variable C is the execution of the current instruction and the current The total execution consumption required by all the instructions before the instruction, if the boundary instruction is executed, the variable C is the above-mentioned third execution consumption; if the sequential execution instruction is executed, the variable C is the above-mentioned sixth execution consumption); and then according to the preset third The wasm standard instruction (such as implemented by the instruction "I64Const") means to push the constant (limit value, that is, the instruction consumption threshold) into the stack; then according to the preset fourth wasm standard instruction (such as implemented by the instruction I64Ge_U), the stack is stored on the stack. The first value on the stack is the instruction consumption threshold, the second value on the stack is the third execution consumption or the sixth execution consumption, if the first value is greater than the second value returns 1, if The first value is less than or equal to the second value and returns 0, and pushes the return value into the stack; then according to the preset fifth wasm standard instruction (such as through if), it is judged whether the top of the stack is 0, and 0 means the instruction The consumption threshold is less than or equal to the third execution consumption or the sixth execution consumption; when it is judged that the top of the stack is 0, the fourth internal instruction is preset (for example, implemented by the instruction Break) to exit the execution and throw an error. Through the stack code program, it is possible to judge whether the current code execution consumption exceeds the execution limit, and stop the execution if it exceeds the limit.

During the execution of the smart contract in the embodiment of the present application, when the executed bytecode is a boundary instruction, the bytecode is calculated according to the execution consumption associated with the boundary instruction, and the first execution consumption of the program block corresponding to the boundary instruction is calculated; Since the execution consumption calculation bytecode is an executable program obtained by correlating the first consumption of the program block corresponding to the boundary instruction with the preset instruction in the smart contract deployment process, the bytecode is directly calculated according to the execution consumption to obtain the boundary The first execution consumption of the program block corresponding to the instruction does not need to be calculated one by one in the program block corresponding to the boundary instruction, and the resource consumption can be measured quickly and efficiently. And obtain the second execution consumption, accumulate the second execution consumption and the first execution consumption, and obtain the third execution consumption; wherein, the second execution consumption is all bytecodes that have been executed before the current boundary instruction The total execution consumption of the instruction; when it is detected that the third execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited, and the execution of the smart contract can be exited when the third execution consumption is greater than the instruction consumption threshold, Thus, the execution stability of smart contracts can be improved.

Embodiment 3

The embodiments of the present application further provide a smart contract deployment device, which is used to execute the steps in the above smart contract deployment method embodiments. As shown in FIG. 4 , the smart contract deployment device 400 provided in the embodiment of the present application includes:

A receiving module 401, configured to read bytecode instructions in the smart contract in sequence when receiving a request instruction for deploying the smart contract;

The calculation module 402 is configured to calculate the first consumption of the program block corresponding to the boundary instruction when the read bytecode instruction in the smart contract is a boundary instruction; wherein, the boundary instruction includes an instruction bytecode instruction Start and end instructions for branch execution instructions or loop execution instructions;

Obtaining module 403, for associating the first consumption with a preset instruction to obtain the execution consumption calculation bytecode of the program block corresponding to the boundary instruction;

The association module 404 is configured to associate the execution consumption calculation bytecode with the boundary instruction for storage, so that in the process of executing the boundary instruction, the smart contract executes the execution consumption calculation bytecode to obtain The boundary instruction corresponds to the first execution consumption of the program block;

The processing completion module 405 is configured to determine that the bytecode instructions of the smart contract have been processed when all bytecode instructions in the smart contract are read.

In one embodiment, the computing module 402 is specifically configured to, when the read bytecode instruction in the smart contract is a boundary instruction, consume the execution consumption of each instruction in the program block corresponding to the boundary instruction Accumulation is performed to obtain the first consumption.

In one embodiment, the associating module is specifically configured to: associate the execution consumption calculation bytecode with the boundary instruction for storage, so that during the execution process of the smart contract, each time it detects that it starts to execute the When the boundary instruction is used, the first consumption associated with the boundary instruction is accumulated to the first execution consumption once to update the first execution consumption;

Embodiment 4

Embodiments of the present application further provide an apparatus for executing a smart contract, which is used to execute the steps in the above-mentioned embodiments of the method for executing a smart contract. As shown in FIG. 5 , the execution device 500 of the smart contract provided by the embodiment of the present application includes:

The first obtaining module 501 is configured to obtain the instruction consumption threshold when receiving the request instruction for executing the deployed smart contract;

The calculation module 502 is configured to execute the execution consumption calculation bytecode associated with the boundary instruction when the currently executed bytecode instruction is a boundary instruction, and obtain the first execution consumption of the program block corresponding to the boundary instruction; The boundary instruction includes a start instruction and an end instruction indicating that the bytecode instruction is a branch execution instruction or a loop execution instruction. an executable program obtained by consuming the associated preset instruction;

The second obtaining module 503 is configured to obtain the second execution consumption, and accumulate the second execution consumption and the first execution consumption to obtain the third execution consumption; wherein, the second execution consumption is before the current boundary instruction The total execution cost of all bytecode instructions executed;

The first exit module 504 is configured to exit the execution of the smart contract when it is detected that the third execution consumption is greater than the instruction consumption threshold.

In one embodiment, the calculation module 502 is specifically configured to: in the process of executing the execution consumption calculation bytecode associated with the boundary instruction, every time it is detected that the boundary instruction starts to be executed once, calculate the boundary instruction The associated first consumption is accumulated once to the first execution consumption to update the first execution consumption;

In one embodiment, the execution device 500 further includes:

a third obtaining module, configured to obtain the fourth execution consumption of the sequential execution instruction when the currently executed bytecode instruction is a sequential execution instruction;

a fourth acquisition module, configured to acquire the fifth execution consumption, and accumulate the fifth execution consumption and the fourth execution consumption to obtain the sixth execution consumption; wherein, the fifth execution consumption is before the current sequential execution instruction The total execution cost of all bytecode instructions executed;

The second exit module is configured to exit the execution of the smart contract when it is detected that the sixth execution consumption is greater than the instruction consumption threshold.

Embodiment 5

As shown in FIG. 6 , an embodiment of the present application further provides a terminal device 600 including: a processor 601, a memory 602, and a computer program 603 stored in the memory 602 and running on the processor 601, For example, the deployer and/or the executor of the smart contract. When the processor 601 executes the computer program 603, the steps in the above-mentioned embodiments of the deployment method of each smart contract and/or the execution method of each smart contract are implemented. When the processor 601 executes the computer program 603, the functions of the modules in the foregoing apparatus embodiments are implemented, for example, the functions of the third embodiment and/or the fourth embodiment.

Exemplarily, the computer program 603 may be divided into one or more modules, and the one or more modules are stored in the memory 602 and executed by the processor 601 to complete the present application. The one or more modules may be a series of computer program instruction segments capable of accomplishing specific functions, and the instruction segments are used to describe the execution process of the computer program 603 in the terminal device 600 .

The terminal device 600 may be a server, a tablet computer, a wearable device, an in-vehicle device, an augmented reality (AR)/virtual reality (VR) device, a laptop, and an ultra-mobile personal computer (ultra-mobile personal computer). computer, UMPC), netbooks, personal digital assistants (personal digital assistants) assistant, PDA), cell phone, or other computing device. The terminal device may include, but is not limited to, the processor 601 and the memory 602 .

In the foregoing embodiments, the description of each embodiment has its own emphasis. For parts that are not described or described in detail in a certain embodiment, reference may be made to the relevant descriptions of other embodiments.

The above-mentioned embodiments are only used to illustrate the technical solutions of the present application, but not to limit them; although the present application has been described in detail with reference to the above-mentioned embodiments, those of ordinary skill in the art should understand that: it is still possible to implement the above-mentioned implementations. The technical solutions described in the examples are modified, or some technical features thereof are equivalently replaced; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions in the embodiments of the application, and should be included in the within the scope of protection of this application.

Claims

A method for deploying a smart contract, comprising:

When receiving the request instruction for deploying the smart contract, read the bytecode instructions in the smart contract in sequence;

When the read bytecode instruction in the smart contract is a boundary instruction, calculate the first consumption of the program block corresponding to the boundary instruction; wherein, the boundary instruction includes indicating that the bytecode instruction is a branch execution instruction or a loop Execute the start command and end command of the command;

Associating the first consumption with a preset instruction to obtain the execution consumption calculation bytecode of the program block corresponding to the boundary instruction;

storing the execution consumption calculation bytecode in association with the boundary instruction, so that in the process of executing the boundary instruction, the smart contract executes the execution consumption calculation bytecode to obtain a program corresponding to the boundary instruction the first execution consumption of the block;

When all bytecode instructions in the smart contract are read, it is determined that the bytecode instructions of the smart contract have been processed.
The deployment method according to claim 1, wherein, when the read bytecode instruction in the smart contract is a boundary instruction, calculating the first consumption of the program block corresponding to the boundary instruction comprises:

When the read bytecode instruction in the smart contract is a boundary instruction, the execution consumption of each instruction in the program block corresponding to the boundary instruction is accumulated to obtain the first consumption.
The deployment method according to claim 1, wherein the execution consumption calculation bytecode is associated with the boundary instruction for storage, so that the smart contract executes the boundary instruction in the process of executing the boundary instruction. The execution consumption calculates the bytecode to obtain the first execution consumption of the program block corresponding to the boundary instruction, including:

The execution consumption calculation bytecode is stored in association with the boundary instruction, so that during the execution process of the smart contract, each time it detects that the boundary instruction starts to be executed once, the first consumption associated with the boundary instruction is associated with the boundary instruction. Accumulate once to the first execution consumption to update the first execution consumption;

Wherein, the first consumption is the consumption required for one execution of the boundary instruction calculated and stored when the smart contract is deployed, and the first execution consumption is the consumption according to the boundary instruction when the smart contract is executed The number of executions of and the total execution consumption of the program block corresponding to the boundary instruction of the first consumption calculation.
The deployment method according to claim 1, wherein the storing the execution consumption calculation bytecode in association with the boundary instruction comprises:

Inserting the execution cost calculation bytecode at a preset position before the boundary instruction.
The deployment method according to claim 1, wherein the execution consumption calculation bytecode is an executable program implemented by a wasm bytecode program.
A method for executing a smart contract, comprising:

When receiving a request instruction to execute a deployed smart contract, obtain the instruction consumption threshold;

When the currently executed bytecode instruction is a boundary instruction, the execution consumption associated with the boundary instruction is executed to calculate the bytecode, and the first execution consumption of the program block corresponding to the boundary instruction is obtained; wherein, the boundary instruction includes a pointer The section code instruction is the start instruction and the end instruction of the branch execution instruction or the loop execution instruction, and the execution consumption calculation bytecode is a preset instruction that associates the first consumption of the program block corresponding to the boundary instruction with the calculation during the smart contract deployment process the resulting executable program;

Obtain the second execution consumption, accumulate the second execution consumption and the first execution consumption, and obtain the third execution consumption; wherein, the second execution consumption is all bytecode instructions that have been executed before the current boundary instruction The total execution cost of ;

When it is detected that the third execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited.
The execution method according to claim 6, wherein the executing the execution consumption calculation bytecode associated with the boundary instruction, and obtaining the first execution consumption of the program block corresponding to the boundary instruction, comprises:

In the process of calculating the bytecode of execution consumption associated with the boundary instruction, each time it is detected that the boundary instruction starts to be executed once, the first consumption associated with the boundary instruction is accumulated once to the first execution consumption, to update the first execution consumption;

Wherein, the first consumption is the consumption required for one execution of the boundary instruction calculated and stored when the smart contract is deployed, and the first execution consumption is the consumption according to the boundary instruction when the smart contract is executed The number of executions of and the total execution consumption of the program block corresponding to the boundary instruction of the first consumption calculation.
The execution method according to claim 6, wherein the execution method further comprises:

When the currently executed bytecode instruction is a sequential execution instruction, obtain the fourth execution consumption of the sequential execution instruction;

Obtain the fifth execution consumption, and accumulate the fifth execution consumption and the fourth execution consumption to obtain the sixth execution consumption; wherein, the fifth execution consumption is all bytecodes that have been executed before the current sequential execution instruction The total execution cost of the instruction;

When it is detected that the sixth execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited.
A terminal device, characterized in that it includes a memory and a processor, the memory stores a deployment program of a smart contract that can run on the processor, and the memory stores a program that can run on the processor The executor of the running smart contract;

The method steps implemented when the deployment program of the smart contract is executed by the processor include:

When receiving the request instruction for deploying the smart contract, read the bytecode instructions in the smart contract in sequence;

When the read bytecode instruction in the smart contract is a boundary instruction, calculate the first consumption of the program block corresponding to the boundary instruction; wherein, the boundary instruction includes indicating that the bytecode instruction is a branch execution instruction or a loop Execute the start command and end command of the command;

Associating the first consumption with a preset instruction to obtain the execution consumption calculation bytecode of the program block corresponding to the boundary instruction;

storing the execution consumption calculation bytecode in association with the boundary instruction, so that in the process of executing the boundary instruction, the smart contract executes the execution consumption calculation bytecode to obtain a program corresponding to the boundary instruction the first execution consumption of the block;

When all bytecode instructions in the smart contract are read, it is determined that the bytecode instructions of the smart contract have been processed;

The method steps implemented when the execution program of the smart contract is executed by the processor include:

When receiving a request instruction to execute a deployed smart contract, obtain the instruction consumption threshold;

When the currently executed bytecode instruction is a boundary instruction, the execution consumption associated with the boundary instruction is executed to calculate the bytecode, and the first execution consumption of the program block corresponding to the boundary instruction is obtained; wherein, the boundary instruction includes a pointer The section code instruction is the start instruction and the end instruction of the branch execution instruction or the loop execution instruction, and the execution consumption calculation bytecode is a preset instruction that associates the first consumption of the program block corresponding to the boundary instruction with the calculation during the smart contract deployment process the resulting executable program;

Obtain the second execution consumption, accumulate the second execution consumption and the first execution consumption, and obtain the third execution consumption; wherein, the second execution consumption is all bytecode instructions that have been executed before the current boundary instruction The total execution cost of ;

When it is detected that the third execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited.
The terminal device according to claim 9, wherein, when the read bytecode instruction in the smart contract is a boundary instruction, calculating the first consumption of the program block corresponding to the boundary instruction comprises:

When the read bytecode instruction in the smart contract is a boundary instruction, the execution consumption of each instruction in the program block corresponding to the boundary instruction is accumulated to obtain the first consumption.
The terminal device according to claim 9, wherein the execution consumption calculation bytecode is stored in association with the boundary instruction, so that the smart contract executes the boundary instruction in the process of executing the boundary instruction. The execution consumption calculates the bytecode to obtain the first execution consumption of the program block corresponding to the boundary instruction, including:

The execution consumption calculation bytecode is stored in association with the boundary instruction, so that during the execution process of the smart contract, each time it detects that the boundary instruction starts to be executed once, the first consumption associated with the boundary instruction is associated with the boundary instruction. Accumulate once to the first execution consumption to update the first execution consumption;

Wherein, the first consumption is the consumption required for one execution of the boundary instruction calculated and stored when the smart contract is deployed, and the first execution consumption is the consumption according to the boundary instruction when the smart contract is executed The number of executions of and the total execution consumption of the program block corresponding to the boundary instruction of the first consumption calculation.
The terminal device according to claim 9, wherein the storing the execution consumption calculation bytecode in association with the boundary instruction comprises:

Inserting the execution cost calculation bytecode at a preset position before the boundary instruction.
The terminal device according to claim 9, wherein the execution consumption calculation bytecode is an executable program implemented by a wasm bytecode program.
The terminal device according to claim 9, wherein the method steps implemented when the execution program of the smart contract is executed by the processor further comprises:

When the currently executed bytecode instruction is a sequential execution instruction, obtain the fourth execution consumption of the sequential execution instruction;

Obtain the fifth execution consumption, and accumulate the fifth execution consumption and the fourth execution consumption to obtain the sixth execution consumption; wherein, the fifth execution consumption is all bytecodes that have been executed before the current sequential execution instruction The total execution cost of the instruction;

When it is detected that the sixth execution consumption is greater than the instruction consumption threshold, the execution of the smart contract is exited.