CN114327477A - Intelligent contract execution method and device, electronic device and storage medium - Google Patents

Abstract

The present application relates to a smart contract execution method, device, electronic device and storage medium, wherein the smart contract execution method includes: obtaining the bytecode of the smart contract; according to the intermediate language structure of the LLVM project, converting the bytecode of the smart contract Convert to the intermediate code of the smart contract; call the compiler provided by the LLVM project to determine the machine code of the smart contract according to the intermediate code of the smart contract; execute the machine code of the smart contract. This application solves the problem in the related art that when executing a smart contract, it needs to be parsed and then executed, resulting in a low execution efficiency of the smart contract, and the execution efficiency of the smart contract is improved.

Description

Smart contract execution method, device, electronic device and storage medium

technical field

This application relates to the field of blockchain technology, and in particular, to a smart contract execution method, device, electronic device and storage medium.

Background technique

Blockchain technology is an Internet database technology that is characterized by decentralization, openness and transparency, allowing everyone to participate in database records. With the development of blockchain technology, smart contracts have been used more and more. Specifically, smart contracts are programmed contracts that are automatically executed when preset conditions are met, and can be deployed in the blockchain.

The process of executing a smart contract in related technologies is to obtain the written smart contract, deploy the smart contract in the blockchain node for invocation, and need to parse the smart contract before executing the invocation, which is inefficient.

There is no effective solution to the problem that the execution of smart contracts in related technologies needs to be parsed and then executed, resulting in low execution efficiency of smart contracts.

SUMMARY OF THE INVENTION

In this embodiment, a smart contract execution method, device, system, electronic device and storage medium are provided to solve the problem in the related art that when executing a smart contract, it needs to be parsed and then executed, resulting in low execution efficiency of the smart contract .

In a first aspect, this embodiment provides a smart contract execution method, including:

Get the bytecode of the smart contract;

Convert the bytecode of the smart contract into the intermediate code of the smart contract according to the intermediate language structure of the LLVM project;

Invoke the compiler provided by the LLVM project, and determine the machine code of the smart contract according to the intermediate code of the smart contract;

Machine code that executes the smart contract.

In some of these embodiments, converting the bytecode of the smart contract into the intermediate code of the smart contract according to the intermediate language structure of the LLVM project includes:

obtaining a grammatical specification determined by the intermediate language structure;

According to the grammar specification, all the statement sequences in the bytecode of the smart contract are converted into the intermediate code of the smart contract.

In some of the embodiments, converting all the statement sequences in the bytecode of the smart contract into the intermediate code of the smart contract according to the grammar specification includes:

obtaining the first instruction type in the bytecode of the smart contract, and determining the second instruction type in the intermediate language structure according to the grammar specification;

The first instruction type and the second instruction type are stored to obtain the intermediate code of the smart contract.

In some of the embodiments, the invoking the compiler provided by the LLVM project to determine the machine code of the smart contract according to the intermediate code of the smart contract includes:

Compile the intermediate code of the smart contract into the first machine code of the smart contract through the compiler provided by the LLVM project;

A symbol table is added to the first machine code, and the first machine code and the symbol table are converted into binary sequences to obtain the second machine code of the smart contract.

In some of these embodiments, before executing the machine code of the smart contract, the method includes:

The machine code of the smart contract is stored in a cache and/or database.

In some of these embodiments, the machine code for executing the smart contract includes:

If the machine code of the smart contract exists in the cache, execute the machine code of the smart contract in the cache;

If the machine code of the smart contract does not exist in the cache, obtain the machine code of the smart contract from the database and execute it;

In the case where the machine code of the smart contract does not exist in the database, the bytecode of the smart contract is executed.

In some of these embodiments, converting the bytecode of the smart contract into the intermediate code of the smart contract according to the intermediate language structure of the LLVM project includes:

According to the bytecode sequence in the bytecode of the smart contract, sequentially convert the bytecode of the smart contract into the intermediate code of the smart contract; or,

