Communication protocol using block chain transaction

Abstract

To provide a method and a program for granting a requester permission to participate in a first network.SOLUTION: In a system 500, a first network 501 comprises: a set of bridge nodes 503; and a set of devices 502 that can be controlled by one or a plurality out of the set of bridge nodes. Each bridge node is also a node of each block chain network 106. A method generates a first block chain transaction including an input that is executed by a registration agency and includes a signature linked to a first public key of the registration agency and a first output including a first certificate that has an identifier allocated by a requester, and transmits the first block chain transaction to a block chain network for inclusion in a block chain.SELECTED DRAWING: Figure 5

Description

[Technical field]

[0001] The present disclosure relates to a method for granting permission to a requesting entity to join a network, for example, for the requesting entity to access the network. [Background technology]

[0002] Blockchain refers to a form of distributed data structure in which a duplicate copy of the blockchain is maintained at each of multiple nodes in a peer-to-peer (P2P) network. The blockchain includes a chain of data blocks, each block containing one or more transactions. Each transaction may point to a preceding transaction in a sequence that may span one or more blocks. Transactions may be submitted to the network for inclusion in a new block by a process known as "mining," which involves each of multiple mining nodes competing to perform a "proof of work," i.e., solving a cryptographic puzzle based on a pool of pending transactions waiting to be included in a block.

[0003] Traditionally, transactions in a blockchain are used to convey digital assets, i.e. data that acts as a store of value. However, blockchains can also be leveraged to layer additional functionality on top of the blockchain. For example, blockchain protocols may allow for the storage of additional user data in the output of a transaction. Modern blockchains increase the maximum amount of data that can be stored within a single transaction, allowing for more complex data to be incorporated. For example, this can be used to store electronic documents or even audio or video data on the blockchain.

[0004] Each node in the network can take on any one, two, or all three roles: forwarding, mining, and storing. Forwarding nodes propagate transactions across the nodes of the network. Mining nodes perform the mining of transactions into blocks. Storage nodes each store their own copy of the mined blocks of the blockchain. To have a transaction recorded in the blockchain, a party sends the transaction to one of the nodes of the network to be propagated. Mining nodes that receive a transaction may compete to mine the transaction into a new block. Each node is configured to respect the same node protocol, which includes one or more conditions for a transaction to be valid. Invalid transactions are neither propagated nor mined into a block. Assuming the transaction is validated and thereby accepted onto the blockchain, the additional user data thus remains stored in each of the nodes in the P2P network as an immutable public record. Summary of the Invention

[0005] Internet of Things (IoT) technology enables a network of physical devices to monitor events and exchange data without human intervention. The motivation for the development of IoT technology is the need for real-time data collection and automated control mechanisms to replace traditional monitoring and control methods across a wide range of industries. IoT systems generate large amounts of data and rely on systems with network scalability, strong cybersecurity, reliable connectivity, and minimal network latency.

[0006] Currently, a centralized architecture model is widely used to authenticate, authorize, and connect nodes in an IoT network. Such a model is vulnerable to attacks and acts as a single point of failure. If a centralized system is compromised, permissions to access the IoT network can be given to malicious devices and / or removed from existing devices. If a malicious device is given access to the IoT network, it can, for example, obtain sensitive data or disrupt the network.

[0007] Peer-to-peer (P2P) architectures offer a more secure and efficient solution compared to centralized architectures, whereby neighbors interact with each other directly without the use of centralized nodes or agents between them. Blockchain technology is the basis for secure P2P communication and is expected to revolutionize the development of IoT systems. However, if next-generation blockchain-based systems for IoT devices are to be realized, blockchain-based control methods for IoT will need to overcome challenges inherent to open systems. These include data privacy and device protection / control mechanisms that may not be inherent to the blockchain itself.

[0008] According to one aspect disclosed herein, a computer-implemented method is presented for granting permission to a requester to join a first network, the first network including a set of bridge nodes and a set of devices controllable by one or more of the set of bridge nodes, each bridge node also being a respective node of the blockchain network, the method being performed by a registrar and including generating a first blockchain transaction, where the first blockchain transaction includes an input including a signature linked to a first public key of the registrar and a first output including a first certificate, the first certificate including an identifier assigned to the requester, and transmitting the first blockchain transaction to the blockchain network for inclusion in the blockchain.

[0009] The first network (e.g., an IoT network) includes one or more bridge nodes and one or more devices that can be controlled by one or more of the bridge nodes. The bridge nodes are also nodes of the blockchain network. That is, they are part of the IoT network and the blockchain network in the sense that they can connect to both the IoT network (e.g., to communicate with other network nodes and devices) and the blockchain network (e.g., to send transactions to the blockchain and to identify and retrieve transactions recorded in the blockchain). These nodes act as a gateway or bridge between the first network and the blockchain network. They do not have to also serve as mining nodes, forwarding nodes, or storage nodes of the blockchain network, although this is not excluded. In some examples, one or more of the devices of the first network can also be nodes of the blockchain network.

[0010] A registrar (which may or may not be a bridge node of an IoT network) is a node of a blockchain network. That is, the registrar is connected to the blockchain and configured to send transactions to the blockchain network. The registrar is responsible for granting certificates to requesters (requesting entities), and these certificates authorize the requesters to join the network. Now, once a requester joins the network, the requester can perform tasks such as, for example, communicating with other nodes and / or devices connected to the first network. The registrar is a trusted party that can verify the credentials of new devices and issue digital certificates. The registrar acts as a barrier to entry, allowing or denying new devices onto the IoT network.

[0011] The first blockchain transaction includes, in the output of the transaction, a certificate issued to the requester. The certificate includes an identifier ("device ID") unique to the requester. The device ID can be a pseudo-random byte string. The registration authority broadcasts the transaction (and therefore the certificate) to the blockchain network. The first blockchain transaction is linked to the registration authority by the signature in the first input. The signature is linked to the registration authority's public key. In other words, the signature is generated based on a private key corresponding to the registration authority's public key. Since only the registration authority has knowledge of the private key, only the registration authority can sign the transaction with its signature. In other words, the certificate cannot be forged. Thus, the certificate can only be granted to authentic entities. When the requester, having received the issuance of the certificate, communicates with other nodes or devices of the first network, those nodes and devices can check whether the requester has been issued a certificate and therefore whether the requester is an authentic entity.

[0012] In some embodiments, the requester is also a node of the blockchain network. In that case, the certificate may include a public key assigned to the requesting node. In other words, the public key is a certified public key. If the requesting node uses its certified public key or a key derived from it to communicate with other nodes (e.g., send transactions to the node or blockchain signed with one of the above public keys), the other nodes can be confident that the node sending those transactions is an authentic node.

[0013] According to another aspect disclosed herein, there is provided a computer-implemented method for requesting permission to join a first network, the first network including a set of bridge nodes and a set of devices controllable by one or more of the set of bridge nodes, each bridge node also being a respective node of a blockchain network, the method being performed by a requester and including sending a request to join the first network to a registration authority and obtaining a first certificate, where the certificate is issued by the registration authority and includes an identifier assigned to the requester. [Brief description of the drawings]

[0014] To aid in the understanding of embodiments of the present disclosure and to show how such embodiments may be carried into effect, reference is made, by way of example only, to the accompanying drawings, in which: [Figure 1] FIG. 1 is a schematic block diagram of a system for implementing a blockchain. [Diagram 2] Figure 2 shows a schematic of some examples of transactions that may be recorded on a blockchain. [Diagram 3] FIG. 3 is a schematic block diagram of another system for implementing a blockchain. [Figure 4] FIG. 4 is a schematic block diagram of a portion of the node software for processing transactions according to the output-based model node protocol. [Diagram 5] Figure 5 illustrates diagrammatically the overlap between IoT networks and blockchain networks. [Figure 6] FIG. 6 illustrates a schematic of a hierarchical network topology. [Figure 7a] FIG. 7a illustrates a schematic of a partial command transaction. [Figure 7b] FIG. 7b shows a schematic of a complete command transaction. [Figure 8a] FIG. 8a illustrates diagrammatically an alternative partial transaction. [Figure 8b] FIG. 8b shows an alternative complete transaction diagrammatically. [Figure 9] FIG. 9 illustrates generally the command request and response cycle. [Figure 10a] FIG. 10a illustrates a schematic of a partial command transaction sent from a server node to a slave node. [Figure 10b] FIG. 10b shows a schematic of a complete command transaction sent from a server node to a slave node. [Figure 11a] FIG. 11a illustrates a schematic of a command request transaction. [Figure 11b] FIG. 11b illustrates a schematic of a command approval transaction. [Figure 12a] FIG. 12a illustrates a schematic of an encrypted partial command transaction. [Figure 12b] FIG. 12b shows a schematic of a complete encrypted command transaction. [Figure 13] FIG. 13 shows an exemplary command data format. [Figure 14] FIG. 14 illustrates a schematic of an exemplary peer-to-peer printing system. [Figure 15a] FIG. 15a illustrates generally an exemplary transaction for use in a peer-to-peer printing system. [Figure 15b]FIG. 15b illustrates generally an exemplary transaction for use in a peer-to-peer printing system. [Figure 15c] FIG. 15c illustrates generally an exemplary transaction for use in a peer-to-peer printing system. [Figure 16a] FIG. 16a illustrates a schematic of a certificate transaction and an exemplary certificate format. [Figure 16b] FIG. 16b illustrates a schematic of a certificate transaction and an exemplary certificate format. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0015] Exemplary System Overview FIG. 1 illustrates an exemplary system 100 for implementing a blockchain 150 in general. The system 100 includes a packet-switched network 101, which is typically a wide area internetwork such as the Internet. The packet-switched network 101 includes a plurality of nodes 104 configured to form a peer-to-peer (P2P) overlay network 106 within the packet-switched network 101. Each node 104 includes a peer's computing equipment, with different ones of the nodes 104 belonging to different peers. Each node 104 includes a processing unit comprising one or more processors, e.g., one or more central processing units (CPUs), accelerator processors, application specific processors and / or field programmable gate arrays (FPGAs). Each node also includes a memory, i.e., computer-readable storage in the form of one or more non-transitory computer-readable media. The memory may include one or more memory units using one or more memory media, e.g., magnetic media such as hard disks, electronic media such as solid-state drives (SSDs), flash memories or EEPROMs, and / or optical media such as optical disk drives.

