System for securing verification key from alteration and verifying validity of a proof of correctness

The method and system protect verification keys and validate proofs of correctness using locking scripts and cryptographic techniques, enhancing the security and efficiency of blockchain transactions and smart contract execution.

JP2024156763AActive Publication Date: 2024-11-06NCHAIN LICENSING AG
View PDF 5 Cites 0 Cited by

Patent Information

Application Number
JP2024121031
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2018-04-20
Filing Date
2024-07-26
Publication Date
2024-11-06
Estimated Expiration
2038-10-29

AI Technical Summary

Technical Problem

Existing blockchain technologies face challenges in protecting verification keys from modification and verifying the validity of proofs of correctness, particularly in the execution of zero-knowledge protocols and smart contracts, which can lead to inefficiencies and security vulnerabilities.

Method used

A method and system that utilize locking scripts and cryptographic techniques to protect verification keys, ensuring their integrity and validate proofs of correctness through zero-knowledge protocols, using finite field elements and elliptic curve points, with scripts encoded in stack-based languages to ensure secure transactions.

Benefits of technology

Enhances the security and efficiency of blockchain transactions by protecting verification keys from modification and enabling the execution of complex smart contracts with reduced computational overhead, improving the overall throughput and reducing energy consumption.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 2024156763000001_ABST
    Figure 2024156763000001_ABST
Patent Text Reader

Abstract

To provide a computer-implemented method and system for a node of a blockchain network.SOLUTION: A computer-implemented method comprises: a step of generating an output of a transaction comprising an indication of a digital asset and a locking script that encodes a set of conditions for transferring control of the digital asset, the set of conditions being determined based at least in part on a verification key and a proof; a step of generating a transaction input comprising an identifier associated with the transaction output and an unlocking script comprising the proof; a step of verifying that the set of conditions are satisfied based on the locking script and the unlocking script; and a step of transferring control of the digital asset in response to verifying satisfaction of the set of conditions.SELECTED DRAWING: Figure 6
Need to check novelty before this filing date? Find Prior Art

Description

[Technical field]

[0001] The present invention relates generally to blockchain technology, and more specifically to enabling the execution of zero-knowledge protocols on a blockchain by utilizing locking scripts to protect verification keys from modification and to validate proofs of correctness. The present invention further utilizes cryptographic and mathematical techniques to enforce security for electronic transfers made on a blockchain network. The present invention is particularly suited for, but not limited to, use in the creation and execution of smart contracts. [Background technology]

[0002] As used herein, the term "blockchain" may refer to any of several types of electronic, computer-based distributed ledgers. These include consensus-based blockchain and transaction chain technologies, permissioned and unpermissioned ledgers, shared ledgers, and variations thereof. The most widely known application of blockchain technology is the Bitcoin ledger, although other blockchain implementations have been proposed and developed. For convenience and illustrative purposes, Bitcoin may be referenced as a beneficial application of the technology described herein, but Bitcoin is only one of many applications to which the technology described in this disclosure may be applied. However, it should be noted that the present invention is not limited to use with the Bitcoin blockchain, and alternative blockchain implementations and protocols, including non-commercial applications, are also within the scope of the present invention.

[0003] A blockchain is a peer-to-peer electronic ledger implemented as a computer-based, decentralized, distributed system composed of blocks, which may be composed of transactions and other information. In some examples, a "blockchain transaction" refers to an input message that encodes a structured collection of field values ​​that contain data and a set of conditions, where satisfying the set of conditions is a prerequisite for the set of fields to be written to the blockchain data structure. For example, in Bitcoin, each transaction is a data structure that encodes the transfer of control of a digital asset between participants of the blockchain system and includes at least one input and at least one output. In some embodiments, a "digital asset" refers to binary data that is associated with usage rights. Examples of digital assets include Bitcoin, Ether, and Litecoin. In some implementations, transferring control of a digital asset may be performed by reassociating at least a portion of the digital asset from a first entity to a second entity. Each block of a blockchain may include a hash of the previous block, such that the blocks are chained together to create a permanent, immutable record of all transactions written to the blockchain since its inception.

[0004] In some examples, a "stack-based scripting language" refers to a programming language that supports various stack-based or stack-oriented execution models and operations. That is, a stack-based scripting language may utilize a stack. In a stack, values ​​can be pushed onto the top of the stack or popped off the top of the stack. Various operations performed on a stack may result in one or more values ​​being pushed onto or popped off the top of the stack. For example, an OP_EQUAL operation pops the top two items off the stack, compares them, and pushes the result (e.g., 1 if equal, 0 if not) onto the top of the stack. Other operations performed on a stack, such as OP_PICK, may allow an item to be selected from a position other than the top of the stack. In some scripting languages ​​used in some of the embodiments, there may be at least two stacks, a main stack and an alternate stack. Some operations in the scripting language can move an item from the top of one stack to the top of another stack. For example, OP_TOALTSTACK moves a value from the top of the main stack to the top of the alternate stack. Note that stack-based scripting languages, in some cases, are not limited to strictly last-in-first-out (LIFO) operations. For example, a stack-based scripting language may support an operation that copies or moves the nth item in the stack to the top (e.g., OP_PICK and OP_ROLL in Bitcoin, respectively). Scripts written in stack-based scripting languages ​​may be pushed onto a logical stack, which may be implemented using any suitable data structure, such as a vector, list, or stack.

[0005] In order for a transaction to be written to the blockchain, it must be "validated." Network nodes (mining nodes) perform work to ensure that each transaction is valid, and invalid transactions are rejected from the network. Nodes can have different standards for validity than other nodes. Since blockchain validity is consensus-based, a transaction is considered valid if a majority of nodes agree that it is valid. A software client installed on a node performs this validation work for transactions that partially reference a UTXO by executing the UTXO's locking and unlocking scripts. A transaction is validated by a node if execution of the locking and unlocking scripts evaluates to TRUE and other validation conditions are met, if applicable. Validated transactions are propagated to other network nodes, where mining nodes can choose to include the transaction in the blockchain. Thus, for a transaction to be written to the blockchain, i) it must be verified by the first node that receives it, which, if verified, relays the transaction to other nodes in the network; ii) it must be added to a new block constructed by mining nodes; and iii) it must be mined, i.e., added to the public ledger of past transactions. A transaction is considered confirmed once a sufficient number of blocks have been added to the blockchain to make it effectively irreversible.

[0006] Although blockchain technology is most widely known for its use in implementing cryptocurrencies, digital entrepreneurs are beginning to explore the use of both the cryptographic security system on which Bitcoin is based, and the data that can be stored on the blockchain, to implement new systems. It would be highly advantageous if blockchain could be used to automate tasks and processes that are not limited to the cryptocurrency realm. Such solutions would be able to take advantage of the benefits of blockchain (e.g. persistence, tamper-proof record of events, distributed processing, etc.), although their uses are more diverse.

[0007] This disclosure describes technical aspects of one or more blockchain-based computer programs. A blockchain-based computer program may be a machine-readable, executable program that is recorded in a blockchain transaction. A blockchain-based computer program may include rules that can process inputs to generate results and then cause actions to be performed depending on those results. One area of ​​current research is the use of blockchain-based computer programs for the implementation of "smart contracts." Unlike traditional contracts that are written in natural language, smart contracts may be computer programs that are designed to automate the execution of the terms of a machine-readable contract or agreement.