Divide the bytecode of the smart contract into multiple bytecode sequences, convert the multiple bytecode sequences into multiple intermediate code sequences of the smart contract through parallel processing, and determine the multiple intermediate code sequences according to the multiple intermediate code sequences. Intermediate code for smart contracts.

In a second aspect, a smart contract execution device is provided in this embodiment, including an acquisition module, a conversion module, a calling module, and an execution module:

The obtaining module is used to obtain the bytecode of the smart contract;

The conversion module is used to convert the bytecode of the smart contract into the intermediate code of the smart contract according to the intermediate language structure of the LLVM project;

The calling module is used to call the compiler provided by the LLVM project, and determine the machine code of the smart contract according to the intermediate code of the smart contract;

The execution module is used to execute the machine code of the smart contract.

In a third aspect, this embodiment provides an electronic device, including a memory, a processor, and a computer program stored on the memory and executable on the processor, where the processor executes the computer During the program, the smart contract execution method described in the first aspect above is realized.

In a fourth aspect, this embodiment provides a storage medium on which a computer program is stored, and when the program is executed by a processor, implements the steps of the smart contract execution method described in the first aspect above.

Compared with related technologies, the smart contract execution method provided in this embodiment obtains the bytecode of the smart contract; according to the intermediate language structure of the LLVM project, the bytecode of the smart contract is converted into the intermediate code of the smart contract; Call the compiler provided by the LLVM project to determine the machine code of the smart contract according to the intermediate code of the smart contract; execute the machine code of the smart contract, which solves the need to parse and then execute the smart contract in related technologies, resulting in the execution efficiency of the smart contract. Lower problems and improve the execution efficiency of smart contracts.

The details of one or more embodiments of the application are set forth in the accompanying drawings and the description below in order to make other features, objects and advantages of the application more apparent.

Description of drawings

The drawings described herein are used to provide further understanding of the present application and constitute a part of the present application. The schematic embodiments and descriptions of the present application are used to explain the present application and do not constitute an improper limitation of the present application. In the attached image:

Fig. 1 is the hardware structure block diagram of the terminal of the smart contract execution method of the present embodiment;

Fig. 2 is the flow chart of the smart contract execution method of the present embodiment;

Fig. 3 is the flow chart of the acquisition method of the intermediate code of the smart contract of the present embodiment;

4 is a flowchart of a method for acquiring a machine code of a smart contract according to an embodiment of the present application;

5 is a flowchart of a method for deploying and invoking a smart contract according to a preferred embodiment of the present application;

FIG. 6 is a structural block diagram of the smart contract execution apparatus of this embodiment.

Detailed ways

For a clearer understanding of the purpose, technical solutions and advantages of the present application, the present application is described and illustrated below with reference to the accompanying drawings and embodiments.

Unless otherwise defined, the technical or scientific terms involved in this application shall have the general meaning understood by a person with ordinary skills in the technical field to which this application belongs. Words like "a", "an", "an", "the", "these" and the like in this application do not denote quantitative limitations, and they may be singular or plural. The terms "comprising", "comprising", "having" and any variations thereof referred to in this application are intended to cover non-exclusive inclusion; for example, processes, methods and The system, product or device is not limited to the listed steps or modules (units), but may include unlisted steps or modules (units), or may include other steps or modules inherent to these processes, methods, products or devices (unit). References in this application to "connected," "connected," "coupled," and similar words are not limited to physical or mechanical connections, but may include electrical connections, whether direct or indirect. As used in this application, "plurality" refers to two or more. "And/or" describes the association relationship between associated objects, indicating that there can be three kinds of relationships. For example, "A and/or B" can mean that A exists alone, A and B exist at the same time, and B exists alone. Normally, the character "/" indicates that the objects associated with each other are an "or" relationship. The terms "first", "second", "third", etc. involved in this application are only for distinguishing similar objects, and do not represent a specific order for the objects.