[0016] The blockchain 150 includes a chain of data blocks 151, with a respective copy of the blockchain 150 maintained at each of multiple nodes in the P2P network 160. Each block 151 in the chain includes one or more transactions 152, where a transaction in this context refers to a type of data structure. The nature of the data structure depends on the type of transaction protocol used as part of the transaction model or scheme. A given blockchain typically uses one particular transaction protocol throughout. In one common type of transaction protocol, the data structure of each transaction 152 includes at least one input and at least one output. Each output specifies an amount that represents the amount of digital assets belonging to a user 103 that the output is cryptographically locked (requiring that user's signature to be unlocked and thereby redeemed or used). Each input points to the output of a preceding transaction 152, thereby linking the transactions.

[0017] At least some of the nodes 104 assume the role of forwarding nodes 104F, which forward and thereby propagate transactions 152. At least some of the nodes 104 assume the role of miners 104M, which mine blocks 151. At least some of the nodes 104 assume the role of storage nodes 104S (sometimes referred to as "full copy" nodes), each of which stores a respective copy of the same blockchain 150 in its respective memory. Each miner node 104M also maintains a pool 154 of transactions 152 waiting to be mined into blocks 151. A given node 104 may be a forwarding node 104, a miner 104M, a storage node 104S, or any combination of two or all of these.

[0018] For a given current transaction 152j, the input (or each input) contains a pointer that references the output of a preceding transaction 152i in the sequence of transactions, specifying that this output should be redeemed or "used" in the current transaction 152j. In general, the preceding transaction can be any transaction in the pool 154 or any block 151. Although the preceding transaction 152i must exist and be validated for the current transaction to be valid, the preceding transaction 152i does not necessarily have to exist when the current transaction 152j is created or sent to the network 106. Thus, "preceding" in this specification refers to something that precedes in the logical sequence linked by the pointer, and not necessarily to the time of creation or transmission in the time sequence, and therefore does not necessarily exclude transactions 152i, 152j from being created or transmitted out of order (see the discussion below regarding orphan transactions). The preceding transaction 152i is also called the antecedent transaction or a predecessor transaction.

[0019] The input of the current transaction 152j also includes the signature of the user 103a to which the output of the preceding transaction 152i is locked. The output of the current transaction 152j can then be cryptographically locked to the new user 103b. Thus, the current transaction 152j can transfer the amount defined in the input of the preceding transaction 152i to the new user 103b as defined in the output of the current transaction 152j. In some cases, the transaction 152j can have multiple outputs to divide the input amount among multiple users (one of which can be the original user 103a to give the change). In some cases, the transaction can also have multiple inputs to pool amounts from multiple outputs of one or more preceding transactions and redistribute them to one or more outputs of the current transaction.

[0020] This may be referred to as an "output-based" transaction protocol, and sometimes as an unspent transaction output (UTXO) type protocol (where the outputs are referred to as UTXOs). A user's total balance is not defined by any one number stored in the blockchain, instead, the user needs a special "wallet" application 105 to collate the values ​​of all of that user's UTXOs, which are scattered across many different transactions 152 in the blockchain 151.

[0021] An alternative type of transaction protocol may be referred to as an "account-based" protocol, as part of an account-based transaction model. In the account-based case, each transaction defines the amount to be transferred by referencing the absolute account balance, not by referencing the UTXO of a preceding transaction in a sequence of past transactions. The current state of every account is stored and constantly updated by miners separately from the blockchain. In such a system, transactions are ordered using the running transaction tally (also called the "position") of the account. This value is signed by the sender as part of its cryptographic signature and hashed as part of the transaction reference calculation. In addition, an optional data field in the transaction may also be signed. This data field may point to a previous transaction, for example if a previous transaction ID is included in the data field.

[0022] When a user 103 wants to make a new transaction 152j, using any type of transaction protocol, he sends the new transaction from his computer terminal 102 to one of the nodes 104 of the P2P network 106 (which today is typically a server or a data center, but in principle could be other user terminals). The nodes 104 check that the transaction is valid according to a node protocol applied at each of the nodes 104. The details of the node protocol correspond to the type of transaction protocol used in the blockchain 150 and together form a transaction model. The node protocol typically requires the nodes 104 to check that the cryptographic signature in the new transaction 152j matches an expected signature that depends on the previous transaction 152i in the ordered sequence of transactions 152. In the output-based case, this may include checking whether the cryptographic signature of the user included in the input of the new transaction 152j matches a condition defined in the output of the previous transaction 152i used by the new transaction, which typically includes at least checking that the cryptographic signature in the input of the new transaction 152j unlocks the output of the previous transaction 152i to which the input of the new transaction points. In some transaction protocols, the condition may be defined at least in part by a custom script included in the input and / or output. Alternatively, it may be fixed solely by the node protocol, or by a combination of these. In any case, if the new transaction 152j is valid, the current node forwards it to one or more other of the nodes 104 in the P2P network 106. At least some of these nodes 104 also act as forwarding nodes 104F, applying the same tests according to the same node protocol, and thus forwarding the new transaction 152j to one or more further nodes 104, and so on.In this manner, the new transaction is propagated throughout the network of nodes 104.

[0023] In an output-based model, the definition of whether a given output (e.g., UTXO) has been spent is whether it has been validly redeemed by the input of another forward transaction 152j according to the node protocol. Another condition for a transaction to be valid is that the output of the preceding transition 152i that it attempts to spend or redeem has not yet been spent / redeemed by another valid transaction. Similarly, if it is not valid, the transaction 152j is not propagated or recorded in the blockchain. This prevents double-spending, where a spender attempts to spend the same transaction output multiple times. On the other hand, an account-based model prevents double-spending by maintaining an account balance. Again, since the transaction order is defined, the account balance is always in a single defined state.

[0024] In addition to validation, at least some of the nodes 104M also compete to be the first to create a block of transactions in a process known as mining, which is backed by "proof of work." At the mining nodes 104M, new transactions are added to a pool of valid transactions that have not yet appeared in a block. Miners then compete to assemble a new valid block 151 of transactions 152 from the pool of transactions 154 by attempting to solve a cryptographic puzzle. Typically, this involves searching for a "nonce" value such that when the nonce is concatenated with the pool of transactions 154 and hashed, the output of the hash satisfies a predefined condition. For example, the predefined condition may be that the output of the hash has a certain predefined number of leading zeros. A property of a hash function is that it has an unpredictable output for its input. This search therefore consumes a significant amount of processing resources at each node 104M trying to solve the puzzle, since it can only be performed in a brute force manner.

[0025] The first miner node 104M to solve the puzzle publishes it to the network 106, providing a proof of its solution that can be easily checked later by other nodes 104 in the network (given the solution to the hash, it is easy to check that the output of the hash satisfies the condition). The pool of transactions 154 for which the winner solved the puzzle then becomes recorded as a new block 151 in the blockchain 150 by at least some of the nodes 104 acting as storage nodes 104S, based on checking the winner's published solution at each such node. A block pointer 155 is also assigned to the new block 151n that points to the previously created block 151n-1 in the chain. Proof of work helps reduce the risk of double spends, since it takes a lot of effort to create a new block 151, and since blocks containing double spends are likely to be rejected by other nodes 104, mining nodes 104M are incentivized to not include double spends in their blocks. Once created, blocks 151 cannot be modified because they are known and maintained at each of the storage nodes 104S in the P2P network 106 according to the same protocol. Block pointers 155 also impose a sequential order on the blocks 151. As transactions 152 are recorded in ordered blocks at each storage node 104S in the P2P network 106, this provides an immutable public ledger of transactions.

[0026] Note that different miners 104M competing to solve the puzzle at any given time can do so based on different snapshots of the unmined transaction pool 154 at any given time, depending on when they started searching for a solution. Whoever solves their respective puzzle first defines which transactions 152 will be included in the next new block 151n, and the current pool of unmined transactions 154 is updated. Miners 104M then continue competing to create blocks from the newly defined unprocessed pool 154, and so on. There are also protocols to resolve any "forks" that may occur if two miners 104M solve the puzzle within a very short time of each other, causing conflicting views of the blockchain to propagate. In essence, whichever prong of the fork grows the longest will be the final blockchain 150.

[0027] In most blockchains, the winning miner 104M is automatically rewarded with a special type of new transaction that suddenly creates a new amount of digital assets (as opposed to a regular transaction that transfers an amount of digital assets from one user to another). Thus, the winning node is said to have "mined" an amount of digital assets. This special type of transaction is sometimes referred to as a "generating" transaction. It automatically forms part of the new block 151n. This reward incentivizes the miner 104M to participate in the proof-of-work competition. Often, a regular (non-generating) transaction 152 also specifies an additional transaction fee in one of its outputs to further reward the winning miner 104M who created the block 151n in which the transaction was included.

[0028] Due to the computational resources involved in mining, typically at least each of the miner nodes 104M takes the form of a server including one or more physical server units or takes the form of an entire data center. Each forwarding node 104M and / or storage node 104S may also take the form of a server or a data center. However, in principle, any given node 104 can take the form of a user terminal or a group of user terminals networked together.

[0029] The memory of each node 104 stores software configured to execute on the processing unit of the node 104 to perform its respective one or more roles and to process transactions 152 in accordance with the node protocol. It will be understood that any action attributed to a node 104 herein may be performed by software executing on the processing unit of the respective computing device. Additionally, the term "blockchain" as used herein is a general term generally referring to a type of technology and is not limited to any particular proprietary blockchain, protocol or service.

[0030] Also connected to the network 101 are computer equipment 102 of each of a number of parties 103 acting as consuming users. They act as payers and payees in transactions, but do not necessarily participate in mining or propagating transactions on behalf of other parties. They do not necessarily execute the mining protocol. Two parties 103 and their respective equipment 102 are shown for illustrative purposes: a first party 103a and its respective computer equipment 102a, and a second party 103b and its respective computer equipment 102b. It will be understood that many more such parties 103 and their respective computer equipment 102 may exist and participate in the system, but for convenience they are not shown. Each party 103 may be an individual or an organization. Purely by way of example, the first party 103a is referred to herein as Alice and the second party 103b is referred to as Bob, but it will be understood that this is not limiting and that any reference herein to Alice or Bob may be replaced with "first party" and "second party", respectively.

[0031] The computer equipment 102 of each party 103 includes a respective processing device including one or more processors, e.g., one or more CPUs, GPUs, other accelerator processors, application specific processors, and / or FPGAs. The computer equipment 102 of each party 103 includes memory, i.e., computer readable storage in the form of one or more non-transitory computer readable media. This memory may include one or more memory units using one or more memory media, e.g., magnetic media such as hard disks, electronic media such as SSDs, flash memories or EEPROMs, and / or optical media such as optical disk drives. The memory on the computer equipment 102 of each party 103 stores software including a respective instance of at least one client application 105 configured to execute on the processing device. It will be understood that any action attributed to a given party 103 in this specification may be performed using software executed on the processing device of the respective computer equipment 102. The computer equipment 102 of each party 103 includes at least one user terminal, e.g., a desktop or laptop computer, a tablet, a smartphone, or a wearable device such as a smart watch. The computing equipment 102 of a given party 103 may also include one or more other networked resources, such as cloud computing resources, accessed via a user terminal.

[0032] The client application or software 105 may initially be provided to the computing equipment 102 of any given party 103 on one or more suitable computer-readable storage media, for example downloaded from a server or provided on a removable storage device such as a removable SSD, a flash memory key, a removable EEPROM, a removable magnetic disk drive, a magnetic floppy disk or tape, an optical disk such as a CD or DVD ROM, or a removable optical drive.

[0033] The client application 105 has at least a "wallet" functionality. It has two main functions. One of these is to allow each user party 103 to create, sign and send transactions 152 that are propagated throughout the network of nodes 104 and thereby included in the blockchain 150. The other is to report to each party the amount of digital assets that it currently owns. In an output-based system, this second function involves reconciling the amounts defined in the outputs of the various transactions 152 scattered throughout the blockchain 150 that belong to that party.

[0034] An instance of the client application 105 on each computing device 102 is operatively coupled to at least one of the forwarding nodes 104F of the P2P network 106. This allows the wallet function of the client 105 to send transactions 152 to the network 106. The client 105 can also contact one, some, or all of the storage nodes 104 to query the blockchain 150 for any transactions in which the respective party 103 is a recipient (or, in an embodiment, actually inspect the transactions of other parties in the blockchain 150, since the blockchain 150 is a public facility that provides trust in transactions in part through its public visibility). The wallet function on each computing device 102 is configured to formulate and send transactions 152 according to a transaction protocol. Each node 104 runs software configured to validate transactions 152 according to the node protocol and, in the case of a forwarding node 104F, to forward the transactions 152 for propagation throughout the network 106. The transaction protocol and the node protocol correspond to each other, and a given transaction protocol proceeds with a given node protocol, and together they implement a given transaction model. The same transaction protocol is used for all transactions 152 in the blockchain 150 (although the transaction protocol may allow different subtypes of transactions therein). The same node protocol is used by all nodes 104 in the network 106 (although it may process different subtypes of transactions differently according to rules defined for the subtype, and different nodes may take on different roles and thus implement different corresponding aspects of the protocol).

[0035] As mentioned, the blockchain 150 includes a chain of blocks 151, each of which includes a set of one or more transactions 152 created by a proof-of-work process as described above. Each block 151 also includes a block pointer 155 that points to a previously created block 151 in the chain to define a sequential order to the blocks 151. The blockchain 150 also includes a pool of valid transactions 154 waiting to be included in a new block by the proof-of-work process. Each transaction 152 (other than the originating transaction) includes a pointer back to a previous transaction to define an order to the sequence of transactions (note: it is possible for a sequence of transactions 152 to branch). The chain of blocks 151 goes all the way back to the originating block (Gb) 153, which was the first block in the chain. One or more original transactions 152 earlier in the chain 150 pointed to the originating block 153, not to a preceding transaction.

[0036] When a given party 103, for example Alice, wishes to send a new transaction 152j to be included in the blockchain 150, Alice formulates the new transaction (using a wallet function in Alice's client application 105) according to the associated transaction protocol. Alice then sends the transaction 152 from her client application 105 to one of one or more forwarding nodes 104F to which Alice is connected. For example, this may be the forwarding node 104F that is closest or best connected to Alice's computer 102. When any given node 104 receives the new transaction 152j, it processes it according to the node protocol and its respective role. This includes first checking whether the newly received transaction 152j meets certain conditions to be "valid", examples of which are described in more detail below. In some transaction protocols, the conditions for validation may be configurable on a per-transaction basis by a script included in the transaction 152. Alternatively, the conditions may simply be a built-in feature of the node protocol, or may be defined by a combination of the script and the node protocol.

[0037] Provided that the newly received transaction 152j passes the tests to be considered valid (i.e., it is "validated"), any storage node 104S that receives the transaction 152j adds the new validated transaction 152 to a pool 154 in the copy of the blockchain 150 maintained at that node 104S. Additionally, any forwarding node 104F that receives the transaction 152j propagates the validated transaction 152 onward to one or more other nodes 104 in the P2P network 106. Because each forwarding node 104F applies the same protocol, assuming the transaction 152j is valid, this means that it will be propagated throughout the P2P network 106 immediately.

[0038] Once admitted to the pool 154 in the copy of the blockchain 150 maintained in one or more storage nodes 104, the miner nodes 104M begin competing to solve the proof-of-work puzzle for the latest version of the pool 154 that contains the new transaction 152. (Other miners 104M may be trying to solve the puzzle based on an old view of the pool 154, but whoever gets there first will define where the next new block 151 ends and the new pool 154 begins, and eventually someone will solve the puzzle for the part of the pool 154 that contains Alice's transaction 152j.) Once the proof-of-work is done for the pool 154 that contains the new transaction 152j, it immutably becomes part of one of the blocks 151 in the blockchain 150. Since each transaction 152 contains a pointer back to the previous transaction, the order of the transactions is also immutably recorded.

[0039] UTXO-based model Figure 2 shows an exemplary transaction protocol. This is an example of a UTXO-based protocol. A transaction 152 (abbreviated as "Tx") is the basic data structure of the blockchain 150 (each block 151 contains one or more transactions 152). In the following, it will be described with reference to an output-based or "UTXO"-based protocol. However, this is not limited to all possible embodiments.

[0040] In a UTXO-based model, each transaction ("Tx") 152 includes a data structure that includes one or more inputs 202 and one or more outputs 203. Each output 203 may include an unspent transaction output (UTXO), which may be used as a source of input 202 for another new transaction (if the UTXO has not yet been redeemed). The UTXO specifies an amount of a digital asset (store of value). It may also include, among other information, a transaction ID for the underlying transaction. The transaction data structure may also include a header 201, which may include indicators indicating the size of the input field(s) 202 and output field(s) 203. The header 201 may also include an ID for the transaction. In an embodiment, the transaction ID is a hash of the transaction data (excluding the transaction ID itself) and is stored in the header 201 of the raw transaction 152 that is submitted to the miner 104M.

[0041] Note that although each output in Figure 2 is shown as a UTXO, a transaction may additionally or alternatively include one or more unspendable transaction outputs.

[0042] Suppose Alice 103a wants to create a transaction 152j that transfers an amount of the digital asset to Bob 103b. In FIG. 2, Alice's new transaction 152j is labeled "Tx1". It takes the amount of the digital asset locked to Alice in the output 203 of the previous transaction 152i in the sequence and transfers at least a portion of it to Bob. The previous transaction 152i is labeled "Tx0" in FIG. 2. Tx0 and Tx1 are just arbitrary labels. They do not necessarily imply that Tx0 is the first transaction in the blockchain 151, nor that Tx1 is the immediate next transaction in the pool 154. Tx1 can point to any previous (i.e., earlier) transaction that still has an unspent output 203 locked to Alice.

[0043] The preceding transaction Tx0 may already be validated and included in the blockchain 150 by the time Alice creates the new transaction Tx1, or at least by the time Alice sends it to the network 106. It may already be included in one of the blocks 151 at that time, or it may still be waiting in the pool 154, in which case it will be included in the new block 151 immediately. Alternatively, Tx0 and Tx1 may be created and sent to the network 102 together, or even Tx0 may be sent after Tx1 if the node protocol allows for buffering of "orphan" transactions. The terms "preceding" and "successor" as used herein in the context of a sequence of transactions refer to the order of transactions in a sequence defined by transaction pointers (such as which transaction points to which other transaction) specified in the transaction. They may similarly be interchanged with "preceding" and "successor", or "earlier" and "later", "parent" and "child", etc. This does not necessarily imply the order of their creation, transmission to the network 106, or arrival at any given node 104. Nevertheless, a subsequent transaction (a later transaction or "child") that points to a preceding transaction (an earlier transaction or "parent") is not validated until and unless the parent transaction is validated. A child that arrives at a node 104 before its parent is considered an orphan. It may be buffered for a certain amount of time to await its parent or discarded, depending on the node protocol and / or minor behavior.

[0044] One of the one or more outputs 203 of the preceding transaction Tx0 includes a particular UTXO, labeled herein as UTXO0. Each UTXO includes a value specifying the amount of the digital asset represented by the UTXO and a locking script, which defines a condition that an unlocking script in the input 202 of the following transaction must satisfy in order for the following transaction to be validated and thus the UTXO to be successfully redeemed. Typically, the locking script locks the amount to a particular party (the beneficiary of the transaction in which it is included). That is, the locking script typically defines an unlocking condition, which includes a condition that an unlocking script in the input of the following transaction includes a cryptographic signature of the party to whom the preceding transaction is locked.

[0045] A lock script (commonly called scriptPubKey) is a piece of code written in a domain-specific language recognized by the node protocol. A specific example of such a language is called "script" (capital S). A lock script specifies what information is needed to use the transaction output 203, e.g., the requirements of Alice's signature. An unlock script appears in the transaction's output. An unlock script (commonly called scriptSig) is a piece of code written in a domain-specific language that provides the information needed to satisfy the lock script criteria. For example, it may include Bob's signature. An unlock script appears in the transaction's input 202.

[0046] That is, in the illustrated example, UTXO0 in output 203 of Tx0 must have Alice’s signature Sig P in order for UTXO0 to be redeemed (or, more precisely, for a subsequent transaction that attempts to redeem UTXO0 to be valid). A Requires lock script [Checksig P A ]. [Checksig P A ] is the public key P from Alice’s public-private key pair. ATx1's input 202 includes a pointer to Tx1 (e.g., by its transaction ID, TxID0, which in an embodiment is a hash of the entire transaction Tx0). Tx1's input 202 includes an index that identifies UTXO0 within Tx0 to identify it among any other possible outputs of Tx0. Tx1's input 202 includes an unlock script that includes Alice's cryptographic signature, created by Alice applying her private key from her key pair to a given piece of data (sometimes called a "message" in cryptography). <Sig P A What data (or "message") needs to be signed by Alice to provide a valid signature may be defined by the lock script, or by the node protocol, or by a combination of these.

[0047] When a new transaction Tx1 arrives at node 104, the node applies the node protocol, which involves running the lock script and the unlock script together to check if the unlock script satisfies the conditions defined in the lock script (which may include one or more criteria). In an embodiment, this involves concatenating the two scripts. <Sig P A > <P A >||[Checksig P A ] Here, "||" represents concatenation, "<...>" means to put data on the stack, and "[...]" are functions that are composed in the unlock script (a stack-based language in this example). Equivalently, the scripts could be executed one after the other using a common stack rather than concatenating the scripts. In any case, when executed together, the scripts will generate Alice's public key P as included in the lock script in the output of Tx0. A, to authenticate that the lock script in Tx1's input contains Alice's signature, who signed the expected portion of data. The expected portion of data itself (the "message") must also be included in the Tx0 instruction to perform this authentication. In an embodiment, the signed data includes the entirety of Tx0 (i.e., a separate element specifying the signed portion of the plaintext data need not be included, since that is already inherently present).

[0048] The details of authentication via public-private cryptography are well known to those skilled in the art. Essentially, if Alice signs a message by encrypting it with her private key, then given Alice's public key and the plaintext message (the unencrypted message), another entity, such as node 104, can authenticate that the encrypted version of the message must have been signed by Alice. Signing typically involves hashing the message, signing the hash, and tagging this as the signature to the plaintext version of the message, allowing any holder of the public key to authenticate the signature.

[0049] If the unlock script in Tx1 satisfies one or more conditions specified in the lock script of Tx0 (i.e., in the illustrated example, Alice's signature is provided and authenticated in Tx1), the node 104 considers Tx1 valid. If it is a mining node 104M, this means adding it to the pool of transactions 154 waiting for work-of-proofs. If it is a forwarding node 104F, it forwards the transaction Tx1 to one or more other nodes 104 in the network 106 so that the transaction Tx1 is propagated throughout the network. Once Tx1 is validated and included in the blockchain 150, this defines the UTXO0 from Tx0 as spent. Note that Tx1 can only be valid if it uses an unspent transaction output 203. If it attempts to use an output that has already been spent by another transaction 152, Tx1 becomes invalid even if all other conditions are met. Therefore, node 104 also needs to check whether the referenced UTXO in the preceding transaction Tx0 has already been spent (already formed a valid input to another valid transaction). This is one reason why it is important for blockchain 150 to impose a defined order on transactions 152. In practice, a given node 104 may maintain a separate database marking which UTXOs 203 in which transactions 152 have been spent, but ultimately, what defines whether a UTXO has been spent is whether it already forms a valid input to another valid transaction in blockchain 150.

[0050] Note that in the UTXO-based transaction model, a given UTXO must be spent in its entirety. It is not possible to "leave behind" a portion of the amount defined in the UTXO as spent, and another portion is spent. However, it is possible to split the amount from the UTXO among multiple outputs of a subsequent transaction. For example, the amount defined in UTXO0 in Tx0 can be split among multiple UTXOs in Tx1. Thus, if Alice does not want to give Bob the entire amount defined in UTXO0, she can use a reminder to give the remainder to herself in the second output of Tx1, or to pay another party.

[0051] In practice, since today the reward for the generating transaction alone is typically not enough to motivate mining, Alice also typically needs to include a fee for the winning miner. If Alice does not include a fee for the miner, Tx0 will likely be rejected by the miner nodes 104M, and thus, even if technically valid, it will still not be propagated and included in the blockchain 150 (the miner protocol does not force the miner 104M to accept the transaction 152 if it does not want to). In some protocols, the mining fee does not require its own separate output 203 (i.e., it does not require a separate UTXO). Instead, the difference between the total amount pointed to by the input(s) 202 of a given transaction 152 and the total amount specified in the output(s) 203 is automatically given to the winning miner 104. For example, suppose a pointer to UTXO0 is the only input to Tx1, and Tx1 has only one output UTXO1. If the amount of digital assets specified in UTXO0 is greater than the amount specified in UTXO1, the difference is automatically awarded to the winning miner 104M. However, it is not necessarily excluded that a miner's fee may alternatively or additionally be explicitly specified in one of the UTXOs 203 of transaction 152 itself.

[0052] Note also that if the total amount specified in all outputs 203 of a given transaction 152 is greater than the total amount pointed to by all its inputs 202, this is another ground of invalidity in most transaction models. Thus, such a transaction is not propagated to block 151 or mined.

[0053] Alice and Bob's digital assets consist of unspent UTXOs locked to them in any transaction 152 anywhere in the blockchain 150. Thus, typically, a given party 103's assets are scattered across the UTXOs of various transactions 152 across the blockchain 150. No number is stored anywhere in the blockchain 150 that defines the total balance of a given party 103. The role of the wallet function in the client application 105 is to collate together the values ​​of all the various UTXOs locked to each party that have not yet been spent in another forward transaction. This can be done by querying the copy of the blockchain 150 stored in one of the storage nodes 104S, for example the storage node 104S that is closest or best connected to each party's computer device 102.

[0054] Note that script code is often expressed diagrammatically (i.e., not in a precise language). A ] and write [Checksig P A]=OP_DUP OP_HASH160<H(Pa)> OP_EQUALVERIFY may mean OP_CHECKSIG. "OP..." refers to a specific opcode in the scripting language. OP_CHECKSIG (also called "Checksig") is a scripting opcode that takes two inputs (a signature and a public key) and verifies the validity of the signature using the Elliptic Curve Digital Signature Algorithm (ECDSA). At execution, the occurrence of the signature ("sig") is removed from the script, but additional requirements such as a hash puzzle remain for transactions that were verified by the "sig" input. As another example, OP_RETURN is a scripting language opcode for creating an unusable output of a transaction that can store metadata within the transaction, thereby immutably recording the metadata to the blockchain 150. For example, the metadata may include a document that is desired to be stored on the blockchain.

[0055] signature P A is a digital signature. In an embodiment, it is based on ECDSA using the elliptic curve secp256k1. A digital signature signs a specific portion of data. In an embodiment, for a given transaction, the signature signs some of the transaction inputs, and all or some of the transaction outputs. The specific portion of the outputs that are signed depends on the SIGHASH flag, which is a 4-byte code included at the end of the signature to select which outputs are signed (and thus fixed at the time of signing).

[0056] A lock script is sometimes referred to as a "scriptPubKey", referring to the fact that each transaction contains the public key of the party being locked. An unlock script is sometimes referred to as a "scriptSig", referring to the fact that it supplies the corresponding signature. However, more generally, it is not required in all applications of blockchain 150 that the condition for a UTXO to be redeemed includes authenticating the signature. More generally, any condition or conditions may be defined using a scripting language. Thus, the more general terms "lock script" and "unlock script" may be preferred.

[0057] Optional Side Channel FIG. 3 illustrates a further system 100 for implementing a blockchain 150. The system 100 is substantially the same as described in connection with FIG. 1, except that an additional communication function is included. The client applications on the respective computing devices 102a, 120b of Alice and Bob each include an additional communication function. That is, it allows Alice 103a to establish (at the direction of either party or a third party) a separate side channel 301 with Bob 103b. The side channel 301 allows for the exchange of data apart from the P2P network. Such communication may be referred to as "off-chain". For example, it may be used to exchange transactions 152 between Alice and Bob without the transaction (yet) being published on the network P2P 106 or progressing on the chain 150 until one of the parties chooses to broadcast the transaction to the network 106. Alternatively or additionally, the side channel 301 may be used to exchange any other transaction-related data, such as keys, negotiated amounts or terms, data content, etc.

[0058] The side channel 301 may be established over the same packet-switched network 101 as the P2P overlay network 106. Alternatively or additionally, the side channel 301 may be established over a different network, such as a mobile cellular network, or a local area network, such as a local wireless network, or even a direct wired or wireless link between Alice's device 1021 and Bob's device 102b. In general, the side channel 301 referred to anywhere herein may include any link or links over one or more networking technologies or communication media for exchanging data "off-chain," i.e., apart from the P2P overlay network 106. When more than one link is used, the bundle or collection of off-chain links as a whole may be referred to as the side channel 301. Thus, it should be noted that when it is said that Alice and Bob exchange information or particular portions of data, etc., over the side channel 301, this does not necessarily mean that all of these portions of data must be transmitted over the exact same link or the same type of network.

[0059] Node Software FIG. 4 illustrates an example of node software 400 running on each node 104 of the P2P network 106 in an example UTXO or output-based model. The node software 400 includes a protocol engine 401, a script engine 402, a stack 403, an application level decision engine 404, and a set of one or more blockchain-related function modules 405. In any given node 104, these may include any one, two, or all three of a mining module 405M, a forwarding module 405F, and a storage module 405S (depending on the node's role or roles). The protocol engine 401 is configured to recognize different fields of a transaction 152 and process them according to the node protocol. Another preceding transaction 152m-1 (Tx m-1) output (e.g., UTXO). m ) is received, the protocol engine 401 m The protocol engine 401 also identifies the unlock script in the Tx m Based on the pointer in the input of Tx m-1 It identifies and extracts Tx m-1 from its own pool 154 of pending transactions if Tx is not already on the blockchain 150, or m-1 If already on the blockchain 150, the node or another node 104 stores a copy of the block 151 in the blockchain 150, Tx m-1 In any case, the script engine 401 may extract Tx m-1 The script engine 402 then identifies the lock script in the pointed to output and passes it to the script engine 402.

[0060] Therefore, the script engine 402 m-1 Lock script and Tx m and an unlock script from the corresponding inputs of Tx1 and Tx2. For example, Tx1 and Tx2 are shown in Figure 4, but the same applies to any pair of transactions, such as Tx0 and Tx1. The script engine 402 executes the two scripts together as described above, which includes placing and retrieving data on the stack 403 according to the stack-based scripting language being used (e.g., Script).

[0061] By executing the scripts together, the script engine 402 determines whether the unlock script meets one or more criteria defined in the lock script, i.e., whether to "unlock" the output in which the lock script is included. The script engine 402 returns the result of this determination to the protocol engine 401. If the script engine 402 determines that the unlock script meets one or more criteria specified in the corresponding lock script, it returns the result "true". Otherwise, it returns the result "false".

[0062] In an output-based model, the result "true" from the script engine 402 is one of the conditions for the validity of a transaction. Typically, Tx m the total value of the Digital Assets specified in the output(s) of Tx will not exceed the total value indicated by the input(s) of Tx m-1 There are also one or more further protocol level conditions evaluated by protocol engine 401 that must be satisfied as well, such as that the pointed-to output of has not already been used by another valid transaction. Protocol engine 401 evaluates the result from script engine 402 along with one or more protocol level conditions, and only if they are all true does it accept transaction Tx m The protocol engine 401 outputs an indication of whether the transaction is valid to the application level decision engine 404. m is actually validated, the decision engine 404 m 151. The mining module 405M may choose to control one or both of the mining module 405M and the forwarding module 405F to perform respective blockchain-related functions with respect to the block 151. This is because the mining module 405M may m 4 for each of the nodes, and / or the forwarding module 405F mto another node 104 in the P2P network 106. Note, however, that although in an embodiment, the decision engine 404 does not choose to forward or mine an invalid transaction, this does not necessarily mean that it is obligated to conversely trigger the mining or forwarding of a valid transaction simply because it is valid. Optionally, in an embodiment, the decision engine 404 may apply one or more additional conditions before triggering one or both functions. For example, if the node is a mining node 104M, the decision engine may choose to mine the transaction only on the condition that it is valid and has sufficient mining fees remaining.

[0063] It should also be noted that the terms "true" and "false" herein are not necessarily limited to returning a result expressed in the form of only a single binary digit (bit), but that is certainly one possible implementation. More generally, "true" can refer to any state that indicates a successful or positive outcome, and "false" can refer to any state that indicates an unsuccessful or non-positive outcome. For example, in an account-based model (not shown in FIG. 4), a "true" outcome may be indicated by a combination of an implicit (protocol-level) validation of the signature by the node 104 and an additional positive output of the smart contract (if both individual outcomes are true, the overall outcome is considered to indicate true).

[0064] Internet of Things The IoT is the extension of the Internet to everyday physical devices and objects. With the incorporation of computing power and Internet connectivity, devices can communicate and interact with one another, allowing for remote monitoring and control. Over time, the definition of IoT has evolved due to machine learning, real-time analytics, and the convergence of multiple technologies, but it is generally accepted that a system of devices capable of supporting wireless sensor networks and / or control systems is likely to realize the IoT.

[0065] IoT systems face several challenges. For example, the scalability and cost of such systems may prevent IoT systems from realizing their full potential. When connected and controlled in a centralized manner, IoT devices require back-end infrastructure to transmit data and receive control commands. These back-end infrastructures are hosted either in third-party cloud services or on-premise server farms. The scalability of IoT solutions is then determined by the scalability of the back-end servers and data centres, which can make the operational costs for IoT service providers prohibitive. As a result, many proposed IoT solutions are not cost-effective and are unsuitable for use in everyday scenarios. Performance measures such as network latency also become important factors in determining the rate of IoT adoption.

[0066] Another challenge faced by IoT systems is the trade-off between automation and control. IoT solutions are designed to enable remote access and control of everyday electronic devices. Most IoT solutions balance full user control with automated communication between the device and other IoT solution components. If either the device or the IoT system malfunctions, safety measures such as override mechanisms must be in place.

[0067] Another challenge is the threat from cyber attacks. By enabling automated control of devices over the Internet, users are exposed to two forms of potential security risks. The first is a privacy risk created by transmitting IoT device metadata over the Internet. For example, if an eavesdropper gains access to data from devices such as home appliances, patterns of device usage can be used by criminals, e.g., thieves, to predict when people will be at home. The second risk is the possibility that an attacker or other third party could gain control of the IoT device. For performance-critical control software, such as those used to operate heavy machinery or hazardous materials, an attack could have catastrophic consequences.

[0068] IoT systems can be designed to be centralized or distributed and / or hybrid. Centralized solutions suffer from bottlenecks but can allow for faster and more reliable control by privileged components in the IoT system. Distributed reporting of state updates allows IoT solutions to be more scalable. Edge computing can help reduce network latency for critical applications, reduce the dependency of IoT systems on the cloud, and provide better management of large amounts of IoT data. The increase in distributed processing highlights opportunities in system architectures to better utilize the benefits of centralized and distributed architectures. Hybrid systems that combine centralized and distributed systems within a hierarchical control structure can enhance user safety and usability objectives.

[0069] Blockchain technology has the potential to play a major role in the future of IoT because: blockchain allows payments and control to be integrated into one network; existing infrastructure can be used to piggyback messages about device state changes; and distributed control of data on the network allows for faster user-device interaction. Combined with blockchain technology, traditional IoT devices that play a role in the physical world can send messages and exchange value at the same time. A public blockchain would act not only as a global payment network, but also as a universal commodity ledger, with strong cryptographic security built into its protocol that automatically addresses some of the risks associated with IoT.

[0070] FIG. 5 illustrates an exemplary system 500 for implementing an embodiment of the present disclosure. The exemplary system 500 comprises a first network 501 consisting of one or more end devices (i.e., computing devices) 502 and one or more bridge nodes 503 (i.e., computing devices that run a blockchain client application and thus act as a bridge between the blockchain network 106 and the first network 501). For clarity, the first network 501 is referred to as an IoT network, i.e., a network of computing devices interconnected by the Internet. Typically, the end devices 502 and the bridge nodes 503 are embedded in everyday devices. The end devices 502 may take one of a variety of forms, for example, a user device (e.g., a smart TV, a smart speaker, a toy, a wearable, etc.), a smart appliance (e.g., a refrigerator, a washing machine, an oven, etc.), a meter or a sensor (e.g., a smart thermostat, a smart lighting, a security sensor, etc.). Similarly, the bridge nodes 503 may also take a variety of forms, including but not limited to the same forms that the end devices may take. The nodes 503 may also take the form of dedicated server equipment, base stations, access points, routers, etc. In some examples, each device may have a fixed network (e.g., IP) address. For example, one, some, or all of the end devices may be fixed devices (e.g., smart lights, or smart central heating controllers, etc.) as opposed to mobile devices.

[0071] The IoT network is a packet-switched network 101, typically a wide area internetwork such as the Internet. Nodes 503 and devices 502 of the packet-switched network 101 are configured to form a peer-to-peer (P2P) overlay network 501 within the packet-switched network 101. Each node 503 comprises a respective computing device, each computing device comprising one or more processors, e.g., one or more central processing units (CPUs), accelerator processors, application specific processors and / or field programmable gate arrays (FPGAs). Each node 503 also comprises a memory, i.e., computer-readable storage in the form of one or more non-transitory computer-readable media. The memory may comprise one or more memory units using one or more memory media, e.g., magnetic media such as hard disks, electronic media such as solid-state drives (SSDs), flash memories or EEPROMs, and / or optical media such as optical disk drives.

[0072] Each node 503 in the IoT network is also a blockchain node 104. These nodes 503 are configured as bridge nodes (gateway nodes) that act as a bridge (gateway) between the first network 501 and the blockchain network 106. The blockchain nodes 104 may be "listening nodes". Listening nodes run client applications that hold a full copy of the blockchain and validate and propagate new transactions and blocks, but do not actively mine or generate new blocks. Alternatively, a node may be a "simplified payment verification node" (SPV node). SPV nodes run light clients that can generate and broadcast Bitcoin transactions and indirectly monitor addresses, but do not hold a full copy of the blockchain.

[0073] Each node 503 in the IoT network is configured to directly or indirectly control an end device 502. A node 503 directly connected to an end device 502 can directly control that device. A node 503 not directly connected to an end device 502 can only indirectly control that device, for example, by forwarding control messages to the end node via one or more intermediate nodes. Each node 503 is connected to one or more mining nodes 104M.

[0074] 5 also shows a network 504 of mining nodes 104M that is a subset of the blockchain network 106. Mining nodes are described above with reference to Figures 1-3. The mining nodes 104M are configured to mine valid transactions (e.g., transactions submitted from IoT nodes) into the blockchain 150.

[0075] As shown in Figure 5, node 503 forms part of both the P2P network 501 and the blockchain P2P network 106, while mining node 104M forms part only of the blockchain P2P network 106. Although end device 502 is shown in Figure 5 as forming part only of the P2P IoT network 501, this does not exclude that end device 502 can also be a blockchain node 104.

[0076] FIG. 6 illustrates an exemplary IoT network 501 topology. The IoT network 501 can control a master node 503a, one or more sets 601 of one or more intermediate nodes 503b, 503c, and a set of end devices 502. The master node 502a is configured to control one or more intermediate nodes 503b, 503c. If the IoT network 501 includes multiple sets (e.g., tiers) 601a, 601b of intermediate nodes, the master node 503a is configured to directly control a first set (tier) 601a of intermediate nodes ("server nodes" 503b) and indirectly control one or more further sets (tiers) 601b of intermediate nodes (e.g., tiers of "slave nodes" 503c). The master node 503a is a control node with the ability to override and control the server nodes and slave nodes. Each server node 503b is a node with the ability to control the slave nodes 503c. The slave node 503c is a node under the control of the server node 503b and the master node 503a. As an example, to instruct the end device 502a, the master node 503a issues a command to the slave node 503c via the servant node 503b.

[0077] Although the example IoT network of FIG. 6 shows only two layers of intermediate nodes (server nodes and slave nodes), other examples may include one or more additional sets of intermediate nodes, for example, between the master node 503a and the server node 503b, and / or between the server node 503b and the slave node 503c. As shown, each node is connected to one or more other nodes via respective connections 602, and each end device 502 is connected to one or more slave nodes via respective connections 602. One or more nodes (e.g., the master node) are referred to below as control nodes. Each control node is a node 503 that can instruct other nodes to perform actions by issuing commands.

[0078] The IoT network nodes 503 may correspond to a hierarchy in scope of function, command / privilege superiority, and / or span of access. In some implementations, a hierarchical set of SPV nodes implements an "IoT Controller" with three hierarchical levels corresponding to the master node 503a, server node 503b, and slave node 503c of FIG. 5 and FIG. 6. The master node 503a commands one or more server nodes 503b, each of which commands one or more slave nodes 503c. Each slave node 503c receives commands from one or more server nodes 503b. All slave nodes 503c communicate with one or more IoT end devices 502, which are the direct channel of communication between the IoT Controller 503 and the IoT end devices 502. The state of execution of the IoT Controller 503 is recorded in a blockchain transaction Tx. Each IoT node (master, server, or slave) has the ability to create and broadcast a corresponding transaction Tx to the blockchain network 106. Each slave node monitors for trigger and / or confirmation signals from the end devices 502, and all IoT nodes 503 have the ability to interact with any other IoT node for the purpose of executing the overall logic of the IoT controller.

[0079] The master node, server node(s), and slave node(s) can each independently connect to a node 104 on the blockchain network 106, operate a blockchain wallet (e.g., to monitor blockchain addresses), and possibly run a full node (although this is not required). The master node 503a is configured to monitor the activity of other IoT nodes under their control, both directly and indirectly, issue commands to these nodes in the form of blockchain transactions Tx, and respond to alerts. The server node 503b is configured to monitor multiple addresses, including addresses not directly controlled by the server node 503b. The server node 503b can be commanded to perform actions by the master node 503a. The slave node 503c is configured to directly monitor the activity of the end device 502 under their control. The slave node 503c is under the direct command of the server node 503b and can also be commanded to perform actions by the master node 503a. The slave node 503c serves as a gateway node for the end device 502 (i.e., a gateway between the end device and the blockchain network 106). End devices 502 are configured to connect to nearby slave devices that report on end device status using an off-chain messaging protocol.

[0080] Note that the end device 502 is distinct from the IoT node 503 in that the end device 502 is controlled by the IoT node 503 but does not itself control the IoT node 503, although the end device 502 may be a node 104 of the blockchain network 106. That is, in some examples, the end device 502 may run a blockchain protocol client or a wallet application.

[0081] The IoT network 501 is both centralized and decentralized by combining a command and control hierarchy with the use of a blockchain network infrastructure. Users of the network 501 can create their own multi-level control hierarchies, including client-server and peer-to-peer relationships between devices. The network architecture includes three layers: the IoT network 501, the blockchain P2P network 104 (i.e., full and lightweight blockchain clients, e.g., master, servant and slave nodes are lightweight clients that run SPV wallets), and the blockchain mining network 504 (a subset of the blockchain P2P network that validates, propagates and stores transactions propagated by the IoT nodes). The blockchain network 106 serves as a back-end infrastructure, and there is an overlap between the IoT network 501 and the blockchain P2P network 106.

[0082] Authorization Protocol Embodiments of the present disclosure provide a protocol for granting permission to a node 503 or device 502 requesting access to a network 501 to join the network 501. In the context of IoT, new nodes 503 are authorized onto the IoT network 501 using on-chain forgery-proof digital certificates provided by a registration authority (e.g., a trusted entity in the network). The protocol solves problems associated with cyber attacks by ensuring that only authentic nodes can access the network and / or control other nodes or devices in the network.

[0083] Permission to participate in the IoT network 501 is granted by a registration authority (which may also be referred to as an "authorization granting authority" or "certification authority"). The registration authority is responsible for issuing digital certificates to requesting entities (e.g., requesting nodes or requesting devices). Entities with valid certificates have access to the IoT network 501. The registration authorities comprise respective computing equipment, each of which comprises a respective processing unit comprising one or more processors, e.g., one or more central processing units (CPUs), accelerator processors, application specific processors and / or field programmable gate arrays (FPGAs). The computing equipment of the registration authorities also comprises memory, i.e., computer readable storage in the form of one or more non-transitory computer readable media. The memory may comprise one or more memory units using one or more memory media, e.g., magnetic media such as hard disks, electronic media such as solid state drives (SSDs), flash memories or EEPROMs, and / or optical media such as optical disk drives.

[0084] To grant permission for the requesting entity to participate in the network 501, the registrar generates a blockchain transaction Tx, hereafter referred to as a "certificate transaction". An exemplary certificate transaction is shown in FIG. 16a. The certificate transaction Tx includes one or more inputs and one or more outputs. At least one input 1501a includes the registrar's digital signature. That is, the registrar has a first private key (e.g., a first private-public key pair) that can generate a digital signature, and the registrar signs the transaction with that digital signature. An exemplary certificate format is shown in FIG. 16b. By signing the certificate transaction, the registrar certifies the data contained in the output(s) of the transaction. The digital signature can only be generated by a registrar with knowledge of the first private key. The transaction also has a first output 1502a (e.g., an unusable output) that includes a digital certificate issued by the registrar to the requester. The digital certificate includes an identifier assigned to the requester. The identifier is unique to the requester within the IoT network 501. The requester is assigned an identifier that must remain fixed once issued and appears in any certificate the device is issued for. Preferably, the device identifier is assigned when the certificate is generated. However, this does not preclude the requester from already having a device identifier, which is evidenced by its inclusion in the certificate.

[0085] Once generated, the registration authority transmits the certificate transaction to one or more nodes 104 of the blockchain network 106 to be recorded in the blockchain 150. Once recorded in the blockchain 150, the requestor can use the certificate to prove to other nodes or devices of the network 501 that the requestor has been granted permission to participate in the network 501. For example, when communicating with other nodes 503 of the network 501, the requestor may include information identifying the certificate transaction, and therefore the certificate.

[0086] Referring to FIGS. 1-3, in these examples, the first node may be Alice's 103a's computing device 102a and the second node may be Bob's 103b's computing device 102b.

[0087] If the requester is a node 503 in the network 501 (or is requesting permission to join the network 501 as a node), the certificate may include a unique public key assigned to that node. The public key enables the requesting node 503, once it joins the network 501, to send and receive blockchain transactions.

[0088] A private key is a secret numerical value known only to the owner of the private key. For example, a private key may be a 256-bit string. A public key is an associated public value that is derived from the private key and can be shared. For example, a public key may be computed by elliptic curve multiplication of the private key and a secp256k1 elliptic curve generator point. A signature may be a cryptographic signature, such as one generated using the Elliptic Curve Digital Signature Algorithm (ECDSA). Alternative signature schemes may be used, such as Rabin signatures.

[0089] The certificate transaction may include a second output 1502b that is locked to a second public key of the registration authority. The second public key may be the same public key as the public key used to generate the signature that signs the certificate transaction, or a different public key. The second output 1502b is locked to the second public key in the sense that knowledge of the second public key is required to unlock the output. For example, the second output may include a hash of the second public key, and in order to be unlocked by a later transaction input, that input must include the second public key. When the second output 1502b is run in parallel with the second transaction input, the second public key provided in the input is hashed and compared to the hash included in the second output 1502b. If the two hashes match, the second output 1502b may be unlocked (provided any additional constraints are met).

[0090] Outputs can be locked to a public key via a pay-to-public-key-hash (P2PKH). P2PKH is a script pattern that locks outputs to a public key hash. A P2PKH output can be used if the recipient provides a valid signature for a public key that matches the public key hash. That is, the P2PKH output challenges the spender to provide two items, not necessarily in that order: a public key such that the hash of the public key matches an address in the P2PKH output, and a valid signature for the public key and the transaction message.

[0091] Because the second output 1502b is locked to the registration authority's public key, only the registration authority can revoke the certificate, thereby preventing the certificate from being revoked by malicious parties.

[0092] The second output 1502b may be time-locked to a second public key. A time-locked output cannot be unlocked until after a predefined period of time. For example, a registration authority may include a lock time in a certificate transaction. The lock time prevents the second output 1502b of a certificate transaction from being successfully used by a later transaction until after a certain time (which may be specified, for example, by Unix time or block height). The lock time may be implemented using the "nLocktime" field of the transaction. nLocktime is a parameter of the transaction that dictates the minimum time before the output is available. In combination with nLocktime, an opcode (e.g., OP_CHECKLOCKTIMEVERIFY(CLTV)) prevents a later transaction from using the second output (by causing the script execution to fail) unless the nLockTime on the first transaction is equal to or greater than the time parameter provided to the opcode. Since a later transaction may only be included in a valid block if its nLockTime is in the past, it is guaranteed that the CLTV-based time lock has expired before a later transaction can be included in a valid block.

[0093] Additionally or alternatively, the second output 1502b may be a "multi-signature" output. A multi-signature output is locked to multiple public keys, namely the second public key of the registration authority and at least one other public key. The other public keys may be the public keys of another node in the network 501, or a third party node outside the IoT network but within the blockchain network 106. The input of a subsequent transaction seeking to use the second output 1502b must include multiple signatures, one for each public key to which the second output is locked.

[0094] A time lock prevents a registration authority from revoking a certificate before an agreed upon time or without the permission of a different node (e.g., the master node). A multi-signature output prevents a certificate from being revoked without the permission of a different node (e.g., the master node). Both techniques enforce a minimum certificate duration length.

[0095] Each transaction, once recorded in the blockchain 150, can be identified by a unique transaction identifier TxID. The transaction identifier may be generated by computing a (double) SHA256 hash of the serialized transaction bytes. Other hash functions may be used instead of SHA256. The registrar may send the transaction identifier of the certificate transaction to the requester. This allows the requester to identify the certificate transaction and thus obtain the certificate in the certificate transaction. Alternatively, the requester may listen for transactions sent to the blockchain 150 from the address of the registrar.

[0096] If the requester is participating in the network 501 as a node (e.g., a servant node), the requesting node may use the transaction identifier to obtain the first public key of the registration authority and identify one or more further transactions (i.e., further certificate transactions) sent from that first public key. Each of the further transactions may include a respective certificate of one or more further nodes or devices of the network 501. The requester may then obtain (e.g., download and store) those certificates. The information in the certificates (e.g., device identifiers and / or public keys) may be used to communicate with other nodes 503 and / or devices 502 of the network 501. For example, the requester may send a blockchain transaction to another node 503 using the node's attested public key, e.g., by including an output (e.g., a P2PKH output) in the transaction locked to the attested public key. Upon receiving a command, the requester may use the certificate to check whether the command was issued from an authorized node 503 or device 502.

[0097] If the requester is participating in the network 501 as an end device 502 that does not have access to the blockchain, the registration authority may send a certificate to the end device, e.g., via a wired connection or a wireless connection, e.g., Bluetooth, Wi-Fi, etc. The registration authority may also send a set of one or more second certificates to the requesting end device 502. These second certificates, each issued to a respective node or end device of the network 501, can be used to ensure that the requesting end device's communications are with authorized nodes 503 and devices 502.

[0098] Each certificate (first and second) may include a network address (e.g., IP address) of the node 503 or end device 502 to which the certificate is issued. A requester can use the network address of an authorized (i.e., certified) node to communicate with that node, for example to send sensor readings or command acknowledgments.

[0099] The registration authority may transmit the certificate issued to the requester to one or more nodes and / or end devices of the network 501. These end devices may use the certificate to communicate with the requester and verify whether the requester is authorized to participate in the network 501.

[0100] To prevent third parties from viewing the contents of the certificate (which may contain sensitive information), the registration authority may encrypt the certificate. For example, the certificate may be encrypted using an encryption key based on the registration authority's public key (which may or may not be the same as the registration authority's first and / or second public keys). Alternatively, the encryption key may be a random number generated by the registration authority.

[0101] In some examples of the registration authority, the registration authority may simply issue a certificate to the requester, i.e., without receiving an explicit request. In other examples, the requester may first send a request to the registration authority. The request may include one or more credentials of the requester. For example, the credentials may include one or more of a device type (e.g., laptop, phone, oven, refrigerator, etc.), a node type (e.g., master node, servant node, slave node, end device), a network address (e.g., an IP address that may be an IPv6 address), and the like. The registration authority or a different node (e.g., master node) may validate the request. If validated, the registration authority may generate a first transaction and send it to the blockchain network 106. If the request is not authorized, the registration authority will not generate the transaction.

[0102] In some cases, it may be necessary to revoke a certificate issued to a requester. For example, if the requester may be compromised or may be compromised. To revoke a certificate, the registrar generates a second blockchain transaction (the "revocation transaction"). The revocation transaction has an input that references the second output of the certificate transaction (i.e., an output locked to the registrar's second public key). The input includes a signature linked to the second public key. If the second output of the certificate transaction is a P2PKH output, the input of the revocation transaction must include a public key whose hash (e.g., OP_HASH160) matches the public key hash in the P2PKH output. The P2PKH output challenges the user to provide two items, not necessarily in that order: a public key whose hash matches an address in the P2PKH output, and a signature that is valid for the public key and the transaction message.

[0103] The revoked transaction may include one or more outputs, for example, outputs locked to the registrar's third public key (which may or may not be the same as the registrar's first and / or second public keys). The registrar then sends the revoked transaction to the blockchain network 106 to be recorded in the blockchain 150. Once the revoked transaction is recorded in the blockchain 150, the certificate transaction is removed from the Unspent Transaction Output (UTXO) set. A UTXO is an output from a blockchain transaction that has not been used by another blockchain transaction. When a different node on the network 501 attempts to identify the certificate issued to the requesting node, it will see that the certificate transaction containing the certificate has been used and will interpret the certificate as revoked. The nodes of the network 501 can dynamically update their peer list (i.e., list of authorized / certified nodes) by monitoring transactions generated from and to the issuing address (i.e., second public key).

[0104] The validity of a node / device certificate may depend on three criteria: the issuing key is a recognized issuing key (contained in a certificate signed by a master key), the certificate is correctly formatted according to a predefined protocol, and the available outputs in the certificate transaction are unused. Certificates can be updated when they expire. The registration authority uses the UTXO in the old certificate and then creates a new certificate Tx with the updated information. The registration authority can then broadcast the new certificate outpoint location index to devices on the IoT network 501. This also applies to the registration authority's own (self-signed) certificate.

[0105] As mentioned above, the certificate includes a unique identifier for the requester. The certificate may include a unique public key for the requester. In general, the certificate may include one or more of the following fields: [Table 1] A certificate in this format requires, for example, 104 to 184 bytes of data to be encoded into the unspendable (OP_RETURN) output of a blockchain transaction.

[0106] As described above, the network 501 may include a master node 503. In some examples, the registration authority may include the master node 503a. The requester may be a node 503 or an end device 502. Thus, the master node 503a itself may issue a certificate to the node 503 or the device 502. In additional or alternative examples, the requester may be the master node 503a. When the master node 503a is both the registration authority and the requester, the master node 503a self-signs its certificate.

[0107] Access to the IoT network 501 is granted and an authorization (or bootstrap) algorithm is used to authorize new entities (nodes or devices). Two exemplary algorithms are provided below. The master node 503a may be controlled by a registration authority that can verify (directly or indirectly) the credentials of any new device that requests to be granted authorization on the network 501. The master node 503s may then issue an on-chain certificate that will be broadcast to all other nodes 503 on the network 501. The bootstrap algorithm for devices that do not run blockchain wallets is different as it relies on communication between IP addresses instead of via blockchain transactions.

[0108] Example Authorization Algorithm (Master / Servant / Slave) Step 1: A computing device running a node registers its credentials, including all relevant manufacturing information, with a registration authority. The registration authority may be the same entity that operates the master node 503a. However, the public key used to sign regular commands or messages should preferably be different from the public key used to sign certificate transactions.

[0109] Step 2: Key PK Issue A registration authority that controls the TLS 502 TLS 503 TLS 504 TLS 505 TLS 506 TLS 507 TLS 508 TLS 509 TLS 510 TLS 511 TLS 512 TLS 513 TLS 514 TLS 515 TLS 516 TLS 517 TLS 518 TLS 519 TLS 520 TLS 521 TLS 522 TLS 523 TLS 524 TLS 525 TLS 526 TLS 527 TLS 528 TLS 529 TLS 530 TLS 531 TLS 532 TLS 533 TLS 534 TLS 535 TLS 536 TLS 537 TLS 538 TLS 539 TLS 540 TLS 541 TLS 542 TLS 543 TLS 544 TLS 545 TLS 546 TLS 547 TLS 548 TLS 549 TLS 548 TLS 550 TLS 551 TLS 552 TLS 553 TLS 554 TLS 555 TLS 556 TLS 557 TLS 558 TLS 559 ...

[0110] Step 3: If the device is authorized, the registration authority creates a unique certificate transaction for the node. This transaction is Issue From PK Issue The TxID is broadcast to the address of the new node. The registrar sends the TxID to the new node.

[0111] Step 4: The new node finds the transaction and PKs it with the registrar. Issue The new node is identified by the PK Issue Download and validate all currently active certificates issued by.

[0112] Step 5: Servant and slave nodes already on the network 501 Issue The new nodes are configured to listen to transactions broadcast between them. Once they see the new transactions and download and evaluate the new device certificates, they can configure their wallets to communicate with the new nodes.

[0113] Exemplary Authorization Algorithm (End Device) Step 1: End device 502 registers its credentials, including all relevant manufacturing information and IP address, with a registration authority. Again, the registration authority may be the same entity that operates master node 503a. However, the public key used to sign regular commands or messages should preferably be different from the public key used to sign certificate transactions.

[0114] Step 2: Key PK Issue A registration authority that controls the TLS 1.0 TLS 1.1 TLS 1.2 TLS 1.3 TLS 1.4 TLS 1.5 TLS 1.6 TLS 1.7 TLS 1.8 TLS 1.9 TLS 1.10 TLS 1.11 TLS 1.12 TLS 1.13 TLS 1.14 TLS 1.15 TLS 1.16 TLS 1.17 TLS 1.18 TLS 1.19 TLS 1.20 TLS 1.21 TLS 1.22 TLS 1.23 TLS 1.24 TLS 1.25 TLS 1.26 TLS 1.27 TLS 1.28 TLS 1.29 TLS 1.30 TLS 1.31 TLS 1.32 TLS 1.33 TLS 1.34 TLS 1.35 TLS 1.36

[0115] Step 3: If the device 502 is authorized, the registration authority creates a unique device certificate transaction for the device. This transaction is performed using the PK Issue The certificate data is encrypted so that only IOT nodes can see the details.

[0116] Step 4: The registration authority sends a list of certificates that allows the end device 502 to create a peer list that allows the end device 502 to connect to other nodes 503c on the network 501 and interpret the public key hierarchy.

[0117] Step 5: Node 503 on network 501 can see the device certificate and can communicate with the end device over IP-IP (TLS).

[0118] Request and Response Protocol The present disclosure also provides a protocol for nodes of a network (e.g., an IoT network) 501 to issue command requests using blockchain transactions Tx, instruct devices based on those command requests, and issue command acknowledgments. Although embodiments are described with respect to an IoT network 501, in general, the teachings of the present disclosure may be applied to any network that includes nodes running blockchain protocol client applications 105 and end devices controllable by at least a subset of those nodes.

[0119] A first bridge node 503 (e.g., a master node 503a or a server node 503b) of the network 501 generates a first transaction Tx1 including an input signed by the first node and an output including command data. The command data includes an identifier of the end device 502 to be controlled and a command message for controlling the end device 502. The first node may be the originator of the command; that is, the first node may generate the command data.

[0120] The first node may transmit the first transaction Tx1 to a second bridge node 503 (e.g., slave node 503c) of the first network 501 that controls the end device 502. The first transaction Tx1 may be transmitted off-chain, i.e., without being transmitted to the blockchain. For example, the first transaction Tx1 may be transmitted directly from the first node to the second node, for example, via the Internet. For example, the first node may be the server node 503b and the second node may be the slave node 503c. Alternatively, the first transaction Tx1 may be transmitted indirectly, for example, via one or more intermediate nodes. As an example, the first transaction Tx1 may be transmitted from the master node 503a to the slave node 503c via the server node 503b. The second node may be connected to the end device 502 via a wired or wireless connection, for example, via an Ethernet or Wi-Fi connection.

[0121] Additionally or alternatively, the first node may transmit the first transaction Tx1 to the blockchain network 106 to be recorded in the blockchain 150. This relies on the first transaction Tx1 being a valid transaction. As described below, it may be preferable not to transmit the first transaction Tx1 to the blockchain.

[0122] 1-3, in these examples, a first node may be comprised of Alice's 103a's computing device 102a and a second node may be comprised of Bob's 103b's computing device 102b. As previously described, Alice and Bob may exchange transactions using a side channel (e.g., side channel 301) without the transaction being published on the blockchain network 106 or progressing on the chain 150 (yet) until one of the parties chooses to broadcast the transaction to the network 106.

[0123] The second node may obtain the first transaction Tx1 directly or indirectly from the first node, e.g., the first transaction Tx1 may be forwarded to the second node via one or more intermediate nodes. The second node uses the command data to send a control instruction to the end device 502, which is identified by a device identifier ("device ID") in the command data. The control message in the command data may define a desired action of the end device 502. The control message may be configured to cause the second node to send a specific one of several possible instructions to the end device 502. Alternatively, the second node may be configured to send a single instruction to the end device 502, i.e., the second node sends only the same instruction to the end device. This is the case, for example, when the end device 502 is a simple device such as a sensor and the instruction is a request for a sensor reading.

[0124] Commands (i.e., instructions for an end device) may be sent to the device off-chain via a wired or wireless connection, for example using Wi-Fi. Alternatively, if the device is also a node in the network, the commands may be sent via a blockchain transaction Tx.

[0125] In some embodiments, a request and response cycle for device and controller communication may be implemented by the first and second nodes. A request (command) is issued as a partially complete transaction that includes an output that includes the command data (e.g., OP_RETURN payload). The response (acknowledgment of the command) is a broadcast of a finalized transaction that includes the signatures of both the requester and the responding node. The malleability of transactions makes this method of communication possible, since message recipients cannot modify the command data (e.g., OP_RETURN payload) but can add inputs and outputs.

[0126] Opcodes are instruction syllables or parcels used within the script engine 402 to instruct the miner 104M to perform stack-based and cryptographic operations on data. Here, the script engine 402 is the execution environment used to validate the script within the blockchain transaction Tx, and the stack 403 is a data structure (a collection of elements) with two main operations: "push" to add an element to the collection, and "pop" to remove the most recently added element. Opcodes are designed to perform operations on stack elements. When validating a transaction Tx, the script engine 402 will not execute any data in the output script (ScriptPubkey) after the OP_RETURN opcode. In practice, this means that the remaining script data can be optional, and the output itself is unspendable (one blockchain protocol requires that an OP_FALSE opcode precedes OP_RETURN to ensure output non-spendability).

[0127] A first transaction Tx1 sent from a first node to a second node may be sent without a second output. That is, the transaction includes a single output (the output includes the command data). To complete the partial transaction, the second may update the transaction by adding an input and an output to the first transaction. The input includes the signature of the second node, i.e., a signature generated using the private key of the second node. The output is an output locked to the public key of the second node, e.g., a P2PKH output. To use a P2PKH output, the input of the transaction to use must include a public key such that the hash of the public key (e.g., OP_HASH160) matches the public key hash in the P2PKH output. The P2PKH output challenges the spender to provide two items, not necessarily in that order: a public key such that the hash of the public key matches an address in the P2PKH output, and a signature that is valid for the public key and the transaction message. The public key may correspond to the private key used to generate the signature. Alternatively, the signature may be linked to the first public key and the output may be locked to a different public key. The second node may then send the completed transaction to the blockchain network 106. The completed transaction (referred to as a command transaction in these embodiments) is available in the blockchain 150 for other nodes, e.g., the first node, to view and serves as a record of the command executed by the device. That is, when a transaction is broadcast, an independent observer can see which public key issued the command / message and which public key responded to it.

[0128] 7a and 7b show an exemplary partial first transaction Tx1 (partial) and an exemplary updated first transaction Tx1 (complete). The partial first transaction includes a single input 701a and a single output 702a. The updated first transaction includes an input 701b and an output 702b added by a second node. A desired level of transaction malleability can be achieved using the SIGHASH_SINGLE signature type. For example, a node with public key PK0 sends an instruction to a node with public key PK1. The instruction is encoded in an unspent output (e.g., an OP_RETURN output) of the transaction that is signed using the SIGHASH_SINGLE signature type (Fig. 10a). The partially complete transaction is valid. Once the instruction is complete, the second node with PK1 adds the locked output to their address. The second node with PK1 then finalizes the transaction by signing the entire transaction using the SIGHASH_ALL signature type (see Fig. 10b).

[0129] In an alternative embodiment, the first transaction Tx1 sent from the first node to the second node may be sent with a second output, which is locked to the public key of the second node. For example, the second output may be a P2PKH to the public key of the second node.

[0130] To complete the first transaction Tx1, the second node updates the first transaction by adding an input to the first transaction. At this point, the first transaction Tx1 includes two inputs and two outputs. The second input includes the public key of the second node. The public key in the second input may or may not be the same as the public key to which the second output is locked. Once completed, the updated first transaction (referred to as a command transaction in these embodiments) is sent to the blockchain network 106 for inclusion in the blockchain 150. Once the command transaction is broadcast, any independent observer can see which public keys issued the command / message and which public keys responded to it.

[0131] The second output locked to the public key of the second node may transfer an amount of digital assets that is greater than the amount of digital assets referenced by the first input of the first transaction. In that case, the first transaction Tx1 is a partially complete transaction that is not considered valid by other nodes of the blockchain network 106. That is, the first transaction Tx1 will not be mined into block 152 of the blockchain 150 because it does not satisfy the consensus rules followed by the blockchain nodes. When updating the first transaction Tx1, the second node would have to ensure that the aggregate amount of digital assets referenced by the first and second inputs is greater than the amount of digital assets locked in the second output.

[0132] 8a and 8b show an exemplary partial first transaction Tx1 (partial) and an exemplary updated first transaction Tx1 (complete). The first transaction includes command data in a first output 802a and a second output 802b locked to the public key of the second node. The updated first transaction includes an additional input 801b added by the second node. If a first node with PK0 sends an instruction to a second node with PK1 that it wants executed by the second node with only PK1, they can send a partially complete transaction that locks both outputs 802a, 802b but does not pay a fee (and thus is not mined or propagated). To redeem the digital assets locked in PK1, the second node with PK1 needs to provide an input 801b that pays a fee. To issue a command using a partially complete transaction,

number

[0133] Note that the SIGHASH flag is a flag added to a signature in a transaction input to indicate which parts of the transaction the signature is signing. The default is SIGHASH_ALL (all parts of the transaction except the ScriptSig are signed). Unsigned parts of a transaction can be modified.

[0134] An exemplary request and response algorithm is provided below with reference to Figures 9, 10a, and 10b. The control device 503b is configured to communicate with other nodes on the network 501 and can calculate the shortest communication path to any other node on the network. For example, the PK serv PK slave is the controller closest to the device with device_ID.

[0135] Step 1: Public Key PK serv The control device 503b having the public key PK slave The IoT message included in the transaction specifies the command and the target device with its device_ID.

[0136] Step 2: Second control device (PK slave ) checks that the transaction signature is valid and that the message contained within the IoT message payload is valid according to the rules of the network 501.

[0137] Step 3: Second Control Device (PK slave ) sends a command message ("Msg") to the device (device_ID) via off-chain communication (e.g., wired connection, Bluetooth, IP-to-IP).

[0138] Step 4: Upon completion of the command requested action, the device (device_ID) sends a command completion or acknowledgment message ("ack") to the second controlling device (PK slave ) back to

[0139] Step 5: Second Controller (PK slave) adds a second input and signature, finalizing the transaction (see Figure 10b), signaling that the second controller has confirmed the command's completion.

[0140] Step 6: Second Controller (PK slave ) broadcasts the finalized transaction to the blockchain (mining) network 504.

[0141] In some embodiments, the first transaction Tx1 may be a command request transaction Tx1 (request) rather than a transaction. That is, the first node may send a request to two or more nodes of the network for approval to control the end device 502. For example, the first node may be a master node 503a and a server node 503b requesting approval from a different bridge node 503 (e.g., another server node 503b). The first transaction Tx1 includes command data including a command message for controlling the end device 502. However, instead of sending the first transaction Tx1 to one node that controls the end device 502, the first node sends the first transaction Tx1 to two or more nodes that can approve the command request. That is, the first node includes an output locked to two or more nodes of the network 501. To unlock the output, a signature from each node must be provided in the input of a later transaction Tx2. The first transaction Tx1 is broadcast to the blockchain network 160 for inclusion in the blockchain 150. When two or more nodes see transaction Tx2 (by listening to transactions paid to their public keys or public key addresses), if two or more nodes wish to approve the command request, they each sign the inputs of a command approval transaction Tx2 (the approval) and broadcast that transaction Tx2 to the blockchain network 106. The command approval transaction Tx2 contains the same command data as the command request transaction Tx1, plus an additional output locked to the public key of the second node that controls the end device 502.

[0142] 11a and 11b show exemplary first and second transactions, where the first transaction Tx1 is a command request transaction and the second transaction Tx2 is a command authorization transaction. The first transaction Tx1 includes an input 1101a signed by a first node, a first output 1102a containing command data, and a second output 1102b locked to two different public keys, one public key of a third node and one public key of a fourth node (also a bridge node 503 of the IoT network 501). The second transaction Tx2 includes an input 1101b signed by the third and fourth nodes, a first output 1102a, and a second output 1102c locked to the public key of the second node. Multi-signature scripts allow multi-factor authorization for commands. In some cases, command interpretation or certificate validation may require signatures from more than one node (e.g., nodes of the IoT network). It may also require checking if the available output is in the UTXO set. For example, a first node with public key PK0 may want to command a second node with public key PK3 to perform an action. As a security requirement, this command may require a third and fourth node with public keys PK1 and PK2, respectively, to approve. The first node with public key PK0 creates a first transaction that sends funds to a multi-signature address. The first transaction also includes command data (encoding a command to PK3) that requires approval. In response, node 503 with public keys PK1 and PK2 has the option to spend funds from the multi-signature address if both provide a signature. The approval is interpreted as spending the output in the command request transaction. These figures show two-of-two pay to multi-sig (P2MS) outputs, but in general a P2MS output can be an n-of-n output, where n is any integer; P2MS is a type of script pattern that allows a payer to lock an output to multiple addresses.To be used, an output may require one or more signatures from a designated set of public keys.

[0143] In some embodiments, the first node may generate the command request transaction Tx1 as described above. Additionally or alternatively, the first node may generate the command approval transaction Tx2 in response to a command request transaction generated by a different node of the IoT network 501. For example, the first node may be a master node 503a that may grant approval for the request. In that case, the blockchain 150 includes a command request transaction that includes an output locked to the public key of the first node and one or more respective public keys of one or more further nodes 503 of the IoT network 501. For example, the first node may be a node that approves a command issued to an end device 502 controlled by a second node. If the first node approves the command, the first node signs a command approval transaction that references the output of the command request transaction. If the first node is the last node to sign the command approval transaction, the first node transmits the transaction to the blockchain network 106. The broadcast transaction Tx2 is interpreted as a command approval request.

[0144] When a second node (e.g., a slave node) gets a command transaction or a command acknowledgement transaction, the second node sends the command (Msg) to the device identified by the device identifier (Device_ID) in the command data. In some examples, the device 502 may send an acknowledgement message (Ack) to the second node to indicate that it has received and / or executed the command. In these examples, the second node may only update the first transaction (and then broadcast the updated transaction) conditional on receiving an acknowledgement from the device. This provides further corroborating evidence that the end device executed the command.

[0145] Due to the resource constraints that most everyday small electronic devices have, they may not be able to easily monitor the blockchain 150 and / or even communicate with IoT network components outside their immediate location, and thus control of the end device 502 is performed locally (from a second node to the device) and off-chain. Messages to and from the end device may take the form of raw command data (e.g., OP_RETURN payload) without additional transaction metadata. This ensures that data packets containing messages remain small and no computationally intensive operations (such as elliptic curve mathematics) are required.

[0146] In some embodiments, the command data included in the transaction is encrypted. The command data may be encrypted with an encryption key based on a random number, but the encryption key is preferably generated based on the public key of the first node and the public key of the second node. The public keys of the first node and / or the second node may be certified public keys (certified public keys are described below). The certified public keys are included in the respective certificates issued to the first and / or second nodes. These public keys may be different from the public keys used by the first and second nodes to generate and update the first transaction. That is, the public key used to generate a signature or to lock the output of the transaction (the "transaction public key") may not be the same as the public key used to generate the encryption key. In other examples, the transaction public key may be used to generate the encryption key.

[0147] The encryption keys used to encrypt the command data may be generated independently by the first and second nodes. For example, the first node may generate an encryption key based on a private key known to the first node and a public key of the second node. The second node may generate an encryption key based on a public key corresponding to the private key of the first node and a private key corresponding to the public key of the second node. This ensures that both the first node and the second node can decrypt the command data, so that, for example, the second node can access the command message to instruct the device.

[0148] Optionally, the output of the first transaction, including the command data, may include an encryption key used to encrypt the command data. The encrypted key may be encrypted with a second, different encryption key. A party who knows the second encryption key can decrypt the encrypted encryption key and decrypt the encrypted command data. For example, it may be beneficial for an entity, such as a master node, to be able to view all command messages sent to and from the nodes of the network. The second encryption key may be generated based on the public key of the first node and a public key of a different node, e.g., the master node. The public key of the first node may be the attested key or transaction public key of the first node. Similarly, the public key of the master node may be the attested key or transaction public key of the master node.

[0149] The encryption may be symmetric. Symmetric encryption provides the same degree of privacy for on-chain data that HTTPS provides for communications over the Internet. To do this, the master node creates a secret encryption key that is used to encrypt all regular messages between nodes on the local IoT network. Each IoT transaction OP_RETURN payload (i.e., the output containing the command data) may have two chunks of data. First, the BIE1 ECIES encrypts the IoT message, where the encryption key is derived using the (certified) public keys of the requesting and responding devices (end-to-end). Second, the BIE1 ECIES encrypts the encryption / decryption key for the IoT message. Elliptic Curve Integrated Encryption Scheme (ECIES) is an encryption scheme based on Diffie-Hellman exchange. The second encryption key (which is used to encrypt this data push) is derived using the master public key and the requester public key. An additional byte push is added to the end of the encrypted payload, which itself contains the decryption key for the IoT message encrypted using BIE1 between the requesting node and the master. This ensures that the master node can view decrypted data sent between devices on the network. Other encryption techniques may also be used, such as American Encryption Standard (AES) encryption.

[0150] 12a and 12b show depicted command and response transactions with encrypted payload data.

[0151] As described above, the first and second nodes may use transaction public keys when generating and updating transactions. Although public keys are used to identify nodes on the IoT network, preferably those public keys should not be used to sign transactions. For example, each node may have a public key included in a certificate issued by a registration authority. The owner of the certified key (e.g., a public key with a corresponding certificate signed by a master node) can derive a shared secret that can be used to hide his or her identity from third parties and sign transactions.

[0152] As described above, the IoT network 501 may include a master node 503a. The master node 503a may obtain (e.g., generate) a seed key and then generate a set of private keys (e.g., multiple private keys), each based on the seed key. The master node 503a may then transmit the set of private keys (hereinafter referred to as joint private keys) to the nodes of the network (e.g., server nodes and slave nodes). Each node receives the same set of joint private keys, but not the seed private keys.

[0153] Each node has a respective master private key, e.g., a private key that corresponds to that node's certified public key. Each node, including the master node 503a, uses a set of joint private keys to generate a corresponding set of secondary (or transaction) private keys. The transaction private keys are generated by appending the respective node's master private key to each joint key. For each node, a corresponding set of transaction public keys can be generated from the set of transaction private keys.

[0154] The first node may be the master node 503a, i.e., the node that generates the set of joint private keys. Alternatively, the first node may be an intermediate node (e.g., a server node or a slave node) that receives the set of joint private keys from the master node. In some examples, each node may use the transaction public key only once.

[0155] An exemplary key masking algorithm for generating transaction keys from the attested key is provided below. All nodes 503 on the local IoT network 501 are issued certificates that register their public keys. Specifically, the server node receives the attested key PK serv The master node has a private key sk Master A certified key PK with Master has.

[0156] Step 1: The master node 503a derives the master extended private key m from the seed. joint m is used to generate a wallet of keys that are shared across the IoT network 501 and used to mask each node address. The joint wallet has the following index keys:

number

[0157] Step 2: The master node 503a shares m with other nodes on the IoT network in an off-chain message using an off-chain end-to-end encryption scheme (e.g., BIE1 ECIES).

[0158] Step 3: Once the server node 503b has obtained m, it can derive a set of hierarchical deterministic key pairs in the wallet.

[0159] Step 4: Each node 503 on the network 501 generates their wallet private key by appending the private key from their attested key pair to the private key generated from the joint wallet. For example, the master node generates a transaction signing key

number

number

[0160] Step 5: Each node 503 can identify all payment endpoints (addresses) of other nodes 503 on the IoT network 501 by appending the other node public keys to the public key from the joint wallet. For example, the server node 503b can identify the payment address public key of the master node

number

number

[0161] Each node 503 on the IoT network 501 derives its own wallet and can monitor the addresses of other devices if they know the location of m and the associated IoT certificate.

[0162] Both encryption and key masking protect device activity data from being leaked to third parties, while still ensuring device visibility to all nodes 503 on the local IoT network 501.

[0163] Each transaction sent by a node 503 of the IoT network 501 includes an output that includes command data. The output and / or the command data may include a protocol flag to indicate that the output includes command data. This allows IoT devices and independent third parties to identify when an on-chain command, action, or status update has occurred.

[0164] FIG. 13 shows an example command data output of a first transaction. The first transaction includes an input (not shown) containing the signature of the first node, and an output 1301 containing the command data. The first transaction may also include a second output (not shown), which is described below. In this example, following the protocol identifier (4 bytes), there is a 93-byte payload containing IoT communication information. The communication information includes a 32-byte device ID of the intended recipient of the command instruction, the location of the device certificate, the command, and the device status. In some examples, all transactions that issue new commands or status updates must follow this format or be considered invalid commands. If a field is not required for any on-chain message, the byte may be set to 0x00000000. Preferably, the payload data itself is encrypted, as described below. The payload data can only be accessed by the party that holds the decryption key. The following table describes the fields of an example IOT message payload:

[0165] [Table 2] A device state replica is a logical representation of a device's reported or desired state. Within an IoT message, device state information is encoded into a device ID, status, and previous status. The most recent transaction on the device ID represents the current device status. Messages containing commands, responses, and data related to the device's status are included in timestamped blocks on the blockchain and secured using public key cryptography and proof of work.

[0166] In summary, nodes 503 on the IoT network 106 communicate not only directly using transactions containing IoT command data, but also by connecting to the blockchain network 501 and broadcasting transactions. The blockchain 150 is used as a persistent data store for recording commands and status updates from the IoT network components, as well as for issuing reports and alerts related to the IoT devices 502. The protocol may utilize one or more of the following features:

[0167] Request and Response Messaging System - A request and response system for receiving and acknowledging commands is used. Requests are offline (peer-to-peer) transactions that encode IoT logic that can be interpreted by end devices. Responses or acknowledgments are interpreted from visibility of the transaction on the blockchain network 106.

[0168] Offline transaction propagation - instructions encoded in the transaction are sent directly (peer-to-peer). Master, server and slave nodes can independently verify the source of the transaction by verifying the transaction signature. This also serves as a payment method for the controller.

[0169] Direct communication between a node and an end device - If the instruction encoded in the transaction command payload is targeted to an end device, a server or slave node can extract the instruction from the transaction and communicate it directly to the end device.

[0170] Broadcasting the transaction as an acknowledgment of the action - Broadcasting the transaction to the blockchain network indicates that the action encoded in the command was performed by the device with the device ID.

[0171] Mined transactions encoding device status and history - The blockchain acts as a (logically) centralized and physically distributed database that stores the complete device status and history.

[0172] Embodiments provide one or more of the following advantageous features.

[0173] Security of the underlying blockchain infrastructure - All transactions that encode the transfer of value and log IoT interactions are secured using public key cryptography and proof of work. Elliptic Curve Cryptography (ECC) based on secp256k1 parameters protects the public / private keys used to identify IoT nodes, and proof of work secures the blockchain that records the IoT network status and history.

[0174] Secure Key Management and Obfuscation - Key obfuscation techniques are used to ensure that sensitive public keys are not weakened by overuse of their corresponding private keys. Key obfuscation also enables IoT solution components to increase privacy by masking their public addresses.

[0175] Encryption - The contained device specific data is encrypted end-to-end (e.g. BIE1 or AES) so that only IoT nodes with the decryption key can gain access.

[0176] Example Use Cases An exemplary use case is a printer service for a public library. In most publicly funded or university libraries, printing costs are paid for by charging a minimum amount per page (e.g., 6-10 pence). Within the current (centralized) model, users open an account that is managed by the library administration. The account needs to be pre-funded and transactions must be managed by software operated by the library, creating a large administrative burden for the library. This disclosure solves this problem by using a permission protocol in conjunction with a peer-to-peer control protocol. Figure 14 shows an exemplary IoT network 501 for P2P printing. 1) The library administration establishes a master node 503a (controlled by the library administration) and configures a slave node 503c that directly controls the printer (end device) 502. 2) The administration configures a rules engine that the slave node 503c and the end device 502 will use to interpret messages. A rules engine is a system that executes one or more rules. 3) The library administration configures a slave node 503c, which is a payment receiving device that can directly command the printer to perform a physical action. 4) A new library user is authorized and verified by the master node 503a using standard registration / login methods (e.g., one or more credentials such as username and password). The IoT authorization algorithm runs in the backend. Figure 15a shows an example transaction used by the library administrator to issue a certificate to a new library user. In this case, the library administrator is the master node 503a as well as a registration authority with certificate revocation authority. 5) If the user wants to print an item, the printed document can be sent within the library intranet system. Along with the document is a command transaction. This transaction includes a payment to the slave node that coordinates the printer, the printer device ID, and a SIGHASH_SINGLE transaction signature. Figure 15b shows an example command transaction sent by the laptop (server) to the (slave) controller.6) The controller (slave node) verifies that the transaction is a valid blockchain transaction, the transaction source (public key) is authorized on the system, and the transaction value is sufficient to pay the cost of the instructions included in the command. 7) If all checks pass, the slave node commands the printer to perform the action requested by the user. 8) The slave node adds the output that locks the payment to their address, adds the signature with SIGHASH_ALL, and then broadcasts the transaction to the blockchain network 106. Figure 15c shows an example command-acknowledgement transaction broadcast by the controller to the blockchain network 106.

