Transaction method for ZK (zero knowledge)-rollup network for block chain
The ZK rollup transaction method enables parallel operation of multiple aggregators using recursive ZK proofs to reduce on-chain data and computation, addressing decentralization and cost challenges, thereby enhancing availability and reducing costs.
Patent Information
- Application Number
- JP2024078744
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2023-05-15
- Filing Date
- 2024-05-14
- Publication Date
- 2024-11-27
AI Technical Summary
Existing ZK rollups face challenges in ensuring decentralization and availability of aggregators without relying on a single aggregator, leading to complexity in leader selection and potential aborts if one aggregator fails, and incur high computational and storage costs due to frequent on-chain data posting.
A transaction method for ZK rollups that allows multiple independent and untrusted aggregators to operate in parallel, using recursive ZK proofs to verify transactions off-chain, reducing on-chain data and computation by bundling and deferring verifications, and enabling permissionless block production without knowledge of previous blocks.
This approach enhances availability, reduces censorship resistance, and lowers computational and storage costs by allowing parallel aggregator operations, while ensuring fast final settlement times and efficient resource usage.
Smart Images

Figure 2024164832000001_ABST
Abstract
Description
[Technical field]
[0001] The present invention relates to a computer-implemented transaction method for a zero-knowledge rollup network (called ZK-ROLLUP) for a blockchain, where transaction rules are specified by a ZK-ROLLUP smart contract deposited on the blockchain. [Background technology]
[0002] In the context of blockchain, so-called on-chain computation and on-chain data storage, i.e. computation performed on the blockchain itself and data stored, are expensive and often also a technological bottleneck. Therefore, so-called layer 2 solutions like zero-knowledge rollup (called ZK rollup) bundle or roll up transactions into batches that are executed off-chain. Off-chain computation reduces the amount of data that has to be posted to the blockchain. Instead of sending each transaction individually, the ZK rollup operator populates an overview of the changes required to represent all the transactions in the batch. The ZK rollup operator also produces a validity proof to prove the correctness of their changes. Such a validity proof shows with cryptographic certainty that the proposed changes to the blockchain state are truly the final result of executing all the transactions in the batch. In the case of ZK rollup, the validity proof involves techniques known from zero-knowledge proofs (or ZK proofs for short).
[0003] Even if on-chain computation and on-chain data storage are reduced by the adoption of any ZK Rollup, the manner in which transactions are processed by ZK Rollup varies greatly and greatly impacts the benefits in terms of costs that the manner may bring.
[0004] For most existing ZK rollups, transaction data needs to be posted on-chain for each transaction, including the sender, token index, amount, and recipient of the transaction. This is improved in Springrollup, a ZK rollup where senders can batch any number of transfers to other accounts while only posting these addresses as call data, i.e., data that is put into the blockchain from the rollup, in addition to some small, constant-size data per block. Each sender can send as many transactions as they want in a block without adding on-chain data costs. This results in a reduction in on-chain data compared to previous solutions. As a by-product, improved privacy is achieved since less user data is posted on-chain.
[0005] The technique employed in Springrollup has been further improved in Intmax by combining client-side ZK proofs with limited online assumptions, whereby the former helps to reduce aggregator costs by outsourcing part of the zero-knowledge verification process to users. They need to generate ZK proofs and post them to aggregators, which then aggregate user transactions and send the aggregated batch of transactions on-chain to complete the transactions. Summary of the Invention [Problem to be solved by the invention]
[0006] Another challenge in the context of ZK Rollup concerns decentralized aggregators that aggregate transactions from users, allowing for data compression and reduced need for computational resources. The challenge is how to ensure liveness without having to trust the aggregators. In the case of Intmax, if we simply allow multiple aggregators, each aggregator would have to provide data (updated user state) to the next aggregator so that the next aggregator can create a new block. There are two drawbacks to this approach. First, since each aggregator needs to build the previous block, this method requires the complexity of the leader selection method to determine which aggregator can create a new block. Second, and more importantly, if one of the aggregators cannot provide data to the next aggregator, ZK Rollup would abort and all users would have to exit the rollup. [Means for solving the problem]
[0007] It is an object of the present invention to provide a transaction method for ZK-ROLLUP for blockchain that solves at least one of the problems of the prior art.
[0008] A blockchain is understood herein to be a smart contract compatible blockchain, such as Ethereum.
[0009] At least one of the objects of the present invention is achieved by a transaction method for ZK-ROLLUP for blockchain as set forth in claim 1.
[0010] A transaction method for a ZK Rollup network for a blockchain, the transaction rules being specified by a ZK Rollup smart contract deployed on the blockchain, the ZK Rollup network including a number of user ZK Rollup nodes, at least one of which is an aggregator ZK Rollup node, the ZK Rollup smart contract comprising: a) receiving an aggregator transfer transaction from an aggregator ZK rollup node A of at least one aggregator ZK rollup node, the aggregator transfer transaction being generated at the aggregator ZK rollup node A; i. a Merkle root of a Merkle tree for at least one user transfer instruction, each of the at least one user transfer instruction being generated in one of a number of user ZK-rollup nodes and routed to an aggregator ZK-rollup node A; ii. an aggregated signature constructed from at least one user signature on a Merkle root, each of which corresponds to a user ZK rollup account and is transferred from one of the number of user ZK rollup nodes to the aggregator ZK rollup node A after the number of user ZK rollup nodes receive the Merkle root together with a proof of inclusion of a user transfer instruction generated at the user ZK rollup node from the aggregator ZK rollup node A; and iii. A list of every user ZK-rollup account that corresponds to any of at least one user signature of the Merkle root from which the aggregated signature is constructed. Including, receiving, b) verifying that the aggregator transfer transaction is duly valid; and c) If the validation in the previous step is successful, do not perform any further validation, but calculate the historical root hash from the content of the aggregator transfer transaction and from the previous historical root hash, and store the calculated historical root hash in the ZK-ROLLUP contract state until a predefined condition is met. and processing user transfers by a) receiving an aggregator withdrawal transaction from an aggregator ZK rollup node B of at least one aggregator ZK rollup node, the aggregator withdrawal transaction being generated at the aggregator ZK rollup node B; i. one or more blockchain addresses; ii. History root hash M, iii. the purported total amount purported by each of one or more blockchain addresses in the history root hash M; iv. One or more recursive ZK proofs of the correctness of each purported amount received. Including, receiving, b) i. the Aggregator Withdrawal Transaction is duly valid; ii. The historical root hash M is stored in the ZK-Rollup contract state; and iii. each of one or more recursive ZK proofs of the correctness of each purported amount received; To verify the following: c) If the validation in the previous step was successful, i. transferring funds according to the purported total amount received by each of the one or more blockchain addresses in the historical root hash M, and according to the purported total amount already withdrawn to each of the one or more blockchain addresses; ii. updating a list of the amount already withdrawn to each of the one or more blockchain addresses according to the amount processed for each of the one or more blockchain addresses in step i, where the list of the amount withdrawn to each of the one or more blockchain addresses is stored in a ZK-ROLLUP contract state; and process the withdrawal of funds to one or more blockchain addresses by A transaction method comprising the steps of:
[0011] Please note that Aggregator ZK Rollup Node A and Aggregator ZK Rollup Node B may be the same Aggregator ZK Rollup Node.
[0012] Aggregator transfer transactions can arrive in the form of ZK-ROLLUP blocks that are added to the ZK-ROLLUP chain by corresponding nodes by creating a blockchain transaction with the content of the respective transaction as call data or blob data to the ZK-ROLLUP smart contract. Aggregator withdrawal transactions can be executed via the withdraw function of the ZK-ROLLUP smart contract.
[0013] The transaction method presented here is based on the Intmax design and improves on existing solutions in two ways: First, it allows many independent, trustless aggregators working in parallel, improving availability and censorship resistance: block production can occur without needing to know any previous blocks. Second, the settlement time for a transaction is reduced; the settlement time is the time from when a user initiates a payment to when that same user receives assurance that the payment was successful and will not be reversed.
[0014] Moreover, these improvements come together with a reduction in the resource requirements for so-called on-chain computation and on-chain data storage, i.e. computations performed and data stored on the blockchain itself. In the context of blockchain, such on-chain computation and on-chain data storage are expensive and also represent a technical bottleneck. The reason for this is that blockchain is a public database that is updated and shared across two or more nodes in the network. Therefore, storing data on-chain means storing data on every node. Moreover, since blockchains usually work in a consensus manner, on-chain computations implied by one node usually need to be verified by other nodes. Therefore, the amount of on-chain data storage and on-chain computation is very relevant in determining the hardware requirements that should be met by a node to be able to participate in the blockchain.
[0015] Moreover, the cost of adding a ZK-ROLLUP block to the ZK-ROLLUP chain, and therefore the cost of a ZK-ROLLUP transaction, is bound by the fee required to post the block to the blockchain. For example, in Ethereum or similar blockchains, users need to pay a fee when sending a transaction to the blockchain. These fees are determined by the amount of resources the transaction uses. These resources can be categorized into three categories: computational resources required when validating a ZK proof, bandwidth resources, which is the data sent to the blockchain, and storage, which is the data stored in the storage of the ZK-ROLLUP smart contract. ZK-ROLLUP mainly uses computational resources to validate ZK proofs and bandwidth resources to make the transaction data available, while storage is used slightly by ZK-ROLLUP, e.g. only to store state or history hashes. Note the difference between storage and bandwidth here: storage is used when permanently storing data in the blockchain in the storage of the ZK-ROLLUP smart contract, while bandwidth is for data that is not stored and can be removed by the blockchain nodes. Bandwidth is cheap compared to storage: since the computation is fixed and independent of the number of transactions in a ZK-ROLLUP block, while ZK-Proofs can prove any number of transactions without increasing the cost of verifying the proof, the main bottleneck of ZK-ROLLUP is the bandwidth consumption, which is proportional to the number of transactions in a ZK-ROLLUP block, as is the case in existing ZK-ROLLUP, or to the number of senders in the block, as is the case in our protocol.In this regard, the present design is more data-efficient than existing ZK rollups because the present design only requires posting of the sender address for each sender in a block, while other ZK rollups need to post both the sender address and other transaction details such as the token ID, amount, and recipient address. This makes the present design more efficient than existing ZK rollups. The present design is also more computationally efficient than existing ZK rollups. In fact, by performing on-chain validation of ZK proofs only at the time of withdrawal, withdrawal operations can be performed less frequently than adding new ZK rollup blocks. In this way, fast final settlement times can be maintained by having frequent ZK rollup blocks, while on-chain computational costs are kept low by having infrequent withdrawals. For example, if one ZK-ROLLUP block is added in every blockchain block and withdrawal operations are performed on average every 100 blockchain blocks, then the present design is roughly 100 times more efficient in terms of on-chain computations than ZK-ROLLUP, which validates every ZK-ROLLUP block as it is added.
[0016] The strategy of the present transaction method is made possible in part by the use of recursive ZK proofs, which allow bundling and deferring the validation required to ensure security.
[0017] As is the normal case, the manner in which transactions are processed by ZK Rollup is dictated by transaction rules enforced by a ZK Rollup smart contract deployed on the blockchain. A ZK Rollup smart contract is a program that can be deployed on a blockchain by adding a compatible block containing the ZK Rollup smart contract program to the blockchain. The ZK Rollup smart contract program comprises at least one function and a ZK Rollup state, where the at least one function is callable by a block added to the blockchain after the ZK Rollup smart contract is deployed, and the ZK Rollup state is a data set that can be transformed by calling the at least one function, or, if there is more than one, by calling a subset or all of the at least one function, and by blocks being added to the blockchain and / or ZK Rollup chain after the ZK Rollup smart contract is deployed.
[0018] By running a blockchain node on a computing device, it is understood that a client runs on this computing device, which is software that downloads a copy of the blockchain, verifies the validity of each block, and then keeps the blockchain up to date with new blocks and transactions, and helps other software download and update their own copies. User ZK Rollup nodes, and therefore Aggregator ZK Rollup nodes, are also blockchain nodes.
[0019] A user is understood here as a user operator who can access a user ZK rollup node on a computer device. A user operator can be one or more natural persons or software.
[0020] An aggregator is understood herein as an aggregator operator that has access to an aggregator ZK-ROLLUP node on a computing device. An aggregator operator can be one or more natural persons or software. It is understood herein that a User ZK-ROLLUP node is also an aggregator ZK-ROLLUP node if the User ZK-ROLLUP node interacts with the on-chain ZK-ROLLUP smart contract by sending an aggregator transfer transaction and / or an aggregator withdrawal transaction to the on-chain ZK-ROLLUP smart contract.
[0021] Having access to a node means hereby running or accessing the node through a computing device and user interface provided by a trusted third party, such as Infura.
[0022] Every user of ZK Rollup and every aggregator must have access to the blockchain. There are several ways to access the blockchain, including running a blockchain node or by using a trusted third-party node such as Infura. Every blockchain node needs to process transactions to the ZK Rollup smart contract and all other transactions that occur on the blockchain, but does not necessarily need to be involved with ZK Rollup in any other way.
[0023] To make a transaction, a user can send a user transfer command to one of the aggregators. Note that it is possible that a user can send different user transfer commands to different aggregators. The aggregator then bundles the set of received user transfer commands and builds a Merkle tree from these commands. The aggregator then sends the Merkle root of the just-built Merkle tree to each of the users who contributed user transfer commands to the Merkle tree, together with a proof of inclusion of this particular user's user transfer command. Upon receiving the Merkle root and a proof of inclusion of the user's user transfer command in the corresponding Merkle tree, the user can sign the Merkle root and send the signature back to the aggregator. The aggregator can then collect the signatures corresponding to the Merkle root until the aggregator has received all the signatures, or preferably until some specified time limit. The aggregator can then generate an aggregated signature from the received user signatures and send this aggregated signature, along with the corresponding Merkle root and the list of users who contributed their signatures to the aggregated signature, to the ZK-ROLLUP smart contract by appending a block to the ZK-ROLLUP chain that calls the ZK-ROLLUP smart contract.
[0024] It is understood herein that by calling a ZK-Rollup smart contract, functions of the smart contract are invoked and the ZK-Rollup state is modified.
[0025] Note that at least one user transfer instruction may include a user transfer instruction generated at a user ZK rollup node that is the aggregator ZK rollup node A itself. Furthermore, the aggregator transfer transaction may only include such user transfer instructions generated at the aggregator ZK rollup node A itself. However, this may be advantageous in terms of cost and resources if several user transfer transactions are bundled together in an aggregator transfer instruction, rather than every user simply sending its own transaction, since data may be compressed more efficiently in this manner.
[0026] Communication between an aggregator ZK rollup node and a user ZK rollup node is typically accomplished by the user ZK rollup node communicating with one or more servers owned by the corresponding aggregator using an existing data communication protocol such as JSON-RPC or similar.
[0027] A user transfer instruction from a user may include instructions for at least one transfer of funds from a ZK rollup address assigned to the user's user ZK rollup account to another ZK rollup address or blockchain address. All transfers included in a single user transfer instruction must have the same sending ZK rollup address but may have different receiving addresses, and each receiving address may be several ZK rollup addresses or several blockchain addresses.
[0028] A blockchain address is at the level of the blockchain itself, whereas a ZK-Rollup address is at the level of the ZK-Rollup.
[0029] Transfer of funds between blockchains and / or ZK-rollup addresses refers to the change in allocation of funds from one address to another.
[0030] Funds here are any kind of assets supported by the underlying blockchain. Such assets are typically a set of tokens. Tokens are understood here as digital tokens, such as non-fungible tokens (NFTs), ERC-20s, or any units of a native cryptocurrency.
[0031] A Merkle tree is a tree in the computer science sense, where every tree node that is a leaf is labeled with the cryptographic hash of the data block, and every non-leaf tree node is labeled with the cryptographic hash of the labels of its children's tree nodes.
[0032] A proof of containment in the context of Merkle trees, also called a Merkle proof, consists of the siblings of the leaf for which containment is to be proven, and each intermediate hash that needs to be calculated, the root hash, i.e. the hash of the intermediate node and its siblings.
[0033] The user signature on the Merkle root may be generated at a user ZK rollup node that transfers the user signature to aggregator ZK rollup node A, or may be generated by separate software, possibly on a separate computing device, and then transferred to the user ZK rollup node for further transfer to aggregator ZK rollup node A. In the latter case, the separate software may have received the Merkle root and containment proof from the user ZK rollup node before generating the signature.
[0034] Note that there is no need for a user signature on the Merkle root for each user transfer instruction: in the absence of a user signature, the corresponding user transfer instruction can be kept in the aggregator transfer transaction, but cannot be validly referenced by a recursive ZK proof.
[0035] The list of user ZK rollup accounts may include, for example, a user identifier assigned to the user account, which may be, for example, a BLS public key or a shorter identifier assigned to the user upon user registration.
[0036] When the ZK Rollup smart contract receives a batch of transactions from an aggregator, i.e., when a block is added to the ZK Rollup chain by the aggregator calling the smart contract, the ZK Rollup smart contract accepts the batch of transactions if it is formally valid. A batch of transactions is formally valid if the corresponding blocks and instructions are in the intended format. In particular, the ZK Rollup smart contract does not validate any of the contents of the batch of transactions. If the batch of transactions is formally valid, the smart contract computes a history root hash using a hash function that has as input at least the last history root hash that has been previously computed and all or only a portion of the contents of the batch of transactions. The ZK Rollup smart contract then stores the computed history root hash in the ZK Rollup state until a predefined condition is met. Hence, the current historical root hash is stored in the ZK Rollup state and remains there until a predefined condition is met, after which it is automatically removed from the ZK Rollup state.
[0037] The output of a hash function is called a hash or a hash value, and hashing X is understood here as computing the hash function on inputs that include X.
[0038] The first history root hash can take as input all or part of the content of the corresponding transaction and a predefined input as a replacement for the previous history root hash.
[0039] The lack of further validation means that the contents of the aggregator transfer transaction are not validated, e.g., the validity of the signature is not verified.
[0040] Computing the history root hash from X here means computing the output of some hash function with input X. Note that here, all or only a part of the content of the aggregator transfer transaction may be included in the input of the hash function.
[0041] Note that since each user has received a proof of inclusion of their transaction in the aggregator transfer transaction, the transaction itself does not need to be published on-chain, only the root of the transaction's Merkle tree. This makes this method more data-efficient than other ZK-ROLLUP transaction methods, where all transaction data is published on-chain.
[0042] Note also that an aggregator does not need to know previously processed transactions in order to add new transactions to the rollup, which means that aggregates are completely permissionless and therefore new transactions can be added from anyone at the same time.
[0043] When a user wants to withdraw funds to a blockchain address, the user can initiate a corresponding transaction as described above. Then, after or during additional processing of the block containing the last transaction to be taken into account, any aggregator can choose a stored historical root hash M. The aggregator that chose the historical root hash M can then generate a recursive ZK proof itself and / or collect such proofs from other users that, for a set of blockchain addresses, a given amount received by one of the blockchain addresses in the historical root hash M is correct. The recursive ZK proof can be a cryptographic proof that the blockchain address received at least the purported amount at the time the historical root hash M was calculated, including information about any relevant transactions. The aggregator can then send the recursive ZK proof to the ZK-rollup smart contract together with the purported amount received, the historical root hash M, and the corresponding blockchain address in the aggregator withdrawal transaction. When the ZK-ROLLUP smart contract receives an aggregator withdrawal transaction, it verifies that the aggregator withdrawal transaction is formally valid, i.e., has the intended format, that the history root hash M is stored in the ZK-ROLLUP contract state, and that each recursive ZK proof is verified. If all validations by the ZK-ROLLUP smart contract are successful, the ZK-ROLLUP smart contract transfers funds according to the purported total amount received by the blockchain address and according to the total amount already withdrawn to each of the involved blockchain addresses, which is stored in the ZK-ROLLUP contract state, updated with each withdrawal, and set to some predefined initial value, e.g., 0, if no withdrawal to the corresponding blockchain address has been processed yet.The transfer can be performed by transferring assets belonging to the blockchain address in response to the aggregator withdrawal transaction, as well as assets that have not been withdrawn and therefore not previously transferred, to the blockchain address in response to the total amount withdrawn to the blockchain address stored in the ZK-ROLLUP contract state. Finally, the ZK-ROLLUP smart contract replaces the total amount withdrawn to the blockchain address stored in the ZK-ROLLUP contract state before the withdrawal with the updated total amount withdrawn to the blockchain address after the withdrawal. More specifically, the ZK-ROLLUP smart contract can comprise a withdrawal function, which is callable by any aggregator, takes as input the content of the aggregator withdrawal transaction, performs a validation, and if the validation is successful, performs the transfer of funds and updates the total amount withdrawn.
[0044] Here, M in history root hashes M can simply be some label or count of all the history root hashes that have been computed.
[0045] Of course, note that the aggregator withdrawal transaction with the historical root hash M must be generated by the aggregator ZK-ROLLUP Node B after the historical root hash M has been calculated and stored in the ZK-ROLLUP contract state.
[0046] The total amount received by a blockchain address can be, for example, a list of the amounts of each type of asset received by this address.
[0047] The amount withdrawn to a blockchain address can be a list of the amount per asset type withdrawn to the blockchain address. The amount withdrawn to a blockchain address prior to any withdrawals to this blockchain address can be set to a default value, for example the value 0, or an index.
[0048] The amount withdrawn to each blockchain address is stored and updated in the ZK-ROLLUP contract state. Transferring funds in response to an aggregator withdrawal transaction and in response to the amount already withdrawn to one of the included blockchain addresses means that the transaction and the amount withdrawn data are taken into account and the actual transfer amount is calculated from the amount possibly dictated by this data.
[0049] The recursive ZK proofs can be maintained as a set of recursive ZK proofs for each alleged amount received, or the recursive ZK proofs can be summarized into a combined recursive ZK proof for all alleged amounts received. In the former case, each recursive ZK proof can be generated in one of several user ZK rollup nodes and then transferred to the aggregator ZK rollup node B, or each recursive ZK proof can be generated in separate software and then provided to one of several user ZK rollup nodes, from which each recursive ZK proof is then transferred to the aggregator ZK rollup node B. In the latter case, a combined recursive ZK proof for all purported amounts received can be generated at the aggregator ZK-rollup Node B, for example by generating an aggregated ZK proof from the recursive ZK proofs for each purported amount received, and the latter proof can be provided in the same manner as in the former case.
[0050] This ZK-Rollup design differs from other designs in the way state is handled. Instead of having a global state of user balances, each user maintains and updates recursive ZK proofs of the balances of ZK-Rollup addresses and blockchain addresses owned by this user. With each new ZK-Rollup block or transaction processed by a smart contract, each user can update its balance and compute a new recursive ZK proof of the balance of its address.
[0051] The requirements for a recursive ZK proof to be formally valid depend on the corresponding ZK proof system.
[0052] Balance recursive ZK proofs can be based on Plonky2 and / or Nova and / or SuperNova.
[0053] Note that the time when the ZK-rollup block corresponding to a transaction referenced by a balance-recursive ZK proof was added is relevant only in the sense that it must be before or during the time when the historical root hash M was stored. Since every historical root hash is calculated from the previous historical root hash, a transaction is verifiable even if the corresponding block was added a long time ago.
[0054] The security assumptions about the protocol presented here are the same as those about the underlying blockchain, along with the assumption that the ZK proof system employed is secure.
[0055] Further embodiments of the invention are set forth in the dependent claims.
[0056] In some embodiments, the transaction method includes, by a ZK-ROLLUP smart contract: a) receiving a user registration transaction from one of a number of user ZK rollup nodes, the user registration transaction including a user identifier of the user ZK rollup account and a user signature of the user identifier; b) verifying the user signature of the user identifier; and c) if the validation in the previous step is successful, (i) calculate a historical root hash (31) from the content of the user registration transaction and the previous historical root hash (31') and store the calculated historical root hash (31) in the ZK-ROLLUP contract state (32) until a predefined condition is met, and (ii) assign a ZK-ROLLUP address to the user ZK-ROLLUP account. By processing the registration of user ZK Rollup accounts The method may include the additional step of:
[0057] Note that it is possible that there are User ZK Rollup nodes under which several User ZK Rollup Accounts are registered, or there is a single User ZK Rollup node, or there are no User ZK Rollup nodes. A user can register a User ZK Rollup Account under one User ZK Rollup node and then participate in ZK rollups either equally or exclusively with other User ZK Rollup nodes.
[0058] The blockchain address from which funds can be withdrawn can correspond to a smart contract account or an Externally Owned Account (EOA).
[0059] In some embodiments, the user signature and / or the aggregated signature may be a BLS signature.
[0060] A Boneh-Lynn-Shacham (BLS) signature is a cryptographic signature scheme that allows a user to verify that a signer is authentic. The scheme involves a private key and a corresponding public key. In this scheme, a user can generate a user signature for a bit string by computing a given function from the bit string and the private key. A verifier can then verify the signature taking into account the signature and the public key. Multiple BLS signatures corresponding to multiple private keys and / or multiple bit strings can be aggregated into a single BLS signature.
[0061] When using BLS signatures, the user identifier and the user signature of the user identifier included in a user registration transaction can be a public BLS key and a signature calculated from the public BLS key together with the corresponding private BLS key.
[0062] In some embodiments, the transaction method includes, by a ZK-ROLLUP smart contract: a) receiving a set of tokens together with a user token deposit transaction from one of a number of user ZK rollup nodes, the user token deposit transaction being generated at the user ZK rollup node; i. at least one token ID; ii. the amount of tokens for at least one token ID; and iii. ZK-ROLLUP address to receive the amount of tokens Including, receiving, b) i. the User Token Deposit Transaction is duly valid; and ii. for at least one Token ID, the set of received tokens includes as many tokens corresponding to this Token ID as indicated by the token quantity of this Token ID; To verify the following: c) If the validation in the previous step is successful, calculate a history root hash from the content of the user token deposit transaction and the previous history root hash, and store the calculated history root hash in the ZK-ROLLUP contract state until a predefined condition is met. By processing user token deposits The method may include the additional step of:
[0063] A User Token Deposit transaction is duly valid if it is in the intended format.
[0064] Computing the history root hash from X here means computing the output of some hash function with input X. Note that here, it is possible that all or only a part of the content of the user deposit transaction is included in the input of the hash function.
[0065] It is noted that user registration transactions, user token deposit transactions, and aggregator transfer transactions can arrive in the form of ZK-ROLLUP blocks that are added to the ZK-ROLLUP chain by corresponding nodes by making blockchain transactions with the content of the respective transactions as call data or blob data to the ZK-ROLLUP smart contract, respectively.
[0066] A token ID is understood here as an identifier of a particular class of token, or type of token, such as a type of cryptocurrency, e.g., ETH, DAI, or USDC, or a particular NFT. A token ID can be, for example, a natural number.
[0067] In addition to the ZK-ROLLUP chain on the blockchain, it is possible that there is a corresponding ZK-ROLLUP chain computed off-chain that is accepted as valid. Here, we consider a ZK-ROLLUP block corresponding to an aggregator transfer transaction as valid if the aggregator transfer transaction is formally valid and the aggregated signature of the aggregator transfer transaction against the list of user ZK-ROLLUP accounts in the aggregator transfer transaction is correct. Otherwise, we consider a ZK-ROLLUP block corresponding to an aggregator transfer transaction as invalid. Furthermore, we consider a ZK-ROLLUP block corresponding to a user registration transaction as valid if the aggregator transfer transaction is formally valid and the user signature of the user identifier against the user identifier is correct. User token deposit transactions are always considered valid because their contents are verified by the ZK-ROLLUP smart contract when they are added. The accepted as valid ZK-ROLLUP chain is then computed by including only accepted as valid ZK-ROLLUP blocks and skipping invalid ZK-ROLLUP blocks. More precisely, the original history root hash of the original ZK Rollup chain is calculated from the previous original history root hash and the contents of the current ZK Rollup block regardless of whether the current ZK Rollup block is valid or not, but the same is done for the ZK Rollup chain that is recognized as valid only if the current ZK Rollup block is valid. Therefore, to update the ZK Rollup chain that is recognized as valid, the validity of the newly added ZK Rollup block to the original ZK Rollup chain must be verified beforehand. This verification can be done by tracking the user ZK Rollup account and its corresponding ZK Rollup address in the off-chain user ZK Rollup state, which involves verifying the signature corresponding to the user ZK Rollup account or user identifier.When a ZK-Rollup block is validated, a proof of the validity of this ZK-Rollup block can be generated and posted on-chain. Note that the computation and proof for a ZK-Rollup chain that is found to be valid can be performed by any user who is involved in ZK-Rollup, i.e., who has registered at least one user ZK-Rollup account. Moreover, a user who is involved in ZK-Rollup can store their own version of the chain that is found to be valid without performing any computation, by trusting the validity proof of the ZK-Rollup block posted on-chain. For example, appropriate rules can be built into the ZK-Rollup smart contract to encourage an aggregator to handle the tasks of validating ZK-Rollup blocks, generating proofs, and posting the proofs on-chain. Similarly, appropriate rules can help motivate trusting the posted validity proofs of ZK-Rollup blocks without the need for these proofs to be verified on-chain in most cases.
[0068] If a validated ZK-rollup chain is available (in the sense that the validity proofs of the ZK-rollup blocks are posted on-chain), a balance recursive ZK proof of a user withdrawal command can take as public input the original history root hash M, one or more blockchain addresses, and their claim balances at the original history root hash M, and prove that 1) there exists a validated history root hash M' and a recursive ZK proof that this is the correct validated history root hash corresponding to the original history root hash M, and 2) for one or more blockchain addresses, there exists a recursive ZK proof that this blockchain address has the specified balance at the validated history root hash M'.
[0069] More generally, the proof system can be any proof system capable of performing recursive ZK proofs.
[0070] In some embodiments, the predefined condition may be that the historical root hash is stored a fixed number x of times later, or the predefined condition is that another historical root hash corresponding to the same blockchain block and / or the historical root hash is stored a fixed number x of times later.
[0071] Here, the fixed number x is a natural number equal to or greater than 1.
[0072] For both options, up to x+1 historical root hashes are maintained in storage. The two options may still differ, since there can be several ZK-Rollup blocks included in one blockchain block, i.e. one blockchain transaction. The second option can be realized by storing the blockchain block number where the last ZK-Rollup block was added in the ZK-Rollup contract state.
[0073] Note that it is possible for a history root hash to be deleted from storage by overwriting it with the x-th later history root hash or with another history root hash corresponding to the same blockchain block, respectively. In this case, deleting the old history root hash and storing the x-th later history root hash or with another history root hash corresponding to the same blockchain block, respectively, occur simultaneously. This also means that in this case, there will be at most x history root hashes in storage at the same time.
[0074] In some embodiments, the fixed number x is between 1 and 2 16 Natural numbers up to and including 2 7<=x<=2 9 , and most preferably x=2 8 That's fine too.
[0075] Note that in principle, x can be any natural number > 0. However, there is a trade-off: on the one hand, if the number is too small, there may not be enough time to generate the necessary balance recursive ZK proofs to withdraw before the historical root hash is removed from the ZK Rollup contract state; on the other hand, if the number is too large, there is a lot of data that needs to be stored by the ZK Rollup smart contract.
[0076] If the predefined condition is that different historical root hashes corresponding to the same blockchain block and / or a fixed number x of later historical root hashes are stored, then at most one historical root hash is stored per blockchain block. So, for example, if a blockchain block is added every 12 seconds, then x=2 8 Setting =256 ensures that each historical root hash is stored for at least 256*12 seconds = 51 minutes. Note further that 256 is the maximum number that fits into one byte, which may be an advantage in some implementations. Nevertheless, this number can be adjusted depending on, for example, the time required for proofs.
[0077] In some embodiments, each user transfer instruction may include instructions for at least one transfer of funds between two different ZK-rollup addresses or from a ZK-rollup address to a blockchain address.
[0078] Note that a single transfer of funds is always between two distinct addresses, and in the case where the receiving address is a blockchain address, the blockchain address is represented in an appropriate manner within the rollup structure. However, a user transfer instruction may include several transfers from a ZK-rollup address to other ZK-rollup addresses and / or blockchain addresses. A user transfer instruction typically includes transfers from only one ZK-rollup address. Nevertheless, it is possible for a user to have more than one user ZK-rollup account registered.
[0079] In some embodiments, the blockchain may be the Ethereum blockchain.
[0080] In some embodiments, the funds may be cryptocurrencies and / or digital token types of assets.
[0081] The invention also refers to a computer program product which, when executed on a network of computing devices, performs the above-mentioned transaction method.
[0082] The invention is further explained below with reference to the figures. [Brief description of the drawings]
[0083] [Figure 1] A schematic diagram of a ZK-ROLLUP chain. [Diagram 2] FIG. 1 is a schematic diagram of adding a batch to a ZK rollup. [Diagram 3] FIG. 13 is a diagram of an example of a registration batch. [Figure 4] FIG. 2 is an example of a deposit batch. [Diagram 5] FIG. 1 is a schematic diagram of a transfer transaction method for the ZK-ROLLUP network. [Figure 6] FIG. 1 is a schematic diagram of a chain that has been found to be valid. [Figure 7] FIG. 1 is a schematic diagram of adding a valid registration batch. [Figure 8] FIG. 1 is a schematic diagram of adding a valid deposit or transfer batch. [Figure 9] FIG. 13 is a schematic diagram of adding an invalid batch. [Figure 10] Schematic diagram of updating user state / balance. [Figure 11] FIG. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0084] In this section and in the figures, for ease of reading, ZK-ROLLUP blocks are referred to as batches and blockchain blocks are referred to as blocks.
[0085] A ZK rollup chain consists of a chain of batches, here with their batch hashes 31 (history root hashes), as seen in Figure 1. There are three types of batches: register batch 6 (user registration transaction), deposit batch 7 (user token deposit transaction), and transfer batch 51 (aggregator transfer transaction), which will be explained later. Each batch hash 31 is a hash of the batch contents along with the previous batch hash 31' (the previous history root hash).
[0086] The ZK Rollup smart contract is a blockchain (also called Layer 1 or L1, whereas ZK Rollup is called Layer 2 or L2) smart contract that stores a list of the last 256 batch hashes31 needed for withdrawal as described below. The process of adding a batch to a ZK Rollup is shown in Figure 2.
[0087] Anyone involved in ZK Rollup can add new batches 6, 7, 51 to ZK Rollup by making a blockchain transaction to the ZK Rollup smart contract 3 with the contents of the new blocks 6, 7, 51 included as call data or blob data. The ZK Rollup smart contract 3 will then calculate the batch hash 31 of the new batch by hashing the contents of the new batch together with the previous batch hash 31', which is already stored in the contract storage 32 (ZK Rollup contract state). The ZK Rollup smart contract 3 will then add the new batch hash 31(N) to the list of recent batch hashes 31'(N-1, ..., N-255) and remove the oldest batch hash from the list.
[0088] An aggregator 5 does not need to know previous batches in order to add a new batch to a ZK rollup, which means that aggregation can be completely permissionless, and therefore new batches can be added simultaneously from anyone.
[0089] Before a user can make a transaction on the ZK-ROLLUP network, the user can register a user ZK-ROLLUP account by registering a public Boneh-Lynn-Shacham (BLS) key. This can be done by adding a registration batch 6 to ZK-ROLLUP. Registration batch 6 comprises at least the public BLS key and a signature of the BLS key by the corresponding private key (Figure 3). The signature proves that each user knows the private key corresponding to their public BLS key, which thwarts brute-force attacks. When a user registers a new account, the account is given an account ID (e.g., an L2 address), which may be an integer that increments for each new account.
[0090] To deposit tokens into ZK Rollup, a user must create a deposit batch 7 (user token deposit transaction) and send it to the ZK Rollup smart contract 3 along with the amount of tokens specified in the deposit batch 7. The deposit batch 7 specifies at least the account IDs (L2 addresses) that will receive the tokens, the token IDs (i.e., the types of tokens that will be deposited), and the amount of tokens per type (i.e., corresponding to each of the specified token IDs) (Figure 4). The ZK Rollup smart contract 3 then verifies that it received the correct amount of tokens in the same transaction and adds the deposit batch 7 to the ZK Rollup. The receiving L2 address can be owned by the user initiating the deposit or by another user.
[0091] Figures 5(a) to 5(d) show how users can initiate token transfers between each other via user ZK rollup nodes 4, 4', and 4''. Transfers between users are aggregated by the aggregator via the aggregator ZK rollup node 5 into a transfer batch (aggregator transfer transaction) 51, which is then added to the ZK rollup.
[0092] A user is understood here as a user operator having access to a user ZK rollup node 4 on a computing device. A user operator can be one or more natural persons or software. An aggregator is understood here as an aggregator operator having access to an aggregator ZK rollup node 5 on a computing device. An aggregator operator can be one or more natural persons or software.
[0093] A user who wants to send tokens to another user can create a transaction consisting of one or more transfers (user transfer instructions 43, 43', 43'') and send it to the aggregator 5 (Figure 5(a)). The aggregator 5 receives the user transactions 43, 43', 43'', creates a Merkle tree 52 of transactions, and sends a Merkle root 53 and a Merkle proof of the user's transaction (i.e., a proof that the user's transaction is included in the Merkle tree) to each user 4, 4', 4'' (Figure 5(b)). In Figure 5(b), the third user 4'' is offline and does not receive the Merkle root and the user's Merkle proof. After receiving the inclusion proof of user 4, 4' from the aggregator 5, user 4, 4' signs the transaction tree root (i.e., the Merkle root) using the BLS signature of user 4, 4' and sends the signature 44, 44' back to the aggregator 5 (Figure 5(c)). The aggregator 5 sends a transfer batch 51 (aggregator transfer transaction, see Figure 2 for adding a batch to ZK-ROLLUP) to the ZK-ROLLUP smart contract 3 (Rollup contract), which consists of a transaction tree (Merkle) root 53, a BLS aggregated signature 54 (aggregated from user signatures 44, 44'), and a list 55 of users included in the BLS (aggregated) signature 54 (Figure 5(d)).
[0094] Because each sender has received an inclusion proof of their transaction in transfer batch 51, the transactions themselves do not need to be published on-chain, only the transaction tree (Merkle) root. This makes our ZK rollup more data-efficient than other rollups that publish all transaction data on-chain.
[0095] When the ZK Rollup smart contract 3 receives new batches 6, 7, 51, it verifies that the batches 6, 7, 51 have the correct format, but does not verify the validity of the contents of the batches 6, 7, 51, i.e., that the BLS-aggregated signature 54 of the transfer batch 51 is correct, or that the signature of the registration batch 6 is correct. This means that a ZK Rollup can contain both valid and invalid batches. In detail, if the BLS-aggregated signature 54 of the transfer batch 51 of the transfer tree (Merkle) root 53 of the transfer batch 51 by a specified list of users 55 is correct, the transfer batch 51 is valid. Otherwise, the transfer block 51 is invalid. The registration batch 6 is valid if the provided signature is a correct signature of the provided public key by the corresponding private key. Every deposit batch 7 in a ZK rollup is valid because the validity of these deposit batches 7 is checked by the ZK rollup smart contract when they are added.
[0096] Instead of validating each new ZK-Rollup batch as it is added by the ZK-Rollup smart contract, a derived chain of ZK-Rollup batches is computed off-chain by including only valid batches from the original ZK-Rollup chain (Figure 6). This chain is called the validated chain.
[0097] Computing the Validated Chain: The original batch hashes 31, 31' are denoted by Bi′ and the validated batch hash is denoted by Bi. In the case shown in Figure 6, the first and third batches (from left to right in Figure 6) are valid, while the second batch is invalid. The original batch hash 31 is calculated by taking the hash of the previous original batch hash 31 and the contents of the current batch, which includes both valid and invalid batches. These hashes 31, 31' are the ones stored on-chain in the ZK-ROLLUP smart contract 3. Meanwhile, the validated batch hashes are calculated in the same manner as the original batch hashes 31, 31', except that now only valid batches are included and all invalid batches are skipped.
[0098] To check the validity of a transfer batch 51, the public keys corresponding to the L2 addresses are tracked. In particular, the root of the user L2 address (Merkle) tree (denoted as Ui) and the batch hashes that are accepted as valid (denoted as Bi) are computed and maintained off-chain.
[0099] If registration batch 6 is valid, the new public key is added to the (Merkle) tree of L2 addresses (Figure 7).
[0100] When a valid deposit batch 7 or a valid transfer batch 51 is added, the valid deposit batch 7 or valid transfer batch 51 is hashed together with the previous accepted valid batch hash to form a new accepted valid batch hash (Figure 8).
[0101] When an invalid batch (invalid transfer batch 51 or invalid registration batch 6) is added, the Merkle tree of L2 addresses and the batch hashes that are recognized as valid do not change (Figure 9).
[0102] When adding new batches 6, 7, 51 to the ZK-ROLLUP, nothing is validated on-chain except for computing new history root hashes 31, 31'. Instead, every user 4 (exemplarily also named Alice in Figure 10) tracks its own balance and computes a user recursive ZK proof 46, 46' that user 4's balance is correct at the particular history root hash 31, 31'. When a user sends or receives funds, the balance is updated and a new recursive ZK proof 46 is generated, replacing the old recursive ZK proof 46' (Figure 10).
[0103] For each new batch6, 7, 51 added to the ZK rollup, each user will update their balance and compute a new recursive ZK proof46 for the updated balance. In particular, let Bi be the i-th batch hash31 and let xi be the user's balance at Bi. Then, a proof that a user's balance at BN is a particular value xN proves that: 1. There exists a recursive ZK proof for some value x′ and x′ = xN-1. 2. The value x is obtained from x′ by subtracting all transfers from users in batch N and adding the set of transfers to users in batch N. 3. There exists a recursive ZK proof that each transfer to a user in the batch N used in the above computation is valid, i.e., each sender's balance is non-negative after the transfer.
[0104] Both L2 (ZK-ROLLUP) addresses and L1 (blockchain) addresses can be recipients of transfers in transfer batch 51. However, transfers to blockchain (L1) addresses are not processed by ZK-ROLLUP smart contract 3 when the corresponding transfer batch 51 is added. Instead, a withdrawal function is implemented in ZK-ROLLUP smart contract 3, which can be used by anyone to process transfers. Additionally, ZK-ROLLUP smart contract 3 will store a list of how much has already been withdrawn to each blockchain (L1) address.
[0105] The withdraw function can be called by anyone participating in the ZK rollup and takes as input a list of blockchain (L1) addresses, the amount each blockchain (L1) address in the ZK rollup received, the most recent original batch hash Bi′31, and a ZK proof that the blockchain (L1) address in Bi′31 received the claimed amount (Figure 11).
[0106] A ZK proof takes as public input a recent batch hash Bi′31, a list of blockchain (L1) addresses, and a corresponding list of amounts, and proves that 1. There exists a purportedly valid batch hash Bi, and a ZK proof that this is the correct purportedly valid batch hash corresponding to Bi′31. 2. For each blockchain (L1) address in the list, there is a ZK proof that the blockchain (L1) address received the specified amount in the batch hash Bi that is accepted as valid.
[0107] The withdrawal function will verify the proof, check that the provided original batch hash Bi′31 is in the list of recent batch hashes, and transfer the given amount to each blockchain address by taking the received claim amount and subtracting the previously withdrawn amount stored in the contract storage32 (ZK-rollup contract state).
[0108] In summary, the process of withdrawing funds to a blockchain (L1) account consists of two steps. The first step is to transfer the funds to a blockchain (L1) address in transfer batch 51. The second step is to call the withdraw function in the ZK-ROLLUP smart contract 3, which will perform the withdrawal. [Explanation of symbols]
[0109] 3. ZK-ROLLUP Smart Contract 31, 31' History Root Hash / Batch Hash 32 ZK Rollup Contract State / Storage 4, 4', 4'' User ZK Rollup Node, User 43, 43', 43'' User transfer instructions 44, 44' User signature 46 Balance Recursive ZK Proof 5 Aggregator ZK Rollup Node, Aggregator 51, 51' Aggregator transfer transaction / transfer batch 52 Merkle tree of user transfer transactions 53 Merkle Root of User Transfer Transactions 54 Aggregated Signatures List of 55 user ZK rollup accounts 6 User Registration Transactions / Registration Batches 7 User Token Deposit Transactions / Deposit Batches
Claims
1. A transaction method for a ZK-ROLLUP network for a blockchain, wherein transaction rules are defined by a ZK-ROLLUP smart contract (3) deployed on the blockchain, the ZK-ROLLUP network includes a number of user ZK-ROLLUP nodes (4), at least one of which is an aggregator ZK-ROLLUP node (5), and the ZK-ROLLUP smart contract (3) performs: a) receiving an aggregator transfer transaction (51) from an aggregator ZK rollup node A (5) of the at least one aggregator ZK rollup node (5), the aggregator transfer transaction (51) being generated in the aggregator ZK rollup node A (5); i. a Merkle root (53) of a Merkle tree (52) for at least one user transfer command (43), each of the at least one user transfer command (43) being generated in one of the number of user ZK rollup nodes (4) and transferred to the aggregator ZK rollup node A (5); ii. an aggregated signature (54) constructed from at least one user signature (44, 44') of the Merkle root (53), each of the at least one user signature (44, 44') of the Merkle root (53) corresponding to a user ZK rollup account and transferred from one of the number of user ZK rollup nodes (4) to the aggregator ZK rollup node A (5) after the number of user ZK rollup nodes receive the Merkle root (53) together with a proof of inclusion of the user transfer instruction (43) generated at the user ZK rollup node (4) from the aggregator ZK rollup node A (5); iii. A list (55) of every user ZK rollup account that corresponds to any of the at least one user signature (44, 44') of the Merkle root (53) from which the aggregated signature (54) is constructed. including, b) verifying that the aggregator transfer transaction (51) is duly valid; and c) if the validation in the previous step is successful, no further validation is performed, but calculating a historical root hash (31) from the content of the aggregator transfer transaction (51) and from the previous historical root hash (31′) and storing the calculated historical root hash (31) in a ZK-rollup contract state (32) until a predefined condition is met. and processing user transfers by a) receiving an aggregator withdrawal transaction from an aggregator ZK rollup node B (5) of said at least one aggregator ZK rollup node (5), said aggregator withdrawal transaction being generated in said aggregator ZK rollup node B (5); i. one or more blockchain addresses; ii. History root hash M(31); iii. Amounts, which represent the total amounts received by each of the one or more blockchain addresses in historical root hash M(31); iv. One or more recursive ZK proofs (46) of the correctness of each purported amount received. including, b) i. the aggregator withdrawal transaction is duly valid; ii. The historical root hash M (31) is stored in the ZK-rollup contract state (32); and iii. each of said one or more recursive ZK proofs (46) of the correctness of each purported amount received; To verify the following: c) if the verification in the previous step was successful, i. transferring funds according to the amount received by each of the one or more blockchain addresses in historical root hash M(31) and according to the amount already withdrawn to each of the one or more blockchain addresses; ii. updating a list of total amounts already withdrawn to each of the one or more blockchain addresses according to the amount processed for each of the one or more blockchain addresses in step i, wherein the list of total amounts withdrawn to each of the one or more blockchain addresses is stored in the ZK-rollup contract state (32); and processing the withdrawal of funds to one or more blockchain addresses by A transaction method comprising the steps of:
2. The method further comprises the steps of: a) receiving a user registration transaction from one of the number of user ZK rollup nodes (4), the user registration transaction including a user identifier of the user ZK rollup account and a user signature of the user identifier; b) verifying the user signature of the user identifier; and c) if the verification in the previous step was successful, i. calculating a historical root hash (31) from the content of the user registration transaction and the previous historical root hash (31'), and storing the calculated historical root hash (31) in the ZK-rollup contract state (32) until the predefined condition is met; ii. Assigning a ZK Rollup Address to the User ZK Rollup Account; Processing user ZK rollup account registration by 2. The method of claim 1, further comprising the additional step of:
3. Method according to one of claims 1 to 2, wherein the user signatures (44, 44') and / or the aggregated signature (54) are BLS signatures.
4. The method further comprises the steps of: a) receiving a set of tokens together with a user token deposit transaction (7) from one of said number of user ZK rollup nodes (4), said user token deposit transaction (7) being generated at said user ZK rollup node (4); i. at least one token ID; ii. A quantity of tokens for each of said at least one token ID; and iii. A ZK-ROLLUP address for receiving said amount of tokens; including, b) i. said User Token Deposit Transaction (7) is duly valid; and ii. for the at least one token ID, the set of received tokens includes as many tokens corresponding to the token ID as indicated by the quantity of tokens for the token ID; To verify the following: c) if the verification in the previous step was successful, i. calculating a historical root hash (31) from the contents of the user token deposit transaction (7) and the previous historical root hash (31'), and storing the calculated historical root hash (31) in the ZK-rollup contract state (32) until the predefined condition is met; Processing user token deposits by 4. A transaction method according to claim 1, comprising the additional step of:
5. 5. The method of claim 1, wherein the predefined condition is that a fixed number x of later historical root hashes are stored, or the predefined condition is that another historical root hash corresponding to the same blockchain block and / or a fixed number x of later historical root hashes are stored.
6. The fixed number x is between 1 and 2 16 Natural numbers up to and including 2 7 <= x <= 2 9 and most preferably x=2 8 6. The transaction method according to claim 5, wherein:
7. 7. A transaction method according to claim 1, wherein each user transfer instruction comprises an instruction for at least one transfer of funds between two different ZK-rollup addresses or from a ZK-rollup address to a blockchain address.
8. 8. The method of claim 1, wherein the blockchain is the Ethereum blockchain.
9. Method of transactions according to one of the claims 1 to 8, wherein said funds are assets of the cryptocurrency and / or digital token type.
10. A computer program product which, when executed on a network of computing devices, executes a transaction method according to one of claims 1 to 9.