The method embodiments provided in this embodiment may be executed in a terminal, a computer or a similar computing device. For example, running on a terminal, FIG. 1 is a block diagram of the hardware structure of the terminal of the smart contract execution method of this embodiment. As shown in FIG. 1 , the terminal may include one or more (only one is shown in FIG. 1 ) processor 102 and a memory 104 for storing data, wherein the processor 102 may include but is not limited to a microprocessor MCU or may A processing device such as a programming logic device FPGA. The above-mentioned terminal may also include a transmission device 106 and an input and output device 108 for communication functions. Those of ordinary skill in the art can understand that the structure shown in FIG. 1 is only for illustration, which does not limit the structure of the above-mentioned terminal. For example, the terminal may also include more or fewer components than shown in FIG. 1 , or have a different configuration than that shown in FIG. 1 .

The memory 104 can be used to store computer programs, for example, software programs and modules of application software, such as computer programs corresponding to the smart contract execution method in this embodiment. The processor 102 executes the computer programs stored in the memory 104 to execute Various functional applications and data processing implement the above method. Memory 104 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, memory 104 may further include memory located remotely from processor 102, and these remote memories may be connected to the terminal through a network. Examples of such networks include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

Transmission device 106 is used to receive or transmit data via a network. The above-mentioned network includes a wireless network provided by a communication provider of the terminal. In an example, the transmission device 106 includes a network adapter (Network Interface Controller, NIC for short), which can be connected to other network devices through a base station so as to communicate with the Internet. In one example, the transmission device 106 may be a radio frequency (Radio Frequency, RF for short) module, which is used to communicate with the Internet in a wireless manner.

A smart contract execution method is provided in this embodiment, and FIG. 2 is a flowchart of the smart contract execution method in this embodiment. As shown in FIG. 2 , the process includes the following steps:

Step S201, obtaining the bytecode of the smart contract.

A smart contract is a computer protocol designed to inform, verify, or execute a contract. Smart contracts allow for trusted transactions that are traceable and irreversible without a third party. Specifically, both parties to the transaction execute smart contracts through blockchain nodes to update or query data.

Bytecode is a sequence binary file. By compiling the source code of the smart contract, the binary sequence of the smart contract can be obtained, that is, the bytecode of the smart contract can be obtained. Preferably, the bytecode of the smart contract in this embodiment may be in the WASM (WebAssembly) format, and WASM is a new bytecode format with a brand new underlying binary syntax, and has the following advantages: 1) High performance. WASM adopts binary encoding, which has superior performance in the process of program execution; 2) the storage cost is low. Compared with the text format, the binary-coded text occupies less storage space; 3) Multi-language support. Users can use C, C++, RUST, Go and other computer languages to write smart contracts and compile them into WASM format bytecodes.

In step S202, according to the intermediate language structure of the LLVM project, the bytecode of the smart contract is converted into the intermediate code of the smart contract. Therefore, the language structure of the intermediate code of the smart contract is the same as the intermediate language structure of the LLVM project.

The LLVM project in this application, which is different from the Low Level Virtual Machine (Low Level Virtual Machine), is a collection of modular and reusable compilers and tool technologies. It is a framework system that can be used to build compilers. LLVM A project consists of many modules, each module is a translation unit of the input program. Each module consists of functions, global variables, and symbol table entries. Further, a program in WASM format consists of a module, which is a unit for deployment, loading, and compilation. The module contains definitions of types, functions, memory, and global variables, and its definition characteristics are similar to those of LLVM modules. So it is possible to convert WASM modules to LLVM modules, or just function methods in WASM modules.

Intermediate Representation (IR) is a syntax-oriented equivalent internal representation code of a source program that is easy to translate into a target program. It is an intermediate format converted during program compilation. The degree of object code is between the source language and the target language. The intermediate language of the LLVM project is recorded as LLVM-IR (LLVM Intermediate Representation).

The intermediate language structure of the LLVM project in this embodiment specifies the syntax specification of the intermediate language of the LLVM project, that is, the program structure.

