CN111258714A - A blockchain smart contract execution method - Google Patents

Abstract

The invention discloses a blockchain smart contract execution method. A contract data service module and a contract loading module are set in a blockchain node, and the blockchain node receives a dynamic shared library of smart contracts and smart contract deployment transactions from users. After the legality check, the smart contract dynamic shared library is forwarded to the contract loading module for loading, the contract Docker container is created and started, and then the contract service program is started. The blockchain node receives the smart contract request from the user and forwards it to the contract service program is executed. By adopting the present invention, the loading and running of the smart contract can be quickly completed, and the convenience and efficiency of the blockchain smart contract invocation can be improved.

Description

A blockchain smart contract execution method

technical field

The invention belongs to the technical field of blockchain, and more specifically, relates to a method for executing a blockchain smart contract.

Background technique

As a new distributed infrastructure and computing paradigm, blockchain technology covers P2P networks, encryption algorithms, smart contracts, consensus algorithms and other technologies. Based on this integrated technology stack, the blockchain implements a tamper-proof, traceable, and decentralized system, which effectively solves the problems of central authority, poor reliability, and low security in the traditional model.

A smart contract is a computer protocol designed to disseminate, verify or execute contracts in an informative manner. Essentially, a smart contract in a blockchain is a piece of code that is jointly written by various parties, confirmed and then deployed on the blockchain to run in a sandbox. However, most of the current smart contract execution has problems such as complex design and difficulty in function expansion.

SUMMARY OF THE INVENTION

The purpose of the present invention is to overcome the deficiencies of the prior art, provide a blockchain smart contract execution method, quickly complete the loading and running of the smart contract, and improve the convenience and efficiency of the blockchain smart contract invocation.

In order to achieve the above purpose of the invention, the blockchain smart contract execution method of the present invention includes the following steps:

S1: Set up a contract data service module and a contract loading module in the blockchain node. The contract data service module is implemented by remote procedure call RPC based on network socket UDS, which is used to provide the required execution of the smart contract target function. Business data is started in the form of UDS when the blockchain node is started; the contract loading module is used to create and start the contract Docker container;

S2: The blockchain node receives the dynamic shared library of the smart contract and the smart contract deployment transaction from the user, and the files in the dynamic shared library are compiled from the smart contract source code; the blockchain node executes the received smart contract deployment transaction. Validity verification, after the verification is passed, the smart contract dynamic shared library is forwarded to the contract loading module;

S3: The contract loading module uses the received smart contract dynamic shared library and the basic environment Docker image to create a contract Docker image, and then performs directory mapping on the contract and blockchain nodes to obtain the directory mapping relationship, and then uses the contract Docker image and Directory mapping relationship to create and start the contract Docker container;

S4: The contract service program in the Docker container is started, and the contract dynamic shared library is parsed during the startup process to create a smart contract instance, and create a client that communicates with the contract data service module;

S5: The blockchain node receives the smart contract request from the user, and the smart contract request includes the contract address, target function name and its execution parameters; After the verification is passed, the smart contract call request is forwarded to the corresponding contract service program according to the contract address;

S6: The contract service program in the Docker container first parses out the target function name and its execution parameters in the smart contract call request, and creates an instance object corresponding to the smart contract programming interface; then uses the reflection mechanism according to the contract instance and target function name Obtain the handle of the target function; finally, encapsulate the target function execution parameters and the programming interface instance object into the request parameters of the target function, and complete the corresponding processing logic through the obtained target function handle, and the contract service program uses the programming interface instance throughout the processing process. The object obtains the corresponding business data from the contract data service module.

In the blockchain smart contract execution method of the invention, a contract data service module and a contract loading module are set in the blockchain node, and the blockchain node receives the dynamic shared library of the smart contract and the smart contract deployment transaction from the user, and performs legality verification. After verification, the smart contract dynamic shared library is forwarded to the contract loading module for loading, the contract Docker container is created and started, and then the contract service program is started. The blockchain node receives the smart contract request from the user and forwards it to the contract service program for execution.

In the present invention, the source code of the smart contract is compiled into the form of a dynamic shared library file, which has the characteristics of concise code file and easy to load quickly. The smart contract is run in the way of Docker container, and the contract data service module and contract are loaded in the way of UDS service. The integration of modules and contract service programs has the characteristics of simple and lightweight design. At the same time, it can also realize mutual calls between smart contracts, so that each smart contract is not independent of each other, which is convenient for the expansion of business functions.