[0008] Another area of ​​interest related to blockchain is the use of "tokens" (or "colored coins") to represent and transfer real-world entities through the blockchain. Potentially sensitive or secret items can be represented by tokens that have no discernible meaning or value. Thus, the tokens act as identifiers that allow real-world items to be referenced from the blockchain.

[0009] In embodiments, interactions with specific entities may be encoded in specific steps of a smart contract, but the smart contract may otherwise be automatically executed and self-enforcing. It is machine-readable and executable. In some examples, automatic execution refers to the execution of a smart contract that is successfully executed to enable the transfer of UTXOs. Note that in such examples, the "entity" that enables the transfer of UTXOs refers to an entity that can create the unlocking script without being required to prove knowledge of any secret. In other words, the unlocking transaction can be verified without verifying that the source of the data (e.g., the entity that created the unlocking transaction) has access to a cryptographic secret (e.g., a private asymmetric key, a symmetric key, etc.). Also, in such examples, self-enforcing refers to validating nodes of the blockchain network forcing the unlocking transaction according to constraints. In some examples, "unlocking" a UTXO (also known as "spending" a UTXO) is used in a technical sense to refer to creating an unlocking transaction that executes as valid, with reference to the UTXO.

[0010] The output of a blockchain transaction includes a locking script and information about the ownership of a digital asset, such as Bitcoin. A locking script, sometimes called an encumbrance, "locks" a digital asset by specifying conditions that must be satisfied in order for a UTXO to be transferred. For example, a locking script may require that certain data be provided in the unlocking script in order to unlock the associated digital asset. A locking script is also known as a "scriptPubKey" in Bitcoin. A technique for requiring a party to provide data to unlock a digital asset involves embedding a hash of the data inside the locking script. Summary of the Invention [Problem to be solved by the invention]

[0011] It would therefore be desirable to provide a method and system for improving blockchain technology in one or more of these aspects. Such an improved solution has now been devised. Thus, according to the present invention there is provided a method as defined in the accompanying claims.

[0012] Such an improved solution has now been devised. [Means for solving the problem]

[0013] Therefore, in accordance with the present invention there is provided a system and method as defined in the accompanying claims.

[0014] According to the present invention, a computer-implemented method may be provided for a node of a blockchain network, the computer-implemented method including: generating a transaction output for the transaction including an indication of a digital asset and a locking script encoding a set of conditions for transferring control of the digital asset, where satisfaction of the set of conditions is determined based at least in part on a verification key and a proof; generating a transaction input for the transaction, where the transaction input includes an identifier associated with the transaction output and an unlocking script including the proof; verifying based on the locking script and the unlocking script that the set of conditions are satisfied; and transferring control of the digital asset in response to verifying satisfaction of the set of conditions.

[0015] The verification key may include a plurality of first elements of a finite field, and the proof includes a plurality of second elements of the finite field.

[0016] The elements of the field may be points on an elliptic curve.

[0017] The elements of the finite field may be encoded in a compressed format.

[0018] Preferably, the method may include a client encoding the transaction input with a verification key and a first digital certificate associated with the client, and a worker encoding the transaction input with the proof and a second digital certificate associated with the worker.

[0019] The locking script may include instructions to reclaim the digital asset for the provider of the digital asset, provided a set of conditions are not met by the unlocking script.

[0020] The locking script may further include a redeem script, where the verification key and the redeem script encode information sufficient to determine satisfaction of at least a subset of the set of conditions; and the locking script encodes as one of the set of conditions that a hash of the redeem script matches a predetermined value.

[0021] The redeem script may be up to a certain maximum size, for example up to 520 bytes.

[0022] The unlocking script may include one or more elements of the verification key, and the redeem script may include at least some of the remaining elements of the verification key. The unlocking script and the redeem script may collectively comprise the verification key.

[0023] The locking script, unlocking script and redeem script of the transaction may follow the Pay-to-Script-Hash transaction of the Bitcoin-based protocol or a variation thereof.

[0024] The transactions may follow standard transactions of a blockchain-based protocol, such as the Bitcoin protocol.

[0025] Scripts, such as locking and unlocking scripts, may be encoded with commands and data in a stack-based scripting language, where the commands and data are placed on a stack in last-in, first-out order.

[0026] The set of conditions may include one or more bilinear constraints.

[0027] It is also desirable to provide a system comprising a processor and a memory containing executable instructions which, upon execution by the processor, cause the system to perform any of the claimed methods.

[0028] It is also desirable to provide a non-transitory computer-readable storage medium storing executable instructions that, upon execution by one or more processors of a computer system, cause the computer system to perform at least any of the claimed methods.

[0029] The present invention can be described as a verification method / system and / or a control method / system for controlling the exchange or transfer of digital assets over a blockchain. In some embodiments, the digital assets are tokens or portions of a cryptocurrency. As described below, the present invention can also be described as a secure method / system for new, improved and advantageous ways of performing operations over a blockchain network or platform. [Brief description of the drawings]

[0030] These and other aspects of the invention will be apparent from and elucidated with reference to the embodiments described hereinafter. Embodiments of the invention will now be described, by way of example only, with reference to the accompanying drawings in which:

[0031] [Figure 1] FIG. 1 illustrates a blockchain environment in which various embodiments may be implemented. [Diagram 2] FIG. 1 illustrates a computing environment that may be utilized to implement protocols in accordance with various embodiments. [Diagram 3] FIG. 1 is a diagram of an environment suitable for performing verifiable computations. [Figure 4] FIG. 1 illustrates an example diagram in which points on an elliptic curve are represented using compressed and uncompressed encodings suitable for use with a blockchain script, such as a locking script or an unlocking script, according to one embodiment. [Diagram 5] FIG. 2 illustrates a diagram in which a client supplies a verification key that is used to validate a proof. [Figure 6] FIG. 1 illustrates a diagram in which an operator provides a verification key that is used to validate a proof. [Figure 7] FIG. 7 illustrates a process 700 for generating a redeem script according to one embodiment. [Figure 8] FIG. 1 illustrates a computing device that may be used to implement at least one embodiment of the present disclosure. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0032] Reference is first made to Figure 1, which illustrates an example blockchain network 100 associated with a blockchain according to one embodiment of the present disclosure. In this embodiment, the example blockchain network 100 includes blockchain nodes implemented as peer-to-peer distributed electronic devices, each of which executes instances of software and / or hardware that perform operations according to a blockchain protocol agreed upon at least in part among operators of the nodes 102. In some examples, a "node" refers to a peer-to-peer electronic device that is distributed among the blockchain network. One example of a blockchain protocol is the Bitcoin protocol.

[0033] In some embodiments, node 102 may be comprised of any suitable computing device (e.g., by a server in a data center, by a client computing device (e.g., a desktop computer, a laptop computer, a tablet computer, a smart phone, etc.), by multiple computing devices in a distributed system of a computing resource service provider, or by any suitable electronic client device, such as computing device 800 of FIG. 8). In some embodiments, node 102 has an input for receiving data messages or objects representing proposed transactions, such as transaction 104. The node, in some embodiments, is queried for information it maintains, such as information on the state of transaction 104.

[0034] As shown in Figure 1, some of the nodes 102 are communicatively coupled to one or more of the other nodes 102. Such communicative coupling may include one or more of wired or wireless communication. In an embodiment, the nodes 102 each maintain at least a portion of a "ledger" of all transactions in the blockchain. In this manner, the ledger is a distributed ledger. Transactions processed by a node that affect the ledger are verifiable by one or more of the other nodes such that the integrity of the ledger is maintained.

