CN110704063B - Method and device for compiling and executing intelligent contract - Google Patents
Method and device for compiling and executing intelligent contract Download PDFInfo
- Publication number
- CN110704063B CN110704063B CN201910939503.8A CN201910939503A CN110704063B CN 110704063 B CN110704063 B CN 110704063B CN 201910939503 A CN201910939503 A CN 201910939503A CN 110704063 B CN110704063 B CN 110704063B
- Authority
- CN
- China
- Prior art keywords
- code
- function
- contract
- external
- intelligent contract
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 54
- 230000006870 function Effects 0.000 claims abstract description 391
- 230000015654 memory Effects 0.000 claims description 20
- 230000008676 import Effects 0.000 claims description 19
- 238000004590 computer program Methods 0.000 claims description 3
- 238000004458 analytical method Methods 0.000 claims description 2
- 230000008569 process Effects 0.000 description 17
- 238000010586 diagram Methods 0.000 description 13
- 230000005540 biological transmission Effects 0.000 description 5
- 238000011161 development Methods 0.000 description 5
- 238000012545 processing Methods 0.000 description 5
- 238000007726 management method Methods 0.000 description 3
- 230000007246 mechanism Effects 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 239000003999 initiator Substances 0.000 description 1
- JEIPFZHSYJVQDO-UHFFFAOYSA-N iron(III) oxide Inorganic materials O=[Fe]O[Fe]=O JEIPFZHSYJVQDO-UHFFFAOYSA-N 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000004806 packaging method and process Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/43—Checking; Contextual analysis
- G06F8/436—Semantic checking
- G06F8/437—Type checking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- 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
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computational Linguistics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The embodiment of the specification provides a method and a device for compiling and executing an intelligent contract, according to the method, when the intelligent contract is compiled and depends on an external function, implementation codes of the external function are not included in the contract for compiling any more, but are converted into a calling instruction of the external function, and declaration information of the function is added into an importing section of a contract module. The contract module thus generated contains only declaration information of the external function, and does not contain implementation code of the external function. When the intelligent contract is executed, the virtual machine determines the function code for realizing the external function from the function library which is realized by adopting the same language, and further obtains the executable code block corresponding to the function code, and links the code segment with the contract code, thereby executing the external function.
Description
Technical Field
One or more embodiments of the present disclosure relate to the field of blockchain technology, and more particularly, to a method and apparatus for compiling and executing intelligent contracts in blockchains.
Background
Currently, more and more blockchain platforms support intelligent contracts to perform richer transactions. The intelligent contract is a transaction contract which can be automatically executed, is written into a block chain in a digital form, and ensures that the whole process of storage, reading and execution is transparent, traceable and not falsifiable by the characteristics of the block chain technology. Meanwhile, a set of state machine system is constructed by the block chain self-contained consensus algorithm, so that the intelligent contract can run efficiently. For example, the etherhouse provides an open-source blockchain underlying system, and by providing a plurality of interfaces, developers are allowed to develop various blockchain applications on the basis of the open-source blockchain underlying system and write intelligent contracts.
In this way, the blockchain platform allows users to conduct richer transactions, thereby providing richer functionality. Accordingly, more and more data storage, program applications (e.g., distributed applications Dapp), are implemented through blockchains. Correspondingly, a virtual machine is provided in each node of the block chain and used for executing the intelligent contract in the block chain, and the virtual machines in each node are ensured to have the same execution state and execution result through a consensus mechanism. Therefore, the execution efficiency of the intelligent contract becomes the main performance index of the blockchain platform.
Therefore, it is desirable to provide an efficient scheme for improving the execution efficiency of intelligent contracts in a blockchain and improving the performance of a blockchain platform.
Disclosure of Invention
One or more embodiments of the present specification describe a method and apparatus for compiling and executing an intelligent contract, so as to improve the deployment efficiency and execution performance of the intelligent contract.
According to a first aspect, there is provided a method of executing an intelligent contract, performed by a virtual machine, the method comprising:
acquiring a contract module corresponding to an intelligent contract, wherein the contract module comprises a code section and an import section, and the import section comprises function declaration information of a first external function;
analyzing the byte codes in the code section to obtain a calling instruction code of the first external function;
according to the function declaration information of the first external function, determining a function code for realizing the first external function from a function library which is contained in a virtual machine and realized by adopting the same language, and acquiring an executable first code segment corresponding to the function code;
linking the calling instruction code to the first code segment to obtain a link code;
executing the linking code to execute the first external function in the intelligent contract.
In one embodiment, before obtaining the contract module corresponding to the intelligent contract, the method further includes: a first transaction is received, a target address field of the first transaction pointing to a contract address of the intelligent contract to request invocation of the intelligent contract.
According to one embodiment, the bytecode module is a WASM module.
In one embodiment, the method further comprises determining that the first external function is a function provided in the function library according to the function declaration information of the first external function.
In one embodiment, the virtual machine and the function code are implemented in C language or C + + language.
According to one embodiment, obtaining the corresponding executable first code segment of the function code includes: compiling the function code into the first code segment, wherein the first code segment is a native code suitable for a platform where the virtual machine is located.
According to another embodiment, obtaining the corresponding executable first code segment of the function code includes: and obtaining the first code segment which is loaded and generated by compiling the function code from the memory, wherein the first code segment is a native code suitable for the platform where the virtual machine is located.
In one embodiment, the call instruction code is linked to the first code segment by: and pointing the address for executing the calling instruction code to a memory address for storing the first code segment.
According to a second aspect, there is provided an apparatus for executing an intelligent contract, the apparatus being deployed in a virtual machine, the apparatus comprising:
the intelligent contract management system comprises a module acquisition unit, a contract module management unit and a contract management unit, wherein the contract module is configured to acquire a contract module corresponding to an intelligent contract, the contract module comprises a code section and an import section, and the import section comprises function declaration information of a first external function;
the analysis unit is configured to analyze the byte codes in the code section to obtain a calling instruction code of the first external function;
a code obtaining unit, configured to determine, according to function declaration information of the first external function, a function code for implementing the first external function from a function library implemented in the same language included in a virtual machine, and obtain an executable first code segment corresponding to the function code;
a linking unit configured to link the call instruction code to the first code segment to obtain a linking code;
an execution unit configured to execute the linking code to execute the first external function in the intelligent contract.
According to a third aspect, there is provided a computer readable storage medium having stored thereon a computer program which, when executed in a computer, causes the computer to perform the method of the first aspect.
According to a fourth aspect, there is provided a computing device comprising a memory and a processor, wherein the memory has stored therein executable code, and wherein the processor, when executing the executable code, implements the method of the first aspect.
According to the method and the device provided by one embodiment of the specification, when the intelligent contract is compiled and depends on the external function, only the declaration information of the external function is contained in the generated contract module, and the implementation code of the external function is not contained. When executing the intelligent contract, the virtual machine determines a function code for realizing the external function from a local function library, further acquires a corresponding executable code segment, and links the code segment with the contract code, thereby executing the external function. Through the mode, the contract module does not contain the implementation code of the external function, the size is very small, and the transmission and the deployment of the contract are convenient. In addition, the smaller module size also greatly reduces the burden of loading the contract module and analyzing the byte code of the virtual machine, so that the contract execution efficiency is higher. Thus, the execution performance of the intelligent contract and the availability of the blockchain platform are improved.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings needed to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.
FIG. 1 is a process diagram of deploying an intelligent contract in a blockchain network;
FIG. 2 illustrates a compilation process diagram of an intelligent contract;
FIG. 3 illustrates a flowchart of a method of compiling a smart contract, according to one embodiment;
FIG. 4 illustrates a schematic diagram of compiling an intelligent contract, according to one embodiment;
FIG. 5 illustrates a flowchart of a method of executing an intelligent contract, according to one embodiment;
FIG. 6 illustrates a schematic diagram of executing an intelligent contract in one example;
FIG. 7 shows a schematic block diagram of a compiling apparatus according to an embodiment;
FIG. 8 illustrates a schematic block diagram of a contract execution apparatus according to one embodiment.
Detailed Description
The scheme provided by the specification is described below with reference to the accompanying drawings.
FIG. 1 is a process diagram for deploying an intelligent contract in a blockchain network. As shown in fig. 1, the blockchain network includes several nodes, and each node can communicate with each other. The user can initiate a transaction through the node by means of the external account, and the transaction can be a common transfer transaction and can also be used for creating an intelligent contract or calling the intelligent contract. Assuming that at a certain node in the network, the contract developer Bob wants to publish a piece of intelligent contract, a publishing process as shown in the figure may be employed.
First, Bob may write an intelligent contract in a high-level language. Then, the high-level language is compiled into a byte code (bytecode) file by a compiler, and a contract module is generated.
Bytecode is an intermediate code format between high-level languages and machine code, comprising a binary character encoding of a sequence of opcode code (opcode)/data pairs. Bytecode is not machine code that can be directly executed, and needs a corresponding virtual machine to parse the bytecode for execution.
Bob may then issue the contract in the form of a transaction. Specifically, Bob can initiate a transaction, the from field of the initiator in the transaction content is Bob (more specifically, the address of Bob), and the to field of the receiver is set to null; the transaction content also includes a Data field containing a code after compiling the intelligent contract into byte codes.
After Bob issues such a transaction to the blockchain network, each node in the blockchain network can acquire the bytecode of the intelligent contract, and thus, the intelligent contract is deployed to each node in the blockchain network. As with conventional transactions, the accounting node will perform operations such as validating, packaging, etc. the transaction, record it in the block, and add it to the chain of blocks through a consensus mechanism. In this process, a contract address, such as 0x6f …, is also assigned to the smart contract according to an algorithm, such as hashing based on the publisher address. Thus, an intelligent contract corresponds to a contract address, which is not formally different from the user's external account address. After the above intelligent contract is packed and linked, any user in the block chain network can call the intelligent contract.
When a user calls the intelligent contract, the virtual machine in the node executes the operation corresponding to the contract logic and realizes the change of the contract state on the network through the consensus mechanism. Specifically, the virtual machine loads and runs byte codes of the intelligent contract which is deployed before, and more specifically, an interpreter in the virtual machine interprets and executes an instruction stream represented by the byte codes, so that the intelligent contract is executed, and the state of parameters in the contract is changed.
Through the above process, when the intelligent contract is issued, the compiled byte codes of the intelligent contract are deployed to each node. When dependencies on external interfaces are introduced in source code during compilation from contract source code into bytecode, it is often the case that compiled code is inflated.
FIG. 2 illustrates a compilation process diagram of an intelligent contract. As mentioned above, the intelligent contract may be written in a high-level language, and therefore, when a developer writes the intelligent contract, some functions may be defined in the contract, or called contract interfaces, as needed, and dependencies on other interfaces may also be introduced in the contract, that is, some external functions are called, where the external functions refer to functions other than the functions defined in the contract and are usually provided by an external function library, for example, an intelligent contract development tool or a development platform may provide a system function library and/or a third-party function library, or other third-party organizations may also provide a third-party function library, and so on.
In the example of FIG. 2, a smart contract written in a high-level language C contains the following source code:
int openat(…){
…
size＝_myvm_strlen(…)；
…
}
the above source code segment defines a contract function or contract interface "openat", in which the library function "_ myvm _ strlen" in the system library libc provided by the contract development platform for C language is called, and the function is used for obtaining the length of the character string, and is an external function of the contract relative to the contract.
When compiling the source code, for a conventional statement, the compiler directly compiles the statement itself into bytecode. However, when the external function is called, the compiler queries the corresponding function library, obtains the implementation code of the external function from the function library, incorporates the implementation code into the contract, and then compiles the implementation code into byte code.
For example, by querying the system library libc, the implementation code "size _ t strlen (constchar. s) … …" of the library function "_ myvm _ strlen" may be found, as pointed by the arrow in FIG. 2. This section of implementation code is then incorporated into the contract and compiled into bytecode.
Therefore, the code section in the contract module generated by compilation includes, in addition to the bytecode generated by compilation of the contract self statement, the bytecode generated by compilation of the implementation code of the external function. For example, in the wasm module generated by contract compilation in fig. 2, the code section contains not only the bytecode implementing the contract function "openat" but also the bytecode implementing the external function "_ myvm _ strlen".
Through the above process, it can be seen that if a dependency on an external interface is introduced into the contract source code, or an external function is called, the implementation code of the external function is also compiled and incorporated into the contract module, and thus, a line of calling statements for the external function in the source code is converted into the whole implementation code of the external function, resulting in that the generated bytecode module is extremely expansive. For example, in the case of the intelligent contract written in C/C + +, if the source code is 2k in size, the generated bytecode code is usually at least 20k, and the code volume is expanded by more than 20 times.
The expansion of the code in the compiling process causes the generated contract byte code to be large in size, and the transmission cost and the deployment efficiency of the contract are increased. Further, when a contract is executed, the performance overhead in the process of loading and parsing the bytecode is also increased by the larger bytecode module, which brings a larger challenge to the performance of the virtual machine execution model.
In view of the above, in one embodiment of the present specification, it is proposed to provide a shared function library in a virtual machine, which contains specific implementations of individual functions. Accordingly, when the intelligent contract source code is compiled and the intelligent contract depends on the external function, only the function declaration information of the external function can be introduced, and the implementation code of the function does not need to be integrated into the contract. When executing the intelligent contract, the virtual machine may obtain the implementation code of the function from its local shared function library, thereby executing the external function. Therefore, the specific implementation code of the external function is not contained in the contract module generated by compiling any more, the module volume is greatly reduced, the efficiency of contract transmission and deployment is improved, and the contract execution performance is also improved.
Specific implementations of the above concepts are described below.
FIG. 3 illustrates a flowchart of a method of compiling a smart contract, according to one embodiment. By the method of fig. 3, the smart contract is compiled into hexadecimal bytecode, and a contract module or a contract file corresponding to the smart contract is generated, where the compiled bytecode is included.
The method of fig. 3 may be applied to intelligent contracts in multiple languages and multiple bytecode formats. For example, in one embodiment, the intelligent contracts may be written in a Solidity language and compiled into bytecode to generate contract modules in the.bin format. In another embodiment, the intelligent contracts are written in a high level language such as C/C + +, Java, Kotlin, TypeScript, Rust, etc., and compiled into WASM byte codes to generate the corresponding WASM format contract modules.
The WASM, WebAssembly, is an open standard developed by the W3C community group, and is a new platform-independent intermediate bytecode format. WASM is a low-level assembly language of classes, has a compact binary format, can run efficiently on the Web, and therefore has recently been the target of compilation of intelligent contracts in blockchains.
FIG. 4 illustrates a schematic diagram of compiling an intelligent contract, showing an example process of compiling a C language written intelligent contract into WASM bytecode, according to one embodiment. The method flow of fig. 3 is described below in conjunction with fig. 4, taking the example of the WASM bytecode, but it is understood that the concept of the compilation process can be generalized to be applicable to other languages and other bytecode formats.
As shown in fig. 3, first, in step 31, a statement in the source code of the smart contract is read. For a conventional contract statement, it is compiled into bytecode according to conventional compilation rules. For example, in the example in fig. 4, the source code segments of the smart contract are the same as those shown in fig. 2, and are all code segments written in C language. For the contract statement "int openat (…)", it is compiled in a conventional manner.
In particular, if the read current statement involves a dependency on an external interface, or the current statement includes a call to an external function, special processing is required. For simplicity, such a statement is referred to as a first statement, and the external function called in the first statement is referred to as a first external function.
For example, the statement "size _ myvm _ strlen (…)" in fig. 4 calls the external function "_ myvm _ strlen", and special processing is performed on the statement.
The special processing of the statement includes a step 32 of determining whether the first external function is a predetermined type of function according to a function library corresponding to the first external function, where the predetermined type of function is a function implemented in the virtual machine, or a predetermined type of function, that is, a function in the shared function library provided by the virtual machine, and its code is already included in the virtual machine.
If the first external function is not a predetermined type function, then the implementation code of the first external function is included into the contract code for compiling processing in a conventional manner; if the first external function is a predetermined type of function, the call to the first external function may be specially compiled. Therefore, it is necessary to first make a judgment on the first external function.
Whether the first external function is a predetermined type of function may be determined in various ways.
First, a function library corresponding to a first external function is determined. The external function called in the contract may be from a system function library or a third party function library. For example, in the example of fig. 4, myvm-libc library is a system function library provided for C language, libc + + library is a system function library provided for C + + language, and mychainlib is a trigonometric function library provided for a blockchain development platform. In one example, the function library used is declared in the contract source code, such as by an "include" statement. In some examples, the function name of the first external function may also contain information of the corresponding function library, for example, the prefix "myvm" of the first external function "_ myvm _ strlen" in fig. 4 indicates the function library information. Through the information, the function library corresponding to the first external function can be determined. For example, it can be determined that the function library corresponding to the first external function "_ myvm _ strlen" is a myvm-libc library.
Then, it is determined whether the first external function is a predetermined type of function based on the function library.
In one embodiment, the function library providing the first external function labels the functions therein in advance, for example, adding a special mark to the function implementing the code contained in the virtual machine. The special mark may take various forms, for example, "extern", "CodeNull", and the like.
In this case, the first external function may be queried in the function library by a function name, and when a flag indicating a predetermined type of function is marked in the function library for the first external function, the first external function is determined to be the predetermined type of function.
For example, according to the example of fig. 4, in the myvm-libc library, a tag "extern" is added before some functions to indicate that the implementation code of the function is already contained in the virtual machine, i.e. the aforementioned predetermined type of function is indicated by the tag. Accordingly, for functions with "extern" tags, only function declaration information of the functions, such as function names, parameter types, return types, and the like, is recorded in the myvm-libc library, but implementation codes of the functions are not included.
For the first external function "_ myvm _ strlen", it may be queried in the myvm-libc library with its function name, resulting in the record "extern _ myvm _ strlen" in the library, i.e., the function library labels a specific label "extern" for the first external function, and thus, it may be determined that the first external function is a predetermined type of function.
In another embodiment, the function library is not specially labeled for predetermined types of functions, but may be differentiated by: for a conventional type function, recording declaration information of the function and an implementation code in a function library; for the function of the preset type, only the declaration information of the function is recorded in the function library, and the implementation code of the function is not recorded.
In such a case, in order to judge the first external function, the compiler may query the first external function in the function library by a function name; and if only a function declaration is recorded in the function library for the first external function and the implementation code of the function is not included, determining that the first external function is a predetermined type of function.
In yet another embodiment, some function libraries may be predetermined to be function libraries dedicated to defining predetermined types of functions, wherein all the included functions are predetermined types of functions. For example, assuming that the development platform has previously integrated implementation code for all functions in the system library myvm-libc into the virtual machine, the function library may be marked as a function library dedicated to defining a predetermined type of function and notified to the compiler. Thus, when the compiler determines that the function library corresponding to the first external function is the dedicated function library, it may determine that the first external function is a predetermined type of function.
As described above, in the case where it is determined that the first external function is a predetermined type of function, special compilation of the first statement that calls the first external function is required.
Specifically, in step 33, a call instruction to the first external function is generated for the first statement. For example, for a first statement, a call instruction is generated, and the first external function is made the object of the call.
In one embodiment, before generating the call instruction, the compiler first checks whether the function call is legitimate. Specifically, the compiler may obtain declaration information of the first external function from a previously determined function library by querying, where the declaration information includes at least one of a parameter type, a parameter number, a return type, and the like, in addition to the function name. The compiler may then check whether the call to the first external function in the first statement matches the declaration information. For example, when a first external function is called in a first statement, the number of parameters provided is checked to see if the parameters are consistent with those in the function declaration, the types of the parameters are checked to see if the parameters are matched with those in the function declaration, the type of the definition for the return value in the contract is checked to see if the definition for the return value is consistent with that in the function declaration, and so on. In the case that the call information in the first statement matches the function declaration, a call instruction to the first external function is generated.
And for the generated call instruction, converting the call instruction into byte codes according to a compiling rule.
Then, in step 34, the bytecode corresponding to the call instruction is included in the code section of the contract module to be formed, and the function information of the first external function is included in the import section of the contract module.
As known to those skilled in the art, an intelligent contract may generate a corresponding contract module, or contract file, by compiling. The contract module contains byte codes after contract compiling, and optionally can also contain other contract related information. Contract modules in different language formats may have different module forms.
For example, taking a contract module in the WASM format as an example, the generated contract module includes a plurality of sections, wherein the mandatory section includes a code section, and a compiled WASM byte code of the contract source code is recorded. In addition, the WASM file optionally contains an import section and an export section. The import section (import section) defines functions, tables, memories, global variables, etc. that the module imports from other modules, and the export section (export section) defines functions, tables, memories, global variables, etc. that the module exports.
Accordingly, in step 34, the bytecode corresponding to the call instruction may be included in the code block, and the function declaration information of the first external function may be included in the lead-in block.
Referring to fig. 4, a WASM module is illustrated. It can be seen that for the first external function "_ myvm _ strlen", its function declaration information is contained in the lead-in section of the WASM module, as shown by "import _ myvm _ strlen" (…). Accordingly, in the code section of the module, regarding the first external function, only the bytecode corresponding to the call instruction of the function is included in fig. 4, unlike the bytecode including the entire implementation code of the function in fig. 2, and thus is a very brief short section of bytecode.
As can be seen from the above procedures, according to one embodiment of the present specification, when an intelligent contract is compiled and the intelligent contract depends on an external function, implementation code of the external function is no longer incorporated into the contract for compilation, but is converted into a call instruction for the external function, and declaration information of the function is added to an import section of a contract module.
Because only the function declaration is contained and the function implementation code is not contained, the intelligent contract has no obvious expansion in the volume during compiling, so that the generated contract module has small volume, is very beneficial to the transmission and deployment of the contract and obviously improves the contract deployment efficiency.
It should be understood that the premise that the implementation codes of the functions are no longer required to be included in the contract module in the compiling process is that the virtual machine for executing the intelligent contract can locally acquire the implementation codes from the virtual machine, so that the corresponding function functions can be executed, and the intelligent contract is further executed.
The following describes the implementation code of the virtual machine fetch function, and the process of executing the intelligent contract.
It will be appreciated that a virtual machine may also be considered to be a program running on an operating system that is used to simulate some execution environment. Therefore, in one embodiment, a function library for implementing various functions may be added to an existing virtual machine program, and the function library is implemented in the same language as the virtual machine. For example, the virtual machine and the function library can be implemented in C language, or both can be implemented in C + + language. Thus, the virtual machine includes a function library implemented in the same language, which includes function code for executing each function.
Thus, when the virtual machine executes the intelligent contract, if the intelligent contract calls the external function and does not contain the implementation code of the external function, the virtual machine acquires the implementation code of the function from the locally-contained function library and "links" the code implementation body and the corresponding part of the contract module, thereby executing the intelligent contract. In this way, the virtual machine executes the above-described external function with nearly native code performance, so that contract execution efficiency is further improved.
FIG. 5 illustrates a flow diagram of a method of executing an intelligent contract, according to one embodiment. The method is executed by a virtual machine in any node in a blockchain network, where the blockchain network may be a public chain, a private chain, or a federation chain, which is not limited herein.
It will be appreciated that execution of a smart contract is typically triggered by receipt of a transaction invoking the smart contract. Therefore, before the steps of fig. 5 are started, it is assumed that the intelligent contracts have been compiled in advance in the manner of fig. 3, and contract modules generated by the compilation are deployed into the nodes of the blockchain network. Then, when an account (e.g., Alice) at a node wants to invoke the intelligent contract already created and deployed, he may initiate a transaction that invokes the contract, point the destination address field (to field) of the transaction to the contract address of the intelligent contract to be invoked, and include the function in the contract to be invoked in the data field of the transaction. Accordingly, after the virtual machine in each node receives the transaction, the to field may be used to determine the intelligent contract to be invoked, and the method flow of fig. 5 is executed.
As shown in fig. 5, at step 51, a contract module corresponding to the intelligent contract is obtained. It will be appreciated that the intelligent contract is the intelligent contract invoked in the transaction described above, with the contract modules having been previously deployed into the respective nodes. Accordingly, at step 51, the contract module may be loaded into memory. The contract module is generated by compiling the intelligent contract according to the mode of fig. 3, and includes a code block in which a bytecode generated by compiling a source code of the intelligent contract is recorded, and an import section in which function information imported from the outside is recorded. In one embodiment, the contract module is a WASM module. It is assumed that the lead-in section includes function declaration information of the first external function.
In step 52, the bytecode of the code section in the contract module is parsed to obtain the call instruction code for the first external function. It should be understood that, through the compiling process of fig. 3, only the calling information of the first external function is included in the bytecode of the contract module, and the code specifically for implementing the first external function is not included. Accordingly, in this step 52, by parsing the bytecode in the contract module, only the call instruction code of the first external function can be obtained, and the implementation code of the first external function cannot be obtained.
Then, an attempt is made to locally acquire the implementation code of the first external function from the virtual machine, based on the function declaration information of the first external function contained in the lead-in section. As described above, in one embodiment, the virtual machine includes a function library implemented in the same language, and the function library includes implementation codes of respective functions. Therefore, in one embodiment, it may be first determined whether the first external function is a function provided in a function library included in the virtual machine, based on the function declaration information of the first external function. For example, a query may be made in an operating system function library using function declaration information.
Once the first external function is determined to be a function provided in the function library of the virtual machine, in step 53, a function code for implementing the first external function may be determined from the function library provided in the virtual machine, and an executable first code segment corresponding to the function code may be obtained.
In one embodiment, the determined function code for implementing the first external function is compiled into an executable code segment suitable for the platform where the virtual machine is located, i.e., the first code segment. Thus, in this embodiment, the native code segment is obtained as the first code segment by just-in-time compilation.
In another embodiment, all function code in the virtual machine function library is loaded and compiled into executable code suitable for the platform when the virtual machine is started, i.e. simultaneously. Or, for the function code of the external function which is more commonly used, the function code can be loaded and compiled in advance and converted into the executable code. In the above case, the executable code segment corresponding to at least part of the function has been stored in the memory. In the case that the function code corresponding to the first external function has been preloaded and compiled, in step 53, the first code segment suitable for the platform where the virtual machine is located to execute may be directly read from the memory.
Then, in step 54, the calling instruction code obtained by parsing the bytecode is linked to the first code segment to form a linked code. Specifically, in an embodiment, an address for executing the call instruction is pointed to a memory address for storing the first code segment, so as to implement code linking. In another embodiment, the first code segment may also be inserted into the contract bytecode parsed executable code, thereby implementing code linking.
Thus, at step 55, the intelligent contract may be executed by executing the linked code to implement the functionality of the first external function.
FIG. 6 illustrates a schematic diagram of executing an intelligent contract in one example. It can be seen that the WASM contract module exemplarily shown in FIG. 6 is just the contract module generated by compiling in FIG. 4, in which function declaration information of an external function "myvm _ strlen (…)" is contained in the lead-in section, and bytecode corresponding to a call instruction for the external function is contained in the code section.
By the method of fig. 5, the declaration information of the external function can be obtained from the lead-in section, and the call instruction code for the external function is analyzed from the code section. Then, the virtual machine obtains the implementation code of the external function from its own function library, and links it with the parsed contract code. Fig. 6 illustrates 3 operating systems, and a virtual machine and a function library corresponding to each operating system are provided separately for each operating system. The virtual machine acquires the executable code of the external function, which is suitable for the platform, based on the function library, so that the external function is executed, and the intelligent contract is further executed.
Through the process, the contract module does not contain the implementation codes of the external functions, so that the size is very small, the transmission and the deployment of the contract are facilitated, the burdens of the virtual machine for loading the contract module and analyzing the byte codes are greatly reduced, and the execution efficiency of the contract is higher. Furthermore, for the external function called in the contract, the implementation code of the external function is provided by a function library contained in the virtual machine, and the external function is executed in a manner similar to the native code implementation manner, so that the execution efficiency of the contract is further improved. In an actual block chain platform, the execution performance and the throughput rate of the contract are the core of the platform system, so that the execution performance and the throughput of the contract are improved from multiple angles in the above way, and the efficiency and the availability of the platform are greatly improved.
According to an embodiment of another aspect, an apparatus for compiling a smart contract is provided and disposed in a compiler. Fig. 7 shows a schematic block diagram of a compiling apparatus according to an embodiment. As shown in fig. 7, the compiling apparatus 700 includes:
a statement reading unit 71 configured to read a first statement in the source code of the smart contract, wherein the first statement includes a call to a first external function;
a determining unit 72 configured to determine, according to a function library corresponding to the first external function, that the first external function is a predetermined type of function, where the predetermined type of function is a function implemented in a virtual machine executing the intelligent contract;
an instruction generating unit 73 configured to generate a call instruction to the first external function for the first statement, and convert the call instruction into a corresponding bytecode;
a recording unit 74 configured to include the bytecode corresponding to the call instruction in a code section of the contract module to be formed, and include function declaration information of the first external function in an import section of the contract module.
In one embodiment, the function library is a system function library or a third party function library.
According to one embodiment, the determining unit 72 is configured to:
querying the first external function in the function library by a function name;
when a predetermined mark for indicating the predetermined type of function is marked in the function library for the first external function, determining that the first external function is the predetermined type of function.
According to another embodiment, the determining unit 72 is configured to:
querying the first external function in the function library by a function name;
when only a function declaration is recorded in the function library for the first external function and no implementation code of the function is included, determining that the first external function is the function of the predetermined type.
According to a further embodiment, the determining unit 72 is configured to:
when the function library is determined to be a function library dedicated to defining the predetermined type of function, determining the first external function to be a predetermined type of function.
According to one embodiment, the instruction generation unit 73 is configured to:
acquiring function declaration information of the first external function from the function library query, wherein the function declaration information comprises at least one of parameter type, parameter number and return type;
checking whether the call to the first external function in the first statement matches the function declaration information;
in the case of a match, a call instruction to the first external function is generated.
In one embodiment, the bytecode module is a WASM module.
According to another aspect of the embodiments, there is provided an apparatus for executing an intelligent contract, which is deployed in a virtual machine of any node of a blockchain network, where the any node may be embodied as any device, platform or device cluster having computing and processing capabilities, and the virtual machine may be a virtual machine adapted to an intelligent contract format, such as a identity virtual machine, a WASM virtual machine, or the like. FIG. 8 illustrates a schematic block diagram of a contract execution apparatus according to one embodiment. As shown in fig. 8, the contract execution apparatus 800 includes:
a module obtaining unit 81 configured to obtain a contract module corresponding to an intelligent contract, where the contract module includes a code section and an import section, and the import section includes function declaration information of a first external function;
the analyzing unit 82 is configured to analyze the bytecode in the code section to obtain a calling instruction code of the first external function;
a code obtaining unit 83, configured to determine, according to the function declaration information of the first external function, a function code for implementing the first external function from a function library implemented in the same language included in the virtual machine, and obtain an executable first code segment corresponding to the function code;
a linking unit 84 configured to link the calling instruction code to the first code segment, resulting in a linked code;
an execution unit 85 configured to execute the linking code to execute the first external function in the intelligent contract.
According to an embodiment, the apparatus 800 further comprises a receiving unit (not shown) configured to:
a first transaction is received, a target address field of the first transaction pointing to a contract address of the intelligent contract to request invocation of the intelligent contract.
In one embodiment, the bytecode module is a WASM module.
According to an embodiment, the apparatus 800 further includes a determining unit (not shown) configured to determine, according to the function declaration information of the first external function, that the first external function is a function provided in the function library.
In one embodiment, the virtual machine and the function code are implemented in a C language or a C + + language.
According to an embodiment, the code acquisition unit 83 is configured to: compiling the function code into the first code segment, wherein the first code segment is a native code suitable for a platform where the virtual machine is located.
According to another embodiment, the code acquisition unit 83 is configured to: and obtaining the first code segment which is loaded and generated by compiling the function code from the memory, wherein the first code segment is a native code suitable for the platform where the virtual machine is located.
In one embodiment, the linking unit 84 is configured to point the address at which the call instruction code is executed to the memory address at which the first code segment is stored.
According to an embodiment of another aspect, there is also provided a computer-readable storage medium having stored thereon a computer program which, when executed in a computer, causes the computer to perform the method described in connection with fig. 3 and 5.
According to an embodiment of yet another aspect, there is also provided a computing device comprising a memory and a processor, the memory having stored therein executable code, the processor, when executing the executable code, implementing the method described in connection with fig. 3 and 5.
Those skilled in the art will recognize that, in one or more of the examples described above, the functions described in this invention may be implemented in hardware, software, firmware, or any combination thereof. When implemented in software, the functions may be stored on or transmitted over as one or more instructions or code on a computer-readable medium.
The above-mentioned embodiments, objects, technical solutions and advantages of the present invention are further described in detail, it should be understood that the above-mentioned embodiments are only exemplary embodiments of the present invention, and are not intended to limit the scope of the present invention, and any modifications, equivalent substitutions, improvements and the like made on the basis of the technical solutions of the present invention should be included in the scope of the present invention.
Claims (18)
1. A method of executing an intelligent contract, performed by a virtual machine in a blockchain node, the method comprising:
acquiring a contract module corresponding to an intelligent contract, wherein the contract module comprises a code section and an import section, the code section comprises compiled byte codes, and the import section comprises function declaration information of a first external function;
analyzing the byte codes in the code section to obtain a calling instruction code of the first external function;
according to the function declaration information of the first external function, determining a function code for realizing the first external function from a shared function library which is provided by a virtual machine and realized by adopting the same language, and acquiring an executable first code segment corresponding to the function code;
linking the calling instruction code to the first code segment to obtain a link code;
executing the linking code to execute the first external function in the intelligent contract.
2. The method of claim 1, further comprising, prior to obtaining a contract module corresponding to an intelligent contract:
a first transaction is received, a target address field of the first transaction pointing to a contract address of the intelligent contract to request invocation of the intelligent contract.
3. The method of claim 1, wherein the contract module is a WASM module.
4. The method of claim 1, further comprising determining the first external function is a function provided in the shared function library according to function declaration information of the first external function.
5. The method of claim 1, wherein the virtual machine and the function code are implemented in a C language or a C + + language.
6. The method of claim 1, wherein obtaining the corresponding executable first code segment of the function code comprises: compiling the function code into the first code segment, wherein the first code segment is a native code suitable for a platform where the virtual machine is located.
7. The method of claim 1, wherein obtaining the corresponding executable first code segment of the function code comprises: and obtaining the first code segment which is loaded and generated by compiling the function code from the memory, wherein the first code segment is a native code suitable for the platform where the virtual machine is located.
8. The method of claim 1, wherein linking the call instruction code to the first code segment comprises pointing an address at which the call instruction code is executed to a memory address at which the first code is stored.
9. An apparatus for executing an intelligent contract, deployed in a virtual machine in a blockchain node, the apparatus comprising:
the intelligent contract management system comprises a module obtaining unit, a contract module and a contract management unit, wherein the contract module is configured to obtain a contract module corresponding to an intelligent contract, the contract module comprises a code section and an import section, the code section comprises compiled byte codes, and the import section comprises function declaration information of a first external function;
the analysis unit is configured to analyze the byte codes in the code section to obtain a calling instruction code of the first external function;
a code obtaining unit, configured to determine, according to function declaration information of the first external function, a function code for implementing the first external function from a shared function library implemented in the same language provided by a virtual machine, and obtain an executable first code segment corresponding to the function code;
a linking unit configured to link the call instruction code to the first code segment to obtain a linking code;
an execution unit configured to execute the linking code to execute the first external function in the intelligent contract.
10. The apparatus of claim 9, further comprising a receiving unit configured to:
a first transaction is received, a target address field of the first transaction pointing to a contract address of the intelligent contract to request invocation of the intelligent contract.
11. The apparatus of claim 9, wherein the contract module is a WASM module.
12. The apparatus according to claim 9, further comprising a determining unit configured to determine, according to function declaration information of the first external function, that the first external function is a function provided in the shared function library.
13. The apparatus of claim 9, wherein the virtual machine and the function code are implemented in a C language or a C + + language.
14. The apparatus of claim 9, wherein the code acquisition unit is configured to: compiling the function code into the first code segment, wherein the first code segment is a native code suitable for a platform where the virtual machine is located.
15. The apparatus of claim 9, wherein the code acquisition unit is configured to: and obtaining the first code segment which is loaded and generated by compiling the function code from the memory, wherein the first code segment is a native code suitable for the platform where the virtual machine is located.
16. The apparatus of claim 9, wherein the link unit is configured to point an address at which the call instruction code is executed to a memory address at which the first code is stored.
17. A computer-readable storage medium, on which a computer program is stored which, when executed in a computer, causes the computer to carry out the method of any one of claims 1-8.
18. A computing device comprising a memory and a processor, wherein the memory has stored therein executable code that, when executed by the processor, performs the method of any of claims 1-8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910939503.8A CN110704063B (en) | 2019-09-30 | 2019-09-30 | Method and device for compiling and executing intelligent contract |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910939503.8A CN110704063B (en) | 2019-09-30 | 2019-09-30 | Method and device for compiling and executing intelligent contract |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110704063A CN110704063A (en) | 2020-01-17 |
| CN110704063B true CN110704063B (en) | 2021-09-07 |
Family
ID=69196882
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910939503.8A Active CN110704063B (en) | 2019-09-30 | 2019-09-30 | Method and device for compiling and executing intelligent contract |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110704063B (en) |
Families Citing this family (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111008067B (en) * | 2020-03-05 | 2020-06-09 | 支付宝(杭州)信息技术有限公司 | Method and device for executing functional module in virtual machine |
| CN111045792A (en) * | 2020-03-13 | 2020-04-21 | 支付宝(杭州)信息技术有限公司 | Method and device for caching and executing intelligent contracts |
| CN111414159B (en) * | 2020-03-16 | 2023-07-25 | 北京艾鸥科技有限公司 | Block chain virtual machine device, virtual machine creation method and transaction method |
| CN111338639B (en) * | 2020-03-27 | 2023-05-16 | 象链网络科技(上海)有限公司 | Implementation method of instruction set of intelligent contract virtual machine of block chain |
| CN113872948A (en) * | 2020-08-31 | 2021-12-31 | 支付宝(杭州)信息技术有限公司 | Method for executing intelligent contract, block chain node and node equipment |
| CN111770205B (en) * | 2020-08-31 | 2020-12-04 | 支付宝(杭州)信息技术有限公司 | Method, block chain node, system and storage medium for executing intelligent contract |
| CN112199221B (en) * | 2020-12-04 | 2021-03-30 | 杭州趣链科技有限公司 | Event pushing method, system, block chain platform, contract calling end and medium |
| CN112529711B (en) * | 2021-02-07 | 2021-05-14 | 腾讯科技（深圳）有限公司 | Transaction processing method and device based on block chain virtual machine multiplexing |
| CN112967011A (en) * | 2021-02-19 | 2021-06-15 | 浙江焕链科技有限公司 | Contract automatic deployment method and system |
| CN114047908B (en) * | 2021-11-18 | 2025-04-01 | 龙芯中科(合肥)技术有限公司 | Just-in-time compilation method and device |
| CN114327477A (en) * | 2021-12-26 | 2022-04-12 | 杭州趣链科技有限公司 | Intelligent contract execution method and device, electronic device and storage medium |
| CN117215544B (en) * | 2023-11-09 | 2024-02-09 | 中国科学院软件研究所 | Implementation and operation method of intelligent contract special instruction set |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108765158A (en) * | 2018-05-31 | 2018-11-06 | 杭州秘猿科技有限公司 | A kind of intelligent contract automotive engine system and its contract execution method based on block chain |
| CN109284197A (en) * | 2018-10-25 | 2019-01-29 | 中思博安科技（北京）有限公司 | Distributed Application platform and implementation method based on intelligent contract |
| CA3041223A1 (en) * | 2018-11-27 | 2019-04-18 | Alibaba Group Holding Limited | Function-as-a-service (faas) platform in blockchain networks |
Family Cites Families (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US10681033B2 (en) * | 2017-10-16 | 2020-06-09 | Microsoft Technology Licensing, Llc | Selecting and securing proof delgates for cryptographic functions |
| CN108595157B (en) * | 2018-04-28 | 2022-05-10 | 百度在线网络技术（北京）有限公司 | Block chain data processing method, device, equipment and storage medium |
| CN109299587A (en) * | 2018-09-11 | 2019-02-01 | 平安科技（深圳）有限公司 | Algorithm protection method, device, equipment and storage medium based on go language |
| CN109710384B (en) * | 2018-12-29 | 2021-02-23 | 杭州趣链科技有限公司 | Safe Java intelligent contract interpretation execution engine and method |
| CN110111104A (en) * | 2019-04-23 | 2019-08-09 | 矩阵元技术（深圳）有限公司 | Block chain intelligence contract implementation method, device, computer equipment and storage medium |
| CN110096338B (en) * | 2019-05-10 | 2021-12-14 | 百度在线网络技术（北京）有限公司 | Intelligent contract execution method, device, equipment and medium |
| CN110704064B (en) * | 2019-09-30 | 2021-09-14 | 支付宝(杭州)信息技术有限公司 | Method and device for compiling and executing intelligent contract |
-
2019
- 2019-09-30 CN CN201910939503.8A patent/CN110704063B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108765158A (en) * | 2018-05-31 | 2018-11-06 | 杭州秘猿科技有限公司 | A kind of intelligent contract automotive engine system and its contract execution method based on block chain |
| CN109284197A (en) * | 2018-10-25 | 2019-01-29 | 中思博安科技（北京）有限公司 | Distributed Application platform and implementation method based on intelligent contract |
| CA3041223A1 (en) * | 2018-11-27 | 2019-04-18 | Alibaba Group Holding Limited | Function-as-a-service (faas) platform in blockchain networks |
Non-Patent Citations (3)
| Title |
|---|
| Scalable Blockchain Based Smart Contract Execution;Zhimin Gao等;《institute of electrical and electronic engineers》;20180531;全文 * |
| 基于DSL和区块链技术的可编程智能合约设计与实现;朱忠宁;《中国优秀硕士学位论文全文数据库 信息科技辑》;20180615;全文 * |
| 基于多核架构的智能合约执行优化;张克兴;《中国优秀硕士学位论文全文数据库 信息科技辑》;20190501;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110704063A (en) | 2020-01-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110704063B (en) | Method and device for compiling and executing intelligent contract | |
| CN110704064B (en) | Method and device for compiling and executing intelligent contract | |
| CN110688122B (en) | Method and device for compiling and executing intelligent contract | |
| CN111770113B (en) | Method for executing intelligent contract, block chain node and node equipment | |
| US6836883B1 (en) | Method and system for compiling multiple languages | |
| US8464232B2 (en) | Compiler compiler system with syntax-controlled runtime and binary application programming interfaces | |
| CN110069259B (en) | ID L file-based parsing method and device, electronic equipment and storage medium | |
| CN110673837B (en) | Code repairing method and device, electronic equipment and computer readable storage medium | |
| CA2753626C (en) | Packed data objects | |
| CN111240772A (en) | Data processing method and device based on block chain and storage medium | |
| EP1452962B1 (en) | System and method for defining and using subclasses declaratively within markup | |
| WO2025020395A1 (en) | Method for optimizing wasm bytecode, execution method, computer device and storage medium | |
| CN113867704B (en) | Code testing processing method, device, electronic equipment and storage medium | |
| HK40021004B (en) | Method and device for compiling and executing smart contract | |
| HK40021004A (en) | Method and device for compiling and executing smart contract | |
| HK40021005B (en) | Method and device for compiling and executing smart contract | |
| HK40021005A (en) | Method and device for compiling and executing smart contract | |
| HK40020917A (en) | Method and device for compiling and executing smart contract | |
| HK40020917B (en) | Method and device for compiling and executing smart contract | |
| CN116089280A (en) | Debugging method and device for intelligent contract | |
| US9720660B2 (en) | Binary interface instrumentation | |
| CN117555535B (en) | Method for realizing multi-environment code multiplexing in compact framework | |
| US20240272884A1 (en) | Transforming a java program using a symbolic description language model | |
| CN114579135B (en) | Installation package generation method and device | |
| US20240272885A1 (en) | Modeling java source code in a symbolic description language |
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 | ||
| REG | Reference to a national code |
Ref country code: HK Ref legal event code: DE Ref document number: 40021004 Country of ref document: HK |
|
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20240929 Address after: Room 803, floor 8, No. 618 Wai Road, Huangpu District, Shanghai 200010 Patentee after: Ant blockchain Technology (Shanghai) Co.,Ltd. Country or region after: China Address before: 310000 801-11 section B, 8th floor, 556 Xixi Road, Xihu District, Hangzhou City, Zhejiang Province Patentee before: Alipay (Hangzhou) Information Technology Co.,Ltd. Country or region before: China |