After the intermediate language structure of the LLVM project is determined, the bytecode of the smart contract can be parsed and semantically analyzed, and then converted according to the LLVM-IR grammatical specification according to the results of the syntax analysis and semantic analysis to obtain the intermediate of the smart contract. code, the intermediate code of the smart contract is in LLVM-IR format.

Specifically, LLVM-IR has three representations, which are compiler intermediate language in memory, bitcode on disk, and human-readable assembly language. These three representations can be converted to each other, among which, Bitcode on disk is suitable for fast loading by just-in-time compilers.

In step S203, the compiler provided by the LLVM project is invoked, and the machine code of the smart contract is determined according to the intermediate code of the smart contract.

After obtaining the intermediate code of the smart contract, since the LLVM project provides many Application Programming Interfaces (APIs) for compiling IR, for example, you can call the LLVM Target Machine Emit To Memory Buffer interface of LLVM to convert the LLVM -IR is converted to machine code and stored in the cache (Memory Buffer).

Step S204, executing the machine code of the smart contract.

In this embodiment, when the smart contract is deployed, the machine code of the smart contract is obtained through the compilation process. Therefore, when the smart contract is executed, the machine code of the smart contract can be directly executed to improve the execution efficiency of the smart contract.

Through the above steps S201 to S204, after the bytecode of the smart contract is obtained, the LLVM project is used to convert the smart contract into the LLVM-IR format to obtain the intermediate code of the smart contract. Finally, relying on the compiler provided by the LLVM project to obtain The machine code of the smart contract can improve the execution efficiency of the smart contract by executing the machine code of the smart contract. Therefore, this embodiment realizes the execution of the smart contract based on the machine code of the smart contract, which can speed up the execution process of the smart contract more efficiently, and solves the problem that the execution of the smart contract in the related art needs to be parsed and then executed, resulting in a higher execution efficiency of the smart contract. Low problem, improve the execution efficiency of smart contracts.

In some of the embodiments, FIG. 3 is a flow chart of the method for obtaining the intermediate code of the smart contract in this embodiment. As shown in FIG. 3 , the flow includes the following steps:

Step S301, acquiring the grammar specification determined by the intermediate language structure.

Since the syntax specifications of different computer languages are different, it is necessary to determine the syntax specifications of LLVM-IR before conversion to facilitate subsequent compilation. For example, LLVM-IR has modules (Module), function (Function), basic block (BasicBlock) and instruction (Instruction), LLVM-IR header needs to use fixed identifiers to represent module ID, source file name and so on. Further, the syntax specification determined by the LLVM project's intermediate language structure also includes identifiers and variables, such as global identifiers starting with @ and local identifiers starting with %. Among them, global identifiers include global variables, global constants and functions, and local identifiers are usually local variables, including named local variables represented by %tmp and unnamed local variables represented by prefixed unsigned numeric values.

Step S302, according to the grammar specification, convert all the statement sequences in the bytecode of the smart contract into the intermediate code of the smart contract.

The bytecode of the smart contract is a binary file composed of a sequence of op code/data pairs. After the syntax specification is determined, the bytecode of the smart contract can be traversed, and the statement sequence in the bytecode of the smart contract can be converted into LLVM-IR format to get the intermediate code of the smart contract.

Through the above steps S301 and S302, after obtaining the syntax specification determined by the intermediate language structure, the bytecode of the smart contract is converted according to the syntax specification of LLVM-IR, which can avoid errors in the conversion process and improve the accuracy of the intermediate code of the smart contract. Rate.

Further, in the process of obtaining the intermediate code of the smart contract, you can first obtain the first instruction type in the bytecode of the smart contract, determine the second instruction type in the intermediate language structure according to the grammar specification, and then use the first instruction type. And the second instruction type is stored to finally get the intermediate code of the smart contract. In this embodiment, it is necessary to correspond the instruction type in the bytecode of the smart contract with the instruction type in the intermediate language structure. For example, if the source code of the smart contract is the local.get instruction, it means that a local variable needs to be obtained. This behavior corresponds to the LLVM-IR format as the load instruction. For the convenience of conversion, you can re-apply for the storage space to save this local variable, and finally the contents stored in the storage space are alloca, store, and load three instructions.