[0177] conclusion It will be appreciated that the above embodiments have been described by way of example only. More generally, a method, apparatus or program may be provided according to any one or more of the following statements:

[0178] Statement 1. A computer-implemented method for granting permission to a requester to join a first network, the first network including a set of bridge nodes and a set of devices controllable by one or more of the set of bridge nodes, each bridge node also being a respective node of a blockchain network, the method being performed by a registration authority and including: - generating a first blockchain transaction, where the first blockchain transaction includes an input including a signature linked to a first public key of a registration authority and a first output including a first certificate, the first certificate including an identifier assigned to a requester; and -Submitting a first blockchain transaction to a blockchain network for inclusion in the blockchain.

[0179] Statement 2. The method of statement 1, wherein the first transaction includes a second output locked to a second public key of the registration authority.

[0180] Statement 3. The method of statement 2, wherein the first output is time-locked to a second public key of a registration authority, the time-lock preventing the first output from being unlocked until after a predetermined period of time.

[0181] Statement 4. The method of statement 2 or statement 3, wherein the first output is locked to at least a second public key of the registration authority and a different public key.

[0182] The different public key may be the public key of a node of the network or a third party that is not part of the network, which means that certificate revocation requires multiple signatures.

[0183] Statement 5. The method of any of statements 1 to 4, including sending a transaction identifier of the first blockchain transaction to the authorization requester.

