A verifiable computing method, device, computer equipment and medium

Abstract

Embodiments of the present application are suitable for the field of blockchain technology, and provide a verifiable computing method and device, computer equipment and medium. The method is applied to a blockchain node, and includes: in response to a received transaction service, throwing a computing event to a first verifiable computing node, the computing event having a verifiable computing task corresponding to the transaction service; receiving a first receipt transaction returned by the first verifiable computing node for the verifiable computing task; if the first receipt transaction is verified, determining a first end event according to the transaction service; and sending the first end event to a corresponding target verifiable computing node, the target verifiable computing node being the first verifiable computing node or a target verifiable computing node. Through the above method, session collaboration can be realized in verifiable computing.

Description

Technical Field

[0001] This application belongs to the field of blockchain technology, and in particular relates to a verifiable computing method, apparatus, computer equipment and medium. Background Technology

[0002] Verifiable computation can generate proofs of the correctness of a computation process and allow external verification of the validity of those proofs. Combining blockchain with verifiable computation can solve the privacy and scalability issues inherent in blockchain itself.

[0003] Existing approaches to combining blockchain and verifiable computation generally fall into two categories. One is to build a verifiable computation layer on top of the blockchain, meaning that verifiable computation functionality cannot exist independently of the blockchain, and the process of generating proofs for computation also occurs on-chain. This approach incurs too high a performance overhead on the blockchain. The other approach allows verifiable computation to exist independently of the blockchain, as a separate entity. However, verifiable computation and the blockchain can only interact in a simple way, and cannot achieve complex collaboration involving a conversational concept.

[0004] A session refers to a group of communication activities that share the same context. Within a session, the communicating parties exist within a specific context, enabling complex interactions. For example, when a user logs into a website requiring password verification, they initiate a session by entering a password. Subsequent actions all belong to the same session. The website considers the other party in each session to be the same user, therefore, not every message in the session needs to carry the user's password information. The concept of sessions simplifies communication overhead and allows for complex interaction methods.

[0005] Verifiable computation cannot achieve the complex collaboration of the concept of session with blockchain, which means that each execution of verifiable computation requires user participation, increasing the overhead of blockchain. Summary of the Invention

[0006] In view of this, embodiments of this application provide a verifiable computation method for achieving complex collaboration with session significance when performing verifiable computation in a blockchain.

[0007] A first aspect of this application provides a verifiable computation method applied to a blockchain node, the method comprising:

[0008] In response to a received transaction, a computation event is sent to a first verifiable computing node, the computation event having a verifiable computation task corresponding to the transaction;

[0009] Receive the first receipt transaction returned by the first verifiable computing node for the verifiable computing task;

[0010] If the first receipt transaction is verified successfully, then the first termination event is determined according to the transaction business.

[0011] The first end event is sent to the corresponding target verifiable computing node, wherein the target verifiable computing node is either the first verifiable computing node or the target verifiable computing node.

[0012] A second aspect of this application provides a verifiable computation method applied to a verifiable computation node, the method comprising:

[0013] Receive transaction events from blockchain nodes, where each transaction event has a corresponding transaction business;

[0014] If the transaction event carries a verifiable computation task, then the verifiable computation task is executed to obtain a receipt transaction;

[0015] The receipt transaction is returned to the blockchain node.

[0016] A third aspect of this application provides a verifiable computing device applied to a blockchain node, the device comprising:

[0017] The computation event ejection module is used to eject a computation event to a first verifiable computation node in response to a received transaction, wherein the computation event has a verifiable computation task corresponding to the transaction.

[0018] The first receipt transaction receiving module is used to receive the first receipt transaction returned by the first verifiable computing node for the verifiable computing task.

[0019] The first end event determination module is used to determine the first end event based on the transaction business if the first receipt transaction verification is successful.

[0020] The first end event throwing module is used to send the first end event to the corresponding target verifiable computing node, wherein the target verifiable computing node is the first verifiable computing node or the target verifiable computing node.

[0021] A fourth aspect of this application provides a verifiable computing apparatus applied to a verifiable computing node, the apparatus comprising:

[0022] The transaction event receiving module is used to receive transaction events from blockchain nodes, wherein the transaction events have corresponding transaction business.

[0023] A verifiable computation module is used to execute the verifiable computation task if the transaction event carries a verifiable computation task, and obtain a receipt transaction.

[0024] The receipt transaction return module is used to return the receipt transaction to the blockchain node.

[0025] A fifth aspect of this application provides a computer device including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the method described in the first or third aspect above.

[0026] A sixth aspect of this application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the method described in the first or third aspect above.

[0027] A seventh aspect of this application provides a computer program product that, when run on a computer device, causes the computer device to perform the method described in the first or third aspect.

[0028] Compared with the prior art, the embodiments of this application have the following advantages:

[0029] In this embodiment, when processing transactions, a blockchain node can decompose verifiable computation tasks from the transaction and determine corresponding transaction events, such as computation events and termination events, based on these tasks. The blockchain node then sends these transaction events to the corresponding verifiable computation nodes, allowing the verifiable computation to be performed independently of the blockchain, thus improving the efficiency of the verifiable computation and avoiding the inefficiencies caused by performing verifiable computations on the blockchain. After receiving a receipt transaction from the verifiable computation node, the blockchain node can verify it. Uploading the receipt transaction to the blockchain ensures the verifiability and traceability of the verifiable computation task, guaranteeing the reliability of the blockchain. After successfully verifying the receipt transaction, the blockchain node can determine the first termination event based on the transaction and send it to the corresponding target verifiable computation node. This allows the transaction to proceed only through collaborative sessions between the blockchain node and the verifiable computation nodes, eliminating the need for users to input and confirm passwords for each computation. Therefore, this embodiment enables complex interactions between verifiable computation and blockchain nodes. Attached Figure Description

[0030] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below.

[0031] Figure 1 This is a flowchart illustrating the steps of a verifiable calculation method provided in an embodiment of this application;