In some of the embodiments, FIG. 4 is a flowchart of a method for acquiring a machine code of a smart contract according to an embodiment of the present application. As shown in FIG. 4 , the method includes the following steps:

In step S401, the intermediate code of the smart contract is compiled into the first machine code of the smart contract through the compiler provided by the LLVM project.

Specifically, the first machine code of the smart contract can be implemented through the interface of the LLVM project compiler.

Step S402, adding a symbol table to the first machine code, and converting the first machine code and the symbol table into a binary sequence to obtain the second machine code of the smart contract.

When calling a smart contract, in order to facilitate the execution of the smart contract, a symbol table needs to be added to the first machine code of the smart contract. The symbol table is a data structure used in the language translator. In the symbol table, Each identifier in the program code is bound with its declaration or usage information, such as its data type, scope, and memory address, etc., acting as a comment. After adding the symbol table, it is necessary to perform binary conversion on the first machine code and the symbol table to obtain the second machine code in the binary sequence format.

Through the above steps S401 and S402, the second machine code in binary format is obtained, which can further accelerate the execution efficiency of the smart contract.

In some of these embodiments, before executing the machine code of the smart contract, the machine code of the smart contract needs to be stored, and the bytecode of the smart contract needs to be stored in the ledger. Specifically, the machine code of the smart contract can be stored in the cache and/or database, and then the machine code of the smart contract can be called from the cache and/or database for execution, so as to improve the execution efficiency of the smart contract.

Further, the priority of obtaining the smart contract is: first the machine code in the cache, and then the machine code in the database. If the machine code is stored in the cache and the database at the same time, if the machine code of the smart contract exists in the cache, execute the machine code of the smart contract in the cache; if the machine code of the smart contract does not exist in the cache, from the database Obtain the machine code of the smart contract for execution; if the machine code of the smart contract does not exist in the database, directly obtain the bytecode of the smart contract to recompile and cache for execution. It should be noted that if the machine code is only stored in the cache, when the machine code cannot be obtained in the cache, the bytecode of the smart contract can be obtained directly. If the machine code is only stored in the database, it can be directly obtained from the database. The machine code is obtained from the cache without having to go through the cache. This embodiment provides a variety of machine code storage methods, which improves the scene adaptability of the smart contract storage process.

When obtaining the machine code of the smart contract and executing it, you can first determine whether the obtained machine code is the machine code corresponding to the current compiler. For example, you can load the machine code of the smart contract through the machine code format of the current compiler. If the content of the smart contract can be loaded and parsed, it means that the obtained machine code of the smart contract is the machine code executable by the current compiler, otherwise, the bytecode of the smart contract is compiled and then executed.

In some of these embodiments, when converting the bytecode of the smart contract into the intermediate code, the bytecode of the smart contract can be sequentially converted into the intermediate code of the smart contract according to the bytecode sequence in the bytecode of the smart contract , that is, the former statement in the bytecode is converted first, and the latter statement in the bytecode is converted to ensure that the order of the statements remains unchanged during conversion and improve the accuracy of the intermediate code of the smart contract; The bytecode of the contract is divided into multiple bytecode sequences. Through parallel processing, the multiple bytecode sequences are converted into multiple intermediate code sequences of the smart contract to improve the efficiency of the smart contract conversion process. Finally, according to the multiple intermediate code sequences The code sequence determines the intermediate code of the smart contract.

The present embodiment will be described and illustrated below through preferred embodiments.

FIG. 5 is a flowchart of a method for deploying and invoking a smart contract according to a preferred embodiment of the present application. As shown in FIG. 5 , the method includes the following steps:

Step S501, converting the WASM bytecode of the smart contract into LLVM-IR format to obtain the intermediate code of the smart contract, which is used as the input of the LLVM compiler;

Step S502, call the LLVM compiler, convert the smart contract in LLVM-IR format, and obtain the machine code of the smart contract; the LLVM compiler can be used as a dynamic call library on the blockchain platform, or can be directly embedded in the block chain. In the binary of the blockchain platform;

Step S503, write the WASM bytecode of the smart contract into the ledger, and store the machine code of the smart contract in a cache or database;

Step S504, obtaining the machine code of the smart contract from the cache or database; if the blockchain node does not store the machine code of the smart contract locally, interpret and execute the bytecode of the smart contract;

Step S505, execute the machine code of the smart contract and return the execution result. Further, if there is a problem with the smart contract itself, an error is returned.

The above steps S501 to S503 are the deployment process of the smart contract. Specifically, the above deployment process implements an AOT (Ahead of Time Compilation) process. The AOT process refers to compiling the program code into machine code, and then execute the behavior of the machine code.

The above steps S504 and S505 are the calling process of the smart contract. Specifically, the deployment of the smart contract is completed on the blockchain node and the smart contract is executed. Since the machine code of the smart contract is essentially executed, there is no need to parse the process again. Therefore, the execution efficiency of smart contracts can be improved.

In this embodiment, when deploying the contract, the WASM bytecode of the smart contract is converted into LLVM-IR format, and then compiled into machine code by LLVM, and the compiled machine code is directly used to execute the smart contract when the smart contract is executed. AOT's smart contract acceleration method. Therefore, the bytecode is compiled into machine code through the LLVM compiler, and with the help of the LLVM compiler's good compilation optimization, the execution performance of the smart contract can be better improved, thereby improving the processing performance of the blockchain platform.

It should be noted that the steps shown in the above flow or the flow chart of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and although a logical sequence is shown in the flow chart, in the In some cases, steps shown or described may be performed in an order different from that herein.

In this embodiment, a smart contract execution device is also provided, and the device is used to implement the above-mentioned embodiments and preferred implementations, which have been described and will not be repeated. The terms "module", "unit", "subunit", etc. used below may be a combination of software and/or hardware that implements a predetermined function. Although the apparatus described in the following embodiments is preferably implemented in software, implementations in hardware, or a combination of software and hardware, are also possible and contemplated.

FIG. 6 is a structural block diagram of the smart contract execution device of the present embodiment. As shown in FIG. 6 , the device includes an acquisition module 61, a conversion module 62, a calling module 63 and an execution module 64:

an acquisition module 61 for acquiring the bytecode of the smart contract;

The conversion module 62 is used to convert the bytecode of the smart contract into the intermediate code of the smart contract according to the intermediate language structure of the LLVM project;

The calling module 63 is used to call the compiler provided by the LLVM project, and determine the machine code of the smart contract according to the intermediate code of the smart contract;

The execution module 64 is used to execute the machine code of the smart contract.

In this embodiment, after the acquisition module 61 acquires the bytecode of the smart contract, the conversion module 62 uses the LLVM project to convert the smart contract into LLVM-IR format to obtain the intermediate code of the smart contract, and finally, the calling module 63 relies on the LLVM project The provided compiler obtains the machine code of the smart contract, and the execution module 64 can improve the execution efficiency of the smart contract by executing the machine code of the smart contract. Therefore, this embodiment realizes the execution of the smart contract based on the machine code of the smart contract, which can speed up the execution process of the smart contract more efficiently, and solves the problem that the execution of the smart contract in the related art needs to be parsed and then executed, resulting in a higher execution efficiency of the smart contract. Low problem, improve the execution efficiency of smart contracts.

In some of the embodiments, the conversion module 62 is further configured to obtain a grammar specification determined by the intermediate language structure; according to the grammar specification, convert all the statement sequences in the bytecode of the smart contract into the smart contract Intermediate code for the contract.