[0035] With respect to which nodes 102 may communicate with which other nodes, it is sufficient that each of the nodes in the example blockchain network 100 may communicate with one or more other of the nodes 102 such that messages passed between nodes may propagate throughout the example blockchain network 100 (or any significant portion thereof), assuming that the messages are messages that the blockchain protocol indicates should be forwarded. One such message may be the publication of a proposed transaction by one of the nodes 102, e.g., node 102A, which would then propagate along a path such as path 106. Another such message may be the publication of a proposed new block for inclusion in the blockchain.

[0036] In one embodiment, at least some of the nodes 102 are mining nodes that perform complex calculations, such as solving cryptographic problems. The mining nodes that solve the cryptographic problems create new blocks for the blockchain and broadcast the new blocks to other nodes 102. The other nodes 102 verify the mining node's work and, upon verification, accept the block into the blockchain (e.g., by adding the block to the blockchain's distributed ledger). In some examples, a block is a group of transactions, often marked with a timestamp and a "fingerprint" (e.g., a hash) of the previous block. In this manner, each block may become linked to the previous block, thereby generating a "chain" that links the blocks in the blockchain. In an embodiment, valid blocks are added to the blockchain by consensus of the nodes 102. Also, in some examples, the blockchain includes a list of validated blocks.

[0037] In one embodiment, at least some of the nodes 102 operate as validating nodes that validate transactions as described in this disclosure. In some examples, a transaction includes a proof of ownership of a digital asset (e.g., multiple bitcoins) and data providing conditions for accepting or transferring ownership / control of the digital asset. In some examples, an "unlocking transaction" refers to a blockchain transaction that reassociates (e.g., transfers ownership or control) at least a portion of a digital asset represented by a UTXO of a previous transaction to an entity associated with a blockchain address. In some examples, a "previous transaction" refers to a blockchain transaction that includes a UTXO referenced by the unlocking transaction. In some embodiments, a transaction includes a "locking script" that blocks the transaction with conditions that must be met before ownership or control can be transferred ("unlocked").

[0038] In some embodiments, a blockchain address is an alphanumeric string associated with an entity to which control of at least a portion of a digital asset is being transferred / reassociated. In some blockchain protocols implemented in some embodiments, there is a one-to-one correspondence between a public key associated with an entity and a blockchain address. In some embodiments, validation of a transaction includes verifying one or more conditions specified in a locking script and / or an unlocking script. Upon successful validation of a transaction 104, the validating node adds the transaction 104 to the blockchain and distributes it to nodes 102.

[0039] The system and method described herein is a method for locking a locking script using a verification key V K from modification and verifying the validity of the proof π, thereby enabling the execution of zero-knowledge protocols in the blockchain during transaction validation.

[0040] Verifiable computation is a technique that allows for the generation of a proof of computation. In an embodiment, such techniques are utilized by a client to outsource the evaluation of a function f on an input x to another computing entity, referred to herein as a worker. In some cases, the client is computationally limited, making it infeasible for the client to perform the evaluation of the function (e.g., the expected runtime of the computation using the computational resources available to the client exceeds a maximum allowed threshold), but this need not be the case and the client may, generally speaking, delegate the evaluation of the function f on an input x based on any suitable criteria, such as computational runtime or computational cost (e.g., the economic cost of allocating the computational resources to perform the evaluation of the function).

[0041] The worker, in one embodiment, is any suitable computing entity, such as a blockchain node, described in more detail elsewhere in this disclosure. In one embodiment, the worker (e.g., a blockchain node) evaluates a function f on an input x to generate an output y and a proof π of the correctness of the output y that can be verified by other computing entities, such as the client and / or other nodes of the blockchain network. The proof, sometimes referred to as an argument, can be verified faster than an actual computation, and thus can reduce computational overhead (e.g., reducing power overhead and costs associated with powering up and running computational resources) by verifying the correctness of the proof instead of recomputing the function f on the input x to determine the correctness of the output generated by the worker. In zero-knowledge verifiable computation, the worker provides a client with a certificate that the worker knows an input with certain properties.

[0042] A useful variant of zero-knowledge proof of knowledge is the succinct non-interactive ARgument of knowledge (zk-SNARK). In one embodiment, all pairing-based zk-SNARKs involve a process in which an operator computes multiple group elements using a general group operation, and a verifier checks the proof using multiple pairing product equations. In one embodiment, linear interactive proofs work over finite fields, and the operator and verifier messages contain, encode, or otherwise include information usable to determine a vector of field elements.

[0043] In one embodiment, the systems and methods described herein enable mining nodes of a blockchain to perform a computation once (e.g., evaluating a function f on an input x) and generate a proof that can be used to verify the correctness of the output, where evaluating the correctness of the proof is computationally less expensive than evaluating the function. In this context, the cost (i.e., how expensive) of operations and tasks may refer to the computational complexity of performing the operation or task. In one embodiment, computational complexity refers to the average or worst-case computational cost of performing a sorting algorithm - for example, heapsort and quicksort algorithms both have an average computational cost of o(n logn), while quicksort has an average computational cost of o(n logn). 2), whereas heapsort has a worst-case computational cost of o(n logn). In one embodiment, the average and / or worst-case computational cost of evaluating the function f on the input x is worse than the cost of evaluating the correctness of the proof. Thus, the use of the systems and methods described herein may be highly advantageous, for example, allowing for more computationally expensive contracts to be executed, since such contracts do not proportionally increase the time required to verify the blockchain. Further advantages may include reduced power consumption of the verifier system, thereby improving the efficiency of the verifier computer system and reducing the energy costs associated with running such a verifier computer system when evaluating the correctness of the proof. Currently, smart contracts must be executed and verified at all nodes - this constraint limits the complexity of smart contracts. The methods and systems described herein can be used to improve the efficiency of a blockchain by executing a contract once to generate a proof of correctness, and to implement a system in which all nodes of the blockchain can verify the validity of the contract based on the proof of correctness provided by the worker and the verification key provided by the client. In this way, the efficiency of the blockchain is improved by increasing the throughput of smart contracts that can be collectively executed by the nodes of the blockchain and / or allowing the computation of more computationally expensive smart contracts.

[0044] In one embodiment, the verification key V k A proof π, or a portion thereof, can be extracted from the public parameters and input / output data generated in the setup phase of the zero-knowledge protocol and used with the proof π to verify the alleged proof of correctness computation provided by the worker. For example, as described above and in more detail below, systems and methods that allow locking scripts include a verification key V kfrom modification, checks the validity of the proof π, and enables the execution of a zero-knowledge protocol on the blockchain during transaction verification. Accordingly, the present disclosure discloses systems and methods for performing the verification phase using a blockchain script (e.g., in a Bitcoin-based network) to store elements used in verifying a computation.

[0045] 2 illustrates a computing environment 200 that may be utilized to implement the protocol, according to various embodiments. The protocol may be implemented using blockchain technology to store proofs of correctness and combine "correct-by-construction" cryptography with smart contracts. In one embodiment, the publicly verifiable computation scheme includes three phases: a setup phase, a computation phase, and a verification phase.

[0046] The setup phase may be performed as part of a process to outsource the execution of a computational task. A client, as referred to below, may refer to an entity such as a customer or a client computer system that delegates the execution of a computational task to a worker, which may be a different computer system. A client may delegate the execution of a computational task for a variety of reasons, generally speaking, including but not limited to, computational resources, lack of computational resources, economic costs associated with utilizing a client computer system to perform a task, energy costs associated with utilizing a client computer system to perform a task (e.g., a mobile device or laptop that relies on a battery for power may utilize a worker to perform a computationally intensive task, thereby conserving power and extending the use of the battery-powered device).