[0032] Figure 2 This is a flowchart illustrating the steps of another verifiable calculation method provided in this application embodiment;

[0033] Figure 3 This is a schematic diagram illustrating the correspondence between a verifiable computing proxy contract and a verifiable computing node provided in an embodiment of this application;

[0034] Figure 4 This is a flowchart illustrating the steps of another verifiable calculation method provided in this application embodiment;

[0035] Figure 5 This is a flowchart illustrating the steps of another verifiable calculation method provided in this application embodiment;

[0036] Figure 6 This is a schematic diagram of a verifiable computing scenario provided in an embodiment of this application;

[0037] Figure 7 This is a schematic diagram of a verifiable computing device provided in an embodiment of this application;

[0038] Figure 8 This is a schematic diagram of another verifiable computing device provided in an embodiment of this application;

[0039] Figure 9 This is a schematic diagram of a computer device provided in an embodiment of this application. Detailed Implementation

[0040] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods have been omitted so as not to obscure the description of this application with unnecessary detail.

[0041] The technical solution of this application will be described below through specific embodiments.

[0042] Reference Figure 1 The diagram illustrates a step flow of a verifiable method provided in an embodiment of this application. The execution subject of this embodiment is a computer device, which can be a tablet computer, wearable device, vehicle device, laptop computer, super mobile personal computer, server, or other computer device. The computer device can deploy a blockchain network, making it a blockchain node. Figure 1 The verifiable computation method in the process may specifically include the following steps:

[0043] S101, in response to the received transaction, a computation event is sent to the first verifiable computing node, the computation event having a verifiable computing task corresponding to the transaction.

[0044] The aforementioned verifiable computing nodes can be off-chain computing nodes or computer devices, such as tablets, wearable devices, in-vehicle devices, laptops, supercomputers, servers, etc. One or more verifiable computing services can be deployed on a verifiable computing node. For example, multiple data sources can be deployed on a verifiable computing node, each providing different data, and each data source can correspond to a different verifiable computing service. In one possible implementation, the verifiable computing service can be a privacy-preserving computing service, and the data source can be a privacy database. The data in each privacy database needs to be kept confidential; therefore, a privacy-preserving computing service can be deployed for each privacy database. This privacy-preserving computing service can only provide the computation results without providing the privacy data. In another possible implementation, the verifiable computing service can be a service requiring large-scale data computation. Performing large-scale data computation on on-chain nodes may lead to low efficiency; therefore, corresponding services can be deployed on verifiable computing nodes. Fast computation services for large amounts of data can be deployed on verifiable computing nodes to improve computing power.

[0045] The aforementioned transactions can originate from users, who can send transaction requests to blockchain nodes using authorized on-chain accounts and certificates. For example, users can log in to a client provided by the blockchain using an authorized on-chain account and certificate. On this client, users can input their transaction requests or select the transaction they wish to perform based on the content displayed on the client page. The execution of a transaction may require multiple computational steps. For instance, if the transaction corresponds to the computation function H(y(z(x))), it will at least include three computational steps: first calculating z(x), then calculating y(z(x)), and finally calculating H(y(z(x))). The computational data required for these three steps may come from different databases and require verification by different verifiable computation services.

[0046] After receiving a transaction, a blockchain node can break it down based on its execution and interaction processes to obtain the verifiable computational tasks required for execution. Based on the first verifiable computational task, the blockchain node can generate a computational event. This event can include the computational task, computational input, associated transaction ID, and the address of the business contract. The computational task can include the computational logic of the first verifiable task; the computational input can include input data or a description of the input data (the description can be used to obtain the input data for the verifiable computation); and the business contract address can be the address of the business contract on the blockchain node used to execute the transaction. For example, when breaking down a transaction H(y(z(x))), the first verifiable computational task z(x) can be obtained, and a corresponding computational event can be generated based on z(x).

[0047] In this embodiment, the verifiable computing task is executed by a verifiable computing node independent of the blockchain, specifically by a verifiable computing service within that node. Therefore, the blockchain node can determine the verifiable computing service to be invoked based on the verifiable computing task, thereby identifying the corresponding first verifiable computing node and sending the computing event to it. In one possible implementation, the verifiable computing task has corresponding input data, which may reside in a corresponding database. This database may contain verifiable computing services. Based on the database containing the input data of the verifiable computing task, the verifiable computing service required by the task can be determined, thereby identifying the corresponding verifiable computing node.

[0048] S102, Receive the first receipt transaction returned by the first verifiable computing node for the verifiable computing task.

[0049] Upon receiving a computation event, the first verifiable computing node can execute a verifiable computation task based on the computation input and task information, obtaining the corresponding computation result and proof. Based on the computation result and proof, the first verifiable computing node can generate a first receipt transaction and return it to the blockchain node. This first receipt transaction may include information such as the business contract address from the computation event and the associated transaction ID, facilitating cross-chain nodes in determining the transaction corresponding to the first receipt transaction.

[0050] A blockchain node can receive the first receipt transaction and then determine the computational event, computational result, and computational proof corresponding to the first receipt transaction.

[0051] S103, if the first receipt transaction verification is successful, then determine the first end event according to the transaction business.

[0052] According to the computational proof, blockchain nodes can verify the computation results. If the computation result is verified, it can be determined that the computation result of the verifiable computation task corresponding to the computation event is correct, and the computation result can be used to execute subsequent transaction operations.

[0053] A transaction can be broken down into one or more verifiable computation tasks. If a transaction includes only one verifiable computation task, the result of that task can be considered the execution result of the transaction. In this case, the blockchain node can generate a first termination event carrying a termination response, which is used to terminate the transaction. In one possible implementation, if the termination event does not carry a verifiable computation task, then it can be determined as a termination response.