[0184] Statement 6. The method of any of statements 1 to 5, wherein the certificate is encrypted with an encryption key, the encryption key being generated by a registration authority.

[0185] For example, the cryptographic key may be a random number generated by a registration authority.

[0186] Statement 7. A method according to any one of statements 1 to 6, comprising: receiving a request from a requester to join the network, where the request includes one or more credentials; and - validating the request based on one or more credentials, where the generating of the first blockchain transaction is conditioned on the request being valid.

[0187] The one or more credentials may include, for example, manufacturing information and / or an IP address of the requester.

[0188] Statement 8. The method of any of statements 1 to 7, wherein the set of bridge nodes includes a master node and a set of intermediate nodes controllable by the master node, and the registration authority is the master node.

[0189] Statement 9. The method of any of statements 1 to 8, wherein the set of bridge nodes includes a master node and a set of intermediate nodes controllable by the master node, and the requester is the master node.

[0190] Statement 10. The method of any of statements 1 to 9, wherein the requester is a respective node of the blockchain network, and the certificate includes a public key assigned to the authorized requester.

[0191] Statement 11. A method according to any of statements 1 to 8, wherein the requester is a device controllable by one or more bridge nodes of the first network, and the method includes: - Sending a set of certificates to the requester, where each certificate in the set is sent to a respective one of the set of nodes.