In some of these embodiments, the conversion module 62 is further configured to obtain the first instruction type in the bytecode of the smart contract, and determine the second instruction type in the intermediate language structure according to the syntax specification; The first instruction type and the second instruction type are stored to obtain the intermediate code of the smart contract.

In some of the embodiments, the calling module 63 is further configured to compile the intermediate code of the smart contract into the first machine code of the smart contract through the compiler provided by the LLVM project; add the first machine code to the first machine code and converting the first machine code and the symbol table into a binary sequence to obtain the second machine code of the smart contract.

In some of these embodiments, the smart contract execution apparatus further includes a storage module for storing the machine code of the smart contract in a cache and/or a database.

In some of these embodiments, the execution module 64 is further configured to execute the machine code of the smart contract in the cache if the machine code of the smart contract exists in the cache; there is no machine code in the cache. In the case of the machine code of the smart contract, the machine code of the smart contract is obtained from the database to execute; if the machine code of the smart contract does not exist in the database, the bytes of the smart contract are executed. code.

In some of the embodiments, the conversion module 62 is further configured to sequentially convert the bytecode of the smart contract into the intermediate code of the smart contract according to the bytecode sequence in the bytecode of the smart contract; The bytecode of the smart contract is divided into multiple bytecode sequences, and the multiple bytecode sequences are converted into multiple intermediate code sequences of the smart contract through parallel processing, and the smart contract is determined according to the multiple intermediate code sequences. Intermediate code for the contract.

It should be noted that each of the above modules may be functional modules or program modules, and may be implemented by software or hardware. For the modules implemented by hardware, the above-mentioned modules may be located in the same processor; or the above-mentioned modules may also be located in different processors in any combination.

An electronic device is also provided in this embodiment, including a memory and a processor, where a computer program is stored in the memory, and the processor is configured to run the computer program to execute the steps in any one of the above method embodiments.

Optionally, the above-mentioned electronic device may further include a transmission device and an input-output device, wherein the transmission device is connected to the above-mentioned processor, and the input-output device is connected to the above-mentioned processor.

Optionally, in this embodiment, the above-mentioned processor may be configured to execute the following steps through a computer program:

S1, get the bytecode of the smart contract;

S2, according to the intermediate language structure of the LLVM project, convert the bytecode of the smart contract into the intermediate code of the smart contract;

S3, call the compiler provided by the LLVM project, and determine the machine code of the smart contract according to the intermediate code of the smart contract;

S4, the machine code for executing the smart contract.

It should be noted that, for specific examples in this embodiment, reference may be made to the examples described in the foregoing embodiments and optional implementation manners, and details are not repeated in this embodiment.

In addition, in combination with the smart contract execution method provided in the above embodiment, a storage medium may also be provided in this embodiment for implementation. A computer program is stored on the storage medium; when the computer program is executed by the processor, any one of the smart contract execution methods in the foregoing embodiments is implemented.

It should be understood that the specific embodiments described herein are used to illustrate this application, not to limit it. According to the embodiments provided in the present application, all other embodiments obtained by those of ordinary skill in the art without creative work fall within the protection scope of the present application.

Obviously, the accompanying drawings are only some examples or embodiments of the present application, and for those skilled in the art, the present application can also be applied to other similar situations according to these drawings, but no creative work is required. In addition, it can be understood that although the work done in this development process may be complex and lengthy, for those of ordinary skill in the art, certain designs, manufactures and designs based on the technical content disclosed in this application Modifications such as production or production are only conventional technical means, and should not be regarded as insufficient content disclosed in this application.

The term "embodiment" is used in this application to mean that a particular feature, structure, or characteristic described in connection with the embodiment may be included in at least one embodiment of the application. The appearance of the phrase in various places in the specification does not necessarily mean the same embodiment, nor does it mean that it is mutually exclusive or alternative to other embodiments. It can be clearly or implicitly understood by those of ordinary skill in the art that the embodiments described in this application may be combined with other embodiments without conflict.