[0054] In one possible implementation, if the transaction includes a next verifiable computation task, a first termination event carrying the next verifiable computation task can be generated. This first termination event is used to continue executing the transaction. The next verifiable computation task may depend on the computation result of the previous verifiable computation task; therefore, the first termination event can include the computation result and proof of the previous verifiable computation task, as well as information about the next verifiable computation task. For example, a first termination event constructed based on y(z(x)) can include the computation result and proof of z(x).

[0055] In another possible implementation, the transaction process may include a next verifiable computation task, which can be parallel to the previous verifiable computation task. In this case, the structure of the first end event can be similar to the computation event described above.

[0056] S104, the first end event is sent to the corresponding target verifiable computing node.

[0057] If the first termination event carries a termination response, the blockchain node can use the first verifiable computing node as the target verifiable computing node and return the first termination event to the target verifiable computing node. Upon receiving the first termination event, if the first verifiable computing node determines that it is a termination response, it can return the execution result of the transaction to the user. The execution result of the transaction can be the computation result of the computation event. In one possible implementation, when the target verifiable computing node receives the first termination event, if it detects that the first termination event does not carry a verifiable computation task, it determines that the first termination event is a termination response.

[0058] If the first termination event carries a next verifiable computation task, the blockchain node can determine the target verifiable computation node corresponding to the next verifiable computation task and then send the first termination event to that target verifiable computation node. Upon receiving the first termination event, the target verifiable computation node can determine whether the first termination event carries a verifiable computation task. If the verifiable computation node determines that the first termination event carries a verifiable computation task, it can execute the verifiable computation task to obtain the corresponding computation result and computation proof. Then, based on the computation result and computation proof, it continues to return a receipt transaction to the blockchain node. After receiving the receipt transaction, the blockchain node can continue to execute the transaction according to steps S103-S104. When the last verifiable computation task of the transaction is completed and the blockchain node confirms the computation result, the blockchain node can return a termination event carrying a termination response to the verifiable computation node. After receiving the termination response, the verifiable computation node can directly return the final result to the user.

[0059] In one possible implementation of this embodiment, after receiving a transaction, the blockchain node can break down the transaction into multiple verifiable computation tasks and determine the execution relationship between these tasks. This execution relationship can include parallel and serial execution, thereby identifying a target verifiable computation task that does not depend on other verifiable computation tasks. The blockchain node can then determine the corresponding computation event based on the target verifiable computation task and send the computation event to the corresponding verifiable computation nodes. When a receipt transaction is received, the blockchain node can generate a corresponding end event based on the next verifiable computation task of the target verifiable computation task in the computation event. Finally, based on the end event, the blockchain node collaborates with the corresponding verifiable computation nodes to complete the transaction.

[0060] In this embodiment, verifiable computing nodes exist independently of blockchain nodes. A transaction can be broken down into multiple verifiable computing tasks, and blockchain nodes can distribute these tasks to the corresponding verifiable computing nodes for execution based on transaction events. The computation result and proof of each verifiable computing task are sent to the blockchain node, ensuring that the computation result of each step in a blockchain transaction has a corresponding proof on the chain and can be traced back to the verifiable computing node that executed that step. This guarantees the reliability of the blockchain system when verifiable computing is combined with blockchain nodes. In this embodiment, when executing a transaction, the user only needs to send the transaction information to the blockchain node. The verifiable computing node and the blockchain node can complete the transaction through collaborative interaction, without requiring user participation for every interaction. This allows users to use verifiable computing functions in the same way they would operate a regular blockchain.

[0061] Reference Figure 2The diagram illustrates a step flow of a verifiable method provided in an embodiment of this application. The execution subject of this embodiment is a computer device, which can be a tablet computer, wearable device, vehicle device, laptop computer, super mobile personal computer, server, or other computer device. The computer device can deploy a blockchain network, making it a blockchain node. Figure 2 The verifiable computation method in the process may specifically include the following steps:

[0062] S201, receive the transaction business through a business contract deployed in the blockchain node.

[0063] Business contracts can be deployed within blockchain nodes. These contracts can be used to decompose the computational process of a transaction. The business contract is developed and defined by the user according to their specific business needs and then deployed on the blockchain node. This business contract can be universal, meaning it can be directly deployed on various blockchain platforms.

[0064] A blockchain platform can have a corresponding client. Users can log in to this client using their account and certificate, and then initiate transaction requests to the blockchain nodes. Business contracts can receive these transaction requests and determine the corresponding transaction based on them.

[0065] In one possible implementation, different transaction services can correspond to different business contracts. Users can invoke the business contract corresponding to the transaction request in the blockchain node through the user terminal, thereby enabling the business contract in the blockchain node to handle the corresponding business.

[0066] S202, determine the first verifiable computation task in the transaction business according to the execution logic of the transaction business.

[0067] The business contract can define the interaction process of the transaction business. By calling the business contract, the transaction business can be decomposed, thereby obtaining the corresponding verifiable computing tasks.

[0068] Each verifiable computation task in a transaction has corresponding execution steps. Based on these execution steps, the first verifiable computation task in a transaction can be determined.

[0069] In one possible implementation, the transaction can be decomposed based on the databases in the verifiable computing nodes that need to be used. For example, if the execution of functions y and z in H(y(z(x))) requires the participation of database A, and the execution of function H requires the participation of database B, then the business contract can decompose it into two verifiable computing tasks: y(z(x)) and H(y(z(x))). y(z(x)) is sent to database A to obtain the calculation result M, and then the calculation result M is sent to database B to obtain the final calculation result.

[0070] S203, Generate the computation event based on the first verifiable computation task.

[0071] Computation events can include a description of the first verifiable computation task, input data, the business contract address, and the identifier of the transaction. Additionally, computation events can carry the client address, allowing verifiable computation nodes to invoke the appropriate application based on the client address to notify the user of the business execution result.

[0072] Once a blockchain node identifies the first verifiable computation task, it can fill in the corresponding information according to the preset format of the computation event to generate the computation event.

[0073] S204, determine the verifiable computing proxy contract corresponding to the first verifiable computing task.