[0047] In one embodiment, the setup phase involves a client, customer, employee of an organization, or any other suitable entity writing a contract in a formal language with precise semantics. The contract may be written in a high-level programming language such as C or Java. Generally speaking, the contract may be expressed in any language or syntax that is or can be converted into a format that can be manipulated by a computer system. In one embodiment, for limited purposes, a domain-specific language may provide type safety and limited expressivity may be utilized. The generated source code may be a precise description of the contract.

[0048] The compiler 202 may be any hardware, software, or combination thereof that includes executable code that, when executed by one or more processors of a computer system, causes the system to take source code 206 as input and generate a circuit. The compiler 202 may refer to a computer program that executes or performs instructions based on instructions compiled into a machine-readable format, such as binary code. Although the compiler 202 is illustrated, it should be noted that interpreters, assemblers, and other suitable software and / or hardware components may be utilized to convert source code into a circuit. In one embodiment, the circuit is an arithmetic circuit with wires that carry values ​​from a field F and connect to logic and / or arithmetic gates. In one embodiment, the circuit C is used by the system to generate a quadratic program Q 208 that includes a set of polynomials that provide a complete description of the original circuit C.

[0049] In one embodiment, the compiler 202 can recognize a substantial subset of a programming language such as C or Java, including, but not limited to, preprocessor directives, static initializers, global and local functions, block-scoped variables, arrays, data structures, pointers, function calls, functional operators (e.g., functors), conditionals and loops, and arithmetic and bitwise Boolean operators. However, in one embodiment, the compiler 202 does not support the entire set of commands from a programming language standard (which may in some cases be intended to prevent certain types of algorithms from being executed in smart contracts, such as disallowing recursive algorithms). In one embodiment, the compiler extends the representation of the source code to an arithmetic gate language to generate arithmetic circuits. Circuit implementations have been previously considered by Campanelli, M. et al. (2017) in "ZERO-Knowledge Contingent Payments Revisited: Attacks and Payments for Services" and by Tillich, S. and Smart, B. in "Circuits of Basic Functions Suitable For MPC and FHE". The arithmetic circuits may be utilized by a compiler 202 or any other suitable hardware, software, or combination thereof (e.g., software modules not shown in FIG. 2) to construct a Quadratic Arithmetic Problem (QAP). The quadratic program is compiled into a set of cryptographic routines for clients (e.g., key generation and verification) and workers (e.g., calculations and proof generation) according to one embodiment. In some embodiments, arithmetic circuit optimization techniques such as those described in UK Patent Application No. 1718505.9 may be utilized to reduce the resources required for workers to determine the outcome of a smart contract.

[0050] In one embodiment, the key generator 204 is hardware, software, or a combination thereof that includes executable code that, when executed by one or more processors of a computer system, causes the system to generate evaluation and verification keys forming a quadratic program. Techniques for encoding computations as quadratic programs are considered in "Quadratic Span Programs and Succinct NIZKs without PCPs" by Gennaro, R. et al. (2013). In one embodiment, a Quadratic Arithmetic Problem (QAP) Q encodes a circuit C over a field F and includes a set of m+1 polynomials: V={vk(x)}, W={wk(x)}, Y={yk(x)} where 0 ≤ k ≤ m. The target polynomial t(x) is also defined. Let f be a function that takes n elements of F as input and n' elements as output, and given N = n + n', Q is a polynomial that can be expressed as {c1,...,c N}∈F N is a valid assignment of the input and output groups of f, and the list of coefficients {c N+1 ,...,c m}, compute f such that t(x) divides p(x):

number

[0051] Therefore, in the embodiment, there must be some polynomial h(x) such that h(x) t(x) = p(x). Q has size m and its degree is the degree of t(x).

[0052] In one embodiment, constructing a QAP for an arithmetic circuit includes, for each multiplication gate g in the circuit, g Pick ∈F,

number

number

[0053] In one embodiment, the QAP is a field F p is defined above, where p is a large prime. In one embodiment, F p It is desirable for the QAP above to efficiently compute any function that can be expressed in terms of addition and multiplication modulo p. The arithmetic split gate is k-1 ] into k binary output wires. Thus, Boolean functions can be expressed using arithmetic gates, e.g., NAND(a,b)=1-ab. Each embedded Boolean gate requires only one multiplication. Furthermore, new gates, such as split, can be defined as standalone and can be composed with other gates. k-1 ] is known to be in F pGiven, the split gate is Σ k Σ 2i-1 a i Output k wires each holding the binary digits a1,...,ak of a such that a = a, and for each a i is either 0 or 1.

[0054] Finally, the public parameters used by all provers and verifiers are generated by the system as part of the setup phase. K and the verification key V K Note that E is derived using a secret value selected by the client. The key generator 204 utilizes a quadratic arithmetic program (QAP) in conjunction with the key generation algorithm to derive the evaluation key E K 210 and verification key V K 212 can be generated.

[0055] In one embodiment, performing a computational task involves a computation of a function on input 216 (i.e., the process of evaluating f(x)) by an operator. In an embodiment, an operator is any suitable computer system to which a client can delegate a computational task. Input 216, in one embodiment, includes information verifying the identity of the operator, such as a digital signature generated using a private key associated with the operator. In one embodiment, an operator is a computer system to which a client is compensated (e.g., by a transfer of digital assets) for successful computation. A client, in one embodiment, receives input x and an evaluation key E K to the operator, who uses the evaluation module 214 for a computation routine to calculate an output y (i.e., y=f(x), where the input is x and the function is f) and obtains an evaluation key E K 210 to generate a proof of correctness 218. The evaluation module, in one embodiment, is hardware and / or software that includes instructions that, when executed by one or more processors of a computer system, cause the computer system to evaluate values ​​of the internal circuit wires of the QAP 208 and generate an output y of the QAP.

[0056] In one embodiment, each polynomial v of the quadratic program k (x)∈F is an element g in the bilinear group vk(s) where s is a secret value selected by the client, g is the generator of the group, and F is the field of discrete logarithms of g. In one embodiment, for a given input, the operator evaluates the circuit to find the coefficient c i Therefore, the operator obtains the output and value of the internal circuit wire corresponding to v(s)=Σ k∈{m} Rate ck·vk(s) v(s) Obtain w(s) and y(s) and calculate h(x)=p(x) / t(x)=Σ d h i x i Calculate h in the evaluation key. i and g s(i) Using the term g h(s) In one embodiment, the proof of correctness 218 calculates (g v(s) , g w(s) , g y(s) , g h(s) ), and the verifier uses the bilinear map to check p(s)=h(s)·t(s). In one embodiment, the proof π may be stored on the blockchain 222 for later use or verified by multiple parties without the prover needing to interact with each of them separately. In one embodiment, evaluation of the circuit storage of the proof of correctness may be performed to unlock digital assets that are blocked by the transaction's locking script.

[0057] In one embodiment, the proof π is broadcast to the blockchain network and a verifier 220 is used to verify the proof. In one embodiment, the verifier 220 is any suitable computational entity, such as a node on the blockchain. In some cases, an evaluation key E K and the verification key V KIt is further noted that the same computing entity that generates the proof also verifies the proof. In one embodiment, a node in the blockchain generates a verification key V K The payment transaction can be verified using the proof π and the contract can be verified if the verification is successful. One requirement of the protocol is the verification key V K Therefore, in this protocol, the common reference string (CRS) must be at least as long as the evaluation key E K and the verification key V K In one embodiment, the verification key V is generated by a client or a trusted third party that publishes the verification key V. K can be used by any computing entity to validate a computation.