Description of drawings

FIG. 1 is a flow chart of a specific implementation of the blockchain smart contract execution method of the present invention.

Detailed ways

The specific embodiments of the present invention are described below with reference to the accompanying drawings, so that those skilled in the art can better understand the present invention. It should be noted that, in the following description, when the detailed description of known functions and designs may dilute the main content of the present invention, these descriptions will be omitted here.

Example

FIG. 1 is a flow chart of a specific implementation of the blockchain smart contract execution method of the present invention. As shown in Figure 1, the specific steps of the blockchain smart contract execution method of the present invention include:

S101: Blockchain Node Settings:

A contract data service module and a contract loading module are set up in the blockchain node. The contract data service module is implemented by remote procedure call RPC based on network socket UDS (Unix Domain Socket), which is used to provide the execution of smart contract target functions. The required business data is started in the form of UDS when the blockchain node starts; the contract loading module is used to create and start the contract Docker container.

S102: Smart Contract Deployment:

The blockchain node receives the dynamic shared library of the smart contract and the smart contract deployment transaction from the user, and the files in the dynamic shared library are compiled from the source code of the smart contract; the blockchain node checks the validity of the received smart contract deployment transaction. After verification, the smart contract dynamic shared library is forwarded to the contract loading module after the verification is passed.

S103: Contract loading:

The contract loading module uses the received smart contract dynamic shared library and the basic environment Docker image to create a contract Docker image, and then performs directory mapping on the contract and blockchain nodes to obtain the directory mapping relationship, and then uses the contract Docker image and directory mapping. relationship to create and start a contract Docker container. The basic environment Docker image only contains the Ubuntu operating system and the contract service program.

The specific process of directory mapping includes:

1) Associate the UDS file created when the contract data service module starts with the file in the Docker container;

2) Associate the directory of the UDS file created when the contract service program is started with the directory of the smart contract in the blockchain node;

3) Associate the directories of all contracts in the blockchain with the newly created contract directory in the contract Docker container.

S104: The contract service program starts:

The contract service program in the Docker container is started (the contract service program will automatically start in the form of a UDS-based RPC service after the contract Docker container is started), and the contract dynamic shared library is parsed during the startup process to create a smart contract instance and create a contract Client for data service module communication. Among them, the smart contract instance is created by the contract service program using the reflection mechanism when loading the smart contract dynamic shared library, and the client that communicates with the contract data service module is the UDS file of the contract data service in the contract Docker container by the contract service program. created.

S105: Smart contract request processing:

The blockchain node receives the smart contract request from the user, and the smart contract request includes the contract address, target function name and its execution parameters; the blockchain node checks the validity of the received smart contract call request, and the verification passes Then forward the smart contract call request to the corresponding contract service program according to the contract address.

S106: Smart contract execution:

The contract service program in the Docker container first parses out the target function name and its execution parameters in the smart contract call request, and creates an instance object corresponding to the smart contract programming interface; then uses the reflection mechanism to obtain the target according to the contract instance and target function name. The handle of the function; finally, the target function execution parameters and the programming interface instance object are encapsulated into the request parameters of the target function, and the corresponding processing logic is completed through the obtained target function handle. The client that communicates with the contract data service module obtains the corresponding business data.

In order to realize mutual calls between smart contracts, the contract service program can use the UDS files of all smart contracts in the contract Docker container to establish a communication connection with the contract service program in the contract Docker container of other smart contracts, and send a contract call request to it. So as to realize the call between smart contracts

In order to better illustrate the technical solution of the present invention, the present invention will be explained with the transfer application in the payment field. The specific process is as follows:

The blockchain node starts the contract data service module in the form of UDS at startup.

The user writes the transfer contract code according to the programming interface predetermined by the contract service program, and the Transfer function in the contract code provides specific transfer operations. The user compiles the transfer contract into a dynamic shared library, packages it, and sends it to the blockchain node to request contract deployment. The blockchain node first verifies the legitimacy of the deployment request. After the verification is passed, the contract loading module uses the dynamic shared library of the transfer contract and the basic environment Docker image to create a Docker image of the transfer contract, and then uses the contract Docker image and the set directory. The mount relationship creates and starts the Docker container of the transfer contract.

The contract service program in the Docker container of the transfer contract starts, parses the dynamic shared library of the transfer contract to create the transfer contract instance object, then creates a client that communicates with the contract data service module, and finally completes the startup of the entire service in the form of UDS.