[0074] Verifiable computing proxy contracts can be generated by verifiable computing nodes and deployed on blockchain nodes. Each verifiable computing service can have one corresponding verifiable computing proxy contract.

[0075] Figure 3 This is a schematic diagram illustrating the correspondence between a verifiable computation proxy contract and a verifiable computation node, provided in an embodiment of this application. A business contract and multiple verifiable computation proxy contracts can be deployed on a blockchain node, such as... Figure 3 As shown, a blockchain node can include verifiable computation proxy contracts 1-6, each corresponding to verifiable computations 1-6 on the verifiable computation node. Figure 3 As shown, a verifiable computing node can provide one or more verifiable computing services, and there is not necessarily a one-to-one correspondence between blockchain nodes and verifiable computing nodes. In one possible implementation, verifiable computing nodes can provide different computing services based on the data stored within them. By storing data through verifiable computing nodes, the capacity of blockchain nodes can be expanded.

[0076] A business contract can determine the verifiable computations required for the first verifiable computation task, and then invoke the corresponding verifiable proxy contract. For example, if a verifiable computation task requires the computation corresponding to verifiable computation 1, then its corresponding verifiable computation proxy contract is verifiable computation proxy contract 1.

[0077] In one possible implementation, the business contract can determine the database required for the verifiable computation task, and then call the verifiable computation proxy contract corresponding to that database to perform the verifiable computation.

[0078] S205, invoke the verifiable computing agent contract to throw the computing event to the first verifiable computing node.

[0079] The business contract can send computation events to the verifiable computation agent contract, which in turn can send the computation events to the first verifiable computation node.

[0080] In one possible implementation, the verifiable computation proxy contract can establish a connection channel with the corresponding verifiable computation service in the first verifiable computation, thereby sending computation events to the first verifiable computation node through the channel.

[0081] S206, Receive the first receipt transaction returned by the first verifiable computing node for the verifiable computing task.

[0082] The verifiable computation proxy contract can receive the first receipt transaction returned by the first verifiable computation node. The first receipt transaction includes the computation result and computation proof obtained from the verifiable computation task in the computation event. The computation proof will be verified and archived on the blockchain.

[0083] S207, if the first receipt transaction verification is successful, then determine the first end event according to the transaction business.

[0084] The verifiable computation proxy contract is invoked to verify the computation result based on the computation proof. If the computation result is verified, the verifiable computation proxy contract can return the computation result and the computation proof to the business contract. The business contract can determine whether the transaction includes unexecuted verifiable computation tasks. If the transaction includes unexecuted verifiable computation tasks, the business contract generates a first end event carrying the unexecuted verifiable computation tasks. If the transaction does not include unexecuted verifiable computation tasks, the business contract generates a first end event carrying a termination response.

[0085] S208, the first end event is sent to the corresponding target verifiable computing node.

[0086] The business contract can determine the target verifiable computation proxy contract for the first termination event, and the target verifiable computation proxy contract can send the first termination event to the corresponding target verifiable computation node.

[0087] S209, if the first end event includes a verifiable computation task, then receive the second receipt transaction returned by the target verifiable computation node in response to the first end event.

[0088] If the first termination event includes a verifiable computation task, the target verifiable computation node can execute the verifiable computation task and generate the corresponding second receipt transaction. Then, the first receipt transaction is returned to the corresponding verifiable computation proxy contract, i.e., the target verifiable computation proxy contract in the previous step.

[0089] After receiving the second receipt transaction, the verifiable computation agent contract can verify the computation result based on the computation proof contained therein, and return the computation result and computation proof to the business contract after the verification is successful.

[0090] In one possible implementation, if the verification of the computation result fails based on the computational proof, the user can be directly notified of the execution failure, or the information of the execution failure can be fed back to the verifiable computing node, thereby enabling the verifiable computing node to notify the user of the execution failure.

[0091] S210 If the second receipt transaction verification is successful, then based on whether there is a next verifiable computation task for the transaction business, a second end event is thrown to the corresponding verifiable computation node.

[0092] If the transaction has a next verifiable computation task, a second end event carrying the next verifiable computation task is generated, the second verifiable computation node corresponding to the second end event is determined, and the second end event is sent to the second verifiable computation node; if the transaction does not have a next verifiable computation task, a second end event carrying an end response is generated, and the second end event is sent to the target verifiable computation node.

[0093] The second termination event can then be considered as the first termination event. By repeatedly executing steps S209-S210, the verifiable computation task is iterated until the transaction is completed. Those skilled in the art should understand that considering the second termination event as the first termination event is for the purpose of simplifying the iterative process. In this iterative process, the termination condition is that the transaction does not contain any unexecuted verifiable computation tasks. In this case, the second termination event sent is the last termination event sent during the execution of the transaction.

[0094] In this embodiment, verifiable computing nodes can generate verifiable computing proxy contracts. After the verifiable computing proxy contracts are deployed on the blockchain, they handle all interactions with the user, completely shielding the complex logic introduced by the verifiable computing nodes. This allows users to utilize verifiable computing functions in the same way they would operate a regular blockchain. The business contract and the verifiable computing nodes can complete the entire computation process through multiple iterative interactions based on transaction events, achieving complex session-based interactions. This allows the blockchain and verifiable computing nodes to communicate and interact multiple times after a single user trigger. In this embodiment, the computation process of verifiable computing does not require consensus on the blockchain, thus reducing the burden on the blockchain. The computation results and proofs of verifiable computing can be stored on the blockchain, enabling the blockchain to verify the computation results and ensuring its reliability.

[0095] Reference Figure 4 The diagram illustrates a step flow of a verifiable method provided in an embodiment of this application. The execution subject of this embodiment is a computer device, which can be a tablet computer, wearable device, vehicle device, laptop computer, super mobile personal computer, server, or other computer device. The computer device can provide verifiable computing services, making it a verifiable computing node. Figure 4 The verifiable computation method in the process may specifically include the following steps:

[0096] S401, Receive transaction events from blockchain nodes, wherein the transaction events have corresponding transaction business.

[0097] To improve the operating speed of the blockchain, some data or computations can be outsourced to off-chain computing nodes. Verifiable computing nodes are off-chain nodes that provide verifiable computing services. These nodes can store private data that is not suitable for public release, or archived data. Storing large amounts of data on the blockchain can reduce its efficiency; therefore, some data can be placed on verifiable computing nodes. Verifiable computing nodes can perform big data computations and have higher computing power. In this embodiment, verifiable computing nodes are used to protect private data and to expand the capacity of the blockchain nodes by migrating some data from the blockchain nodes to the verifiable computing nodes.

[0098] A verifiable computing node can deploy one or more verifiable computing services, each used for different verifiable computations. A verifiable computing proxy contract corresponding to a verifiable computing service can be deployed on a blockchain node. The blockchain node can invoke the verifiable computing proxy contract to send transaction events to the verifiable computing node.

[0099] A transaction event is generated by blockchain nodes based on a transaction and corresponds to a step in the execution of that transaction. A transaction event can include a computation event and a termination event. A computation event can include information such as the computation task, computation input, business contract address, and transaction ID. A termination event can include information such as the computation result, computation proof, and / or the next computation task.

[0100] S402, if the transaction event carries a verifiable computation task, then the verifiable computation task is executed to obtain a receipt transaction.

[0101] Transaction events can include end events and computation events. Computation events may carry the first verifiable computation task of the transaction; end events may or may not carry a verifiable computation task. If an end event does not carry a verifiable computation task, it indicates that the end event carries a termination response.

[0102] If the transaction event carries a verifiable computation task, the verifiable computation node can execute the verifiable computation task to obtain a computation result and a computation proof. External devices can verify the correctness of the computation result using this computation proof. Based on the computation result and computation proof, the verifiable computation node can generate a receipt transaction, which may include information such as the corresponding amateur contract address and transaction business ID.

[0103] If the transaction event is a computational event, then the verifiable computation service corresponding to the verifiable computation task can be determined. The transaction event can be sent from the verifiable computation proxy contract on the blockchain to the verifiable computation node; based on the sent verifiable computation proxy contract, the verifiable computation service called by the verifiable computation task can be determined. Calling the corresponding verifiable computation service can obtain the corresponding computation result and computation proof, and a corresponding receipt transaction can be generated based on the computation result and computation proof.

[0104] If a transaction event is a termination event and carries a verifiable execution task, it can carry not only information about the verifiable computation task, but also, if the verifiable computation task requires the participation of previous computation results, historical computation results and proofs of those previous tasks. These historical computation proofs can be used to verify the historical computation results. If the historical computation results are verified, the database containing the privacy data corresponding to the verifiable computation task is determined. This database has a corresponding verifiable computation proxy service, which can call the data in the database to perform computations based on the computation task information, thereby outputting computation results and proofs. However, it will not output the privacy data in the database. Based on the historical computation results, the corresponding verifiable computation service in the database can be called to obtain the computation results and proofs of the verifiable computation task. Then, based on the computation results and proofs, a receipt transaction is generated. The historical computation results and proofs carried in the termination event may be provided to the blockchain node by the verifiable computation service of the verifiable computation node; they may also be provided to the blockchain node by other verifiable computation services of the verifiable computation node; or they may be provided to the blockchain node by verifiable computation services of other verifiable computation nodes. In this embodiment, multiple verifiable computation proxy contracts can be deployed on a blockchain node, with each verifiable computation proxy contract corresponding one-to-one with a verifiable computation service. Different verifiable computation services can be deployed on the same verifiable computation node or on multiple different verifiable computation nodes. For example, multiple data sources can be deployed on a verifiable computation node, and each data source can deploy a verifiable computation service to perform computations using the data from that data source. In one possible implementation, the blockchain node can invoke the corresponding verifiable computation proxy contract to send a transaction event to the corresponding verifiable computation service. After receiving the transaction event sent by the corresponding verifiable computation proxy contract, the verifiable computation service can process the verifiable computation task corresponding to the transaction time and return the obtained computation result and computation proof as a receipt transaction to the corresponding verifiable computation proxy contract.

[0105] In one possible implementation, the verifiable computation task is defined as a privacy-preserving computation task. The verifiable computation node can then obtain the privacy data required for the task from a privacy database. Based on the privacy data and the computation logic of the verifiable computation task, the node executes the task to obtain the computation result and a computational proof. Finally, based on the computation result and proof, a receipt transaction is generated. In this embodiment, if privacy computation is performed, the verifiable computation node can ensure that it only provides the computation result, not the privacy data, to the blockchain node, thus strengthening the protection of privacy data.

[0106] S403, the receipt transaction is returned to the blockchain node.

[0107] If the transaction event includes a completion response, the execution result of the transaction is returned to the initiator of the transaction. The transaction event can include the user's address, allowing verifiable computing nodes to invoke user-side services based on the user's address and notify the user of the transaction execution result.

[0108] In this embodiment, based on transaction events, verifiable computing nodes can achieve interactive communication with blockchain nodes; verifiable computing nodes can independently execute verifiable computing tasks in transaction events, reducing the computational burden on the blockchain.

[0109] It should be noted that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0110] Figure 5 This is a flowchart illustrating the steps of another verifiable calculation method provided in this application embodiment. Figure 5 Both the business contracts and verifiable computation proxy contracts are deployed on the blockchain nodes. Verifiable computation nodes can be independent of the blockchain nodes and can independently provide verifiable computation services to the blockchain nodes.

[0111] The verifiable computation in this solution is an independent service, existing without relying on the blockchain. Interaction between blockchain nodes and verifiable computation nodes can be conducted through blockchain events and transactions. Blockchain events can include two types: FINISH events and COMPUTE events. COMPUTE events contain information such as the computation task, computation input, associated transaction ID, and the address of the business contract. FINISH events contain information such as the computation result, proof of computation correctness, and subsequent computation tasks.