[0058] Using the techniques described herein, a client can partially obfuscate transaction data, such as the identity of the recipient of a blockchain transaction. In one embodiment, the unlocking script does not reveal the recipient's address and the recipient's public key. In some cases, however, the value of the transaction (e.g., the amount of digital assets transferred) may be visible to nodes of the blockchain network. In one embodiment, the cryptographic techniques described above and below are utilized by the client to convert the locking script into a quadratic arithmetic program, and the worker solves the arithmetic program to generate a proof.

[0059] Generally speaking, a client can use standard transactions such as P2PK and P2PKH (e.g., standard transactions defined in a Bitcoin-based blockchain network) to pay a counterparty or worker. For example, in one embodiment, the client converts a P2PK locking script into an arithmetic circuit and broadcasts a payment transaction that includes a puzzle derived from the circuit. The counterparty or worker receives the circuit, provides appropriate inputs (e.g., information that proves the identity of the worker, such as a shared secret between the client and the worker or a digital signature generated using the worker's private key), and executes the circuit to generate a proof of correctness π. In one embodiment, the proof is used to unlock the digital asset, and furthermore, information that identifies the counterparty or worker (e.g., a public key and / or digital signature associated with the counterparty or worker) may not be recorded in the blockchain in an obfuscated format.

[0060] In an embodiment, the verification key and corresponding proof are generated according to the techniques described above and / or below. Thus, the verifier generates the verification key V such that the verifier computes multiple elliptic curve multiplications (e.g., one for each public input variable) and five pairing checks, one of which includes an additional pairing multiplication. K And we are given the proof π:

number

[0061] Verification key V K , proof π and (a1, a2, ..., a N ), then t(x) divides p(x), and so (x N+1 ,...,x m )=f(x0,...,x N To verify α, the verifier proceeds as follows. First, the three α terms:

number

number

number

number

number

number

number

number

number

number

number

[0062] Thus, considering the notations from the sections above and the examples described in this disclosure, validation, according to one embodiment, involves a set of paired checks of the following elements:

number

[0063] 3 illustrates a diagram 300 for coordinating the performance of a verifiable computation. The client 302, the worker 304, and the verifier 306 may be nodes of a blockchain network. The client 302 may be any suitable computer system and may include executable code that, when executed by one or more processors of the computer system, causes the computer system to receive a smart contract 308. In one embodiment, the smart contract 308 is encoded in a high-level programming language, such as source code, such as C, C++, or Java. In one embodiment, software, such as a compiler, interpreter, and / or assembler, is used to write the smart contract 308 in a field

number

[0064] In one embodiment, the client 302 provides the worker 304 with an arithmetic circuit 310 and inputs 312 to the circuit. The circuit 310 may be used to generate a quadratic program Q, which includes a set of polynomials that provide a complete description of the original circuit. In either case, the worker 304 may run the circuit C or the quadratic program Q on the inputs 312 to generate one or more outputs 314. In some embodiments, the worker (i.e., the prover) is expected to obtain as output a valid transcript for {C, x, y}, which is the assignment of values ​​to the circuit wires, such that the values ​​assigned to the input wires are those of x, the intermediate values ​​correspond to the correct operation of each gate in C, and the values ​​assigned to the output wires are y; there is no valid transcript for {C, x, y} if the claimed output is incorrect (i.e., y ≠ P(x)). In an embodiment, the worker is expected to provide a subset of the values ​​of the circuit wires, and the selected subset of the values ​​of the circuit wires is not known a priori to the worker.

[0065] In an embodiment, the output y, the values ​​of the internal circuit wires (or a subset thereof) and the evaluation key E K is used to generate a proof of correctness 316. The proof π can be stored on the blockchain and verified by multiple parties without requiring the worker 304 to interact with those parties separately. In this way, the verifier 306 uses the public verification key V K and the proof π can be used to verify the payment transaction, thereby verifying the contract. In some cases, the client 302 may reclaim the digital assets encumbered by the payment transaction if the verification fails. In some cases, the verifier 306 and the client 302 are the same computer system.

[0066] Figure 4 illustrates a diagram 400 of an embodiment of the present disclosure. Specifically, Figure 4 illustrates points on an elliptic curve 402 that are encoded in various formats suitable for use in blockchain-based scripts, such as Bitcoin-based locking and unlocking scripts.

[0067] In various embodiments, the elliptic curve points may be encoded in locking and unlocking scripts that are executed in conjunction with a transaction. In a Bitcoin-based system, these scripts may be written in a stack-based scripting language. For example, the verification key V K teeth,

number

number

number

[0068] FIG. 4 illustrates how points on an elliptic curve 402 can be compressed (P C ) or uncompressed (P U 4 shows an example diagram 400 represented using any of the 3D RGB 3D (3D) encodings.

[0069] In one embodiment,

number

number

[0070] In one embodiment, the uncompressed encoding 404 is a representation of a point P of a finite field, such as the x-coordinate 408 and y-coordinate 410 of a point on an elliptic curve (i.e.,

number

[0071] Generally speaking, the non-compression point P U , P U Note that a compressed point P is an uncompressed elliptic curve point, and may be represented in any suitable format that encodes information that can be used to determine the x-coordinate of the point and the y-coordinate of the point. Similarly, C , P C is a compressed elliptic curve point, and compressed information that can be used to determine the x and y coordinates of the point.

[0072] As an example, consider the representation of points of the secp256k1 elliptic curve in a Bitcoin-based system. In an embodiment where an uncompressed point is represented, the first octet in the encoded bit string of the uncompressed elliptic curve P is 0x04, followed by two 256-bit numbers corresponding to the X coordinate of the point and the Y coordinate of the point (i.e., P=C||X||Y). As an example, the Distinguished Encoding Rules (DER) encoding format is used, although other suitable encoding formats, such as the Basic Encoding Rules (BER) and Canonical Encoding Rules (CER), are also contemplated within the scope of this disclosure.

[0073] In one embodiment, a one-byte script opcode containing the length of the elliptic curve point is concatenated to the actual point (e.g., the length is concatenated to the beginning of the actual point). For example, x=0xe3b01684a8a8b66f8e44203db5869b4dcb74a0afc905ae9197ed74a8d6cecdcc y=0x6424d186a23687532c8b20911defc2f42c93749b3736857912c6abe2dc3f01d1 In this case, the compression script P C and uncompressed script P U are, in one embodiment, respectively: Script P C :0x21||0x03e3b01684a8a8b66f8e44203db5869b4dcb74a0afc905ae9197ed74a8d6cecdcc Script P U :0x41||0x04e3b01684a8a8b66f8e44203db5869b4dcb74a0afc905ae9197ed74a8d6cecdcc6424d1 86a23687532c8b20911defc2f42c93749b3736857912c6abe2dc3f01d1

[0074] In one embodiment, a client is a party to a smart contract and decides to utilize the blockchain for execution of the contract. As part of the decision, the client posts a payment transition to the blockchain to transfer digital assets managed by the client to a party (e.g., a worker) that publishes the proof π. A verifier computer system, such as the one described above, can run a verification routine to determine that the proof π is correct.

[0075] According to the protocol, the client may generate a common reference string for the creation and generation of the proof. In some embodiments, the common reference string is generated by a trusted party (e.g., a third party). Although the trusted third party may generate the common reference string, it should be noted that the introduction of a trusted third party to the protocol is optional and the protocol requires the client and the operator and may be run without an additional third party.

[0076] Continuing with the protocol, the validation of the computation is done as part of the validation phase of the transaction. In one embodiment, such as a Bitcoin-based network, the client or operator may validate the computation as part of the locking and / or unlocking scripts.

number

number

number

number

[0077] A blockchain-based system, such as a Bitcoin-based system, in one embodiment, supports the execution of operations (also called opcodes and commands) according to a scripting language, such as script (e.g., a Bitcoin-based system supports script). In one embodiment, a transaction includes a locking (output) script and an unlocking (input) script, and is identifiable as one of a list of standard types. For example, in a Bitcoin-based system, there are five standard types: Pay-to-Public-Key (P2PK), Pay-to-Public-Key-Hash (P2PKH), Multi-Signature, Pay-to-Script-Hash (P2SH), and OP_RETURN.

[0078] As described herein, when implementing the proposed zk protocol, information such as the common reference string, the proof π, and / or portions thereof are stored on the blockchain. Additionally, as part of the validation process, the system may extract certain elements that were pushed on the stack in the transaction validation process and check the pairing from the validation phase as described above.

[0079] Transactions may contain small programs known as scripts that are embedded in their inputs and outputs, and such scripts specify how and who can access the output of a transaction. In the Bitcoin platform, these scripts are written using a stack-based scripting language. In one embodiment, the protocol includes various technical rules and syntax-based restrictions on transactions that determine whether a transaction is a standard or non-standard transaction. In one embodiment, there are restrictions on the size of elements pushed onto the execution stack and the total size of the input script. For example, in a Bitcoin-based system, all elements pushed onto the execution stack are limited to 520 bytes, and each input script is limited to 1650 bytes. In one embodiment, after script execution, the stack contains exactly one non-false element. An input script cannot contain any OP codes (excluding redeem script parts) other than OP_PUSHDATA. In one embodiment, the Bitcoin-based system requires a minimum output value of 546 satoshis, but it should be noted that different blockchain systems may define different amounts and / or units of digital assets that should be included as an output value (e.g., the minimum payout to a mining node for a transaction). In one embodiment, the minimum output value is zero (i.e., there is no required transfer of digital assets). Transactions that deviate from these rules are considered non-standard.

[0080] As part of the verification phase, the verifier (e.g., the client) generates a verification key V K and extract elements of the proof and use them for the pairing check. In one embodiment, the verification check involves a bilinear mapping that satisfies a set of constraints. For example, e.g., e(3,4+5)=2 3*9 =2 27 e(3,4)*e(3,5)=2 3*4 2 3*5 =212 2 15 =2 27 As such, constraints of the form:

number

[0081] Note that such pairings described above are for illustrative purposes - such mappings may not be verbatim useful for applications in cryptosystems, but note that the process of verifying bilinear constraints remains the same as when the bilinear map is extended onto an elliptic curve. Again, for illustration purposes, let us consider a Bitcoin script that uses a common reference string (e.g., a verification key V) in the verification phase. K ) and the proof π, an example of how to extract and use information is given below: [Table 1]

[0082] Note that the example provided above is merely used to illustrate an example of pair checking, and may include additional constraints, such as those discussed above in connection with FIG. 2.

[0083] A verification key V for use in connection with verifying the proof π K There are various techniques for providing a verification key V to be used to validate the proof π. K 5 is an example diagram 500 that provides a transaction output 502. In one embodiment, a client generates a transaction output 502 that includes or is otherwise associated with an output value 504 (e.g., a payment of a digital asset to a worker for contract execution) and a locking script 508 that performs a validation check that includes a bilinear mapping that satisfies a set of constraints. In one embodiment, the locking script generates a validation key V based at least in part on the client's digital signature.K verifies the integrity of the locking script. In some cases, the locking script may specify that if validation fails, the client may reclaim the digital assets associated with the transaction, as described above. Such transactions may be submitted to the blockchain network to be mined by nodes (e.g., workers) of the blockchain network. In some blockchain systems, the transaction encodes, in association with the locking script, a parameter indicating the size of the locking script (e.g., in bytes). The size of the locking script may be referred to as the locking script size 506, as shown in association with FIG. 5.

[0084] As an example, a locking script may be written based on the following: [Table 2]

[0085] Note that the example provided above is intended to illustrate the locking script, and not necessarily to describe the locking script 508 verbatim. For example, some fields are written in square brackets - e.g. ", which may refer to the client's public key.<PubKey Client> " - is not included verbatim in the locking script 508. Similarly, some fields within brackets may be based on a mathematical calculation - for example, "OP_(i+1)" above may not be included verbatim in the locking script, but rather refers to an opcode or command that is determined based at least in part on a mathematical calculation - in this case, "i" refers to the number of elements in the proof π, so in the example of a proof π={π1,...,π8}, "OP_(i+1)" may be expressed in the locking script as "OP_7" in a stack-based scripting language. Note further that the text after the double slash " / / " above refers to a comment and does not correspond to executable code. For example, " / / verify pairing" does not map to executable code, but merely indicates to a human that the text following the comment is utilized to perform pairing verification.

[0086] Again, it should be noted that the transaction output 502 described above is merely exemplary and that variations are possible - a transaction may include any suitable payment amount in any suitable unit of measure, and that a variety of locking scripts may exist, for example, that utilize the functionality of some or all of the locking scripts described above. Generally speaking, the locking script 508 may be any suitable set of commands that performs a set of pairing checks. In one embodiment, the locking script 508 may include a verification key V using at least an asymmetric public key associated with the client. KIn one embodiment, the locking script allows the client to reclaim the digital asset if validation fails. In one embodiment, the locking script 508 may be configured to lock the digital asset after a threshold period (e.g., a period of time as described above).<n days> ") followed by an instruction to mark the transaction as invalid.

[0087] A client 510, which may be a client as described elsewhere in this disclosure, may generate a transaction input 512 referencing the transaction 502 described above and transmit it to a counterparty (e.g., a worker purportedly computing a valid proof π). In one embodiment, the transaction input 512 may encode an identifier 514 associated with the transaction output 502, a transaction output index 516 associated with the transaction output 502 (e.g., in some cases, the index is zero-based), an unlocking script 520, a parameter indicating the size (e.g., in bytes) of the unlocking script, which may be referred to as the unlocking script size 518, a sequence number 522, and any suitable combination thereof. For example, in some embodiments, the size of the unlocking script is not explicitly encoded in the transaction input 512, but is otherwise derivable (e.g., through detection of a particular ending sequence indicating the end of the unlocking script). In one embodiment, the unlocking script 518 encodes a validation key V K 524 and a digital signature 526 associated with the client. In some cases, the unlocking script 518 includes additional information, such as instructions for branching information that control the execution of the validation process.

[0088] As an example, the unlocking script may be described based on the following:

number

[0089] It should be noted that the example provided above is a description of an unlocking script, and not necessarily the verbatim unlocking script itself. For example, some fields described above in square brackets are not verbatim included in the unlocking script 518. Returning to the above example of a description of an unlocking script, the unlocking script 518 may include a verification key V K The unlocking script 518 may include an ordered or unordered sequence of elements 524, a digital signature 526 associated with the client, and branch information. In one embodiment, the digital signature 526 includes a hash type flag. In one embodiment, the hash flag is SIGHASH_NONE | SIGHASH_ANYONECANPAY in accordance with the Bitcoin-based system. The unlocking script 518 may include execution control information that can be used with the locking script to verify the transaction. For example, in the above example, the "1" indicates that the script should enter the first branch of the control statement of the unlocking script (e.g., the OP_IF branch instead of the OP_ELSE branch).

[0090] In one embodiment, the worker 528 calculates the proof π 530, attaches it to the unlocking script 518 along with a digital signature 532 associated with the worker, and broadcasts the transaction (e.g., to clients and / or one or more nodes of the blockchain network).

[0091] As an example, an unlocking script with a proof and a digital signature of an author may be described based on the following:

number

[0092] Thus, in one embodiment, the unlocking script described immediately above can satisfy the conditions imposed on the output by the locking script and allow the digital asset (e.g., as indicated by the output value) to be used.

[0093] A verification key V for use in connection with validating the proof π K There are various techniques for providing a verification key V that is used to validate the proof π. K 6 is an exemplary diagram 600 in which an operator provides a transaction output 602 according to a Bitcoin-based system and may include an output value 604, a locking script 606 (optionally in some systems), and a locking script 608. In one embodiment, the transaction is a Pay-to-Script-Hash (P2SH) transaction according to a Bitcoin-based system. In one embodiment, the transaction output 612 according to a Bitcoin-based system and includes a transaction ID 614, an output index 616, an unlocking script size 620, an unlocking script 618, and a sequence number 622, as described above in connection with FIG. 5. Note that the structure of the transaction illustrated in FIG. 6 may be according to that described in FIG. 5, but FIG. 6 specifically includes a locking script 608 and an unlocking script 618 according to a P2SH transaction. The client 610 receives a verification key V K and redeem scripts 628 and provide them to the worker 624.

[0094] In one embodiment, the blockchain system supports various types of transactions. In one embodiment, the supported transactions (e.g., standard transactions) are script hash-based transactions, such as Pay-to-Script-Hash (P2SH) transactions according to a Bitcoin-based system. Generally speaking, a script hash-based transaction refers to any transaction, where validating the locking script includes providing a script that matches a specified hash value. For example, in a Bitcoin-based P2SH transaction, the unlocking script 620 includes a redeem script 628, and the locking script 608 includes at least one condition that the hash of the redeem script provided by the unlocking script matches a specified value. For example, in a Bitcoin-based system, the locking script may be written based on the following: OP_HASH160 <20-byte hash of redemption script> OP_EQUAL

[0095] In some cases, the worker 624 may generate a verification key V K 626. The unlocking condition that checks the validation step may be stored in the redeem script in one embodiment. In one embodiment, the locking script of a P2SH transaction includes a hash of the redeem script, and in some cases, the redeem script is kept secret (e.g., encrypted by the operator) and only revealed upon instruction to cause the transfer of the output value.

[0096] In one embodiment, the client 610 creates a P2SH unspent transaction output by identifying a redeem script and applying a hash (e.g., HASH160) to it. To transfer a UTXO, the client creates an input script (which references the UTXO) that includes and / or otherwise references the redeem script. Note that while a blockchain-based system may have limitations regarding the type or amount of data that may be included in a redeem script, in one embodiment, the redeem script is suitable for storing any data. For example, in the context of a Bitcoin-based system, there may be limitations on the size of data that can be exposed to the stack (e.g., a PUSHDATA operation is limited to 520 bytes of data). In one embodiment, the redeem script is generated at the compression point P2SHDATA, as described in connection with FIG. 4. C and the incompression point P U Thus, in one embodiment, the maximum number of elliptic curve points that can be stored in a redeem script according to the Bitcoin-based protocol is 15 compressed points (e.g., 15 points x 34 bytes / point = 510 bytes) or 7 uncompressed points (7 points x 66 bytes / point = 462 bytes). In one embodiment, the unlocking script 618 includes a proof 630, a redeem script 628, and commands (e.g., opcodes) that can be used together to satisfy a set of conditions encoded in the locking script 608.

[0097] 7 is an illustration of a process 700 for generating a redeem script according to one embodiment. In one embodiment, the process 700 is implemented using hardware, software, or a combination thereof. Suitable systems for performing the process include an operator providing a P2SH unlocking script as described in conjunction with the description of FIG. 6.

[0098] In one embodiment, the system uses a verification key V Kis of sufficient cardinality. In one embodiment, the system determines 702 the size of a redeem script, including each element of the verification key and a script for checking a set of constraints, where the redeem script and the proof π are sufficient to unlock the corresponding locking script. The system may determine 704 whether the size of such a redeem script exceeds a predetermined threshold. The predetermined threshold may be based on a size limit imposed by a blockchain protocol - for example, a blockchain protocol may require that the redeem script be 520 bytes or less in size. If the redeem script is of sufficient size, the system generates 706 a redeem script and an unlocking script, where the redeem script includes a verification key and a script for checking a set of constraints, the unlocking script includes the proof π, and the redeem script and the unlocking script together include a set of commands sufficient to verify the payment transaction.

[0099] For example, the verification key V K If the cardinality of is less than 16, then it may be: [Table 3] Here, the redeem script and the unlocking script are sufficient to unlock the locking script.

[0100] If the redeem script exceeds the predefined threshold, the system generates 708 an unlocking script that stores one or more elements of the verification key VK in a portion of the unlocking script preceding the redeem script, so that the total size of the redeem script is within the threshold, and generates 710 the redeem script with the elements of the verification key and the constraints described above. K One or more elements of may be encoded elsewhere in the unlocking script. For example,K If the cardinality of is greater than 15, it may be: [Table 4] Here, the redeem script and the unlocking script are sufficient to unlock the locking script.

[0101] Therefore, by encoding the steps required for the validation phase in the locking script, transaction validation should be a process equivalent to the validation phase of the zk-protocol. In one embodiment, the OP_VERIFYPROOF opcode may be used as follows: [Table 5]

[0102] The unlocking script and the locking script may be implemented in any suitable manner. The unlocking script may be implemented as follows: K Similarly, the locking script may be implemented in any suitable manner to encode π i and

number

[0103] FIG. 8 is an exemplary simplified block diagram of a computing device 800 that can be used to implement at least one embodiment of the present disclosure. In various embodiments, the computing device 800 can be used to implement any of the systems illustrated and described above. For example, the computing device 800 can be configured for use as a data server, a web server, a portable computing device, a personal computer, or any electronic computing device. As illustrated in FIG. 8, the computing device 800 can, in embodiments, include one or more processors 802 that communicate with and are operably coupled to a number of peripheral subsystems via a bus subsystem 804. In some embodiments, these peripheral subsystems include a storage subsystem 806 that includes a memory subsystem 808 and a file / disk storage subsystem 810, one or more user interface input devices 812, one or more user interface output devices 814, and a network interface subsystem 816. Such a storage subsystem 806 can be used for temporary or long-term storage of information.

[0104] In some embodiments, the bus subsystem 804 provides a mechanism that allows the various components and subsystems of the computing device 800 to communicate with each other as intended. Although the bus subsystem 804 is shown generally as a single bus, alternative embodiments of the bus subsystem utilize multiple buses. In some embodiments, the network interface subsystem 816 provides an interface to other computing devices and networks. The network interface subsystem 816, in some embodiments, serves as an interface for receiving data from the computing device 800 and transmitting data to other systems. In some implementations, the bus subsystem 804 is utilized to communicate data such as details, search terms, etc.

[0105] In some embodiments, the user interface input devices 812 include one or more user input devices, such as a keyboard; a pointing device, such as an integrated mouse, trackball, touchpad, or graphics tablet; a scanner; a barcode scanner; a touch screen integrated into a display; an audio input device, such as a voice recognition system, a microphone; and other types of input devices. In general, use of the term "input device" is intended to include all possible types of devices and mechanisms for inputting information into the computing device 800. In some embodiments, the one or more user interface output devices 814 include a display subsystem, a non-visual display, such as a printer or an audio output device, and the like. In some embodiments, the display subsystem includes a flat panel device, such as a cathode ray tube (CRT), a liquid crystal display (LCD) or a light emitting diode (LED) display, a projection device, or other display device. In general, use of the term "output device" is intended to include all possible types of devices and mechanisms for outputting information from the computing device 800. The one or more user interface output devices 814 can be used, for example, to present a user interface and to facilitate user interaction with applications that perform the described processes and variations thereof, when such interaction may be appropriate.

[0106] In some embodiments, the storage subsystem 806 provides a computer readable storage medium for storing basic programming and data constructs that provide functionality of at least one embodiment of the present disclosure. Applications (programs, code modules, instructions), which in some embodiments when executed by one or more processors, provide functionality of one or more embodiments of the present disclosure, are stored in the storage subsystem 806 in embodiments. These application modules or instructions may be executed by one or more processors 802. In various embodiments, the storage subsystem 806 further provides a repository for storing data used in accordance with the present disclosure. In some embodiments, the storage subsystem 806 includes a memory subsystem 808 and a file / disk storage subsystem 810.

[0107] In an embodiment, memory subsystem 808 includes multiple memories, such as a main random access memory (RAM) 818 for storage of instructions and data during program execution and / or a read-only memory (ROM) 820 that may store fixed instructions. In some embodiments, file / disk storage subsystem 810 provides non-transient persistent (non-volatile) storage for program files and data files and may include a hard disk drive, a floppy disk drive with associated removable media, a compact disk read-only memory (CD-ROM) drive, an optical drive, a removable media cartridge, or other similar storage media.

[0108] In some embodiments, computing device 800 includes at least one local clock 824. The local clock 824, in some embodiments, is a counter that represents the number of ticks that have occurred since a particular start date and, in some embodiments, is integrally located within computing device 800. In various embodiments, the local clock 824 is used to synchronize data transfers within the processor and subsystems contained therein for computing device 800 at a particular clock pulse, and may be used to coordinate synchronization operations between computing device 800 and other systems in a data center. In another embodiment, the local clock is a timer with a programmable interval.

[0109] The computing device 800 can be any of a variety of types, including a portable computing device, a tablet computer, a workstation, or any other device described below. In addition, the computing device 800, in some embodiments, can include another device that can be connected to the computing device 800 through one or more ports (e.g., USB, headphone jack, lightning connector, etc.). In embodiments, such a device includes a port that accepts a fiber optic connector. Thus, in some embodiments, the device converts optical signals into electrical signals that are transmitted through a port that connects the device to the computing device 800 for processing. Due to the ever-changing nature of computers and networks, the description of the computing device 800 shown in FIG. 8 is intended only as a specific example for purposes of describing a preferred embodiment of the device. Many other configurations having more or fewer components than the system shown in FIG. 8 are possible.

[0110] It should be noted that the above-described embodiments are illustrative rather than limiting of the invention, and that those skilled in the art can design many alternative embodiments without departing from the scope of the invention as defined by the appended claims. In the claims, any reference signs placed in parentheses shall not be construed as limiting the claims. The words "comprising" and "comprises" and the like do not exclude the presence of elements or steps other than those listed in any claim or the specification as a whole. In this specification, "comprising" means "including or consisting of" and "comprises" or "comprises" or "comprises". A singular reference of an element does not exclude a plural reference of such element and vice versa. The invention may be implemented by means of hardware comprising several distinct elements and by means of a suitably programmed computer. In a device claim enumerating several means, several of these means may be embodied by one and the same item of hardware. The mere fact that certain means are recited in mutually different dependent claims does not indicate that a combination of these means cannot be used to advantage.

[0111] All references cited in this specification, including publications, patent applications, and patents, are hereby incorporated by reference into this specification to the same extent as if each reference was individually and specifically indicated to be incorporated by reference and was set forth in its entirety herein.

Claims

1. 1. A computer-implemented method for controlling a transfer of digital assets over a blockchain, the method comprising: generating a transaction output for the transaction including an indication of a digital asset and a locking script that encodes a set of conditions for transferring control of the digital asset, where satisfaction of the set of conditions is determined at least in part based on the verification key and the proof; generating a transaction input for the transaction, the transaction input comprising: an identifier associated with the transaction output; an unlocking script including said proof; and determining, based at least in part on the locking script and the unlocking script, that the set of conditions is satisfied; transferring control of the digital asset in response to determining satisfaction of the set of conditions; 4. A computer-implemented method comprising:

2. the verification key includes a plurality of first elements of a finite field, and the proof includes a plurality of second elements of the finite field; 2. The computer-implemented method of claim 1.

3. The elements of the finite field are points on an elliptic curve.

3. The computer-implemented method of claim 2.

4. the elements of the finite field are encoded in a compressed format; 4. A computer-implemented method according to claim 2 or 3.

5. a client encodes the transaction input with the verification key and a first digital certificate associated with the client, and an operator encodes the transaction input with the proof and a second digital certificate associated with the operator; 5. A computer-implemented method according to any preceding claim.

6. the locking script includes instructions to recover the digital asset for a provider of the digital asset if a condition of the set of conditions is not satisfied by the unlocking script.

6. A computer-implemented method according to any preceding claim.

7. the unlocking script further comprises a redeem script, the verification key and the redeem script satisfying the set of conditions; the locking script encodes a condition in the set of conditions under which a hash of the redeem script matches a predefined value; A computer-implemented method according to any preceding claim.

8. The redeem script is 520 bytes or less in size.

8. The computer-implemented method of claim 7.

9. the unlocking script includes one or more elements of the verification key; 9. A computer-implemented method according to claim 7 or 8.

10. The transaction is a P2SH transaction according to a Bitcoin-based protocol. A computer-implemented method according to any one of claims 7 to 9.

11. The transaction is a standard transaction according to a blockchain-based protocol. A computer-implemented method according to any preceding claim.

12. the locking script and the unlocking script are encoded in a stack-based scripting language; 12. A computer-implemented method according to any preceding claim.

13. The set of conditions includes a bilinear constraint.

13. A computer-implemented method according to any preceding claim.

14. In the system, A processor; A memory containing executable instructions which, when executed by the processor, cause the system to perform the computer-implemented method of any one of claims 1 to 13; A system comprising:

15. A non-transitory computer readable storage medium storing executable instructions which, when executed by a processor of a computer system, cause the computer system to perform at least the computer-implemented method of any one of claims 1 to 13.

Citation Information

Patent Citations

  • Inhalation device and method with multi-fluid nozzle

    JP2020524541A

  • Method for verifying information

    WO2016155804A1

  • Implementing logic gate functionality using a blockchain

    WO2017187396A1

  • Implementing logic gate functionality using a blockchain

    WO2017187398A1

  • Implementing logic gate functionality using a blockchain

    WO2017187399A1