Registry and automated management method for blockchain-enforced smart contracts
Abstract
A computer-implemented method for controlling the visibility and / or performance of a contract, the method comprising the steps of: (a) storing a contract in a computer-based warehouse; (b) broadcasting a transaction to a blockchain, the transaction comprising: i) at least one unused output (UTXO); and ii) metadata comprising an identifier indicative of the location where the contract is stored; (c) interpret the contract as open or valid until the unused output (UTXO) is used on the blockchain; and d) renewing or continuing the contract by: generating a new key through the use of data related to a previous key associated with the contract; generating a script that comprises the new key, the location of the contract, and a hash of the contract; and the payment of an amount of currency to the script.

Term
10.4 yearsto projected expiry
Projected expiry 16 February 2037, counted from filing; an application has no term until it is granted.
- Priority
- Filed
- Published
- Today
- Projected expiry
16 claims: 6 independent, 10 dependent
- 15 10 15 20 25 30 35 REIVINDICACIONES 1. Un método implementado por ordenador para controlar la visibilidad y/o cumplimiento de un contrato, el método comprendiendo las etapas de:(a) almacenar un contrato en un depósito basado en ordenador;(b) difundir una transacción a una cadena de bloques, la transacción comprendiendo: i) al menos una salida no utilizada (UTXO);y ii) metadatos que comprenden un identificador indicativo de la ubicación donde se almacena el contrato;(c) interpretar el contrato como abierto o válido hasta que la salida no utilizada (UTXO) se utiliza en la cadena de bloques;y d) renovar o continuar el contrato mediante: la generación de una nueva clave mediante el uso de datos relacionados con una clave previa asociada al contrato;la generación de un scriptque comprende la nueva clave, la ubicación del contrato y un hash del contrato;y el pago de una cantidad de moneda al script.
- 2Un método según la reivindicación 1 en donde la transacción además comprende una dirección de script de rescate determinista, preferiblemente en donde la dirección de script de rescate es una dirección de pago al hash del script (P2SH).
- 3Un método según la reivindicación 2 y que además comprende la etapa de finalizar el contrato mediante la difusión de una transacción adicional a la cadena de bloques para utilizar la salida (UTXO).
- 4Un método según la reivindicación 3 en donde la transacción adicional comprende:una entrada que es la salida (UTXO);y un script de desbloqueo que comprende una firma;los metadatos;y una clave pública.
- 5Un método según cualquier reivindicación precedente en donde el contrato define:i) al menos una condición;y ii) al menos una acción cuyo cumplimento depende de la evaluación de la condición;y/o en donde los metadatos comprenden: i) una dirección o representación de una dirección de donde se almacena el contrato en el depósito basado en ordenador;y/o ii) un hash del contrato.
- 6Un método según cualquier reivindicación precedente y que comprende la etapa de:verificar si el contrato ha finalizado mediante la determinación de si la transacción no utilizada UTXO se encuentra en la lista de salidas de transacciones no utilizadas para la cadena de bloques.
- 7Un método según cualquier reivindicación precedente, en donde i) el contrato se almacena en una Tabla de Hash Distribuida (DHT); y/o ii) el método comprende la etapa de:difundir una transacción a la cadena de bloques que comprende una instrucción de utilizar la salida en una fecha y/u hora especificadas, preferiblemente en donde la instrucción es una instrucción CheckLockTimeVerify.
- 8Un método según cualquier reivindicación precedente en donde:5 10 15 20 25 30 35 i) el acceso a algunos o todos los contenidos del contrato se restringe a al menos una parte designada autorizada;y/o ii) el contrato comprende un Autómata Finito Determinista (DFA) para implementar el contrato;preferiblemente en donde el Autómata Finito Determinista se define mediante el uso de un esquema de codificación.
- 9Un método según la reivindicación 8 en donde el Autómata Finito Determinista se implementa mediante el uso de:i) al menos una transacción de la cadena de bloques, preferiblemente mediante el uso de un lenguaje de scripts;ii) un agente informático dispuesto para monitorear el estado de la cadena de bloques;y/o iii) un conjunto de instrucciones para una cartera digital.
- 10Un método implementado por ordenador para controlar la visibilidad y/o cumplimiento de un contrato, el método comprendiendo las etapas de:(a) almacenar un contrato en un depósito basado en ordenador;(b) difundir una transacción a una cadena de bloques, la transacción comprendiendo: i) al menos una salida no utilizada (UTXO);y ii) metadatos que comprenden un identificador indicativo de la ubicación donde se almacena el contrato;(c) interpretar el contrato como abierto o válido hasta que la salida no utilizada (UTXO) se utiliza en la cadena de bloques;y (d) generar un subcontrato derivado del contrato, en donde el subcontrato se asocia a una dirección determinista y se genera mediante: iii) el uso de una nueva clave pública derivada mediante el uso de una semilla;iv) el almacenamiento del subcontrato en el depósito con una referencia al contrato, y la difusión de una transacción a la cadena de bloques que comprende un script que incluye la referencia;y/o v) la adición de una referencia al subcontrato a los metadatos del contrato existente.
- 11Un método según la reivindicación 10 en donde la transacción además comprende una dirección de script de rescate determinista, preferiblemente en donde la dirección de script de rescate es una dirección de pago al hash del script (P2SH).
- 12Un método según la reivindicación 11 y que además comprende la etapa de completar el contrato mediante la difusión de una transacción adicional a la cadena de bloques para utilizar la salida (UTXO); preferiblemente en donde la transacción adicional comprende:una entrada que es la salida (UTXO);y un script de desbloqueo que comprende una firma;los metadatos;y una clave pública.
- 13Un método según cualquiera de las reivindicaciones 10 a 12, en donde:i) el contrato define: a) al menos una condición;y b) al menos una acción cuyo cumplimento depende de la evaluación de la condición;y/o ii) los metadatos comprenden: a) una dirección o representación de una dirección de donde se almacena el contrato en el depósito basado en ordenador;y/o b) un hash del contrato.
- 14Un método según cualquiera de las reivindicaciones 10 a 13 y que comprende la etapa de:verificar si el contrato ha finalizado mediante la determinación de si la transacción no utilizada UTXO se encuentra en la lista de salidas de transacciones no utilizadas para la cadena de bloques. 5 15. Un método según cualquiera de las reivindicaciones 10 a 14, en donde el contrato se almacena en una Tabla de Hash Distribuida (DHT). 16. Un método según cualquiera de las reivindicaciones 10 a 15 y que comprende la etapa de: difundir una transacción a la cadena de bloques que comprende una instrucción de utilizar la salida en una fecha y/u hora especificadas, preferiblemente en donde la instrucción es una instrucción CheckLockTimeVerify. 10 17. Un método según cualquiera de las reivindicaciones 10 a 16, en donde: i) el acceso a algunos o todos los contenidos del contrato se restringe a al menos una parte autorizada designada;y/o ii) el contrato comprende un Autómata Finito Determinista (DFA) para implementar el contrato;preferiblemente en donde:
- 1515 el Autómata Finito Determinista se define mediante el uso de un esquema de codificación; y/o el Autómata Finito Determinista se implementa mediante el uso de:i) al menos una transacción de cadena de bloques, preferiblemente mediante el uso de un lenguaje de scripts;ii) un agente informático dispuesto para monitorear el estado de la cadena de bloques;y/o iii) un conjunto de instrucciones para una cartera digital.
- 1620 18. Un sistema dispuesto para llevar a cabo el método de cualquier reivindicación precedente.
Independent claims16
678 paragraphs in 1 section, as filed
5
10
15
20
25
30
35
40
45
50
DESCRIPTION
Registration and automatic management method for smart contracts executed by blockchain.
The present invention relates, in general, to computer protocols and, more specifically, to the verification, execution and / or compliance of processes controlled by conditions such as, for example, those related to contracts. The invention is particularly suitable for use with a blockchain network and can be used to take advantage of a smart contract.
A blockchain is a distributed and decentralized computer system composed of non-changeable blocks that, in turn, are formed by transactions. Each block contains a hash of the previous block so that the blocks are chained together to create a record of all transactions that have been written to the blockchain from the beginning. Transactions contain small programs known as scripts embedded in their inputs and outputs, which specify how and who can access the outputs of the transaction. Each unused transaction (referred to as UTXO) can be used as an entry in a new transaction.
The most widely known application of blockchain technology is Bitcoin accounting technology, although other blockchain implementations have been proposed and developed. While, herein, reference may be made to Bitcoin for the sake of convenience and illustration, it should be noted that the invention is not limited to use with the Bitcoin blockchain and alternative blockchain implementations fall within the scope of the invention.
Blockchain technology is known for the use of cryptocurrency implementation. However, more recently, digital entrepreneurs have begun to explore both the use of the cryptographic security system on which Bitcoin relies, as well as the data that can be stored in the Blockchain, to implement new systems. These include, but are not limited to:
• Metadata storage
• Implementation of digital tokens
• Implementation and management of contracts.
One of the main problems with modern contract management is that it tends to be ad-hoc, with local stores and copies of contracts that are maintained manually. As a result, computer protocols known as "smart contracts" have begun to attract attention as they can allow the automatic execution or fulfillment of a contract, either partially or in its entirety. Smart contracts can provide benefits such as improved security and reduced transaction costs. However, while there are known technical solutions that claim to ensure that such contracts cannot be modified once stored, there is no public record generally accepted to verify the validity of the contract, namely, if it is still open or has been terminated.
Therefore, it is desirable to provide a computer-implemented mechanism that can control the public visibility of the existence of a contract, and facilitate the ability of relevant parties to manage, enforce compliance and maintain compliance-based processes such as, for example, contracts in an automatic way (namely, by machine rather than human management). Importantly, this mechanism will provide a technical capacity to specify control conditions and triggers for behaviors defined within the contract.
It should be noted that the invention defined and described herein is not limited for use with contracts in the legal sense of the word. The contract can be a document, file or other mechanism that defines a set of behaviors that can be activated under specified conditions. The control condition can be met publicly. The invention should not be considered limited to use within legal or commercially oriented contexts, and the term "contract" should not be construed in that restrictive sense. For example, the contract can be a train or airline ticket, or for a concert venue, and in which an access code is printed, such as a machine-readable barcode to provide unlocking a barrier.
Accordingly, an invention is provided herein as defined in the appended claims.
According to one aspect of the present invention, a method implemented by computer is provided to control the visibility and / or fulfillment of a contract, the method comprising the steps of:
(a) store a contract in a computer-based warehouse;
5
10
15
20
25
30
35
40
45
(b) disseminate a transaction to a blockchain, the transaction comprising:
i) at least one unused output (UTXO); Y
ii) metadata comprising an identifier indicative of the location where the contract is stored; and c) renew or continue the contract by:
the generation of a new key through the use of data related to a previous key associated with the contract; the generation of a script that includes the new key, the location of the contract and a hash of the contract; and the payment of an amount of currency to the script.
By renewing or continuing the contract by generating a new key by using data related to a previous key associated with the contract, generating a script that includes the new key, the location of the contract and a hash of the contract, and the payment of an amount of currency to the script, this provides the advantage that since the new key is related to the previous key, authorized parties can view the source contract through its connection to the renewed or continued contract and, thus, allow verification of the continued contract, without any loss of security or privacy. The additional advantage is provided that the memory and processing capacity can be reduced by storing the contract in an out-of-chain computer-based repository (i.e. not part of the blockchain), without loss of security or privacy , since the key associated with the renewed or continued contract is associated with the key of the source contract.
In the "continuation" situation, the UTXO can be used by sending it to the "new" continued contract. However, it may be possible to cancel the existing contract by using the exit before the blocking time and, consequently, cancel the entire contract.
The invention can provide a method and system implemented by computer to control the visibility and / or fulfillment of a contract. "Visibility" can mean how and for whom the existence and / or contents of the contract are available or accessible. The contract can be a "smart contract." The method can be an automatic smart contract method. It can be a method to automate the process of monitoring the existence, validity and / or fulfillment of the contract. Since the contract can be represented in the form of at least part of a blockchain transaction, the invention can be referred to as a tokenization method / system. The metadata in the transaction can provide a token implemented by the blockchain that is used to represent and / or access a contract.
The invention can provide a method / system that allows the storage of a contract in a warehouse (register), where a hash of the contract can be used as a query key to find the contract.
The method may comprise the steps of:
store a contract in a computer-based warehouse; Y
disseminate a transaction to a blockchain, the transaction comprising:
i) at least one unused output (UTXO); Y
ii) metadata comprising an identifier indicative of the location where the contract is stored.
The contract can be interpreted as open or valid until the UTXO is used in the blockchain. The blockchain may or may not be the Bitcoin blockchain. This provides the benefit of an innovative mechanism to represent the status or validity of a contract in a blockchain as represented by the UTXO.
The method may comprise the step of using a process, agent or other entity implemented by computer outside the chain to observe the state of the blockchain and behave in a certain way depending on whether the output is currently unused or not. The process can be arranged to interpret the unused output as an indicator of the contract status. In other words, while the output remains within the UTXO list in the blockchain, namely, the transaction is not yet used, it can be used to indicate the validity or "open" status of the indicated contract or referenced by metadata. The contract can be considered complete (terminated) once the UTXO has been used. This condition can be established within the contract. However, once the UTXO has been used, the metadata can continue to contain an indicator or reference to the contract and a hash of the contract so that the contract can retain its function.
5
10
15
20
25
30
35
40
45
50
The method may comprise the stage of publishing the existence of the contract. This can be achieved through the following stages:
• The Issuer of the Contract may create a new Contract Document and publish it in the Depository. The location of the store and the secure hash of that document can be stored for later use;
• create a rescue script that covers the contract document that is secured, in a multi-signature structure where:
° m is at least one; Y
° n is m plus the number of metadata blocks
• included at least one public key in the script; This may be the public key of the Issuer of the Contract. However, other firms may also be required.
• pay an amount of currency eg, Bitcoin to the script, preferably through a P2SH transaction
• wait until the transaction has been published in the Blockchain and extract the transaction ID for the published transaction
• create a new transaction, with a blocking time established at the expiration of the contract, pay the transaction exit again to the public key hash; OR
For an ongoing management contract: use an automatic computing agent to detect the transaction in the blockchain and wait until the contract expires before activating the code to continue it in a new contract; OR
For a contract based on termination (where x of y entities agree that the contract has been fulfilled): create a multi-signature transaction and issue it to said entities for the co-signature after termination.
The deposit can be a storage resource outside the block. In other words, the deposit may not be part of the blockchain itself. The computer-based repository can be or comprise a server. The repository can be a database or other storage facility provided in a computer-based resource. The Deposit can be indexed and thus allow your search. The deposit may comprise a Distributed Hashboard. The contract can be stored in or in association with the Distributed Hashboard (DHT).
The transaction may also comprise a deterministic rescue or blocking script address. The address can be a paid hash address of the script (P2SH). Therefore, the existence of a contract (or element defined within a contract) can be made publicly available by using a transaction that is published in the blockchain by using a paid-to-hash address of the script that can be determined or be provided by the issuer of the contract; and / or contract metadata.
The method may also comprise the stage of finalizing the contract by disseminating a (additional) transaction to the blockchain to use the output (UTXO). The additional transaction may comprise an entry that is the exit (UTXO); and an unlock script comprising a signature; the metadata; and a public key. This can provide the benefit of the automatic termination of the contract, by using a blockchain transaction to use the output.
The contract may define: i) at least one condition; and ii) at least one action whose compliance depends on the evaluation of the condition. The condition can be an essay that can be evaluated to see if it is true or false. The condition can be part (eg, a clause) of the contract. The completion or fulfillment of the condition may be required for the fulfillment of the contract. The condition can be completed if the evaluation determines that it is true.
The metadata may comprise i) an address or representation of an address from which the contract is stored in the computer-based warehouse; and / or ii) a hash of the contract.
The method may comprise the step of observing the state of the blockchain. This may include the search of the blockchain to find a transaction that contains the UTXO. You can understand the step of verifying whether the contract has ended by determining whether the unused transaction UTXO is in the list of outflows of transactions not used for the blockchain. Said monitoring or verification process can be automatic. It can be carried out by a resource or computer agent properly programmed. It may be substantially as described below in the section entitled "Illustrative Computing Agent for use with the invention". The agent can carry out an action according to the
4
5
10
15
20
25
30
35
40
45
used or unused status of the UTXO. Therefore, the status of the UTXO can control or influence the behavior of a computer agent outside the block.
The method may comprise the step of spreading a transaction to the blockchain comprising an instruction to use the output on a specific date and / or time. The instruction can be a CheckLockTimeVerify statement.
Access to some or all of the contents of the contract may be restricted to at least one authorized designated party. In other words, authorization may be required in order to agree to see part or all of the contract. In some embodiments, protection mechanisms may apply to the contract itself. For example, one or more portions of the file may be protected but the general content may be public. This partial protection can be applied both to the encryption of the information within the contract and to the hash that detects changes in its content.
The contract may comprise a Finite Determinist Automaton (DFA) to implement the contract. The Finite Determinist Automaton can be defined by using an encoding scheme. The Finite Determinist Automaton can be implemented by using:
i) at least one blockchain transaction, preferably through the use of a scripting language;
ii) a computer agent arranged to monitor the state of the blockchain (this may be as described in the section below entitled "Illustrative Computer Agent for use with the invention"); I
iii) a set of instructions for a digital wallet.
According to another aspect of the present invention, a method implemented by computer is provided to control the visibility and / or fulfillment of a contract, the method comprising the steps of:
(a) store a contract in a computer-based warehouse;
(b) disseminate a transaction to a blockchain, the transaction comprising:
i) at least one unused output (UTXO); Y
ii) metadata comprising an identifier indicative of the location where the contract is stored; Y
(c) generate a subcontract derived from the contract, where the subcontract is associated with a deterministic address and is generated by:
iii) the use of a new public key derived through the use of a seed;
iv) store the subcontract in the warehouse with a reference to the contract, and disseminate a transaction to the blockchain comprising a script that includes the reference; I
v) add a reference to the subcontract to the metadata of the existing contract.
By generating a subcontract derived from the contract, where the subcontract is associated with a deterministic address and is generated through the use of a new public key derived through the use of a seed, the storage of the subcontract in the warehouse with a reference to contract, and the dissemination of a transaction to the blockchain comprising a script that includes the reference and / or addition of a reference to the subcontract to the metadata of the existing contract, the advantage is provided that subcontracts can be managed, independently, without loss of security or privacy, since they are linked, cryptographically, to the source contract. In addition, memory and processing resources can be minimized by storing the subcontract in a warehouse outside the block.
The method may include the use of a computer-based agent to monitor the blockchain and / or execute actions according to the content of the contract. Said agent may be substantially as described below in the section entitled "Illustrative Computing Agent for use with the invention".
The invention may also provide a computer-implemented system arranged to carry out any of the steps of the method mentioned above, or any embodiment of the method described herein. The invention can provide a system implemented by computer to control the visibility and / or fulfillment of a contract, the system comprising:
a computer-based deposit arranged to store a contract; Y
a blockchain comprising a transaction, the transaction comprising:
5
10
15
20
25
30
35
40
45
50
i) at least one unused output (UTXO); Y
ii) metadata comprising an identifier that represents the location where the contract is stored.
Metadata can also store a hash of the contract. The contract can be a smart contract.
The repository may comprise a database. This may comprise a DHT. It can be indexed and arranged for search. It may comprise at least one security mechanism to control access to the contract.
The system may also comprise a properly configured computer-based agent or entity. The agent can be arranged to monitor and / or search the blockchain. It can be arranged to carry out at least one action according to the state of the blockchain. It can be arranged to determine if the UTXO has been used or not. It can be arranged to carry out one or more actions depending on whether the UTXO has been used or not.
Any feature described herein in relation to one embodiment or aspect may also be used in relation to any other embodiment or aspect. For example, any characteristic described in relation to the method can also be used in relation to the system and vice versa.
A non-exhaustive list of some of the benefits that can be provided by the invention is now provided.
The invention may provide a technical arrangement that simplifies the automatic management of structured control conditions, which may be referred to herein as "contracts." This, in turn, makes it easier to agree with the status of the contract in case of dispute. The invention can also provide a mechanism for maintaining a secure public registry of contracts in a manner that allows the automatic determination of their validity by computer, and the release of their details to authorized entities after validation. Accordingly, the invention can provide an improved security control mechanism that allows or prohibits access to a resource in an intelligent manner.
The invention also provides the ability to publish a contract to a hearing through a computer system so that the details of the contract can be restricted to authorized entities only, but knowledge of the existence of the contract is publicly known. In other words, it may be public knowledge that there is a contract between A and B and this can be verified publicly, but any other data other than its existence is restricted to authorized parties (which may normally be A and B only).
It also provides a computer-implemented mechanism that allows contracts to be of limited time (namely, they expire after a certain time or on a given date); limited to one condition (namely, they expire once the deliverable specified within the contract has been fulfilled) or open termination (namely, they continue to be renewed with a notification period to finalize them).
This can provide a mechanism to issue a notification to finalize the contract publicly. For example, by using nLockTime + CheckLockTimeVerify (CLTV) in a transaction used to 'represent' the expiration.
It can provide a mechanism to structure a hierarchy of subcontracts in a deterministic manner to allow control of different aspects of the contract to be partitioned. For example, in a technology development process, the requirements phase may have a different set of control triggers than the development phase.
Since the invention can be implemented in a blockchain platform, and can extend the functionality of the blockchain so that it can be used in a technically different way, the invention can provide an improved blockchain platform or system.
The invention can be used to convert any unused transaction (UTXO) into a smart contract, such as for digital access. For example, it is necessary to consider a scenario where a consumer pays a merchant to access a service for a period. If the merchant's payment address is implemented as a smart contract, then the invention can be used to implement an access control mechanism for the service. A verification can be carried out to ensure that the money has been paid, and an automatic process can be used to move the value at the end of the period to the merchant's account.
These and other aspects of the present invention will be apparent from, and will be elucidated with reference to, the embodiment described herein. An embodiment of the present invention will now be described, by way of example only, and with reference to the accompanying drawings, in which:
Figure 1 shows an overview of how blockchain transactions can be used by an embodiment of the invention to implement various tasks related to the contract.
5
10
15
20
25
30
35
40
45
Figure 2a shows a simple state machine with two states: (i) the contract is open and (ii) the contract is closed.
Figure 2b shows the definition of metadata for the scenario of Figure 2a. The metadata is transported at the transaction exit (bitcoin) and specifies the location of the contract and proof of validity (through the hash).
Figure 2c shows a "issuance" transaction related to the scenario of Figures 2a and 2b, which initially stores the (hash of) the contract in the Blockchain.
Figure 2d cancels the contract of Figures 2a through 2c through the use of bitcoin.
Figure 3a shows illustrative metadata for a scenario where an asset with hidden property is created and published in the blockchain.
Figure 3b shows an illustrative transaction to "finance" the asset of Figure 3a. That is, in order to put some bitcoins in the public key of the asset so that the asset can finance its transactions (such as the publishing transaction shown in 3c).
Figure 3c shows an illustrative blockchain transaction for the publication of the assets of Figures 3a and 3b.
Figure 3d shows an illustrative transaction for the closing of the contract related to Figures 3a, b and c. When the cancellation of the contract is required, the UTXO is used. In this scenario, the requirement has been that both the Asset and the hidden owner of the asset sign.
Figure 4a shows an illustrative state machine model for a scenario that implies a lease.
Figure 4b shows illustrative metadata for the scenario of Figure 4a.
Figure 4c shows an illustrative transaction to publish the ownership of the assets of Figures 4a and 4b in the Blockchain.
Figure 5a shows an illustrative state machine model for a scenario where a contract is renewed.
Figure 5b shows illustrative metadata for the scenario of Figure 5a.
Figure 5c shows an illustrative transaction that can be used to publish the initial contract of Figures 5a and 5b and the initial renewal of the contract in the Blockchain.
Figure 5d shows an illustrative transaction for the termination of the contract of Figures 5a to 5d.
Figure 6a shows an illustrative state machine model for a scenario that implies contract conditionality.
Figure 6b shows illustrative metadata for the scenario of Figure 6a.
Figure 6c shows an illustrative transaction that can be used to create the initial contract and two subcontracts and publish them.
Figure 6d shows an illustrative transaction for use in relation to scenario 6a to 6c.
Figures 7 to 13 show various aspects of a technique for deriving subkeys from a primary key, said technique being appropriate for use in relation to aspects of the present invention.
The fulfillment of the smart contracts built in the Blockchain can be demanded through the logic that is incorporated directly into the bitcoin transaction (namely, within the lock / unlock scripts) and / or through external computer-based applications . These computer-based external applications can be referred to as "agents", "oracles" or "bots". In addition, some contractual conditions may be required through other bitcoin transaction elements, such as the nLockTime field.
An invention is described herein where the contract is interpreted as one that remains in effect whenever there is a valid unused transaction exit UTXO in the blockchain representing the contract. It will be appreciated that said unused state can be influenced and altered as a result of several mechanisms (eg, a programmed computer agent) whose behavior is controlled by conditions or stipulations in the contract itself. For example, the contract stipulates that it will expire on a certain date, or that it will expire when a certain value reaches a specified threshold.
5
10
15
20
25
30
35
40
45
The present principle of using unused transaction outputs to represent contracts can be used in combination with other features such as, for example, encryption techniques. This allows the implementation of complex scenarios and activities. Effectively, the context around the UTXO unsigned transaction exit and the associated metadata within the script that allows them to be used, allows the transaction to act as an indicator or reference to a deposit outside the chain that contains the formal details of the contract . Here, "outside the chain" means that it is not part of the blockchain itself. This provides a mechanism through which anyone can use a software-based component or tool to determine if the contract has ended or is still valid / open by inspecting the blockchain. Once the contract ends, it will be recorded in the blockchain as an exit used in a transaction and will be available for public inspection. The blockchain transaction becomes a permanent, unalterable and public record of the existence and current status of the contract.
The repository (which can also be called a "record") can be implemented in a variety of ways including, for example, as a distributed hash table (DHT). A contract hash can be generated and stored as metadata within the blockchain transaction, and can serve as the query key to refer to the contract from the blockchain. A reference to the location of the contract is also provided within the metadata of the transaction. For example, the URL for the deposit can be provided. While the metadata is open to public view, the contract itself may not be protected or may be partially protected.
Standard features of Bitcoin, such as CheckLockTimeVerify (CLTV), may allow the contract to have an automatic formal expiration at one point in the future. The use of the blockchain allows said expiration date to be a matter of secure (unalterable) public registration. The present concept, in combination with the use of multiple encryption keys described below, allows the CLTV model to automatically continue or renew the contract unless it is explicitly canceled.
The use of deterministic subkeys, in combination with the tokenization mechanism described herein, allows to create subcontracts or schedules against contracts.
In addition, the use of computer agents (oracles) outside the block allows conditionality of the contract to be incorporated into and modified by reliable third parties. This means that the agent's action may be influenced by conditions (eg, "YES" statements) that are provided within the contract definition.
Key Terms
The following terms may be used herein.
• Issuer of the contract:
This entity represents an actor who is responsible for the publication of the contract in the Blockchain.
• Interested part:
This entity represents an actor who may need to determine whether a particular contract is still in place or not, or may need to determine the specific details of the contract.
• Deposit:
This entity represents a location that secures / stores a structured representation of the contract to which the Smart Contract of the Blockchain refers.
• Contract counterpart:
This entity represents the counterpart of a specific contract. It should be noted that, in many cases, this entity will not be present.
• Contract:
This is the structured document or file stored within the warehouse and referenced from the Blockchain. The contract can be any type of contract or agreement. This may include, for example, financial contracts, property titles, service contracts and more. A contract can be public or private in terms of its content. The contract is formalized in that it is expressed in a structured manner through the use of a coding scheme.
Contract model
The basic elements of the contract model are the following:
5
10
15
20
25
30
35
40
45
• A coding scheme that allows a complete description of any type of contract. The scheme can be a new construction or you can use an existing installation, such as XBRL, XML, JSON (etc.);
• A DFA (Finite Determinist Automaton) to implement the Contract that can be fully defined within the coding scheme. This is formed by:
° A set of parameters, and where to originate those parameters;
° A set of status definitions
° A set of transitions between states, including the trigger for the transition and the rules followed during the transition
° Table of standards definition.
• Definitions of the specific parameters for the present instance of the Contract;
• Mechanisms to secure and protect the Contract;
• A "browser" to allow the contract to be readable by humans in formal legal language; Y
• A "complier" to convert the coding scheme into oracle code and / or script, such as a Bitcoin script.
Contract Implementation
When the Contract is registered in a warehouse, the associated address, eg, URL and hash can be used as metadata within a Blockchain transaction to associate the transaction in the chain with the control contract itself. This can be implemented in a variety of ways, but an appropriate coding scheme is provided below to complete this in the section entitled "Coding scheme".
There are a number of different methods on how the DFA contained within the contract definition can be implemented:
• As a blockchain transaction or transaction sequence. Several forms of DFA can be implemented directly within the Bitcoin script language; The person skilled in the art will understand this and the present invention is not limited with respect to the manner in which the DFA is implemented by blockchain transactions;
• As an agent-based process or sequence of processes (eg, oracle). The section below entitled "Illustrative Computing Agent for use with the invention" describes the basic process for defining and executing an appropriate agent to monitor the Blockchain and, possibly, other external sources.
• As a set of instructions for a digital Portfolio. In this content, a smart wallet is simply, effectively, a local oracle process that can handle certain contractual conditions such as, for example, an allocation of transaction entries to a Blockchain transaction.
It should be noted that a given contract definition can be implemented as a mixture of the three mechanisms above, where each transition of contract status is effectively a separate implementation. There are a number of methods to create the implementation from a contract definition, including the handmade elaboration of the relevant transactions / code.
Publication of the Existence of the Contract
In order to publish the existence of a contract (or an element defined within a contract), a Tx transaction is published in the Blockchain by using a payment address to the script hash (P2SH). A P2SH transaction is one in which the recipient must provide a script that matches the hash of the script, and also data that makes the evaluation of the script true, in order for the transaction to be used. In relation to the embodiments of the present invention, the hash payment of the script (P2SH) can be determined immediately from:
• The issuer of the contract; Y
• The metadata of the contract.
5
10
15
20
25
30
35
40
45
50
According to some embodiments of the invention, the unused transaction can be interpreted as an indicator of the contract status. An out-of-chain process can be arranged to monitor the blockchain and behave in a certain way depending on whether the output is used or not. In other words, while said output remains within the UTXO list in the blockchain (namely, the transaction is not yet used), it indicates the validity of the indicated contract or to which reference is made by the metadata. The contract is considered complete once said exit has been used. Such a condition (that the contract remains valid / open only as long as there is a UTXO for it) may be a condition of the contract itself. However, it is not a necessary stipulation of the protocol since in other embodiments an alternative termination condition may be in place. It should be noted that even after the transaction has been used (and therefore no longer exists in the UTXO list) it still resides permanently in the Blockchain and still retains an indicator or reference to the contract and a hash of the contract so that it can retain its function even after it has been used.
Subcontracts / Conditions
A subcontract is a contract that relates directly to an existing contract. A condition is a clause within an existing contract that must be satisfied to comply with the terms of that contract.
According to an embodiment of the invention, subcontracts and conditions can be implemented in the same manner, namely, as a contract that is implemented as a UTXO with a deterministic rescue script address. In both cases, the entity can be interpreted as complete when the UTXO is used (in the case of a condition, this indicates that the condition has been met). As stated above, the metadata will still contain an indicator or reference to the location of the entity within the warehouse, and also a hash of it. Therefore, in other embodiments, the subcontract or condition may remain in existence and retain functionality even after the exit has been used, according to the contractually specified conditions.
There are a number of mechanisms that can be used to create the deterministic direction for a condition or subcontract:
- Derive a new public key through the use of seed information;
- Create and publish the subcontract, with a reference to the framework contract, within the warehouse and by using it as the metadata reference; Y
- Add the condition / subcontract reference to the metadata of the existing contract.
Contract Protection
The formal representation of the contract (that is, the document or file that specifies the content of the contract) can be secured in various ways according to the formal needs of that specific contract, although in all cases a public record of the existence of the contract will be published in the Blockchain contained within the metadata record (see the section entitled "Coding scheme" for details of a specific metadata structure).
From said blockchain record, authorized entities will be able to learn the location of the formal representation, along with the hash to determine that the formal representation has not been modified since the transaction has been published.
However, it is also possible to ensure the formal representation itself through a number of methods:
- The deposit of the document itself may present access control mechanisms; Y
- The Contract itself can be protected through standard encryption techniques that limit access to those entities with access to the relevant decryption keys.
In many cases, the Contract itself will have partial protection. For example, some sections within the archive can be protected while the general content is public, e.g., details of how to implement a fixed-rate loan are published but knowledge of who has applied for the loan, for what amount and at what rate Only the contracting parties know it.
This partial protection applies both to the encryption of the information within the contract and to the hash that detects changes in its content.
For a number of contracts, the contract details may be modified during their duration and this should not require the reissue of the contract itself. This can be achieved by determining the scope of the hash in a subset of the contract. An example where this can be useful is in the implementation of an investment fund. The contract that forms the basis of the investment fund cannot change, but the beneficiary of the fund may
10
be modified through the sale of the contract. In one embodiment, the recording of changes can be achieved through the use of subcontracts.
End of your contract
Since the Blockchain provides a permanent and unalterable record of transactions, a contract 5 cannot be terminated simply by deleting the associated Contract document. This means that the secure deposit of the contract must have the same storage and retention standards as the Blockchain itself that is supported through a number of standard mechanisms. This means that the solution must present a mechanism to detect the expiration of a contract through the registration of the Blockchain directly.
The termination method is defined as a condition in the contract and can be carried out in a variety of 10 ways, all of which are conceptually covered by the present invention. In a preferred embodiment of the invention, the termination is managed through the use of the UTXO representing the contract.
For a number of contract types, the expiration of the contract can be published simultaneously with the publication of the Contract itself. Effectively, two transactions are created, one to publish the contract and obtain the transaction output that represents the contract and a second to use that output. Said second transaction has a CheckLockTimeVerify established in it to use the output on a given future date (representing the end of the contract). According to the previous comment, this is our standard way but not the only way.
Such self-use can be extended to admit the continuation of a contract (for example, contracts that extend automatically for an additional period of twelve months if they are not canceled). In the present situation, the UTXO is used by sending it to the "new" continued contract. However, it is possible to cancel the old contract 20 by using the exit before the blocking time and, consequently, cancel the entire contract.
Use Case Model
Figure 1 shows an overview of a use case model according to an embodiment of the invention. This illustrative use case model demonstrates how standard Bitcoin transactions can be used to implement DFA elements directly within the Bitcoin scripts. Examples of key use cases are now provided for the sake of illustration.
Contract Creation
The Issuer of the Contract (which is the primary actor in the present example) wishes to publish a contract in the Blockchain for public visibility. This process is illustrated in Table 1:
StageDetails
100.10 The Issuer of the Contract creates a new Contract Document and publishes it in a Depository, stores the location of the warehouse and the secure hash of said document for later use. It should be noted that this Deposit can be public, private or semi-private according to the nature of the Contract Document itself. The Deposit is indexed and, thus, allows its search by a variety of attributes.
100.20 The Contract Issuer creates a rescue script that covers the contract document that is secured, in a multi-signature structure where: - m is at least one; and n is m plus the number of metadata blocks (which will be at least two). The only public key that should always be supplied to that script is that of the Issuer of the Contract. However, under the terms of the contract, other signatures may also be required.
100.30 The Issuer of the Contract pays a nominal amount of currency, eg, Bitcoin, to the rescue script calculated in step 100.20 through a standard P2SH transaction.
100.40 The Contract Issuer waits until the transaction has been published in the Blockchain and extracts the transaction ID for the published transaction.
StageDetails
100.50 For a fixed-term contract, the Issuer of the Contract then creates a new transaction, with a blocking time established at the expiration of the contract, and pays the exit from step 100.40 again to the public key hash of the Issuer of the Contract For a contract of continuous duration, a computer-based agent can pick up the transaction and wait until the expiration of the contract before activating the use case of "continuation" of table 3 below to continue it in the contract. For a contract based on termination ( where x of y entities agree that the contract has been fulfilled), one m of n multi-signature transactions is created and issued to said entities for the co-signature after termination).
There are two key embodiments or variations of this scenario that are explained in detail below:
• Creation of a subcontract from an existing contract
• Continuation of an existing contract in a new one (renewal)
5 Creation of a Subcontract
In the present situation, the Issuer of the Contract wishes to create a subcontract from an existing contract. This process is illustrated in Table 2:
StageDetails
150.10 The Issuer of the Contract creates a new subkey from its public key used to create the primary contract by using a seed value in the derivation of the subkey information from the primary contract. This may be any derivation that the Issuer of the Contract wishes (and to which it has committed), but examples of appropriate seeds may include: - UTXO ID / transaction index of the contract created in step 100.40; o- Hash of the rescue script created in step 100.20. It should be noted that the present example assumes that the public key referred to above will be the public key of the Contract Issuer; however, the person skilled in the art will appreciate that there is nothing to prevent this from being the derived subkey (namely, a subcontract of a subcontract).
150.20 According to the nature of the subcontract being created, the Issuer of the Contract: - Uses the location and hash of the framework contract document; o- Creates a new Contract Document with a link to the framework contract incorporated in it, stores the location of the document and protects the hash of said document for later use; o- Creates a new Contract Document with a link to the framework contract incorporated in it, plus a list of the fields of the original Contract Document that is covered. Effectively, this is a document that specifies that said subcontract covers specific sections of another document rather than duplicate the original information. It should be noted that this Deposit can be public, private or semi-private according to the nature of the Contract Document itself.
StageDetails
150.30 The Contract Issuer creates a rescue script that covers the contract document that is being secured, in a multi-signature structure where: - m is at least one; and n is m plus the number of metadata blocks (which will be at least two). The only public key that should always be supplied to that script is that of the Issuer of the Contract. However, under the terms of the contract, other signatures may also be required.
150.40 The Issuer of the Contract pays a nominal amount of currency, eg, Bitcoin, to the rescue script calculated in step 150.30 through a standard P2SH transaction (payment to the script hash).
150.50 The Issuer of the Contract waits until the transaction has been published in the Blockchain and extracts the transaction ID for the published transaction.
150.60 For a fixed-term subcontract, the Issuer of the Contract then creates a new transaction, with a blocking time established at the expiration of the contract, and pays the exit of step 150.50 again to the public key hash of the Issuer of the Contract.
According to one or more embodiments, the subcontract can be monitored independently. For example, it is necessary to consider a property construction contract where the approval of a surveyor is required and the contract establishes "subject to the approval of <x>". In order to implement this, step 150.60 is created and circulated to <x> for signature. The repayment script is not time locked but is created as an m of n multi-signature element where the required signatory is <x>. In some embodiments, the transaction will have two outputs: the rate at <x> plus the payment of the UTXO generated in step 150.50.
Example use case: Renewal of existing contract
In the present use case, the Issuer of the Contract wishes to continue an existing contract in a new one. An illustrative process 10 is provided in table 3:
StageDetails
175.10 The Issuer of the Contract will check the Blockchain to determine if the contract has been canceled or not by validating whether the previous UTXO has been used or not. If it has been used, the process ends.
175.20 The Issuer of the Contract creates a new subkey from its public key used to create the primary contract by using it as a seed value in deriving the subkey information from the primary contract sequence. This may be any deterministic derivation that the Issuer of the Contract wishes (and to which it has committed), but it may be: - Sequence number (eg, instance "1" continued); o- Range of dates for the continued contract The provisions set forth above assume that the public key mentioned above will be the public key of the Contract Issuer, but, in practice, there is nothing to prevent this from being a derived subkey (namely, a subcontract of a subcontract). You need to see the section titled "Subkey Generation Method" for an example of how the subkey can be created.
175.30 The Issuer of the Contract takes the location and hash of the existing contract document. It should be noted that this Deposit can be public, private or semi-private according to the nature of the Contract Document itself.
StageDetails
175.40 The Issuer of the Contract creates a rescue script that covers the contract document being secured, in a multi-signature structure where: - m is at least one; and n is m plus the number of metadata blocks (which will be at least two). The two public keys that should always be supplied to said script are those of the Issuer of the Contract and that of the Client. However, under the terms of the contract, other signatures may also be required.
175.50 The Issuer of the Contract pays a nominal amount of Bitcoin to the rescue script calculated in step 175.40 through a standard P2SH transaction.
175.60 The Issuer of the Contract waits until the transaction has been published in the Blockchain and extracts the transaction ID for the published transaction.
175.70 A process (such as an oracle or bot-based implementation) will pick up the transaction and wait until the expiration of the contract before reactivating the "continuation" process in Table 3 to continue it again if it has not cancelled.
Example: Contract Verification
In the present use case, an Interested Party wishes to confirm that there is an existing contract to cover the activity for which it is requesting information. This process is shown in table 4:
StageDetails
200.10 The Interested Party will check the Blockchain to confirm whether the UTXO related to the contract in which it is interested has been used or not. Where the UTXO has not yet been used, then the contract remains valid. Where the UTXO has not yet been used, but there is a pending lock time transaction, then it will determine the expiration time for the contract. Where the UTXO has been used, then the contract has been completed in some respect.
5
The main variable above assumes that the Interested Party knows the transaction that governs the contract through some other route (in general, that is that they are the Issuer of the Contract or the Counterparty of the Contract). However, any entity that has access to the Contract Document and knowledge of the Contract Issuer may carry out the verification by:
10 - The derivation of the rescue script for the UTXO transaction; Y
- Scanning the Blockchain to find a UTXO with said matching rescue script hash.
Example: Contract Closing
In the present use case, a Contract Issuer or Contract Counterparty wishes to close an existing contract. 15 This process is illustrated in Table 5:
StageDetails
300.10 The Closing Initiator will check the blockchain to determine if the contract has been canceled or not by validating whether the previous UTXO has been used or not. If it has been used, the process ends because the contract has already been closed.
300.20 If there is an existing closing transaction, then the initiator will simply sign that transaction and
5
10
15
20
25
30
35
40
StageDetails
present it to the Blockchain.
300.30 If there is no existing closing transaction, then the initiator will create the transaction with the transaction entry being the UTXO of the last contract, and the unlocking script being your signature, the metadata associated with the contract and your public key.
300.40 At the point where the transaction is accepted in the Blockchain, then it will be public knowledge that the contract has been closed (although only the participants will know the specific reason).
Contractual conditions
The same mechanism described above can be used to monitor the conditions within a given contract, such as checkpoints. For example, if it is determined that a contract is worth 100 BTC, with 20 BTC that will be paid at checkpoint 1 to 5, then the subcontract model described above can be used to derive a framework contract plus five subcontracts. Each of these subcontracts can be marked as complete by using them, or different, signatories (such as notaries or the like, for example). In this way, a public record can be maintained and show that the conditions attached to the contract have been met. It is then possible to combine this concept with a process or application ("boí") that can be used to activate the payments of 20 BTC once the contract has been marked as complete.
For the sake of illustration, some exemplary scenarios are provided below, which show some of the applications for which the invention can be used. In all such scenarios, the content of the contract itself is considered irrelevant and not restrictive.
Scenario as an example 1: Public Registration of an asset
In this scenario, Bob decides to publish his ownership of an asset (eg, his home) in the Blockchain. Nothing else takes place at the present stage; It is simply an asset that can then be used in subsequent transactions. In the present situation, there is no end date of the contract. Figure 2a shows a simple state machine with two states: (i) the contract is open and (ii) the contract is closed. Figure 2b shows the definition of metadata transported in the Bitcoin Transaction exit and specifies the location of the contract and proof of validity through the hash. Figure 2c shows a "broadcast" transaction that initially stores the contract in the Blockchain (although, in reality, it only stores the hash, not the actual contract). Figure 2d cancels the contract through the use of bitcoin.
Scenario as an example 2: Creation and Registration of an Asset with Hidden Property
This is a slightly improved version of scenario 1 where Bob wants to publish the asset in the Blockchain, but does not want to directly disclose its ownership.
In this situation, Bob first creates a subkey from his public key to represent the asset. This subkey is then published as part of the details of the asset in the Blockchain. Again, in the present situation, there is no end date for the asset. (A detailed example is provided below for a way in which the subkey can be generated. You need to see the section below titled "Subkey Generation Method").
The state machine for the present scenario is the same as that for scenario 1, as shown in Figure 2a. Figure 3a shows the definition of metadata for this scenario. The metadata is transported in the Bitcoin Transaction exit and specifies the location of the contract and proof of validity (through the hash). Figure 3b shows the transaction to "finance" the asset. That is, put some bitcoins in the public key of the asset so that the asset can finance its transactions (such as, for example, the publication transaction in Figure 3c). Figure 3b does not show Bob's creation of the asset subkey since it is not a Bitcoin transaction.
Figure 3c shows the blockchain transaction for asset publication. Figure 3d shows the transaction for closing the contract. When cancellation of the contract is required, the UTXO is used. In the present situation, the requirement has been that both the Asset and the hidden owner of the asset sign.
Scenario as an example 3: Lease agreement
5
10
15
20
25
30
35
40
45
50
In this illustrative situation, Bob enters into a lease with Eve for a fixed term of three years. The terms of the contract will specify a number of payments. Payment details are not relevant with respect to the present invention. However, the contract has a fixed term without interruption clauses.
This has a simple state machine model as shown in Figure 4a. Figure 4b shows the metadata for this scenario. Figure 4c shows the transaction to publish the ownership of the asset in the Blockchain. First, Bob provides some financing for the asset, then the asset publishes itself.
Scenario as an example 4: Contract Renewal
In this illustrative situation, Bob decides to lease a house to Eve on an annual basis, where he needs to notify two months in advance to cancel the lease on the renewal date, otherwise, it will be automatically renewed. This has a simple state machine model as shown in Figure 5a. Figure 5b shows the metadata for this scenario. Figure 5c shows the transaction to publish the initial contract and the initial renewal of the contract in the Blockchain.
After the first year, Bob continues the lease and does not finalize it. Immediately after the publication of EVE-S3-T2, this is then collected by an automatic computer agent and renewed for another year. It should be noted that it is also possible that this can be done by EVE by using its own internal logic.
After the second year, Bob decides to end the lease and files a transaction by using the same entry as EVE-S3-T3. However, since such transaction has not yet been submitted, the entry is not used and if Bob's transaction is published in the Blockchain first, it will invalidate EVE-S3-T3. While the amounts involved are trivial, the bot will not endorse the transaction unless the exit is directed to Eve's public key hash (or what the contract actually establishes). The transaction for the termination of Bob's contract is shown in Figure 5d.
Scenario as an example 5: Confidentiality of the Contract
In the present illustrative situation, Bob enters into a contract with a group of builders to deliver a new property, and specifies a number of conditions within the contract that require independent approval (the first being the approval of the plans by the authority of local planning). This has a simple state machine model as shown in Figure 6a. Figure 6b shows the metadata for this scenario. Figure 6c shows the transaction where Bob creates the initial contract and the two subcontracts (after deriving the relevant subkey, possibly by using the subkey generation technique described below) and publishes them. Figure 6d shows the transaction for when the planning permission has been approved.
Coding Scheme
The metadata used to refer to the contract can be formatted in a variety of ways. However, an appropriate coding scheme is described here.
A contract is transferable if the rights it defines are conferred on the holder or owner of the contract. An example of a non-transferable contract is one in which participants are named - that is, where rights are conferred on a specific entity named before the contract holder. Only transferable contracts are described in this coding scheme.
A token represents a specific contract that details or defines rights conferred by a contract. According to the present invention, the token is a representation of the contract in the form of a bitcoin transaction.
The present coding method uses metadata comprising three parameters or data items. Such data may be indicative of:
i) a number of actions available under the contract (reference may be made herein as "NumShares");
ii) a number of transfer units that will be transferred from a sender to at least one receiver (this can be referred to herein as "ShareVal"); Y
iii) a factor for calculating a value for the number of transfer units (this can be referred to herein as an "assignment rate / PeggingRate").
An advantage of the present coding scheme is that it can be used to encapsulate or represent contracts as tokens in a blockchain by using only the three parameters described above. From
16
5
10
15
20
25
30
35
40
45
50
55
In fact, the contract can be specified by using a minimum of said three data items. Since this coding scheme can be used for any type of transferable contract, common algorithms can be conceived and applied. Additional details of such metadata articles are provided as follows.
A divisible token is one in which the value in a transaction exit can be subdivided into smaller amounts allocated along multiple tokens (ie, assigned throughout multiple transactions). The archetype is tokenized fiat currency. Divisible contracts are defined as those that specify a non-zero PeggingRate. For divisible contracts, the tokenized value transferred at the transaction exit is related to the value of the underlying bitcoin (BTC) through PeggingRate. That is, the contract specifies the rights of the holder in terms of an allocation rate. For non-divisible tokens, there is no PeggingRate and the contract specifies the rights of the holder in terms of a fixed value (eg, as a bearer bonus: "this contract is redeemable for exactly $ 1000" or a voucher "this contract is salvageable for a haircut "). For non-divisible contracts, the BTC value of the underlying transaction is irrelevant to the value of the contract.
The phrase "underlying BTC value" refers to the amount of bitcoins (BTC) attached to the transaction exit. In the Bitcoin protocol, every transaction exit must have a non-zero BTC amount to be considered valid. In fact, the BTC amount must be greater than an established minimum (known as "remains") which, at the time of writing, is currently set at 546 satoshis. 1 bitcoin is defined as equal to 100 million satoshis. Since bitcoin transactions are used here only as a means to facilitate an exchange of ownership, the actual underlying BTC amount is arbitrary: the true value lies in the contract specifications. In theory, each token can be transported by the remains.
According to this coding scheme, specifically for divisible tokens, the underlying BTC value has no meaning: it supports a relationship with the value of the contract through PeggingRate. PeggingRate is arbitrary and is chosen to keep the underlying BTC amount small. The reason for using PeggingRate before simply any underlying token transaction with remains is that the protocol of the present invention facilitates divisibility: when a token is divided into several transaction outputs of smaller amounts, it is not necessary to adjust the original contract. Rather, the contract value of each subdivided token is simply calculated according to PeggingRate and the subdivided amount of underlying BTC value.
A limited token is one in which a total issue value is fixed (or "limited") by a fixed number of non-zero shares as defined by an amount called NumShares. Therefore, no more shares can be issued in a limited contract. For example, a contract for ownership by a racehorse is limited to 100% of the racehorse (eg, 100 shares at 1% each or 10 shares at 10% each, etc.). An unlimited contract implies that the issuer can subscribe additional issues of shares, for example by adding the required amount of fiat currency to its Reserve Account. NumShares must be explicitly established in all contracts. Limited contracts must have NumShares> 0; Unlimited contracts are denoted by setting NumShares = 0.
The archetypal example is a currency reserve (analogous to a gold reserve) so that the total value held in the reserve bank account matches the total value in promissory notes in stock (namely, unrescured tokens). This concept extends beyond currency reserves to include stock inventory. For example, a licensed t-shirt token issuer can start with an inventory of 10,000 available t-shirts and can issue a divisible token to represent those 10,000 t-shirts (where, say, each share = 1 t-shirt). The original token can be subdivided and each subdivided token will be redeemable for a number of shirts according to the underlying BTC value of the transaction exit as defined by PeggingRate. If the demand increases, however, the issuer may decide to issue additional shares (namely, increase the number of outstanding shares by (say) another 10,000). In that case, it is up to the issuer to deposit 10,000 additional shirts in their reserve account (namely, stock warehouse) in order to subscribe the additional issue. Therefore, the total number of shirts available (where stocks act as a "reserve account") at any time = the number of total unrescued shares.
PeggingRates only applies to divisible contracts, where the value of an action (represented by an amount called ShareVal) is assigned to the underlying BTC amount. For example, the contract may specify that the issuer promises to rescue the token at a rate of $ 10,000 for each 1 underlying BTC. This will mean (for example) that a transaction with an underlying tokenized exit value of 15,400 satoshis will be redeemable for $ 1.54. A value of 0 for PeggingRate indicates that the contract is not divisible (that is, it can only be transferred in its entirety, as a bearer bonus). When PeggingRate is set to 0 (which means a non-divisible token) the underlying BTC value is not relevant to the contract value and can be set at any amount. Normally, in the present case, it is desirable to keep the underlying BTC amount as small as possible (ie, set in remains) to minimize operating costs.
5
10
15
20
25
30
35
40
45
50
NumShares is the total (fixed) number of shares available in the contract (Limited). For limited contracts NumShares must be a total number greater than zero. For unlimited contracts NumShares is not fixed since more shares can be issued at any time (as long as they subscribe), which is denoted by setting the value to 0.
An action is defined as the transfer unit and ShareVal is the value of that unit. For example, for the fiat currency, the transfer unit can be set to 1 cent. Or, for example, it can be set at 50 cents, in which case transfers can only be made in "lots" of 50 cents. ShareVal can also be expressed as a percentage: for example, if a breeder wants to sell a racehorse in 10 equal shares, then ShareVal = 10%. ShareVal must be> 0 and must be defined in the contract.
TotalIssuance represents the total value of issued shares. This value only refers to limited contracts since for unlimited contracts the issuance is not fixed and more shares can be issued. If the actions are expressed as a percentage, then TotalIssuance = 100% by definition.
For limited contracts, NumShares, ShareVal and TotalIssuance are related as follows:
NumShares x ShareVal = TotalIssuance.
A value of 0 for TotalIssuance implies that it is an unlimited contract. An example of an unlimited contract is a fiat currency (then TotalIssuance is set to 0); Examples of limited contracts are: (i) limited edition commemorative coins (1,000 minted, where 1 share = 1 coin): TotalIssuance = 1000 x 1 = 1000 coins; and (ii) seats in a place with tickets, where TotalIssuance = total number of seats available.
Circulation is defined as the total value of unused tokens (namely, as determined by transactions in UTXO - unused transaction exit). The total set of all unused transactions is kept in a list available for all bitcoin nodes. For example, if an issuer initially issues $ 10,000 as fiat currency tokens and over time the value of $ 5500 tokens is rescued, then the circulation = $ 4500 (being the value of unrescured tokens). This value must be reconciled with the balance in the associated reserve account.
Subkey Generation Method
Above, Table 3 and the example scenarios refer to situations where it is advantageous to generate a subkey from an original (master) key. A method to achieve this is now provided for illustration in a way in which it can be accomplished.
Figure 7 illustrates a system 1 that includes a first node 3 that is in communication with a second node 7 in a communications network 5. The first node 3 has a first associated processing device 23 and the second node 5 has a second device of associated processing 27. The first and second nodes 3, 7 may include an electronic device such as a computer, telephone, tablet, mobile communication device, computer server, etc. In one example, the first node 3 may be a client (user) device and the second node 7 may be a server. The server can be a digital wallet provider server.
The first node 3 is associated with a first pair of asymmetric cryptography having a first node master private key (V1C) and a first node master public key (P1C). The second node (7) is associated with a second pair of asymmetric cryptography that has a second node master private key (V1S) and a second node master public key (P1S). In other words, the first and second nodes are each in possession of the respective public-private key pairs.
The first and second pairs of asymmetric cryptography for the respective first and second nodes 3, 7 can be generated during a registration process such as, for example, the registration of a portfolio. The public key for each node can be shared publicly, such as in a communications network 5.
In order to determine a common secret (SC) in both the first node 3 and the second node 7, the nodes 3, 7 carry out respective method steps 300, 400 without communicating private keys in the communication network 5.
Method 300 carried out by the first node 3 includes determining 330 a second first node private key (V2C) according to at least the first node master private key (Vm) and a Generator Value (VG). The Generator Value may be based on a message (M) that is shared between the first and second nodes, which may include sharing the message in the communication network 5 as described in greater detail below. Method 300 also includes determining 370 a second second node public key (P2S) according to at least the second node master public key (P1S) and the Generator Value (VG). Method 300 includes determining 380 the common secret (SC) according to the second first node private key (V2C) and the second second node public key (P2S).
5
10
15
20
25
30
35
40
45
50
55
Importantly, the same common secret (SC) can also be determined in the second node 7 by method 400. Method 400 includes determining 430 a second public key of the first node (P2C) according to the master public key of the first node (P1C ) and the Generator Value (VG). Method 400 also includes determining 470 a second second node private key (V2S) according to the second node master private key (V1S) and the Generator Value (VG). Method 400 includes determining 480 the common secret (SC) according to the second second node private key (V2S) and the second first node public key (P2C).
The communication network 5 may include a local area network, a wide area network, mobile networks, radio communications network, Internet, etc. Said networks, where the data can be transmitted by means of communications such as, for example, electric cable, fiber optic, or wirelessly, can be susceptible to clandestine listening, for example, by a secret listening device 11. The method 300, 400 may allow the first node 3 and second node 7 to independently determine a common secret without transmitting the common secret in the communication network 5.
Therefore, one advantage is that the common secret (SC) can be determined securely and independently by each node without having to transmit a private key in a potentially insecure communications network 5. In turn, the common secret can be used as a secret key (or as the basis of a secret key).
Methods 300, 400 may include additional steps. It is necessary to see Figure 11. Method 300 may include, in the first node 3, generate a signed message (MF1) according to the message (M) and the second private first node key (V2C). Method 300 also includes sending 360 the first signed message (MF1), in the communications network, to the second node 7. In turn, the second node 7 can carry out the step of receiving 440 the first signed message (MF1) . Method 400 also includes the step of validating 450 the first signed message (MF2) with the second public key of the first node (P2C) and authenticating 460 the first node 3 according to the result of the validation of the first signed message (MF1). Advantageously, this allows the second node 7 to authenticate that the supposed first node (where the first signed message has been generated) is the first node 3. This is based on the assumption that only the first node 3 has access to the first node master private key (V1C) and, therefore, only the first node 3 can determine the second first node private key (V2c) for generate the first signed message (MF1). It will be appreciated that, similarly, a second signed message (MF2) can be generated on the second node 7 and sent to the first node 3 so that the first node 3 can authenticate the second node 7 as, for example, in a scenario between peers
The sharing of the message (M) between the first and second nodes can be achieved in a variety of ways. In one example, the message can be generated in the first node 3 that is then sent, in the communication network 5, to the second node 7. Alternatively, the message can be generated in the second node 7 and then sent, in the network of communications 5, to the second node 7. In some examples, the message (M) may be public and, therefore, may be transmitted in an unsecured network 5. One or more messages (M) can be stored in a data store 13, 17, 19. The person skilled in the art will realize that sharing the message can be achieved in a variety of ways.
Advantageously, a record to allow the recreation of the common secret (SC) can be maintained without the record itself having to be stored privately or transmitted securely.
Registration Method 100, 200
An example of a registration method 100, 200 will be described with reference to Figure 9, where method 100 is carried out by the first node 3 and method 200 is carried out by the second node 7. This includes establishing the first and second pairs of asymmetric cryptography for the respective first and second nodes 3, 7.
Asymmetric cryptography pairs include associated private and public keys, such as those used in public key encryption. In the present example, asymmetric cryptography pairs are generated through the use of Elliptic Curve Cryptography (ECC) and elliptic curve function properties.
In method 100, 200, this includes that the first and second agree 110, 210 on a common ECC system and use a base point (G). (Note: the base point can be referred to as a Common Generator, but the term "base point" is used to avoid confusion with the Generator Value VG). In one example, the common ECC system can be based on secp256K1 which is an ECC system used by Bitcoin. The base point (G) can be selected, generated randomly, or assigned.
Returning now to the first node 3, method 100 includes establishing 110 in the common ECC system and base point (G). This may include receiving the common ECC system and base point of the second node 7, or a third node 9. Alternatively, a user interface 15 can be associated with the first node 3, by means of which a user can provide, in a manner selective, the common ECC system and / or base point (G). In even another alternative, one or both of the common ECC system and / or base point (G) can be randomly selected by the first node 3. The first node 3 can send, in the communications network 5, an indicative notification of the use of the ECC system
19
5
10
15
20
25
30
35
40
common with a base point (G) to the second node 7. In turn, the second node 7 can be established 210 by sending a notification indicating an acknowledgment of the use of the common ECC system and base point (G).
Method 100 also includes the first node 3 that generates 120 a first pair of asymmetric cryptography that includes the first node master private key (V1C) and the first node master public key (P1C). This includes generating the first node master private key (V1C) according to, at least in part, a random integer in a permissible range specified in the common ECC system. This also includes determining the first node master public key (P1C) according to an elliptic curve point multiplication of the first node master private key (P1C) and the base point (G) according to the formula:
PiC = Vic XG {Equation 1)
Therefore, the first pair of asymmetric cryptography includes:
V1C: The first node master private key that is kept secret by the first node.
P1C: The first public master node public key.
The first node 3 can store the first node master private key (V1C) and the first node master public key (P1C) in a first data store 13 associated with the first node 3. For the sake of security, the master private key First node (V1C) can be stored in a secure portion of the first data store 13 to ensure that the key remains private.
Method 100 also includes sending 130 the first public master node key (P1C), in the communication network 5, to the second node 7, as shown in Figure 9. The second node 7 may, upon receiving 220 the public key First node master (P1C), store 230 the first node master public key (P1C) in a second data store 17 associated with the second node 7.
Similar to the first node 3, the method 200 of the second node 7 includes generating 240 a second pair of asymmetric cryptography that includes the second node master private key (V1S) and the second node master public key (P1S). The second node master private key (V1S) is also a random integer within the allowable range. In turn, the second node master public key (P1S) is determined by the following formula:
Pis = Vis XG {Equation 2)
Therefore, the second pair of asymmetric cryptography includes:
V1S: The second node master private key that is kept secret by the second node.
P1S: The second node master public key that is publicly known.
The second node 7 may store the second pair of asymmetric cryptography in the second data store 17. Method 200 further includes sending 250 the second node master public key (P1S) to the first node 3. In turn, the first node 3 it can receive 140 and store 150 the second node master public key (P1S).
It will be appreciated that, in some alternatives, the respective public master keys can be received and stored in a third data store 19 associated with the third node 9 (such as, for example, a trusted third party). This may include a third party that acts as a public directory, such as a certification authority. Therefore, in some examples, the first node master public key (P1C) can be requested and received by the second node 7 only when the determination of the common secret (SC) is required (and vice versa).
Registration stages may only need to occur once as an initial establishment.
Login and determination of the common secret by the first node 3
An example of determining a common secret (SC) will now be described with reference to Figure 10. The common secret (SC) can be used for a session, time, transaction, or other particular purpose between the first node 3 and the second node 7 and it may not be desirable, or safe, to use the same common secret (SC). Therefore, the common secret (SC) can be changed between different sessions, times, transactions, etc.
The following is provided for the illustration of the secure transmission technique described above.
Generation of a message (M) 310
5
10
15
20
25
30
35
In the present example, method 300 carried out by the first node 3 includes generating 310 a message (M). The message (M) can be random, pseudorandom, or user defined. In one example, the message (M) is based on Unix time and a nonce (an arbitrary value). For example, message (M) can be provided as:
Message (M) = UnixTilTLC + IIOIICC (Equation 3)
In some examples, the message (M) is arbitrary. However, it will be appreciated that the message (M) may have selective values (such as Unix Time, etc.) that may be useful in some applications.
Method 300 includes sending 315 the message (M), in the communication network 3, to the second node 7. The message (M) can be sent in an unsecured network since the message (M) does not include information on private keys .
Determination of a Generator Value (VG) 320
Method 300 also includes the step of determining 320 a Generator Value (VG) according to the message (M). In the present example, this includes determining a cryptographic hash of the message. An example of a cryptographic hash algorithm includes SHA-256 to create a 256-bit Generator Value (VG). That is to say:
VG = SHA-256 (M) {Equation 4)
It will be appreciated that other hash algorithms can be used. This may include other hash algorithms in the Hash Insurance Algorithms (SHA) family. Some particular examples include instances in the SHA-3 subset, including SHA3-224, SHA3-256, SHA3-384, SHA3-512, SHAKE128, SHAKE256. Other hash algorithms may include those in the Digest family of RACE Integrity Primitive Evaluation Messages (RIPEMD). A particular example may include RIPEMD-160. Other hash functions may include families based on the Zémor-Tillich hash function and hash functions based on knapsack.
Determination of a second private key of first node 330
Method 300 then includes step 330 of determining 330 the second first node private key (V2c) according to the second node master private key (V1C) and the Generator Value (VG). This can be based on a scalar sum of the first node master private key (V1C) and the Generator Value (VG) according to the following formula:
V2c = Vic + VG (Equation 5)
Therefore, the second private node of the first node (V2C) is not a random value but instead is derived, in a deterministic way, from the master private key of the first node. The corresponding public key in the cryptographic pair, namely the second first node public key (P2C), has the following relationship:
P2C = V2C XG
The substitution of V2C from Equation 5 in Equation 6 provides:
P2C = (Vic + VG) x G
(Equation 6) (Equation 7)
where the "+" operator refers to the scalar sum and the "x" operator refers to the elliptic curve point multiplication. Given that the elliptic curve cryptography algebra is distributive, Equation 7 can be expressed as:
P2C = Vic x G + VG x G
(Equation 8)
Finally, Equation 1 can be substituted in Equation 7 to provide:
P2C = Foot + VG x G
p2C = Foot + SHA-256 (M) x G
(Equation 9.1) (Equation 9.2)
5
10
15
20
25
30
35
40
45
In equations 8 to 9.2, the "+" operator refers to the sum of the elliptic curve point. Therefore, the second corresponding first node public key (P2C) may be derivable given the knowledge of the first node master public key (P1C) and the message (M). The second node 7 may have such knowledge to independently determine the second public first node key (P2C) as will be described in more detail below with respect to method 400.
Generation of a first signed message (MF1) according to the message and the second private key of first node 350
Method 300 also includes generating 350 a first signed message (MF1) according to the message (M) and the second private key of the first node (V2C) determined. The generation of a signed message includes applying a digital signature algorithm to digitally sign the message (M). In one example, this includes applying the second first node private key (V2C) to the message on an Elliptic Curve Digital Signature Algorithm (ECDSA) to obtain the first signed message (MF1). Examples of ECDSA include those based on ECC systems with secp256k1, secp256r1, secp384r1, se3cp521 r1.
The first signed message (MF1) can be verified with the second corresponding first node public key (P2C) in the second node 7. This verification of the first signed message (MF1) can be used by the second node 7 to authenticate the first node 3 , which will be described in method 400 below.
Determination of a second public key of second node 370 '
The first node 3 can then determine 370 a second second node public key (P2S). As described above, the second second node public key (P2S) can be based at least on the second node master public key (P1S) and the Generator Value (VG). In the present example, since the public key is determined 370 'as the private key with elliptic curve point multiplication with the base point (G), the second second node public key (P2S) can be expressed, similar to Equation 6, like:
P2S = V2S x G P2S = Pis + VG x G
(Equation 10.1) (Equation 10.2)
The mathematical proof for Equation 10.2 is the same as described above to derive Equation 9.1 for the second public key of the first node (P2C). It will be appreciated that the first node 3 can determine 370 the second public key of the second node independently of the second node 7.
Determination of common secret 380 in the first node 3
The first node 3 can then determine 380 the common secret (SC) according to the second private key of the first node (V2C) determined and the second public key of the second node (P2S) determined. The common secret (SC) can be determined by the first node 3 by the following formula:
S = V2C x P2S
(Equation 11)
Method 400 carried out on the second node 7
The corresponding method 400 carried out in the second node 7 will now be described. It will be appreciated that some of these steps are similar to those described above that have been carried out by the first node 3.
Method 400 includes receiving 410 the message (M), in the communication network 5, of the first node 3. This may include the message (M) sent by the first node 3 in step 315. The second node 7 then determines 420 a Generator Value (VG) according to the message (M). The step of determining 420 the Generator Value (VG) by the second node 7 is similar to the step 320 carried out by the first node described above. In the present example, the second node 7 carries out the present determination step 420 independently of the first node 3.
The next step includes determining 430 a second first node public key (P2C) according to the first node master public key (P1C) and the Generator Value (VG). In the present example, since the public key is determined 430 'as the private key with elliptic curve point multiplication with the base point (G), the second first node public key (P2C) can be expressed, similar to Equation 9, such as:
P: c = V2C x G (Equation 12.1)
5
10
15
20
25
30
35
P2C = Foot + VG x G (Equation 12.2)
The mathematical proof for Equations 12.1 and 12.2 is the same as that described above for Equations 10.1 and 10.2.
The second node 7 authenticates the first node 3
Method 400 may include steps carried out by the second node 7 to authenticate that the supposed first node 3 is the first node 3. As previously described, this includes receiving 440 the first signed message (MF1) of the first node 3. The Second node 7 can then validate 450 the signature in the first signed message (MF1) with the second public key of the first node (P2C) that has been determined in step 430.
The digital signature verification can be carried out according to an Elliptic Curve Digital Signature Algorithm (ECDSA) as described above. Importantly, the first signed message (MF1) that has been signed with the second private first node key (V2C) should only be correctly verified with the second corresponding public first node key (P2C), since V2C and P2C form a Cryptographic pair Since these keys are deterministic in the first node master private key (V1C) and the first node master public key (P1C) that have been generated in the registration of the first node 3, the verification of the first signed message (MF1) can be used as an authentication base that a supposed first node that sends the first signed message (MF1) is the same first node 3 during registration. Therefore, the second node 7 can also carry out the step of authenticating (460) the first node 3 according to the result of the validation (450) of the first signed message.
The second node 7 determines the common secret
Method 400 may also include the second node 7 which determines 470 a second private second node key (V2S) according to the second master master private key (V1S) and the Generator Value (VG). Similar to step 330 carried out by the first node 3, the second private key of the second node (V2S) can be based on a scalar sum of the master private key of the second node (V1S) and the Generator Value (VG) according to the following formulas:
V2S = Vis + VG (Equation 13.1)
V2s = Vis + SHA-256 (M) (Equation 13.2)
The second node 7 can then, independently of the first node 3, determine 480 the common secret (SC) according to the second second node private key (V2S) and the second first node public key (P2C) according to the following formula:
S = V2s x P2c
(Equation 14)
Common secret test (SC) determined by the first node 3 and second node 7
The common secret (SC) determined by the first node 3 is equal to the common secret (SC) determined in the second node 7. The mathematical proof that Equation 11 and Equation 14 provide the same common secret (SC) will now be described.
Returning to the common secret (SC) determined by the first node 3, Equation 10.1 can be substituted in Equation 11 as follows:
S = V2c x P2s S = V2c x (V2S x G)
s - (V2C X V2S) XG
(Equation 11) (Equation 15)
5
10
15
20
25
30
35
40
Returning to the common secret (SC) determined by the second node 7, Equation 12.1 can be substituted in Equation 14 as follows:
S = Vis x Pac S = V2Sx (V2C x G)
s = (V2S X V2C) XG
(Equation 14) (Equation 16)
Since ECC algebra is commutative, Equation 15 and Equation 16 are equivalent, since:
S = (V2c x V2s) x G - (V2S x V2c) x G (Equation 17)
The common secret (SC) and the secret key
The common secret (SC) can now be used as a secret key, or as the basis of a secret key in a symmetric key algorithm to protect communication between the first node 3 and second node 7.
The common secret (SC) can be in the form of an elliptic curve point (xs, ys). This can be converted into a standard key format by using publicly known standard functions agreed by nodes 3, 7. For example, the value xs can be a 256-bit integer that can be used as a key to AES256 encryption. It can also be converted to a 160-bit integer by using RIPEMD160 for applications that require such a length key.
The common secret (SC) can be determined as required. Importantly, the first node 3 does not need to store the common secret (SC) since it can be determined again according to the message (M). In some examples, the messages (M) used can be stored in a data store 13, 17, 19 (or another data store) without the same level of security as that required for master private keys. In some examples, the message (M) may be publicly available. However, according to some application, the common secret (SC) can be stored in the first data store (X) associated with the first node as long as the common secret (SC) is kept as secure as the first node master private key (V1C ).
Advantageously, this technique can be used to determine multiple common secrets that can correspond to multiple secure secret keys according to a pair of cryptography of a single master key.
Hierarchy of Generator Values (keys)
For example, a series of successive Generator Values (VGs) can be determined, where each successive VG can be determined according to the preceding Generator Value (VG). For example, instead of repeating steps 310 to 370 and 410 to 470 to generate successive single purpose keys, by prior agreement between the nodes, the previously used Generator Value (VG) can be reused as hash repeatedly by both parties to establish a hierarchy of Generator Values. In fact, the Generator Value, according to the hash of a message (M), can be a next generation message (M ') for the next Generator Value generation (VG'). This allows successive generations of shared secrets to be calculated without the need for additional transmissions of protocol establishment, in particular, the transmission of multiple messages for each generation of common secrets. The next-generation common secret (SC ') can be calculated as follows.
First, both the first node 3 and the second node 7 independently determine the next generation of the Generator Value (VG '). This is similar to steps 320 and 420, but adapted with the following formulas:
M '= SHA-256 (M) (Equation 18)
VG '= SHA-256 (M') (Equation 19.1)
VG '= SHA-256 (SHA-256 (M)) (Equation 19.2)
5
10
15
20
25
30
35
The first node 3 can then determine the next generation of the second second node public key (P2s') and the second first node private key (V2c) similar to steps 370 and 330 described above, but adapted with the following formulas :
P2S '= Pis + VG'xG V2C' = Vic + VG '
(Equation 20.1) (Equation 20.2)
The second node 7 can then determine the next generation of the second first node public key (P2c ') and the second second node private key (V2s') similar to steps 430 and 470 described above, but adapted with the following formulas:
Foot '= Foot + VG' XG (Equation 21.1)
V2S '= Vis + VG' (Equation 21.2)
The first node 3 and the second node 7 can then determine, each, the next-generation common secret (SC '). In particular, the first node 3 determines the next-generation common secret (SC ') with the formula:
SC = V2C 'x Pns' (Equation 22)
The second node 7 determines the next-generation common secret (SC ') with the formula:
SC '= V2S' x P2c '(Equation 23)
Additional generations (SC ", SC" ', etc.) can be calculated in the same way to create a string hierarchy. The present technique requires that both the first node 3 and the second node 7 track the original Message (M) or the Generator Value (VG) originally calculated, and whose node it relates to. Since this is publicly known information, there are no security issues regarding the retention of this information. Therefore, this information can be kept in "hash tables" (which link hash values to public keys) and distributed freely throughout network 5 (for example, through the use of Torrent). In addition, if an individual common secret (SC) in the hierarchy is ever compromised, it does not affect the security of other common secrets in the hierarchy as long as the private keys V1C, V1S remain secure.
Tree structure of the keys
Just as a string hierarchy (linear) as described above, a hierarchy can be created in the form of a tree structure. With a tree structure, a variety of keys for different purposes such as authentication keys, encryption keys, signature keys, payment keys, etc. they can be determined, whereby said keys are linked, all, to a single master key kept securely. This is best illustrated in Figure 12 showing a tree structure 901 with a variety of different keys. Each of these can be used to create a secret shared with another party. Tree branching can be achieved in several ways, three of which are described below.
(i) Master key generation
In the string hierarchy, each new "link" (Public / Private key pair) is created by adding a Message with repeated hash of multiplication to the original master key. For example, (only the private key of the first node 3 is shown for the sake of clarity):
V2c = Vic + SHA-256 (M) (Equation 24)
V2C = Vic + SHA-256 (SHA-256 (M)) (Equation 25)
5
10
15
20
25
30
35
40
45
V2c * = Vic + SHA-256 (SHA-256 (SHA-256 (M)))
(Equation 26)
... and so on.
In order to create a branch, any key can be used as a sub-master key. For example, V2c 'can be used as a sub-master key (V3C) by adding the hash to it as is done for the regular master key:
V3C = V2c + SHA-256 (M)
(Equation 27)
The submaster key (V3C) can have a next generation key (V3C '), for example:
V3C = W + SH A-256 (SH A-256 (M)) (Equation 28)
This provides a tree structure 903 through the use of the master key generation method as shown in Figure 13.
(ii) Logical Association
In the present method, all the nodes in the tree (public / private key pairs) are generated as a string (or in any other way) and the logical relationships between the nodes in the tree are maintained by a table in which each Node in the tree is simply associated with its parent node in the tree by using an indicator. Therefore, the indicator can be used to determine the relevant public / private key pairs to determine the common secret key (SC) for the session.
(iii) Multiplicity of Messages
New pairs of private / public keys can be generated by entering a new message at any point in the chain or tree. The message itself may be arbitrary or may carry some meaning or function (eg, it may relate to a "real" bank account number, etc.). It may be desirable that said new messages to form the new private / public key pairs be retained securely.
Illustrative Computer Agent for use with the invention
The present invention may use a computer agent or resource to carry out automatic aspects of the contract process. An example of an appropriate agent is provided below, although other implementations may be used.
The agent can work in conjunction with the blockchain, by using this as the non-erasable tape in the implementation of a Turing machine. This agent runs in parallel with the blockchain network, and monitors and manages the execution of a process (in a loop). The loop process is designed to perform a given task such as, for example, the automation of a process or control of a device or system. The present parallel resource monitors the state of the blockchain and can cause transactions to be written to the blockchain. In a sense, it uses the Block Chain as a non-erasable tape of the Turing Machine, with the following definitions and characteristics:
one. The Block Chain acts as the tape of the Turing Machine. Each transaction in the Blockchain represents a cell on the tape. This cell may contain symbols of a finite alphabet.
2. The head of the tape can read information about the blocks that have already been written in the Blockchain.
3. The head of the tape can write new blocks, which contain many transactions, until the end of the Blockchain. However, you cannot write in blocks that already exist. As such, the blockchain tape is non-erasable.
Four. The metadata for each transaction can be stored as part of a payment transaction to the hash of the multi-signature script (P2SH).
An important function of the agent is to act as an automatic entity that monitors the current state of the Blockchain. You can also receive a signal or input from any source outside the block. Depending on the status and / or an entry received from the Blockchain, the agent may carry out certain actions. The agent decides what action (s) will be carried out. These may or may not involve actions in the "real world" (namely, outside the block) and / or actions in the Blockchain (such as creating and spreading new transactions). The action that the agent performs can be activated by the status of the Blockchain. The agent can also
5
10
15
20
25
30
35
40
45
decide on the next set of transactions that will be disseminated to the Bitcoin network and that will subsequently be written in the Blockchain.
The agent's actions are executed in parallel and simultaneously to the Blockchain network (eg, Bitcoin). In one sense, this extends the function of the blockchain script (e.g., Bitcoin). The present continuous monitoring implements the "loop" control flow constructions making the combined system of combined agent and Block Chain system a complete Turing system.
The Turing Machine includes two batteries:
• Data stack: This is represented by the Blockchain as described above.
• Control stack: This is represented by the agent function. It stores information related to the repeat control flow function.
The separation of the control stack from the data stack provides the advantage of preventing infinite loops from occurring within the Bitcoin core, and thus mitigating denial of service attacks.
The agent manages and executes subroutines that can be repeated in a loop through any type of loop construction (eg, FOR-NEXT; REPEAT UNTIL; etc.). An illustrative embodiment described herein includes a process that uses an example of the "repeat" construction. The user can specify the index (i) and the limit (J). These represent the current iteration number (normally, it starts from 0) and the total number of iterations of the repeat loop respectively.
For each iteration:
one. The Index increases by 1. For the output condition, the iterations will stop when the index reaches the limit.
2. A block of code that contains a statement "if the condition then the action" (ICTA) is executed; The action can be any action on or off the blockchain.
3. A cryptographic hash of this subroutine is calculated. This can be stored in the Blockchain as part of a transaction. Since the hash is unique for each code, this will allow verification of what code has been used.
The loop structure includes a block of code. Each block of code contains a statement "If the condition then the action" (ICTA). This monitors the current status of the Blockchain for transactions that match the:
• Start or activation condition (eg when a particular date is reached).
• Repetition condition (namely, metadata or hash associated with the previous iteration).
• Stop condition (ie, last iteration of the loop).
The ICTA statement allows the agent to decide the next transaction to be made, based on the current state of the blockchain. Carrying out the next transaction involves spreading the transaction on the Bitcoin network and writing the new transaction in the Blockchain. This acts as a record that the present iteration has been executed. Once the transaction has been written in the Blockchain, the Administrator will later discover that the previous iteration has been executed and written in the Blockchain, and will execute the next iteration. The latter continues until the repeat loop leaves when the index (i) reaches the limit (J) specified in the code block.
Each transaction is stored in the blockchain in a way that can be reused. In a Bitcoin implementation, each signature in a transaction is appended with a SIGHASH flag. Said flag may assume different values, each of which indicates whether other parts of the transaction can be modified without the participation of the owner of said firm. A reusable transaction has the SIGHASH flag 'SigHash_AnyoneCanPay' on one of the transaction entries. This allows anyone to contribute to the transaction entries. This parameter allows the agent's ICTA function to be executed and repeated multiple times and with different inputs. The use of the function may be limited to authorized parties - for example, by copyright of the reusable transaction.
The "If condition" section of the ICTA code block can monitor any type of condition. This is similar to other programming languages (eg, C, C ++, Java) and is not limited to the information stored in the Blockchain. For example, you can monitor the date and time (that is, when a certain date and time is reached)
5
10
15
20
25
30
35
40
45
50
or monitor the weather (namely, when the temperature is below 10 ° C and when it is raining), monitor the conditions of a contract or a trust (namely, when company A buys company B).
The "Then the action" section of the ICTA code block can execute a number of actions. The invention is not limited with respect to the number or type of actions that can be taken. The action is not limited to a transaction in the Blockchain, although a transaction that contains metadata related to the action can be written to the Blockchain.
Metadata can be any way. However, in one embodiment, the metadata may store a hyperlink to a file that contains more data or instructions related to the action. Metadata can store a hyperlink to a hash table that contains more data or instructions related to the action along with a hash of the action that acts as the query key for the hash table.
The agent control stack can be implemented in a number of ways that are specific to the needs of each user. For example, the control loop repeat loop can be based on any Full Turing language. One possible language choice is the Forth-style stack-based language. An advantage of using such language is that it keeps the control stack consistent in the programming style with Bitcoin scripts that are already known and are widely used.
Use of the Alternate Stack of the Bitcoin Script as a Data Storage Space
The Bitcoin script contains commands, also called op codes, that allow users to move data in an alternative stack, known as the "alt stack".
The op codes are:
• OP_TOALTSTACK - which moves data from the top of the main stack to the top of the stack alt.
• OP_FROMALTSTACK - which moves data from the top of the alt stack to the top of the main stack.
This allows data from intermediate stages of calculations to be stored in the alt stack, similar to the "memory" function that allows data to be stored in the calculator. In one embodiment, the alt stack is used to configure bitcoin scripts to solve small calculation tasks and return the results in the calculation.
Use of a Code Record to Manage the Agent
The agent also manages a record of all the codes he owns and executes. This record is structured as a query table or dictionary that maps a specific key to a specific value. The key and value pair is represented by the hash of the code block (H1) and the IPv6 address from which the code is stored respectively. In order to retrieve the code block by using the H1 key, the query table is used to retrieve the associated value (this is the location where the code is stored) and, therefore, retrieves the source code. The implementation of the code registration may vary.
Transaction metadata of the agent code, and loop regeneration
The information required to regenerate the agent loop in a particular iteration is stored as metadata in the transaction recorded in the Blockchain.
In this way, a transaction in the blockchain stores or provides access to information about a given iteration of the loop that is running on the agent. Such information may include the values of variables associated with the loop such as index i, and any other necessary information such as values for parameters used in the code block or data related to the location that specify where access to additional information required.
The metadata itself is stored as part of a payment script to the hash of the multi-signature script (P2SH) in the transaction. The metadata recorded with the transaction also gives the ability to record an audit trail of how the code has been executed in the past.
There are several ways in which the agent can regenerate the repeat loop code block in each iteration. The code block can be preprogrammed in the agent itself, or it can be stored in a private or publicly available file, or stored as an entry in a private or public hash table file, or a combination of the above. The code block can be static with preprogrammed variables or it can be static but contain parameters that can be filled. The parameters can be unique values of any data format, or they can be small pieces of code, or combinations of the above. The parameters can be filled by retrieving them directly from the metadata in a transaction (e.g., bitcoin transaction) or from an external source such as a database of
5
10
15
20
25
30
internal data or a private / public file or hash table or any combination of the above. The indicators of the external source of parameter values can be stored in the metadata in a transaction.
The following steps provide an example of how the agent can regenerate a block of repeat loop code in the / th iteration. In the present example, the code record is a hash table whereby the hash values act as query keys for the table and are stored in metadata in transactions.
one. The agent monitors the Blockchain for transactions that contain hashes of the code block that match entries in the code record.
2. The agent finds a transaction that contains the corresponding hash (H1).
3. The agent reads 'Metadata-CodeHash', obtains the CodeHash field to obtain H1 and uses it to retrieve the code (C1). If RIPEMD-160 (SHA256 (C1)) is equal to H1, the code has not been changed and it is safe to proceed to the next stage.
Four. The agent reads 'Metadata-CodeHash' that stores index I, and regenerates the code in the ith iteration. In other words, the loop is "reloaded" in the appropriate iteration.
5. The signature of the User is included in the P2SH command to verify the origin of the metadata.
6. The agent reads 'Metadata-OutputHash' and 'Metadata-OutputPointer' to retrieve the output of the previous stages, if such data is required for said iteration of the loop.
It should be noted that the above-mentioned embodiments illustrate, rather than limit, the invention, and that those skilled in the art may design many alternative embodiments without departing from the scope of the invention as defined by the appended claims. In the claims, any reference sign placed in parentheses shall not be construed as one that limits the claims. The term "comprising" and "comprising", and the like, do not exclude the presence of elements or stages other than those listed in a claim or in the specification as a whole. Here, "comprises (n)" means "includes (n) or consists (n) of" and "which comprises (n)" means "which includes (n) or consists (n) of". The singular reference of an element does not exclude the plural reference of said elements and vice versa. The invention can be implemented by means of hardware comprising several different elements, and by means of a properly programmed computer. In a device claim that lists several means, several of said means can be realized by the single hardware article. The mere fact that certain measures are included in mutually different dependent claims does not indicate that a combination of said measures cannot be used in order to obtain an advantage.
26 sheets
Sheet 1 Sheet 2 Sheet 3 Sheet 4 Sheet 5 Sheet 6 Sheet 7 Sheet 8 Sheet 9 Sheet 10 Sheet 11 Sheet 12 Sheet 13 Sheet 14 Sheet 15 Sheet 16 Sheet 17 Sheet 18 Sheet 19 Sheet 20 Sheet 21 Sheet 22 Sheet 23 Sheet 24 Sheet 25 Sheet 26
645 members in 28 offices
Priority claims34
| Document | Office | Kind | Date |
|---|---|---|---|
| 201603114 | United Kingdom | A | |
| 201603114 | United Kingdom | A | |
| 201603114 | United Kingdom | – | |
| 201603117 | United Kingdom | A | |
| 201603117 | United Kingdom | A | |
| 201603117 | United Kingdom | – | |
| 201603123 | United Kingdom | A | |
| 201603123 | United Kingdom | A | |
| 201603123 | United Kingdom | – | |
| 201603125 | United Kingdom | A | |
| 201603125 | United Kingdom | A | |
| 201603125 | United Kingdom | – | |
| 201605571 | United Kingdom | A | |
| 201605571 | United Kingdom | A | |
| 201605571 | United Kingdom | – | |
| 201619301 | United Kingdom | A | |
| 201619301 | United Kingdom | A | |
| 201619301 | United Kingdom | – | |
| 2017050865 | International Bureau of the World Intellectual Property Organization (WIPO) | W | |
| 2017050865 | International Bureau of the World Intellectual Property Organization (WIPO) | W | |
| 201603114 | – | – | – |
| 201603117 | – | – | – |
| 201603123 | – | – | – |
| 201603125 | – | – | – |
| 201605571 | – | – | – |
| 201619301 | – | – | – |
| GB20160003114 | – | – | – |
| GB20160003117 | – | – | – |
| GB20160003123 | – | – | – |
| GB20160003125 | – | – | – |
| GB20160005571 | – | – | – |
| GB20160019301 | – | – | – |
| PCTIB2017050865 | – | – | – |
| WO2017IB50865 | – | – | – |
Members645
| Document | Office | Kind | |
|---|---|---|---|
| GB201603112D0 | United Kingdom | D0 | |
| GB201603114D0 | United Kingdom | D0 | |
| GB201603117D0 | United Kingdom | D0 | |
| GB201603122D0 | United Kingdom | D0 | |
| GB201603123D0 | United Kingdom | D0 | |
| GB201603125D0 | United Kingdom | D0 | |
| GB201604225D0 | United Kingdom | D0 | |
| GB201604244D0 | United Kingdom | D0 | |
| GB201604493D0 | United Kingdom | D0 | |
| GB201604495D0 | United Kingdom | D0 | |
| GB201604497D0 | United Kingdom | D0 | |
| GB201604498D0 | United Kingdom | D0 | |
| GB201605026D0 | United Kingdom | D0 | |
| GB201607484D0 | United Kingdom | D0 | |
| CA3009731A1 | Canada | A1 | |
| CA3010116A1 | Canada | A1 | |
| CA3013173A1 | Canada | A1 | |
| CA3013180A1 | Canada | A1 | |
| CA3013182A1 | Canada | A1 | |
| CA3013185A1 | Canada | A1 | |
| CA3014726A1 | Canada | A1 | |
| CA3014727A1 | Canada | A1 | |
| CA3014737A1 | Canada | A1 | |
| CA3014748A1 | Canada | A1 | |
| CA3014752A1 | Canada | A1 | |
| CA3015569A1 | Canada | A1 | |
| CA3227439A1 | Canada | A1 | |
| WO2017145002A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145003A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145004A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145005A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145006A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145007A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145008A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145009A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145010A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145016A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145017A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145018A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145019A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145020A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145021A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145047A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145048A1 | World Intellectual Property Organization (WIPO) | A1 | |
| WO2017145049A1 | World Intellectual Property Organization (WIPO) | A1 | |
| TW201732666A | Taiwan Province of China | A | |
| TW201732700A | Taiwan Province of China | A | |
| TW201732705A | Taiwan Province of China | A | |
| TW201732706A | Taiwan Province of China | A | |
| TW201733302A | Taiwan Province of China | A | |
| TW201733303A | Taiwan Province of China | A | |
| TW201733304A | Taiwan Province of China | A | |
| EP3257002A1 | European Patent Office (EPO) | A1 | |
| EP3257006A1 | European Patent Office (EPO) | A1 | |
| EP3257191A1 | European Patent Office (EPO) | A1 | |
| EP3259724A1 | European Patent Office (EPO) | A1 | |
| EP3259725A1 | European Patent Office (EPO) | A1 | |
| EP3268914A1 | European Patent Office (EPO) | A1 | |
| EP3257191B1 | European Patent Office (EPO) | B1 | |
| GB201806517D0 | United Kingdom | D0 | |
| GB201806520D0 | United Kingdom | D0 | |
| GB201806522D0 | United Kingdom | D0 | |
| GB201806524D0 | United Kingdom | D0 | |
| GB201806525D0 | United Kingdom | D0 | |
| GB201806526D0 | United Kingdom | D0 | |
| GB201806694D0 | United Kingdom | D0 | |
| GB201806698D0 | United Kingdom | D0 | |
| GB201806700D0 | United Kingdom | D0 | |
| GB201806701D0 | United Kingdom | D0 | |
| GB201806706D0 | United Kingdom | D0 | |
| GB201806719D0 | United Kingdom | D0 | |
| GB201806739D0 | United Kingdom | D0 | |
| GB201806740D0 | United Kingdom | D0 | |
| GB201806741D0 | United Kingdom | D0 | |
| GB201806742D0 | United Kingdom | D0 | |
| EP3268914B1 | European Patent Office (EPO) | B1 | |
| GB2558484A | United Kingdom | A | |
| AU2017223129A1 | Australia | A1 | |
| CN108292402A | China | A | |
| DK3257191T3 | Denmark | T3 | |
| SG11201805472RA | Singapore | A | |
| CN108352015A | China | A | |
| AU2017223133A1 | Australia | A1 | |
| CO2018008191A2 | Colombia | A2 | |
| EP3364598A1 | European Patent Office (EPO) | A1 | |
| AU2017222421A1 | Australia | A1 | |
| AU2017222471A1 | Australia | A1 | |
| AU2017223126A1 | Australia | A1 | |
| AU2017223127A1 | Australia | A1 | |
| AU2017223138A1 | Australia | A1 | |
| AU2017223158A1 | Australia | A1 | |
| ZA201805019A0 | South Africa | A0 | |
| AU2017222468A1 | Australia | A1 | |
| AU2017222469A1 | Australia | A1 | |
| AU2017222470A1 | Australia | A1 | |
| AU2017223136A1 | Australia | A1 | |
| SG10201805995VA | Singapore | A | |
| GB201811774D0 | United Kingdom | D0 | |
| GB2560274A | United Kingdom | A | |
| ES2680851T3This record | Spain | T3 |
Numbers
- Publication
- 2680851
- Publication, DOCDB
- 2680851
- Publication, EPODOC
- ES2680851T
- Application
- 17708587
- Application, DOCDB
- 17708587
- Application, EPODOC
- ES20170708587T
Titles2
- Spanish
- Registro y método de gestión automática para contratos inteligentes ejecutados por cadena de bloques
- English
- Registration and automatic management method for smart contracts executed by blockchain
Classification
- CPC, 22
- G06Q20/3829
- G06Q20/0655
- G06Q20/367
- G06Q20/02
- H04L9/0836
- H04L9/0891
- H04L9/3066
- H04L9/321
- H04L9/3236
- H04L9/3247
- H04L2209/56
- G06Q2220/12
- G06Q20/3678
- G06Q20/3827
- G06Q2220/00
- H04L9/50
- G06Q30/018
- G06Q20/389
- H04L9/0637
- H04L9/3242
- G06Q30/06
- H04L9/0643
- IPC, 4
- H04L9 00
- G06Q30 06
- G06Q20 36
- G06Q20 02