[0112] Users define the computational interaction process by developing business contracts. Verifiable computing nodes generate verifiable computing proxy contracts. Both business contracts and proxy contracts are deployed on the blockchain and are standard blockchain smart contracts, possessing universality, meaning they can be used without requiring specific modifications to general blockchain platforms. Business contracts can be developed and defined by users according to their specific business needs. Verifiable computing proxy contracts are generated by verifiable computing nodes and include at least the following methods: Method 1: computeAndProve interface; Method 2: finish interface. Verifiable computing proxy contracts support sending at least two types of events: FINISH event and COMPUTE event.

[0113] Figure 5This illustrates a simple and typical interaction flow, comprising four entities: user, business contract, verifiable computing proxy contract, and verifiable computing node. The specific interaction process may include:

[0114] (1) The user initiates an invoke call to the business contract of the blockchain node, which corresponds to the first transaction.

[0115] (2) The business contract calls the computeAndProve interface of the verifiable computation proxy contract, and the verifiable computation proxy contract throws the COMPUTE event.

[0116] (3) When the verifiable computing node hears the COMPUTE event, it performs the calculation and generates a proof. After completion, it constructs a new transaction, namely the second transaction, with the calculation result and the proof. The second transaction calls the finish interface of the verifiable proxy contract.

[0117] (4) After the verifiable computing agent contract receives the call to the finish interface, it first verifies the correctness of the proof. If the verification fails, the process is terminated; if the verification passes, step (5) is executed.

[0118] (5) The callback to the business contract can be verified and the callback result can be obtained. This step is equivalent to notifying the business contract of the intermediate calculation result. The business contract determines whether to continue to the next step of calculation according to business needs and throws a FINISH event. Depending on whether the next step of calculation is needed, the FINISH event can decide whether to carry a new calculation task. The new calculation task may require the calculation result of the previous step.

[0119] (6) The verifiable computing node listens to the FINISH event and takes different actions depending on whether there is a new computing task. If there is a new computing task, it performs the calculation and proves it, then constructs a new transaction, namely the third transaction, and calls the finish interface of the verifiable computing agent contract to repeat step (5); otherwise, it finally calls back the interface provided by the user, informs the user of the final result, and ends the process.

[0120] Steps (5) to (6) can be repeated multiple times. Each time a new transaction is generated, these transactions form an associated chain on the chain, recording the entire iterative computation session.

[0121] Figure 5 The method described in the previous example involves the interaction between a blockchain node and the same verifiable computing node. In the scheme of this application, the verifiable computing node or the verifiable computing proxy contract invoked for each event is not necessarily the same, and the steps for each invocation can be as follows: Figure 5 The steps are shown in the diagram. Based on Figure 3The relationship between verifiable computing agent contracts and verifiable computing nodes is shown. Calling different verifiable computing agent contracts may correspond to the same verifiable computing node.

[0122] In this embodiment of the application, the verifiable computation is performed by an independent verifiable computation node. The time-consuming process of generating proof is not completed on the chain, which can save the performance of the chain. At the same time, the computation proof can be stored on the chain, which ensures the reliability of the computation.

[0123] The concept of sessions simplifies communication overhead and allows for complex interactions. This solution enables complex interactions between verifiable computation and blockchain nodes in the form of sessions. After a user triggers the interaction once, the blockchain and verifiable computation nodes can communicate and interact multiple times, iteratively issuing computation instructions and obtaining computation results and corresponding verifiable computation proofs. Iteration means that subsequent computations in the session depend on the results of previous computations. All computation tasks in the session have corresponding proofs, and these proofs are verified and archived on the blockchain. Based on sessions and iterations, user operations are simpler. From the user's perspective, they only need to send one transaction and wait for a callback; complex interaction logic is shielded from this, and the entire process is recorded on the blockchain. Other existing solutions require users to trigger multiple transactions, breaking down the operations associated with a single session into multiple independent single-step operations, increasing the complexity of the business system. Sessions and iterations enable collaboration among multiple parties and the completion of arbitrarily complex interactions, while verifiable computation proxy contracts simplify this process for users.

[0124] Verifiable computation has important applications in privacy protection. A common approach is to keep privacy data locally on a verifiable computation node instead of on-chain. For example, in the case of a data user and a data provider, because privacy data cannot leave the data provider, the computation is performed by the data provider's verifiable computation node, and the result is then returned to the data user. The verifiable computation node is deployed on the data provider's site. This traditional approach can handle situations with only one data provider, but it becomes difficult to apply in complex scenarios, such as when it is necessary to integrate two privacy data providers and ensure that the computation results are interdependent, while also considering that the data cannot leave their respective databases. However, using the interactive computation method described in this application, a business contract can interact with two verifiable computation proxy contracts simultaneously, thus completing the above scenario. Figure 6 This is a schematic diagram of a privacy computing scenario provided in an embodiment of this application. For the sake of simplicity, Figure 6 The example below only includes a scenario with two data providers. Figure 6The data user needs to use the private data from data provider A and data provider B; data user A can perform verifiable computation g based on the stored private data; data user A can perform verifiable computation f based on the stored private data. During a transaction, the interaction between the verifiable computation proxy contract and the business contract can be as follows:

[0125] Users can call the corresponding methods of the business contract; the business contract can send the computation task and input 'in' to the verifiable proxy contract B to call the data user B, where the user can be the data user.

[0126] Data user B can use the computation task and input in to call the corresponding privacy data to calculate f(in) and generate a computation proof. The computation proof and f(in) can be sent to the verifiable proxy contract B; the verifiable proxy contract B can call back the business contract.

[0127] The business contract sends f(in) as input to the verifiable proxy contract A to invoke the data user A.

[0128] Data user A calculates g(f(in)) and generates a calculation proof, which can verify that the proxy contract B can obtain the calculation proof and g(f(in)). Then, the business contract is called back to return the calculation proof and g(f(in)).