[0192] Statement 12. The method of any of statements 1 to 11, including transmitting the first certificate to one or more of a set of bridge nodes.

[0193] Statement 13. A method according to statement 2 or any statement subordinate thereto, comprising: - generating a second blockchain transaction, where the second blockchain transaction includes an input that references the second output of the first transaction and includes a signature linked to the second public key of the registrar; and -Submitting the second blockchain transaction to the blockchain network for inclusion in the blockchain.

[0194] Statement 14. A computer-implemented method for requesting permission to join a first network, the first network including a set of bridge nodes and a set of devices controllable by one or more of the set of bridge nodes, each bridge node also being a respective node of a blockchain network, the method being performed by a requester and including: sending a request to a registration authority to join the first network; and - Obtaining a first certificate, where the certificate is issued by a registration authority and includes an identifier assigned to the requester.

[0195] Statement 15. The method according to statement 14, wherein the obtaining includes: receiving a transaction identifier for a first blockchain transaction that includes a first certificate; and - Retrieving a first blockchain transaction from a blockchain using the transaction identifier.

[0196] Statement 16. The method of statement 15, wherein the first blockchain transaction includes a first input including a certificate and a second output linked to a public key of a registration authority, the method including: -Identifying the public key of the registration authority; and -Identifying one or more second certificates included in one or more respective transactions sent to the blockchain from the public key of the registration authority, where each second certificate is issued to a respective bridge node or device or network.

