CN111105242A - Intelligent contract implementation method for block chain - Google Patents
Intelligent contract implementation method for block chain Download PDFInfo
- Publication number
- CN111105242A CN111105242A CN202010019972.0A CN202010019972A CN111105242A CN 111105242 A CN111105242 A CN 111105242A CN 202010019972 A CN202010019972 A CN 202010019972A CN 111105242 A CN111105242 A CN 111105242A
- Authority
- CN
- China
- Prior art keywords
- contract
- code
- transaction
- function
- account
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 20
- 238000012545 processing Methods 0.000 claims abstract description 11
- 230000006870 function Effects 0.000 claims description 46
- 239000008186 active pharmaceutical agent Substances 0.000 claims description 22
- 230000008569 process Effects 0.000 description 3
- 230000000977 initiatory effect Effects 0.000 description 2
- 238000012423 maintenance Methods 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- 230000008859 change Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000008520 organization Effects 0.000 description 1
- 230000002688 persistence Effects 0.000 description 1
- 230000001105 regulatory effect Effects 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- G06Q20/00—Payment architectures, schemes or protocols
- G06Q20/38—Payment protocols; Details thereof
- G06Q20/40—Authorisation, e.g. identification of payer or payee, verification of customer or shop credentials; Review and approval of payers, e.g. check credit lines or negative lists
- G06Q20/405—Establishing or using transaction specific rules
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- G06Q40/00—Finance; Insurance; Tax strategies; Processing of corporate or income taxes
- G06Q40/04—Trading; Exchange, e.g. stocks, commodities, derivatives or currency exchange
Landscapes
- Business, Economics & Management (AREA)
- Accounting & Taxation (AREA)
- Engineering & Computer Science (AREA)
- Finance (AREA)
- Economics (AREA)
- Development Economics (AREA)
- Strategic Management (AREA)
- Physics & Mathematics (AREA)
- General Business, Economics & Management (AREA)
- General Physics & Mathematics (AREA)
- Theoretical Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Marketing (AREA)
- Technology Law (AREA)
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
Abstract
The invention relates to the technical field of block chains, in particular to a block chain intelligent contract implementation method, which roughly comprises the following steps: creating a new Lua VM according to a received request for calling a contract interface; finding the code of the called contract from the chain and loading the code to the VM; setting different operation context information according to an operation scene, wherein the operation context information comprises but not limited to caller account information, transferred amount and contract initialization information, and then providing a corresponding interface for contract calling, which is called as a contract API; calling a contract interface, performing subsequent processing according to a returned result, and closing the VM; the block chain intelligent contract implementation method realizes the decentralization of contract execution, and has intelligent and efficient operation, high accuracy and low cost.
Description
Technical Field
The invention relates to the technical field of a block chain, in particular to a block chain intelligent contract implementation method, and particularly relates to an account model-based block chain intelligent contract (SmartContract) implementation method operated by an LVM (Lua Virtual machine).
Background
The term "intelligent contract" is first proposed by the famous cryptologist in 1994, i.e. ninx Sabo, and is a computer protocol which is programmed to accurately and efficiently execute preset contract terms, wherein the intelligent contract is a computer protocol, self-verification and automatic execution are realized by a computer instruction, and verifiable evidence is generated to prove the validity of contract operation, when two parties of the intelligent contract generate asset transactions on a block chain, a code is automatically triggered to automatically complete a specific flow, and the series of computer codes are the intelligent contract. A "figure-full" computer programming language is required to implement an intelligent contract.
The traditional contracts are influenced by factors such as subjectivity, economic cost, application range execution strength and execution time, even if the contracts are signed, the two parties cannot be guaranteed to completely fulfill the contents specified by the contracts within a specified time limit, and compared with the intelligent contracts and the traditional contracts, the intelligent contracts can solve the influence of the factors to a great extent.
The main features of an intelligent contract can be simply summarized as:
(1) decentralization: the biggest characteristic of the block chain is decentralized, trust is created in distrust, the intelligent contract based on the block chain is written into the block chain in a digitalized form, the intelligent contract naturally has the decentralized characteristic under the support of the excellent characteristic of the block chain, the contract content is transparent, clear in organization and not capable of being tampered, the programming language is the legal provision for regulating the contract, and the transaction can be completely relieved by two parties;
(2) intelligence is high-efficient: the whole generating and executing process is traceable and non-falsifiable, once a contract is triggered, the contract can be immediately executed, the operation is automatically carried out according to the contract specification, the whole process is intelligent and efficient, and the accuracy and economy of the contract can be embodied by quickly completing the contract in a short time;
(3) the accuracy is as follows: the block chain consensus mechanism and the property of being not falsifiable can ensure that the data is accurate and correct;
(4) the cost is low: the whole execution process of the contract is automatically executed in the block chain system without manual intervention, so that the execution cost, the right maintenance cost and the operation and maintenance cost of the contract are greatly reduced.
Disclosure of Invention
The intelligent contract is an industry or field applied to digital currency by modern block chain technology, so that the intelligent contract has a capacity, the block chain has high expandability and programming capacity, richer application can be realized on the chain, and the ecology and application range are expanded.
A method for realizing intelligent contracts of block chains is characterized by comprising the following steps:
(1) uploading contract codes, wherein a user constructs and initiates an uploaded contract code transaction, the contract code transaction specifies a transaction fee collection standard, if the fee is insufficient, the transaction fails, after the transaction is successfully executed, a contract code is stored on a chain and cannot be changed, and the Hash of the transaction is the address of the contract code and is used for subsequently deploying contracts;
(2) the contract is deployed, a user constructs and initiates a contract deployment transaction, wherein the contract transaction comprises the address of a contract code which is uploaded successfully before, the initial amount transferred to a contract account and parameters for initializing the contract, a new contract account is generated each time the contract is deployed, and enough amount must be transferred to the new contract account to create the contract account;
(3) the system reads contract codes according to code addresses, creates Lua VMs, loads the contract codes, initializes running context information, sets contract APIs for calling, then calls initialization functions of the contracts and transmits initialization parameters;
(4) if the initialization function fails to execute, the transaction fails, otherwise, the initialization information of the contract is stored into the account book, the deployment is successful, at the moment, the contract account is inquired, and the assets on the account and the corresponding contract code address can be seen;
(5) executing contract operation, wherein a user constructs and initiates a contract calling transaction, which comprises a contract account number generated when a contract is deployed before, the cost of calling the contract, the optional amount of money transferred to the contract account number, and an operation code and parameters of the contract calling, the system finds a corresponding contract code address according to the contract account number, reads a contract code according to the contract code address, creates a Lua VM, loads the contract code, initializes context information, sets a contract API for calling, and then calls an execution function of the contract;
(6) processing the returned result of the execution function, if the returned result fails, the transaction fails, otherwise, continuing the subsequent processing;
(7) and checking whether the cost in the transaction meets the requirement of the cost required by the contract, if not, failing the transaction, and returning an error message to the user, otherwise, successfully trading.
Further, in the above-mentioned case,
the user can also initiate a request for inquiring the contract state, wherein a contract account number, an inquired state code and parameters are specified, the system finds a corresponding contract code address according to the contract account number, reads the contract code according to the contract code address, creates a Lua VM, loads the contract code, sets an API for inquiring the contract state and calls an inquiry contract function of the contract;
and processing a returned result of the query contract function, if the returned result fails, returning an error message to the user, and otherwise, returning the queried contract state to the user.
Further, in the above-mentioned case,
the contract code transaction includes 16-system coded contract codes, if the contract codes do not exceed 4000 bytes, no extra transaction fee is charged, otherwise, 1 unit fee is charged per 1 byte.
Further, in the above-mentioned case,
the query contract function is: function query (status, arg)
status: a contract status code of the query, which is a string;
arg: parameters of the contract state are queried and provided by a user of the contract in JSON format, but the parameters are not necessary, and are analyzed before calling, and the parameters can be String, Number, Boolean, Table or Nil depending on the transmitted values;
and returning a value:
the function may return two values, the first is the query result code, 0 indicates success, and the other indicates failure; the second is the status information or reason for failure of the query.
Further, in the above-mentioned case,
the initialization function is: function deploy (cfg)
cfg: the cfg that is ultimately passed to the function is parsed, depending on the value passed, which may be a String, Number, Boolean or Table, or a Nil, i.e., the user does not provide this information;
and returning a value:
the function may return a value that is stored and provided as initialization information, which is not alterable, when the contract is subsequently executed.
Further, in the above-mentioned case,
the execution function is:
function run (op，arg)
op: an operation code for executing a contract, which is a character string;
arg: the parameters provided to the contract operation are provided in JSON format by the user invoking the contract, but not necessarily, parsed before invocation, depending on the value passed, which may be String, Number, Boolean, Table or Nil;
and returning a value:
the function may contain two return values, the first being the necessary execution result code, 0 indicating success, the other indicating failure; the second is an optional result message that is returned to the user indicating the successful result or reason for the failure.
Further, in the above-mentioned case,
the contract API includes, but is not limited to:
(1) storing a contract state; (2) reading contract status; (3) transferring contract account assets to other accounts; (4) invoking other contracts; (5) issuing a contract event notification;
wherein, (1), (3) and (4) can modify the data on the chain, so that the execution is needed in the transaction context, and (2) and (5) can be called to be used in all contract interfaces of the contract when the deploy or run interface of the contract is executed.
Further, in the above-mentioned case,
other APIs for changing the state of the ledger can be added subsequently, such as transactions which are already supported by the system, and in order to limit the newly added or excessively changed state in a contract, the corresponding limit is carried out by setting an upper limit of the number of the modified states and a charging standard.
Further, in the above-mentioned case,
the risk or API which can influence or occupy the system resource can be removed from the Lua VM of the operating contract, so that the safety is improved, and the risk or API which can influence or occupy the system resource comprises a file IO and a Network IO.
Drawings
FIG. 1 is a schematic diagram of the intelligent contract framework design of the present invention.
Detailed Description
In order to make those skilled in the art better understand the technical solutions in the embodiments of the present specification, the technical solutions in the embodiments of the present specification will be described in detail below, and it is obvious that the described embodiments are only a part of the embodiments of the present specification, and not all embodiments, and other embodiments obtained by those skilled in the art based on the embodiments in the present specification should fall within the protection scope.
The technical solutions provided by the embodiments in the present specification are described in detail below, and it should be noted that the following embodiments can be understood by referring to each other since the technical ideas based on the following embodiments are similar.
Example 1:
further, in the above-mentioned case,
we chose the Lua language as the development language for intelligent contracts because:
lua is a complete programming language, has rich ecology and good interoperability, and can conveniently extend the capability of the Lua through C/C + + for the purpose of efficiency and Host resource access;
lua is a high-efficiency and quick script language, and has high execution speed and less occupied resources;
the Lua can be embedded into a host program for use in a function library mode, and the integration is simple and convenient.
Further, in the above-mentioned case,
each contract code issued to a chain has the following interface requirements:
(1) there is an initialization contract interface that will only be invoked when a contract is created, of the form:
function deploy (cfg)
description of the parameters:
cfg: the cfg that is ultimately passed to the function is parsed, depending on the value passed, which may be a String, Number, Boolean or Table, or a Nil, i.e., the user does not provide this information;
and returning a value:
the function may return a value, which may be stored, which may be provided as initialization information, which may not be altered, when a contract is subsequently executed;
(2) there is an interface for executing contract operations, of the form:
function run (op，arg)
description of the parameters:
op: an operation code for executing a contract, which is a character string;
arg: the parameters provided to the contract operation are provided in JSON format by the user invoking the contract, but not necessarily, parsed before invocation, depending on the value passed, which may be String, Number, Boolean, Table or Nil;
and returning a value:
the function may contain two return values, the first being the necessary execution result code, 0 indicating success, the other indicating failure; the second is an optional result message that is returned to the user indicating a successful result or reason for failure;
(3) there is an interface to query contract status, of the form:
function query (status，arg)
description of the parameters:
status: a contract status code of the query, which is a string;
arg: parameters of the contract state are queried and provided by a user of the contract in JSON format, but the parameters are not necessary, and are analyzed before calling, and the parameters can be String, Number, Boolean, Table or Nil depending on the transmitted values;
and returning a value:
the function may return two values, the first is the query result code, 0 indicates success, and the other indicates failure; the second is the status information or reason for failure of the query.
Further, in the above-mentioned case,
corresponding to the three contract interfaces defined above, each having its different runtime environment and context, as described below:
deploy: when a contract is created or initialized or deployed, the contract is called, the contract has the capacity of storing data to an account book and reading, account information of the deployed contract can be obtained, assets in the contract account can be transferred to other accounts, the deployed contract is executed as a chain in an exchange mode, atomicity of the deployed contract is guaranteed, and state data of the deployed contract can be stored on the chain;
run: executing contract operation, which is called by a contract user, has the capability of storing data into an account book and reading, can acquire account information for calling the contract, the amount information transferred into a contract account and contract initialization information, can transfer assets in the contract account to other account numbers, deploys the contract as a chain for transaction execution, ensures the atomicity of the contract, and can store state data of the contract on the chain;
query: the contract status is queried, invoked by the contract user, which can read the contract data stored on the ledger, as well as the contract initialization information, but which cannot modify the contract status data, to execute as a non-transactional request.
Further, in the above-mentioned case,
the approximate flow of operations on the chain is as follows:
(1) creating a new Lua VM according to a received request for calling a contract interface;
(2) finding the code of the called contract from the chain and loading the code to the VM;
(3) setting different operation context information according to an operation scene, wherein the operation context information comprises but not limited to caller account information, transferred amount and contract initialization information, and then providing a corresponding interface for contract calling, which is called as a contract API;
(4) calling a contract interface, performing subsequent processing according to a returned result, and closing the VM;
wherein, the contract context related information is accessed in the contract code through a global variable named ctx, which is a table;
description of the drawings:
from the description, it can be seen that each time a contract is run, a new Lua VM is created, rather than maintaining a VM for the contract and recording its state all the time, because:
after each contract is executed, a complete VM state is generated and saved for the contract, and space is excessively consumed;
the VM state cannot be subjected to incremental storage, so that the consumed space is rapidly increased;
by doing so, the memory consumption of the system can be reduced, which also means that we should not rely on global variables to save the state of cross-contract calls, and state persistence;
in addition, for safety, the file IO, the Network IO and other dangers or APIs which can influence or occupy system resources are removed from the Lua VM of the running contract;
in addition, with respect to the contract API: only the key APIs for accessing contract status and changing ledger status are given here;
(1) storing a contract state;
(2) reading contract status;
(3) transferring contract account assets to other accounts;
(4) invoking other contracts;
(5) issuing a contract event notification;
wherein, (1), (3), (4) will modify the data on the chain, so need to be carried out in the context of transaction, can while carrying out the deploy or run interface of the contract, call (2), (5) can be used in all contract interfaces of the contract, in addition to above interface, will add other APIs which change the state of the ledger subsequently, such as those transactions that the system has already supported totally;
further, to limit the number of new or changed states in a contract, we limit it accordingly and set an upper limit on the number of modified states and charging criteria.
Further, in the above-mentioned case,
the specific procedure followed in the chain is as follows:
(1) uploading contract codes, and constructing and initiating an uploading contract code transaction by a user, wherein the uploading contract codes comprise contract codes subjected to 16-system coding, the size of the uploaded codes (before 16-system coding) is not more than 4000 bytes, no extra transaction fee is charged, otherwise, 1 unit fee is charged per 1 byte, if the fee is insufficient, the transaction fails, after the transaction is successfully executed, a contract code is stored on a chain and cannot be changed, and the Hash of the transaction, namely the address of the contract code, is used for deploying the contract subsequently;
(2) the contract is deployed, a user constructs and initiates a contract deployment transaction, wherein the contract deployment transaction comprises an address of a contract code which is uploaded successfully before, an initial amount transferred to a contract account, and parameters for initializing the contract, a new contract account is generated each time the contract is deployed, and as with a common account, in order to create the account, enough amount must be transferred to the account, but the account is different from the common account, is not calculated according to a generated public key, so that the account does not have a corresponding private key, cannot be transferred out in a source account signature transaction mode, and can only be transferred out from the contract code in a contract invoking context;
(3) the system reads contract codes according to code addresses, creates Lua VMs, loads the contract codes, initializes the running context, sets the contract APIs for calling, then calls the default functions of the contracts and transmits initialization parameters;
(4) if the execution of the default function fails, the transaction fails, otherwise, the initialization information of the contract is stored in the account book, the deployment is successful, at the moment, the contract account is inquired, and the assets on the account and the corresponding contract code address can be seen;
(5) executing contract operation, constructing and initiating a contract calling transaction by a user, wherein the contract calling transaction comprises a contract account number generated when a contract is deployed before, the cost of calling the contract, the optional amount of money transferred to the contract account number, and an operation code and parameters of the contract calling, finding a corresponding contract code address according to the contract account number by the system, reading a contract code according to the contract code address, creating a Lua VM, loading the contract code, initializing context information, setting a contract API for calling, and then calling a run function of the contract;
(6) processing the return result of the run function, if the return fails, the transaction fails, otherwise, continuing the subsequent processing;
(7) checking whether the cost in the transaction meets the requirement of the cost required by the contract, if not, failing the transaction, and returning an error message to the user, otherwise, successfully trading;
(8) a user initiates a request for inquiring contract state, wherein a contract account number, an inquired state code and parameters are specified, a system finds a corresponding contract code address according to the contract account number, reads a contract code according to the contract code address, creates a LuaVM, loads the contract code, sets an API for inquiring the contract state and calls a query function of a contract;
(9) and processing the returned result of the query function, if the returned result fails, returning an error message to the user, otherwise, returning the inquired contract state to the user.
The above embodiments are merely technical ideas and features of the present invention, and thus should not limit the scope of the present invention, and all equivalent changes or modifications made according to the spirit of the present invention should be covered within the scope of the present invention.
Claims (9)
1. A method for realizing intelligent contracts of block chains is characterized by comprising the following steps:
(1) uploading contract codes, wherein a user constructs and initiates an uploaded contract code transaction, the contract code transaction specifies a transaction fee collection standard, if the fee is insufficient, the transaction fails, after the transaction is successfully executed, a contract code is stored on a chain and cannot be changed, and the Hash of the transaction is the address of the contract code and is used for subsequently deploying contracts;
(2) the contract is deployed, a user constructs and initiates a contract deployment transaction, wherein the contract transaction comprises the address of a contract code which is uploaded successfully before, the initial amount transferred to a contract account and parameters for initializing the contract, a new contract account is generated each time the contract is deployed, and enough amount must be transferred to the new contract account to create the contract account;
(3) the system reads contract codes according to code addresses, creates Lua VMs, loads the contract codes, initializes running context information, sets contract APIs for calling, then calls initialization functions of the contracts and transmits initialization parameters;
(4) if the initialization function fails to execute, the transaction fails, otherwise, the initialization information of the contract is stored into the account book, the deployment is successful, at the moment, the contract account is inquired, and the assets on the account and the corresponding contract code address can be seen;
(5) executing contract operation, wherein a user constructs and initiates a contract calling transaction, which comprises a contract account number generated when a contract is deployed before, the cost of calling the contract, the optional amount of money transferred to the contract account number, and an operation code and parameters of the contract calling, the system finds a corresponding contract code address according to the contract account number, reads a contract code according to the contract code address, creates a Lua VM, loads the contract code, initializes context information, sets a contract API for calling, and then calls an execution function of the contract;
(6) processing the returned result of the execution function, if the returned result fails, the transaction fails, otherwise, continuing the subsequent processing;
(7) and checking whether the cost in the transaction meets the requirement of the cost required by the contract, if not, failing the transaction, and returning an error message to the user, otherwise, successfully trading.
2. A method for implementing intelligent block chain contracts according to claim 1,
the user can also initiate a request for inquiring the contract state, wherein a contract account number, an inquired state code and parameters are specified, the system finds a corresponding contract code address according to the contract account number, reads the contract code according to the contract code address, creates a Lua VM, loads the contract code, sets an API for inquiring the contract state and calls an inquiry contract function of the contract;
and processing a returned result of the query contract function, if the returned result fails, returning an error message to the user, and otherwise, returning the queried contract state to the user.
3. A method for implementing intelligent block chain contracts according to claim 1,
the contract code transaction includes 16-system coded contract codes, if the contract codes do not exceed 4000 bytes, no extra transaction fee is charged, otherwise, 1 unit fee is charged per 1 byte.
4. A method for implementing intelligent block chain contracts according to claim 2,
the query contract function is: function query (status, arg)
status: a contract status code of the query, which is a string;
arg: parameters of the contract state are queried and provided by a user of the contract in JSON format, but the parameters are not necessary, and are analyzed before calling, and the parameters can be String, Number, Boolean, Table or Nil depending on the transmitted values;
and returning a value:
the function may return two values, the first is the query result code, 0 indicates success, and the other indicates failure; the second is the status information or reason for failure of the query.
5. A method for implementing intelligent block chain contracts according to claim 1,
the initialization function is: function deploy (cfg)
cfg: the cfg that is ultimately passed to the function is parsed, depending on the value passed, which may be a String, Number, Boolean or Table, or a Nil, i.e., the user does not provide this information;
and returning a value:
the function may return a value that is stored and provided as initialization information, which is not alterable, when the contract is subsequently executed.
6. A method for implementing intelligent block chain contracts according to claim 1,
the execution function is:
function run (op，arg)
op: an operation code for executing a contract, which is a character string;
arg: the parameters provided to the contract operation are provided in JSON format by the user invoking the contract, but not necessarily, parsed before invocation, depending on the value passed, which may be String, Number, Boolean, Table or Nil;
and returning a value:
the function may contain two return values, the first being the necessary execution result code, 0 indicating success, the other indicating failure; the second is an optional result message that is returned to the user indicating the successful result or reason for the failure.
7. A method for implementing intelligent block chain contracts according to claim 1,
the contract API includes, but is not limited to:
(1) storing a contract state; (2) reading contract status; (3) transferring contract account assets to other accounts; (4) invoking other contracts; (5) issuing a contract event notification;
wherein, (1), (3) and (4) can modify the data on the chain, so that the execution is needed in the transaction context, and (2) and (5) can be called to be used in all contract interfaces of the contract when the deploy or run interface of the contract is executed.
8. A method for implementing intelligent block chain contracts according to claim 7,
other APIs for changing the state of the ledger can be added subsequently, such as transactions which are already supported by the system, and in order to limit the newly added or excessively changed state in a contract, the corresponding limit is carried out by setting an upper limit of the number of the modified states and a charging standard.
9. A method for implementing intelligent block chain contracts according to claim 1,
the risk or API which can influence or occupy the system resource can be removed from the Lua VM of the operating contract, so that the safety is improved, and the risk or API which can influence or occupy the system resource comprises a file IO and a Network IO.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010019972.0A CN111105242A (en) | 2020-01-09 | 2020-01-09 | Intelligent contract implementation method for block chain |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010019972.0A CN111105242A (en) | 2020-01-09 | 2020-01-09 | Intelligent contract implementation method for block chain |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111105242A true CN111105242A (en) | 2020-05-05 |
Family
ID=70426119
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010019972.0A Pending CN111105242A (en) | 2020-01-09 | 2020-01-09 | Intelligent contract implementation method for block chain |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111105242A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR102267560B1 (en) * | 2020-11-13 | 2021-06-21 | 주식회사 케이사인 | Method for Managing Modified Record of Data Which Can Reduce Size of Data Stored in Block Chain |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109087104A (en) * | 2018-08-29 | 2018-12-25 | 北京京东尚科信息技术有限公司 | Block chain intelligence contract administration method and system, computer readable storage medium |
| CN109976871A (en) * | 2018-12-28 | 2019-07-05 | 无锡井通网络科技有限公司 | Intelligent contract dispositions method, device, electronic equipment and storage medium |
-
2020
- 2020-01-09 CN CN202010019972.0A patent/CN111105242A/en active Pending
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109087104A (en) * | 2018-08-29 | 2018-12-25 | 北京京东尚科信息技术有限公司 | Block chain intelligence contract administration method and system, computer readable storage medium |
| CN109976871A (en) * | 2018-12-28 | 2019-07-05 | 无锡井通网络科技有限公司 | Intelligent contract dispositions method, device, electronic equipment and storage medium |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR102267560B1 (en) * | 2020-11-13 | 2021-06-21 | 주식회사 케이사인 | Method for Managing Modified Record of Data Which Can Reduce Size of Data Stored in Block Chain |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109710384B (en) | Safe Java intelligent contract interpretation execution engine and method | |
| CN109034814B (en) | Intelligent contract processing method and device based on Etheng virtual machine | |
| CN107562513B (en) | Intelligent contract life cycle management method based on JAVA | |
| CN111095338A (en) | System and method for executing different types of blockchain contracts | |
| TW202101198A (en) | System and method for implementing different types of blockchain contracts | |
| CN106462412A (en) | Structural identification of dynamically-generated, pattern-based classes | |
| CN111179086B (en) | Intelligent contract virtual machine based on WebAsssemly | |
| KR20010103748A (en) | Techniques for permitting access across a context barrier on a small footprint device using an entry point object | |
| KR20010103747A (en) | Techniques for permitting access across a context barrier in a small footprint device using global data structures | |
| WO2022148390A1 (en) | Methods for deploying, updating and calling smart contract in blockchain | |
| CN108229107A (en) | A kind of hulling method and container of Android platform application program | |
| CN111176791A (en) | Cross-virtual machine calling method based on multi-virtual machine blockchain platform | |
| WO2024045382A1 (en) | Implementation of reflective mechanism in blockchain | |
| KR20010108114A (en) | Techniques for implementing security on a small footprint device using a context barrier | |
| KR20010101622A (en) | Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges | |
| CN112308716A (en) | Block chain intelligent contract execution method, device, equipment and computer storage medium | |
| CN112463294A (en) | Physical GPU virtualization management method, system, equipment and product | |
| CN111105242A (en) | Intelligent contract implementation method for block chain | |
| CZ423598A3 (en) | Portable safe transaction system for programmable intelligent devices | |
| WO2022110775A1 (en) | Serverless container starting method and related device | |
| CN117149292B (en) | Electronic equipment starting method and device, server, computer equipment and medium | |
| CN110751486B (en) | Intelligent contract replay proof method, system, electronic equipment and storage medium | |
| JP3515417B2 (en) | Methods and apparatus for creating objects in non-persistent memory and methods for maintaining accessibility to objects | |
| CN112631613A (en) | Intelligent contract deploying and calling method based on block chain platform and related equipment | |
| CN112256249A (en) | Method and equipment for expanding Android system function and computer storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20200505 |