[0129] The business contract response can verify the calculation of agent contract B, and the response can include the previously calculated g(f(in)) as input for the next round of calculation.

[0130] Data user B calculates the final result f(g(f(in))) and returns the final calculation result to user U.

[0131] In this embodiment, the calculation process of f(g(f(in))) is entirely stored on the blockchain. Neither of the two data providers exposed their own privacy data to complete the collaborative calculation and generate a series of proofs, ensuring the verifiability of the calculation process.

[0132] Reference Figure 7 The diagram illustrates a verifiable computing device provided in an embodiment of this application. This device can be applied to a blockchain node and specifically may include a computing event throwing module 71, a first receipt transaction receiving module 72, a first end event determination module 73, and a first end event throwing module 74, wherein:

[0133] The computation event ejection module 71 is used to eject a computation event to the first verifiable computation node in response to a received transaction, wherein the computation event has a verifiable computation task corresponding to the transaction.

[0134] The first receipt transaction receiving module 72 is used to receive the first receipt transaction returned by the first verifiable computing node for the verifiable computing task.

[0135] The first end event determination module 73 is used to determine the first end event based on the transaction business if the first receipt transaction verification is successful.

[0136] The first end event throwing module 74 is used to send the first end event to the corresponding target verifiable computing node, wherein the target verifiable computing node is the first verifiable computing node or the target verifiable computing node.

[0137] In one possible implementation, the above-mentioned device further includes:

[0138] The second receipt transaction receiving module is used to receive the second receipt transaction returned by the target verifiable computing node for the first end event if the first end event includes a verifiable computing task.

[0139] The second end event throwing module is used to throw a second end event to the corresponding verifiable computing node if the second receipt transaction verification is successful, based on whether there is a next verifiable computing task for the transaction business.

[0140] In one possible implementation, the second end event throwing module mentioned above includes:

[0141] The first determining submodule is used to generate a second end event carrying the next verifiable computing task if the transaction business has the next verifiable computing task, determine the second verifiable computing node corresponding to the second end event, and send the second end event to the second verifiable computing node.

[0142] The second determining submodule is used to generate a second end event carrying an end response if the transaction business does not have the next verifiable computing task, and send the second end event to the target verifiable computing node.

[0143] In one possible implementation, the above-mentioned event-emitting module 71 includes:

[0144] The receiving submodule is used to receive the transaction business through a business contract deployed in the blockchain node;

[0145] The first verifiable computation task determination submodule is used to determine the first verifiable computation task in the transaction business based on the execution logic of the transaction business;

[0146] A generation submodule is used to generate the computation event based on the first verifiable computation task;

[0147] The verifiable computation proxy contract determination submodule is used to determine the verifiable computation proxy contract corresponding to the first verifiable computation task.

[0148] The throw submodule is used to invoke the verifiable computing agent contract and throw the computing event to the first verifiable computing node.

[0149] In one possible implementation, the first receipt transaction includes a calculation result and a calculation proof, and the aforementioned first end event determination module 73 includes:

[0150] The verification submodule is used to call the verifiable computation proxy contract to verify the computation result based on the computation proof;

[0151] The verifiable computation task determination submodule is used to determine whether the transaction business includes unexecuted verifiable computation tasks if the computation result is verified.

[0152] The first generation submodule is used to generate a first end event carrying the unexecuted verifiable computation task if the transaction business includes an unexecuted verifiable computation task.

[0153] The second generation submodule is used to generate a first end event carrying an end response if the transaction does not include the unexecuted verifiable computation task.

[0154] Reference Figure 8 The diagram illustrates another verifiable computing device provided in an embodiment of this application. This device can be applied to a verifiable computing node and may specifically include a transaction event receiving module 81, a verifiable computing module 82, and a transaction receipt return module 83, wherein:

[0155] The transaction event receiving module 81 is used to receive transaction events from blockchain nodes, wherein the transaction events have corresponding transaction business.

[0156] The verifiable calculation module 82 is used to execute the verifiable calculation task if the transaction event carries a verifiable calculation task, and obtain a receipt transaction.

[0157] The receipt transaction return module 83 is used to return the receipt transaction to the blockchain node.

[0158] In one possible implementation, the above-mentioned device further includes:

[0159] The return module is used to return the execution result of the transaction to the initiator of the transaction if the transaction event carries an end response.

[0160] In one possible implementation, the above-mentioned device further includes:

[0161] The determination module is used to determine that the transaction event carries an end response if the transaction event is an end event and the transaction event does not carry a verifiable computation task.

[0162] In one possible implementation, the aforementioned receipt transaction return module 83 includes:

[0163] The privacy data acquisition submodule is used to acquire the privacy data required by the verifiable computing task from the verifiable computing node if the verifiable computing task is a privacy computing task.

[0164] The privacy computing submodule is used to execute the verifiable computing task based on the privacy data and the computing logic of the verifiable computing task, and obtain the computing result and computing proof.

[0165] The receipt transaction generation submodule is used to generate the receipt transaction based on the calculation result and the calculation proof.

[0166] In one possible implementation, the aforementioned receipt transaction return module 83 includes:

[0167] The acquisition submodule is used to acquire the historical calculation results and historical calculation proofs carried by the verifiable calculation task if the transaction event is an end event and the transaction event carries a verifiable execution task. The historical calculation results and the historical calculation results correspond to the historical verifiable calculation tasks of the transaction business.

[0168] The verification submodule is used to verify the historical calculation results based on the historical calculation proof.

[0169] The database determination submodule is used to determine the database where the privacy data corresponding to the verifiable calculation task is located if the historical calculation result is verified.

[0170] The verifiable computing service invocation submodule is used to invoke the verifiable computing service corresponding to the database based on the historical computing results to obtain the computing results and computing proofs of the verifiable computing task;

[0171] The receipt transaction generation submodule is used to generate the receipt transaction based on the calculation results and calculation proof.