[0197] Statement 17. A method as recited in statement 16, wherein the first certificate includes a public key of the requester and each second certificate issued to a respective one of a set of bridge nodes of the first network includes a public key of a respective one of said nodes, the method including: - Sending a third blockchain transaction to at least one of the set of bridge nodes, where the third blockchain transaction includes an output locked to a respective public key of the at least one bridge node.

[0198] Statement 18. The method of any of statements 14 to 17, wherein obtaining the first certificate includes receiving the first certificate from a registration authority.

[0199] Statement 19. The method according to any one of statements 14 to 18, comprising: - Receiving one or more second certificates from a registration authority, where each second certificate is issued to a respective one of a set of bridge nodes or devices of the first network.

[0200] Statement 20. The method of statement 19, wherein the first certificate includes a network address of the requester and each second certificate issued to a respective bridge node of the first network includes a respective network address of said node, the method including: - Sending a message to one or more of a set of bridge nodes, where the message is sent from the network address of the requester to the network address of each of the one or more bridge nodes to which the message is sent.

[0201] The network address may be an IP address.

[0202] Statement 21. The method of statement 14 or any of statements 18 to 20, wherein the requester is one of a set of devices of the first network.

[0203] Statement 22. The method of any of statements 14 to 21, wherein the requester is one of a set of nodes of the first network.