The above-mentioned embodiments only represent several embodiments of the present application, and the descriptions thereof are relatively specific and detailed, but should not be construed as a limitation on the scope of patent protection. It should be pointed out that for those skilled in the art, without departing from the concept of the present application, several modifications and improvements can be made, which all belong to the protection scope of the present application. Therefore, the scope of protection of the present application should be determined by the appended claims.

Claims (10)

1. An intelligent contract execution method, comprising:

acquiring byte codes of the intelligent contracts;

converting the byte codes of the intelligent contracts into intermediate codes of the intelligent contracts according to the intermediate language structure of the LLVM project;

calling a compiler provided by the LLVM project, and determining a machine code of the intelligent contract according to the intermediate code of the intelligent contract;

machine code that executes the smart contract.

2. The intelligent contract execution method of claim 1, wherein the converting the byte code of the intelligent contract into the intermediate code of the intelligent contract according to the intermediate language structure of the LLVM project comprises:

obtaining a grammar specification determined by the intermediate language construct;

and converting all statement sequences in the byte codes of the intelligent contracts into intermediate codes of the intelligent contracts according to the grammar specifications.

3. The intelligent contract execution method of claim 2, wherein said converting all statement sequences in the byte code of the intelligent contract into the intermediate code of the intelligent contract according to the syntax specification comprises:

acquiring a first instruction type in byte codes of the intelligent contract, and determining a second instruction type in the intermediate language structure according to the grammar specification;

and storing the first instruction type and the second instruction type to obtain the intermediate code of the intelligent contract.

4. The intelligent contract execution method of claim 1, wherein the invoking the compiler provided by the LLVM project, the determining the machine code of the intelligent contract from the intermediate code of the intelligent contract comprises:

compiling the intermediate code of the intelligent contract into a first machine code of the intelligent contract through a compiler provided by the LLVM project;

and adding a symbol table in the first machine code, and converting the first machine code and the symbol table into a binary sequence to obtain a second machine code of the intelligent contract.

5. The intelligent contract execution method of claim 1, wherein prior to executing machine code of the intelligent contract, the method comprises:

storing the machine code of the intelligent contract to a cache and/or a database.

6. The intelligent contract execution method of claim 5, wherein the machine code executing the intelligent contract comprises:

executing the machine code of the intelligent contract in the cache if the machine code of the intelligent contract exists in the cache;

under the condition that the machine code of the intelligent contract does not exist in the cache, acquiring the machine code of the intelligent contract from the database for execution;

executing bytecode of the intelligent contract if the machine code of the intelligent contract is not present in the database.

7. The intelligent contract execution method according to any one of claims 1 to 6, wherein the converting the byte code of the intelligent contract into the intermediate code of the intelligent contract according to the intermediate language structure of the LLVM project comprises:

sequentially converting the byte codes of the intelligent contract into intermediate codes of the intelligent contract according to the byte code sequence in the byte codes of the intelligent contract; or,

the byte codes of the intelligent contract are divided into a plurality of byte code sequences, the byte code sequences are converted into a plurality of intermediate code sequences of the intelligent contract through parallel processing, and the intermediate codes of the intelligent contract are determined according to the intermediate code sequences.

8. An intelligent contract execution device is characterized by comprising an acquisition module, a conversion module, a calling module and an execution module:

the acquisition module is used for acquiring byte codes of the intelligent contracts;

the conversion module is used for converting the byte codes of the intelligent contracts into the intermediate codes of the intelligent contracts according to the intermediate language structure of the LLVM project;

the calling module is used for calling a compiler provided by the LLVM project and determining a machine code of the intelligent contract according to the intermediate code of the intelligent contract;

the execution module is used for executing the machine code of the intelligent contract.

9. An electronic device comprising a memory and a processor, wherein the memory stores a computer program, and the processor is configured to execute the computer program to perform the intelligent contract execution method according to any one of claims 1 to 7.

10. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the smart contract execution method of any one of claims 1 to 7.

Images