[0172] As the apparatus embodiments are basically similar to the method embodiments, they are described in a relatively simple manner. For relevant details, please refer to the description in the method embodiment section.

[0173] Figure 9This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. Figure 9 As shown, the computer device 9 of this embodiment includes: at least one processor 90 ( Figure 9 (Only one is shown) a processor, a memory 91, and a computer program 92 stored in the memory 91 and executable on the at least one processor 90, wherein the processor 90 executes the computer program 92 to implement the steps in any of the above method embodiments.

[0174] The computer device 9 can be a desktop computer, laptop, handheld computer, or cloud computing device, etc. This computer device may include, but is not limited to, a processor 90 and a memory 91. Those skilled in the art will understand that... Figure 9 The computer device 9 is merely an example and does not constitute a limitation on the computer device 9. It may include more or fewer components than shown, or combine certain components, or different components, such as input / output devices, network access devices, etc.

[0175] The processor 90 may be a Central Processing Unit (CPU), or it may be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or any conventional processor.

[0176] In some embodiments, the memory 91 may be an internal storage unit of the computer device 9, such as a hard disk or memory of the computer device 9. In other embodiments, the memory 91 may be an external storage device of the computer device 9, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., equipped on the computer device 9. Furthermore, the memory 91 may include both internal and external storage units of the computer device 9. The memory 91 is used to store the operating system, applications, bootloader, data, and other programs, such as the program code of the computer program. The memory 91 can also be used to temporarily store data that has been output or will be output.

[0177] This application also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps described in the various method embodiments above.

[0178] This application provides a computer program product that, when run on a computer device, enables the computer device to perform the steps described in the above-described method embodiments.

[0179] The embodiments described above are only used to illustrate the technical solutions of this application, and are not intended to limit it. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.

Claims

1. A verifiable calculation method, characterized in that, Applied to blockchain nodes, the method includes: In response to a received transaction, a computation event is sent to a first verifiable computing node, the computation event having a verifiable computation task corresponding to the transaction; Receive the first receipt transaction returned by the first verifiable computing node for the verifiable computing task; If the first receipt transaction is verified successfully, then the first termination event is determined according to the transaction business. Send the first termination event to the corresponding target verifiable computing node; If the first end event includes a verifiable computation task, then the second receipt transaction returned by the target verifiable computation node in response to the first end event is received; If the second receipt transaction is verified, a second termination event is thrown to the corresponding verifiable computing node based on whether there is a next verifiable computing task for the transaction.

2. The method as described in claim 1, characterized in that, The step of sending a second termination event to the corresponding verifiable computing node based on whether there is a next verifiable computing task for the transaction includes: If the transaction business has a next verifiable computation task, then generate a second end event carrying the next verifiable computation task, determine the second verifiable computation node corresponding to the second end event, and send the second end event to the second verifiable computation node; If the transaction does not have a next verifiable computation task, a second end event carrying an end response is generated and the second end event is sent to the target verifiable computation node.

3. The method according to any one of claims 1-2, characterized in that, The step of sending a computation event to the first verifiable computing node in response to a received transaction includes: The transaction is received through a business contract deployed in the blockchain node; The first verifiable computation task in the transaction is determined based on the execution logic of the transaction. The computation event is generated based on the first verifiable computation task; Determine the verifiable computation proxy contract corresponding to the first verifiable computation task; The verifiable computing agent contract is invoked to send the computing event to the first verifiable computing node.

4. The method as described in claim 3, characterized in that, The first receipt transaction includes a calculation result and a calculation proof. If the first receipt transaction passes verification, then based on the first receipt transaction and the transaction business, a first termination event is determined, including: The verifiable computation proxy contract is invoked to verify the computation result based on the computation proof; If the calculation result is verified, then it is determined whether the transaction includes unexecuted verifiable calculation tasks; If the transaction includes an unexecuted verifiable computation task, then a first end event carrying the unexecuted verifiable computation task is generated; If the transaction does not include any unexecuted verifiable computation tasks, then a first termination event carrying a termination response is generated.

5. A verifiable calculation method, characterized in that, Applied to verifiable computing nodes, the method includes: Receive transaction events from blockchain nodes, where each transaction event has a corresponding transaction business; If the transaction event carries a verifiable computation task, then the verifiable computation task is executed to obtain a receipt transaction; The receipt transaction is returned to the blockchain node; Wherein, if the transaction event carries a verifiable computation task, then executing the verifiable computation task to obtain a receipt transaction includes: If the transaction event is an end event and the transaction event carries a verifiable computation task, then the historical computation results and historical computation proofs carried by the verifiable computation task are obtained, and the historical computation results and the historical computation proofs correspond to the historical verifiable computation tasks of the transaction business. The historical calculation results are verified based on the historical calculation proof. If the historical calculation results are verified, then the database containing the privacy data corresponding to the verifiable calculation task is determined. Based on the historical calculation results, the verifiable calculation service corresponding to the database is invoked to obtain the calculation results and calculation proof of the verifiable calculation task; Based on the calculation results and proof, the receipt transaction is generated.

6. The method as described in claim 5, characterized in that, The method further includes: If the transaction event carries a termination response, the execution result of the transaction is returned to the initiator of the transaction.

7. The method as described in claim 6, characterized in that, Before returning the execution result of the transaction to the initiator of the transaction if the transaction event carries a termination response, the method further includes: If the transaction event is a termination event and the transaction event does not carry a verifiable computation task, then it is determined that the transaction event carries a termination response.

8. The method as described in claim 5, characterized in that, The execution of the verifiable computation task to obtain a receipt transaction includes: If the verifiable computing task is a privacy computing task, then the privacy data required by the verifiable computing task is obtained from the verifiable computing node; Based on the privacy data and the computation logic of the verifiable computation task, the verifiable computation task is executed to obtain the computation result and the computation proof. The receipt transaction is generated based on the calculation results and the calculation proof.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the method as described in any one of claims 1-8.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by a processor, it implements the method as described in any one of claims 1-8.

Images