[0204] Statement 23. The method according to statement 22, wherein the set of bridge nodes includes a master node and one or more intermediate nodes controllable by the master node, and the requester is the master node.

[0205] Statement 24. The method of any of statements 14 to 23, wherein the request includes one or more credentials of the requester.

[0206] Statement 25. The method of statement 24, wherein the one or more credentials include an IP address of the requester.

[0207] Statement 26. A computer device comprising: a memory comprising one or more memory units, and - a processing device having one or more processing units, where the memory stores code configured to be executed on the processing device, the code being configured, when on the processing device, to perform the method described in any of statements 1 to 13.

[0208] Statement 27. A computer program embodied on a computer readable storage and configured to perform the method according to any of statements 1 to 13 when executed on a computing device according to statement 26.

[0209] Statement 28. A computer device comprising: a memory comprising one or more memory units, and - a processing device having one or more processing units, where the memory stores code configured to be executed on the processing device, the code being configured, when on the processing device, to perform the method described in any of statements 14 to 25.

[0210] Statement 29. A computer program embodied on a computer readable storage and configured to perform the method according to any of statements 14 to 25 when executed on a computing device according to statement 28.

[0211] According to another aspect of the teachings disclosed herein, a method may be provided that includes actions of a registration authority and an authorization requester.

[0212] According to another aspect of the teachings disclosed herein, a system may be provided that includes a registration authority and an authorization requester computing device.