The user sends a contract call request to the blockchain node. The contract address in the request is the contract address of the transfer contract, the target function is named Transfer, and the execution parameter is that user A transfers 10 yuan to user B. The blockchain node checks the validity of the call request, and after the verification passes, the request is forwarded to the contract service program.

The contract service program first obtains the target function name Transfer and its execution parameters from the contract call request. User A transfers 10 yuan to user B, and then the contract service program creates an instance object corresponding to the smart contract programming interface, and then uses the reflection mechanism to transfer money from the transfer. Obtain a function handle named Transfer from the contract instance object, and then encapsulate the execution parameter of the target function, user A to transfer 10 yuan to user B, and the instance object of the programming interface into the request parameter of the target function, and finally use this parameter and the function handle of Transfer To execute the real transfer operation logic, when executing the transfer logic, the instance object of the programming interface will be used to request the corresponding business data through the client that communicates with the contract data service module to complete the change of the account balance.

Although the illustrative specific embodiments of the present invention have been described above to facilitate the understanding of the present invention by those skilled in the art, it should be clear that the present invention is not limited to the scope of the specific embodiments. For those skilled in the art, As long as various changes are within the spirit and scope of the present invention as defined and determined by the appended claims, these changes are obvious, and all inventions and creations utilizing the inventive concept are included in the protection list.

Claims (4)

1. A block chain intelligent contract execution method is characterized by comprising the following steps:

s1: setting a contract data service module and a contract loading module in a block link point, wherein the contract data service module is realized by Remote Procedure Call (RPC) based on a network socket Universal Description System (UDS) and is used for providing required service data for the execution of an intelligent contract target function, and the contract data service module is started in the form of the UDS when the block link point is started; the contract loading module is used for creating and starting a contract Docker container;

s2: the block chain link point receives a dynamic shared library of the intelligent contract and an intelligent contract deployment transaction from a user, and a file in the dynamic shared library is compiled by an intelligent contract source code; the block link points carry out validity check on the received intelligent contract deployment transaction, and the intelligent contract dynamic shared library is forwarded to the contract loading module after the check is passed;

s3: the contract loading module creates a contract Docker mirror image by using the received intelligent contract dynamic shared library and the basic environment Docker mirror image, then performs directory mapping on the contract and the block link point to obtain a directory mapping relation, and then creates and starts a contract Docker container by using the contract Docker mirror image and the directory mapping relation;

s4: starting a contract service program in the Docker container, analyzing a contract dynamic shared library in the starting process to create an intelligent contract instance, and creating a client communicated with a contract data service module;

s5: the block chain node receives an intelligent contract request from a user, wherein the intelligent contract request comprises a contract address, a target function name and an execution parameter thereof; the block chain link points carry out validity check on the received intelligent contract calling request, and the intelligent contract calling request is forwarded to a corresponding contract loading service program according to the contract address after the check is passed;

s6: firstly, analyzing a target function name and an execution parameter thereof in the intelligent contract calling request by a contract service program in the Docker container, and creating an instance object corresponding to an intelligent contract programming interface; then, acquiring a handle of the target function by using a reflection mechanism according to the contract instance and the target function name; finally, the target function execution parameter and the programming interface instance object are packaged into the request parameter of the target function, the corresponding processing logic is completed through the obtained target function handle, and the contract service program utilizes the instance object of the programming interface to obtain the corresponding service data from the contract data service module in the whole processing process.

2. The method of claim 1, wherein the step of mapping the directory in step S3 comprises:

1) associating a UDS file created when a contract data service module is started with a file in a Docker container;

2) associating a directory where a UDS file is located and created when a contract service program is started with a directory of the intelligent contract in a block chain node;

3) the directories of all the contracts in the blockchain are associated with the newly-created contract directory in the contract Docker container.

3. A method for block chain intelligent contract execution according to claim 1, wherein in step S4, the intelligent contract instance is created by a contract service program using a reflection mechanism when loading the intelligent contract dynamic shared library, and the client communicating with the contract data service module is created by the contract service program using a UDS file of the contract data service in the contract Docker container.

4. A block chain intelligent contract execution method according to claim 1, wherein the contract service program establishes a communication connection with the contract service programs in the contract Docker containers of other intelligent contracts by using UDS files of all intelligent contracts in the contract Docker containers, and sends contract call requests thereto.

Images