[0213] According to another aspect of the teachings disclosed herein, a set of transactions may be provided that includes a first and / or a second blockchain transaction.

[0214] Other variations or uses of the disclosed techniques may become apparent to those of ordinary skill in the art given the disclosure herein. The scope of the present disclosure is not limited by the described embodiments, but only by the accompanying statements.

Claims

1. 1. A computer-implemented method for granting permission to a requestor to join a first network, comprising: The first network includes a set of bridge nodes and a set of devices controllable by one or more of the set of bridge nodes, each bridge node also being a respective node of a blockchain network, and the computer-implemented method is performed by a registration authority, the method comprising: generating a first blockchain transaction, the first blockchain transaction including an input including a signature linked to a first public key of the registration authority and a first output including a first certificate, the first certificate including an identifier assigned to the requester, the first certificate including a network address of the requester; transmitting the first blockchain transaction to the blockchain network for inclusion in the blockchain; sending one or more second certificates to the requester, each second certificate issued to a respective one of the set of bridge nodes or devices of the first network, each second certificate issued to a respective bridge node of the first network including a respective network address of the node, the requester being configured to send a message from the network address of the requester to a respective network address of one or more of the bridge nodes to which the message is to be sent; A method comprising:

2. the first blockchain transaction includes a second output locked to a second public key of the registrar, the first output being time-locked to the second public key of the registrar, the time-lock preventing the first output from being unlocked until after a predetermined period of time; The method of claim 1.

3. the first output is locked to at least the second public key and a different public key of the registration authority; The method of claim 2.

4. The method comprises: sending a transaction identifier of the first blockchain transaction to an authorization requester; The method of claim 1.

5. The method comprises: receiving a request from the requestor to join the network, the request including one or more credentials; validating the request based on the one or more credentials, wherein the generating the first blockchain transaction is conditioned on the request being valid; The method of claim 1 , comprising:

6. The set of bridge nodes includes a master node and a set of intermediate nodes controllable by the master node; The registration authority is the master node. The method of claim 1.

7. The set of bridge nodes includes a master node and a set of intermediate nodes controllable by the master node, and the requester is the master node. The method of claim 1.

8. The requestor is a device controllable by one or more bridge nodes of the first network, and the method comprises: transmitting a set of certificates to the requestor, each certificate in the set being transmitted to a respective one of the set of bridge nodes. The method of claim 1.

9. 1. A computer-implemented method for requesting permission to join a first network, comprising: The first network includes a set of bridge nodes and a set of devices controllable by one or more of the set of bridge nodes, each bridge node also being a respective node of a blockchain network, and the computer-implemented method is performed by a requester, the method comprising: sending a request to join the first network to a registration authority; obtaining a first certificate, the certificate having been issued by the registration authority and including an identifier assigned to the requester, the first certificate including a network address of the requester; receiving one or more second certificates from the registration authority, each second certificate issued to a respective one of a set of bridge nodes or devices of the first network, each second certificate issued to a respective bridge node of the first network including a respective network address of the node; sending a message to one or more of the set of bridge nodes, the message being sent from a network address of the requester to a network address of each of the one or more bridge nodes to which the message is sent; A method comprising:

10. The obtaining step includes: receiving a transaction identifier of a first blockchain transaction that includes the first certificate; Retrieving the first blockchain transaction from the blockchain using the transaction identifier; 10. The method of claim 9, comprising:

11. The first blockchain transaction includes a first input including the certificate and a second output linked to a public key of the registrar, and the method further comprises: identifying a public key of the registration authority; identifying, from the public key of the registrar, one or more second certificates included in one or more respective transactions sent to the blockchain, each second certificate being issued to a respective bridge node or device of the first network; The method of claim 10.

12. the first certificate includes a public key of the requester, and each second certificate issued to a respective one of a set of bridge nodes of the first network includes a public key of a respective one of the bridge nodes, and the method further comprises: sending a third blockchain transaction to at least one of the set of bridge nodes, the third blockchain transaction including an output locked to a respective public key of the at least one bridge node; The method of claim 11 , comprising:

13. the requester is one of a set of devices of the first network; 10. The method of claim 9.

14. the requester is one of a set of nodes of the first network; 10. The method of claim 9.

15. The set of bridge nodes includes a master node and one or more intermediate nodes controllable by the master node; and The requester is the master node. The method of claim 14.

16. the request includes one or more credentials of the requester; the one or more credentials include an IP address of the requester; 10. The method of claim 9.

17. 1. A computer device comprising: a memory including one or more memory units; a processing device including one or more processing units; the memory storing code configured to be executed on the processor; The code, when executed by the processing device, is configured to perform the method of any one of claims 1 to 8. Computer equipment.

18. A computer program stored on a computer readable storage medium, comprising: When executed on a computing device according to claim 17, the device is arranged to carry out the method according to any one of claims 1 to 8. Computer program.

19. 1. A computer device comprising: a memory including one or more memory units; a processing device including one or more processing units; the memory storing code configured to be executed on the processor; The code, when executed by the processing device, is configured to perform the method of any one of claims 9 to 16. Computer equipment.

20. A computer program stored on a computer readable storage medium, comprising: When executed on a computing device according to claim 17, the device is arranged to carry out the method according to any one of claims 9 to 16. Computer program.

Images