Method for pooling in spatial attestation-based blockchain via singleton

Abstract

The invention relates to a method for pooling in a spatial attestation-based blockchain via a singleton. A method for pooling and retrieving block rewards in a reward pool, the reward pool comprising an operator node and a set of member nodes in a distributed network extending a space proof-based block chain, the method comprising: submitting a transaction configured to generate a singleton in a set of singleton, the singleton includes: an external puzzle hash linking the singleton to a singleton puzzle hash, and an internal puzzle hash defining a pool address associated with the reward pool; generating a block comprising a space proof and a block reward assigned to the singleton hash; detecting a block reward allocated to the singleton hash; identifying a singleton linked to the singleton puzzle hash; and submitting a transaction configured to remove the singles from the set of singles and to transfer the block reward from the singles puzzle hash to the pool address.

Description

[0001] This application is a divisional application of an application with an application date of October 5, 2022, application number 202280067153.0, and invention name “Method for pooling in a blockchain based on space proof via a singleton”.

[0002] CROSS-REFERENCE TO RELATED APPLICATIONS

[0003] This application claims the benefit of U.S. Patent Application No. 17 / 959,966, filed on October 4, 2022, which claims the benefit of U.S. Provisional Application No. 63 / 253,259, filed on October 7, 2021, each of which is incorporated by reference in its entirety.

[0004] This application is related to U.S. Patent No. 11,165,582 filed on May 13, 2020, U.S. Patent Application No. 17 / 320,114 filed on May 13, 2021, and U.S. Patent Application No. 17 / 497,699 filed on November 8, 2021, each of which is incorporated by reference in its entirety. Technical Field

[0005] The present invention relates generally to the field of blockchain protocols, and more particularly to new and useful methods in the field of blockchain protocols for pooling in proof-of-space blockchains. Summary of the invention

[0006] This application provides the following:

[0007] 1). A method for pooling block rewards in a reward pool, the reward pool comprising an operator node and a set of member nodes in a distributed network extending a proof-of-space based blockchain, the method comprising:

[0008] During an initial time period, by a first member node in the set of member nodes:

[0009] Generate a seeding file, which defines:

[0010] A set of space proofs; and

[0011] Singleton puzzle hashing;

[0012] storing the seeding file on a storage device; and

[0013] Submitting a first transaction, the first transaction being configured to generate a first singleton based on the singleton puzzle hash, the first singleton comprising:

[0014] linking the first singleton to an external puzzle hash of the singleton puzzle hash; and

[0015] An internal puzzle hash defining a collection state of the first singleton, the collection state of the first singleton representing:

[0016] an owner address associated with the first member node; and

[0017] a first pool address associated with the reward pool; and

[0018] During a first time period subsequent to the initial time period, by the first member node:

[0019] accessing a first challenge from a first version of the blockchain;

[0020] generating a first spatial proof from the set of spatial proofs in response to the first challenge;

[0021] broadcasting the first spatial proof on the distributed network;

[0022] generating a first block based on the first proof of space, the first block including a block reward allocated to the singleton puzzle hash; and

[0023] The first block is broadcasted on the distributed network.

[0024] 2) The method according to 1) further comprises: during a second time period following the initial time period, the first member node:

[0025] accessing a second version of the blockchain comprising a set of singletons, the set of singletons comprising the first singleton; and

[0026] Submit a second transaction, wherein the second transaction is configured to generate a second singleton in the set of singletons based on the first singleton, the second singleton comprising:

[0027] linking the second singleton to an external puzzle hash of the singleton puzzle hash; and

[0028] An internal puzzle hash of a transition state of the second singleton is defined, the transition state of the second singleton representing:

[0029] the address of said owner;

[0030] the first pool address;

[0031] a second pool address associated with a different reward pool; and

[0032] Escape time.

[0033] 3). The method according to 2) further includes:

[0034] During a third time period spanning the second time period and an escape period, the escape period being after the second time period and exhibiting a length of the escape time, the first member node:

[0035] accessing a third version of the blockchain that includes the set of singletons, the set of singletons including the second singleton; and

[0036] Submit a third transaction, wherein the third transaction is configured to generate a third singleton in the set of singletons based on the second singleton, the third singleton comprising:

[0037] linking the third singleton to an outer puzzle hash of the singleton puzzle hash; and

[0038] An internal puzzle hash defining the collection state of the third singleton, the collection state of the third singleton representing:

[0039] the address of the said owner; and

[0040] the second pool address; and

[0041] During a fourth time period subsequent to the third time period, a fourth version of the blockchain is accessed, the fourth version of the blockchain omitting the third transaction.

[0042] 4). The method according to 2) further includes:

[0043] During a fourth time period subsequent to a third time period spanning the second time period and an escape period, the escape period being subsequent to the second time period and exhibiting a length of the escape time, the first member node:

[0044] accessing a third version of the blockchain that includes the set of singletons, the set of singletons including the second singleton; and

[0045] Submit a third transaction, wherein the third transaction is configured to generate a third singleton in the set of singletons based on the second singleton, the third singleton comprising:

[0046] linking the third singleton to an outer puzzle hash of the singleton puzzle hash; and

[0047] An internal puzzle hash defining the collection state of the third singleton, the collection state of the third singleton representing:

[0048] the address of the said owner; and

[0049] the second pool address; and

[0050] During a fifth time period subsequent to the fourth time period, a fourth version of the blockchain is accessed, the fourth version of the blockchain including the third transaction.

[0051] 5). According to the method described in 2):

[0052] Also included is accessing, during a third time period subsequent to the second time period, a third version of the blockchain including the set of singletons, the set of singletons omitting the first singleton; and

[0053] Wherein, submitting the second transaction configured to generate the second singleton includes: submitting the second transaction further configured to remove the first singleton from the set of singletons.

[0054] 6) The method according to 1) further comprises: during a second time period following the initial time period, the first member node:

[0055] accessing a second challenge from a second version of the blockchain;

[0056] generating a first portion of space proof corresponding to a first difficulty from the seeding file; and

[0057] The first portion of space proof is sent to the operator node.

[0058] 7) The method according to 6) further comprises: during a third time period following the second time period, the first member node:

[0059] accessing a third challenge from a third version of the blockchain;

[0060] generating from the seeding file a second portion of a proof of space corresponding to a second difficulty exceeding the first difficulty; and

[0061] The second portion of space proof is sent to the operator node.

[0062] 8) According to the method described in 1), generating the seeding file comprises:

[0063] accessing a seeding key associated with the first member node;

[0064] accessing said singleton puzzle hash;

[0065] generating a hash value based on the seeding key and the singleton puzzle hash;

[0066] generating a seeding seed including the hash value; and

[0067] The seeding file is generated based on the seeding seed.

[0068] 9). The method according to 1) further includes: during a second time period following the first time period, the first member node, in response to detecting that the block reward is allocated to the singleton puzzle hash within a time amount exceeding a threshold time amount, submitting a second transaction configured to transfer the block reward from the singleton puzzle hash to another address different from the first pool address.

[0069] 10) A method for retrieving and transferring block rewards in a reward pool, the reward pool comprising an operator node and a set of member nodes in a distributed network extending a proof-of-space based blockchain, the method comprising:

[0070] During an initial time period, a set of singletons in a first version of the blockchain are identified by the operator node, each singleton in the set of singletons comprising:

[0071] linking a corresponding singleton in the set of singletons to an outer puzzle hash of a corresponding singleton puzzle hash in the set of singleton puzzle hashes; and

[0072] Defines the internal puzzle hash of the state of the corresponding singleton, which represents:

[0073] a respective owner address associated with a respective member node in the set of member nodes; and

[0074] a first pool address associated with the reward pool; and

[0075] During a first time period subsequent to the initial time period, by the operator node:

[0076] detecting a block reward assigned to a first singleton puzzle hash in the set of singleton puzzle hashes;

[0077] identifying a first singleton in the set of singletons that is linked to the first singleton puzzle hash; and

[0078] Submit a first transaction, wherein the first transaction is configured as:

[0079] removing the first singleton from the set of singletons; and

[0080] The block reward is transferred from the first singleton puzzle hash to the first pool address.

[0081] 11). The method according to 10), wherein submitting the first transaction comprises submitting the first transaction further configured to generate a second singleton in the set of singletons based on the first singleton, the second singleton comprising:

[0082] linking the second singleton to an external puzzle hash of the first singleton puzzle hash; and

[0083] An internal puzzle hash defining the collection state of the second singleton, the collection state of the second singleton representing:

[0084] The address of the first owner; and

[0085] The first pool address.

[0086] 12) The method according to 10) further comprises: during a second time period following the initial time period, the operator node:

[0087] identifying the set of member nodes based on the set of singletons;

[0088] receiving a first set of partial space proofs from a first member node in the set of member nodes;

[0089] calculating a first partial space proof score for the first member node; and

[0090] Based on the first portion of the proof-of-space score, a first amount of block rewards in the first pool address is transferred to the first member node.

[0091] 13). The method according to 12), wherein calculating the first partial space proof score for the first member node comprises: calculating the first partial space proof score based on the number of partial space proofs in the first group of partial space proofs multiplied by the difficulty assigned to the first member node.

[0092] 14). The method according to 12), wherein calculating the first portion of the space proof score for the first member node comprises:

[0093] For each partial space proof in the first set of partial space proofs, calculating a corresponding point value based on the difficulty of the corresponding partial space proof; and

[0094] The first partial space proof score is calculated based on the sum of the corresponding point values.

[0095] 15). The method according to 12), wherein transferring the first amount of block rewards in the first pool address to the first member node based on the first portion of the proof of space score comprises:

[0096] calculating a first share based on a ratio of the first portion of proof-of-space scores to a total proof-of-space score for the set of member nodes during a transfer period; and

[0097] The first amount of block reward is calculated based on the first share.

[0098] 16). The method according to 12) further includes: based on the amount of storage space allocated to the seeding file by the first member node, selecting the difficulty of the partial space proof corresponding to the target rate of partial space proof generation for the first member node.

[0099] 17). The method according to 10) further comprises:

[0100] During a second time period subsequent to the initial time period, identifying, by the operator node, the set of singletons in a second version of the blockchain, the set of singletons comprising a second singleton, the second singleton comprising:

[0101] linking the second singleton to an outer puzzle hash of a second singleton puzzle hash in the set of singleton puzzle hashes; and

[0102] An internal puzzle hash of a transition state of the second singleton is defined, the transition state of the second singleton representing:

[0103] the first pool address;

[0104] a second pool address associated with a different reward pool; and

[0105] Escape time; and

[0106] During a third time period spanning the second time period and an escape period, the escape period following the second time period and exhibiting a length of the escape time, the operator node:

[0107] detecting a block reward assigned to the second singleton puzzle hash in the set of singleton puzzle hashes;

[0108] identifying the second singleton linked to the second singleton puzzle hash; and

[0109] Submit a second transaction, wherein the second transaction is configured as follows:

[0110] removing the second singleton from the set of singletons; and

[0111] The block reward is transferred from the second singleton puzzle hash to the first pool address.

[0112] 18) The method according to 17), wherein submitting the second transaction comprises submitting the second transaction further configured to generate a third singleton in the set of singletons based on the second singleton, the third singleton comprising:

[0113] linking the third singleton to an external puzzle hash of the second singleton puzzle hash; and

[0114] Define the internal puzzle hash of the transition state of the third singleton, the transition state of the third singleton represents:

[0115] the first pool address;

[0116] the second pool address; and

[0117] The escape time.

[0118] 19) A method for pooling and retrieving block rewards in a reward pool, the reward pool comprising an operator node and a set of member nodes in a distributed network extending a proof-of-space based blockchain, the method comprising:

[0119] During an initial time period, a first transaction is submitted by a first member node of the set of member nodes, the first transaction being configured to generate a first singleton of a set of singletons, the first singleton comprising:

[0120] linking the first singleton to an external puzzle hash of the singleton puzzle hash; and

[0121] defining an internal puzzle hash of a collection state of the first singleton, the collection state of the first singleton representing a pool address associated with the reward pool;

[0122] During a first time period subsequent to the initial time period, by the first member node:

[0123] accessing a first challenge from a first version of the blockchain;

[0124] In response to the first challenge, generating a first proof of space based on a seeding file defining the singleton puzzle hash; broadcasting the first proof of space over the distributed network;

[0125] generating a first block based on the first proof of space, the first block including a block reward allocated to the singleton puzzle hash; and

[0126] broadcasting the first block on the distributed network; and

[0127] During a second time period subsequent to the first time period, by the operator node:

[0128] detecting the block reward assigned to the singleton puzzle hash;

[0129] identifying the first singleton linked to the first singleton puzzle hash; and

[0130] Submit a first transaction, wherein the first transaction is configured as:

[0131] removing the first singleton from the set of singletons; and

[0132] Transferring the block reward from the singleton puzzle hash to the pool address. BRIEF DESCRIPTION OF THE DRAWINGS

[0134] Figure 1 is a flow chart representation of a method;

[0135] Figure 2 is a flowchart representation of a variation of the method;

[0136] Figure 3 is a flowchart representation of a variation of the method; and

[0137] Figure 4 is a flowchart representation of a variation of the method.

[0138] Description of Embodiments

[0139] The following description of the embodiments of the present invention is not intended to limit the present invention to these embodiments, but to enable those skilled in the art to make and use the present invention. The variations, configurations, implementations, example implementations, and examples described herein are optional and are not limited to the variations, configurations, implementations, example implementations, and examples they describe. The present invention described herein may include any and all combinations of these variations, configurations, implementations, example implementations, and examples.

[0140] 1. Methods

[0141] like Figure 1 As shown, method S100 is used to pool block rewards in a reward pool, which reward pool includes an operator node and a group of member nodes in a distributed network that extends a proof-of-space-based blockchain. Method S100 includes: during an initial time period, by a first member node in a group of member nodes: in step S110, generating a plot file, which defines a set of proofs-of-space and a singleton puzzle hash; in step S112, storing the plot file on a storage device; and in step S114, submitting a first transaction configured to generate a first singleton based on the singleton puzzle hash, the first singleton including a) an external puzzle hash linking the first singleton to the singleton puzzle hash, and b) an internal puzzle hash defining a collection state of the first singleton, the collection state of the first singleton representing an owner address associated with the first member node and a first pool address associated with the reward pool.

[0142] Method S100 also includes, during a first time period following the initial time period, by a first member node: in step S120, accessing a first challenge from a first version of the blockchain; in step S122, generating a first space proof from a set of space proofs in response to the first challenge; in step S124, broadcasting the first space proof on a distributed network; in step S126, generating a first block based on the first space proof, the first block including a block reward assigned to the singleton puzzle hash; and in step S128, broadcasting the first block on the distributed network.

[0143] 1.1 Variant: Transferring Block Rewards

[0144] like Figure 2 As shown, a variation of method S100 is used to retrieve and transfer block rewards in a reward pool, which reward pool includes an operator node and a set of member nodes in a distributed network that extends a proof-of-space-based blockchain. The variation of method S100 includes: during an initial time period, identifying a first set of singletons in a first version of the blockchain in step S130, each singleton in the first set of singletons including: an external puzzle hash that links a corresponding singleton in the first set of singletons to a corresponding singleton puzzle hash in a set of singleton puzzle hashes; and an internal puzzle hash that defines a state of the corresponding singleton, the state of the singleton representing a) a corresponding owner address associated with a corresponding member node in a set of member nodes, and b) a first pool address associated with the reward pool.

[0145] This variation of method S100 also includes, during a first time period following the initial time period: in step S132, detecting a block reward assigned to a first singleton puzzle hash in a set of singleton puzzle hashes; in step S134, identifying a first singleton in a set of singletons linked to the first singleton puzzle hash; and in step S136, submitting a first transaction configured to a) remove the first singleton from the set of singletons, and b) transfer the block reward from the first singleton puzzle hash to a first pool address.

[0146] 1.2 Variant: Pooling + Retrieval Block Rewards

[0147] like Figure 1 and Figure 2As shown, another variation of method S100 is used to pool and retrieve block rewards in a reward pool, which reward pool includes an operator node and a group of member nodes in a distributed network that extends a proof-of-space-based blockchain. This variation of method S100 includes: during an initial time period in step S114, a first transaction is submitted by a first member node in a group of member nodes, and the first transaction is configured to generate a first singleton in a group of singletons, the first singleton including: an external puzzle hash linking the first singleton to the singleton puzzle hash; and an internal puzzle hash defining a collection state of the first singleton, the collection state of the first singleton representing a pool address associated with the reward pool.

[0148] This variation of method S100 also includes, during a first time period following the initial time period, by a first member node: in step S120, accessing a first challenge from a first version of the blockchain; in step S122, generating a first proof of space based on a seeding file defining a singleton puzzle hash in response to the first challenge; in step S124, broadcasting the first proof of space on a distributed network; in step S126, generating a first block based on the first proof of space, the first block including a block reward assigned to the singleton puzzle hash; and in step S128, broadcasting the first block on the distributed network.

[0149] This variation of method S100 also includes, during a second time period subsequent to the first time period, by the operator node: in step S132, detecting a block reward allocated to the singleton puzzle hash; in step S134, identifying a first singleton linked to the first singleton puzzle hash; and in step S136, submitting a first transaction configured to a) remove the first singleton from a set of singletons, and b) transfer the block reward from the singleton puzzle hash to a pool address.

[0150] 2. Application

[0151] In general, the steps of method S100 can be performed by a group of nodes (e.g., computing devices) in a distributed network to: allocate a corresponding amount of storage to store a corresponding seeding file defining a set of space proofs; and generate blocks to extend a blockchain based on space proofs in exchange for block rewards. More specifically, the group of nodes competes to obtain the right to generate a block to be attached to the blockchain (or "win" a block), wherein the likelihood of a node winning a block is based on the storage capacity of the seeding file allocated to the storage node, and wherein a larger amount of storage of the seeding file allocated to the storage node corresponds to a higher likelihood of the node winning the block.

[0152] Therefore, the steps of method S100 can be performed by a node to: join a reward pool including a group of nodes (hereinafter referred to as "member nodes") to increase the total storage allocated to storing seeding files on the group of member nodes; submit future block rewards to the reward pool by flexibly allocating these block rewards to the pool address associated with the reward pool; and then periodically receive a portion of the total amount of block rewards accumulated in the reward pool address. Therefore, the group of member nodes can cooperate to: increase the overall probability of winning a block; and share the accumulated block rewards among the member nodes so that each member node can obtain block rewards more consistently.

[0153] In addition, the steps of method S100 can be performed by a member node within a node group to: generate a seeding file defining a set of proofs of space and a singleton puzzle hash; submit a transaction configured to generate a singleton associated with the singleton puzzle hash and specify a pool address associated with a reward pool; generate a proof of space based on the seeding file in response to a challenge from the blockchain; and generate a block based on the proof of space, the block including a block reward assigned to the singleton puzzle hash. Therefore, because the seeding file defines the singleton puzzle hash rather than a specific pool address: a corresponding operator node associated with a corresponding reward pool can retrieve the block reward assigned to the singleton puzzle hash; and a member node can dynamically switch reward pools using an existing seeding file stored on the member node, avoiding the need to generate a new seeding file defining a new pool address associated with another reward pool.

[0154] Similarly, the steps of method S100 may be performed by an operator node to: identify a set of singletons specifying a pool address associated with a reward pool; detect a block reward assigned to a singleton puzzle hash corresponding to a singleton in the set of singletons; and submit a transaction configured to transfer the block reward from the singleton puzzle hash to the pool address. Additionally, the operator node may perform the steps of method S100 to distribute the pooled block reward among the member nodes of the reward pool. Thus, the operator node may: track a set of singletons (and singleton puzzle hashes) corresponding to the member nodes of the reward pool; and claim the block rewards earned on behalf of the member nodes when those member nodes participate in the reward pool.

[0155] In one example, a member node may perform steps of method S100 to switch block rewards by submitting a transaction configured to generate a singleton that indicates a transfer state and includes: a singleton puzzle hash; a new pool address; and an escape time. During an escape period exhibiting an escape time length, an operator node may perform steps of method S100 to: detect a block reward assigned to the singleton puzzle hash; and submit a transaction configured to transfer the block reward from the singleton puzzle hash to a pool address associated with a reward pool. Thus: an operator node may ensure that block rewards are collected on behalf of member nodes while they are submitted to a reward pool; and member nodes may dynamically participate in different reward pools while being prevented from leaving a reward pool immediately upon winning a block and retaining the block reward.

[0156] In another example, an operator node and a group of member nodes of a reward pool may perform the steps of method S100 to: transmit a generated partial space proof in response to a challenge to a blockchain; based on the partial space proof, accumulate a corresponding partial space proof score for each member node; and transfer pooled block rewards between the member nodes of the reward pool based on the partial space proof score. Thus, block rewards may be transferred between the member nodes of the reward pool in proportion to the likelihood of each member node winning an actual block to extend the blockchain.

[0157] Method S100 as described herein is performed by a node to pool, retrieve, and transfer block rewards in a distributed network extending a proof-of-space blockchain. However, nodes in a distributed network extending other types of blockchains (e.g., proof-of-work blockchains, proof-of-stake blockchains) can similarly perform the steps of method S100 to: submit a transaction configured to generate a singleton associated with a singleton puzzle hash and specify a pool address; generate a block to be attached to the blockchain, the block including a block reward assigned to the singleton puzzle hash: identify a set of singletons specifying a pool address associated with a reward pool; detect a block reward assigned to a singleton puzzle hash corresponding to a singleton in the set of singletons; and submit a transaction configured to transfer the block reward from the singleton puzzle hash to the pool address.

[0158] 2.1 Terms and Definitions

[0159] Generally, a “reward pool” as referred to herein is a group of nodes, including an operator node and a group of member nodes, dedicated to pooling and sharing block rewards earned in exchange for generating (or “winning”) new blocks to be appended to the blockchain.

[0160] Generally, a "member node" as referred to herein is a node that is configured to: generate proof of space in response to challenges; generate new blocks to be appended to the blockchain in exchange for block rewards; and distribute block rewards to a reward pool.

[0161] Generally, an "operator node" as referred to herein is a node that is configured to: retrieve block rewards on behalf of a group of member nodes; and transfer a corresponding share of block rewards to each member node in the group of member nodes.

[0162] Generally, a "seed file" as referred to herein is a structure that defines a set of proofs of space.

[0163] Typically, the “singleton puzzle hash” referred to in this article is the address of the contract used to distribute block rewards.

[0164] Generally, a "plot seed" as referred to herein is a value used as a deterministic seed for generating a plot file.

[0165] Generally, a "cryptographic hash" as referred to herein is a mathematical algorithm that maps data to a bit array of a fixed size.

[0166] 3. Blockchain structure

[0167] Typically, a distributed network includes nodes (e.g., computing devices) interconnected by a communication medium (e.g., the Internet, a wide area network, a local area network). Each node in the distributed network can: maintain a copy of a decentralized database (or "blockchain"); and participate in forming a trustless consensus about the state of the decentralized database.

[0168] Typically, a blockchain describes a data structure that includes a series of blocks. A block may include a set of transactions between addresses representing entities that utilize the blockchain. For example, these transactions may include smart contracts that implement specific node behaviors. In one implementation, the structure of a blockchain may be similar to (i.e., similar to, the same as) the structure described in U.S. Patent No. 11,165,582.

[0169] The node performs the steps of method S100 to create and / or modify smart contracts that exist on the blockchain and are enforced by the distributed network. As used herein, the term "enforcement" refers to the idea that non-malicious nodes extend the blockchain version that encodes valid contracts and transactions. Therefore, although nodes can submit invalid transactions or smart contracts for inclusion in the blockchain, most nodes will reject these invalid transactions and / or smart contracts and instead extend the blockchain version that does not include these transactions, thereby preventing these transactions and / or smart contracts from taking effect. Therefore, certain steps of method S100 rely on the enforcement of the distributed network in order to prevent malicious behavior.

[0170] In general, nodes in a distributed network may perform the steps of method S100 to jointly extend a blockchain. More specifically, each node may: allocate an amount of space on a storage device; maintain a transaction buffer (hereinafter referred to as a "mempool") of pending transactions transmitted on the distributed network; generate a space proof in response to receiving a challenge from the distributed network; and, when a valid space proof is generated in response to the challenge, generate a block including a set of transactions from the transaction buffer. In one implementation, a node may generate a block according to the method described in U.S. Patent Application No. 17 / 320,114. Thus, each node in a distributed network may cryptographically prove the allocation of disk space in order to "win" the privilege of adding a block to the blockchain.

[0171] 3.1 Reward Pooling

[0172] Typically, a reward may be distributed to a node that successfully generates a new block and appends it to the blockchain. However, as a single node's share of the total disk space reserved on the distributed network decreases (e.g., due to an increase in the number of nodes participating in the distributed network), the likelihood that a single node will obtain the right to add a block to the blockchain and thus receive a block reward decreases.

[0173] Thus, a group of nodes in a distributed network may perform the steps of method S100 to collaborate in pooling and transferring block rewards between each of the group of nodes. More specifically, each node (or "member node") in a group of nodes (or "a group of member nodes") may allocate the block rewards (or portions thereof) it receives to a reward pool in exchange for periodic allocations of a share of the block rewards collectively received by the group of member nodes. A special node (or "operator node") in the reward pool may: retrieve block rewards on behalf of a group of member nodes; and, as described below, transfer a corresponding share of block rewards to each member node.

[0174] 4. Flexible seeding

[0175] The steps of method S100 record that, during an initial time period, a first member node in a group of member nodes: in step S110, a seeding file defining a set of space proofs and singleton puzzle hashes is generated; and in step S112, the seeding file is stored on a storage device.

[0176] Typically, nodes in a distributed network can compete for the right to generate blocks to append to the blockchain based on proofs of space generated by those nodes from a seeding file. Nodes can allocate a certain amount of disk storage to generate proofs of space.

[0177] In one implementation, the member node may: in step S110, generate a seeding file characterized by a certain amount of allocated storage space on a storage device accessible to the member node; and in step S112, store the seeding file on the storage device. Thus, the member node may algorithmically generate a unique seeding file that occupies the allocated storage space on the storage device accessible to the member node. Each seeding file defines a structure that cryptographically verifies its presence on the storage device accessible to the member node and prevents malicious nodes from generating space proofs in response to a challenge without allocating storage.

[0178] In this implementation, a member node may generate a seeding file by generating a set of tables (e.g., seven tables) representing proofs of space based on a seeding seed, the set of tables including many individual proofs of space (e.g., 4,294,967,296 proofs of space for 100 gigabytes of allocated storage space). For example, a member node may generate a seeding file according to the method described in U.S. Patent Application No. 17 / 320,144. Thus, a member node may identify a match between the proofs of space represented in the seeding file and the challenge.

[0179] 5.1 Singleton Puzzle Hashing

[0180] In one implementation, a member node may generate a seeding file based on a seeding seed including a singleton puzzle hash that represents an address to which a block reward is transferred in response to winning a block based on a proof of space generated from the seeding file. For example, a member node may: access a seeding key associated with a first member node; access a singleton puzzle hash; generate a hash value (e.g., SHA256(seeding key, singleton puzzle hash)) based on the seeding key and the singleton puzzle hash; generate a seeding seed including the hash value; and generate a seeding file based on the seeding seed. In this example, the member node generates a seeding file representing a set of proofs of space, each proof of space in the set of proofs of space being linked to the singleton puzzle hash. Thus, if a member node generates a proof of space to successfully win a block (e.g., a proof of space greater than a threshold amount), the block reward (or a portion thereof) is allocated to the singleton puzzle hash.

[0181] Thus, by associating a seeding file with a singleton puzzle hash rather than with an address owned by a specific entity (e.g., a member node, a specific reward pool), block rewards can be stored in association with the singleton puzzle hash until claimed by an operator node of a reward pool in which the member node is a participant (i.e., a member node can switch pools utilizing a generated seeding file, avoiding the need for the member node to generate a new seeding file associated with another reward pool).

[0182] 6. Singleton creation

[0183] Step S114 of method S100 records submitting, during an initial time period, by a first member node of a group of member nodes: a first transaction configured to generate a first singleton based on a singleton puzzle hash.

[0184] Typically, a member node can submit a transaction to generate a singleton associated with the singleton puzzle hash.

[0185] In one implementation, in step S114, the member node may submit a transaction configured to generate a singleton based on the singleton puzzle hash, the singleton comprising: an external puzzle hash linking the singleton to the singleton puzzle hash; and an internal puzzle hash defining a collection state of the singleton representing the owner address and the pool address. More specifically, the member node may submit the transaction to the distributed network for inclusion in a subsequent block on the blockchain.

[0186] 6.1 External Puzzle Hashing

[0187] Typically, a member node can generate a singleton that includes an external puzzle hash that uniquely identifies the singleton and links the singleton to the singleton puzzle hash. More specifically, a member node can generate a singleton that includes an external puzzle hash that is characterized by a hash function (or other function) that includes the singleton puzzle hash.

[0188] In one implementation, a member node may generate a singleton including an outer puzzle hash characterized by a hash value based on the singleton puzzle hash and the transmitter ID.

[0189] 6.2 Internal Puzzle Hashing

[0190] Typically, a member node may generate a singleton that includes an internal puzzle hash defining the state of the singleton and / or any other metadata associated with the singleton.

[0191] In one implementation, a member node may generate a singleton that includes an internal puzzle hash that defines the state of the singleton representing an owner address (e.g., an address associated with the member node) and a pool address (e.g., an address associated with a reward pool).

[0192] Nodes in the distributed network that extend the blockchain (e.g., nodes that are members of the reward pool, nodes that are excluded from the reward pool) can enforce transactions involving the singleton based on the data represented by the internal puzzle. For example, in response to receiving a transaction associated with an address that is different from the owner address or the pool address (e.g., modifying the singleton), a node in the distributed network can refuse to include the transaction in a subsequent block of the blockchain.

[0193] Member nodes ensure that only member nodes can successfully submit transactions of a specific type associated with a singleton by generating a singleton that includes an internal puzzle representing the owner address. In one implementation, a member node can submit a transaction to the distributed network that modifies the pool address represented by the internal puzzle of the singleton, thereby modifying the destination of the block reward for a block created by the member node. Thus, the representation of the owner address by the internal puzzle of the singleton can enable member nodes with specific rights to modify the singleton. In this implementation, any transaction that attempts to modify a singleton that is not associated with the owner address (or pool address, as described below) represented by the internal puzzle of the singleton is excluded from the blockchain record by well-behaved nodes of the distributed network.

[0194] The member node enables an operator node associated with the pool address to claim block rewards from the associated singleton puzzle hash to which the block reward is allocated by generating a singleton that includes an internal puzzle representing the pool address. Thus, in response to receiving a transaction configured to transfer a block reward from the singleton puzzle hash to the pool address via the singleton, a node of the distributed network may: compare the pool address in the transaction with the pool address represented by the internal puzzle of the singleton; and, in response to detecting a mismatch between the pool address in the transaction and the pool address represented by the internal puzzle of the transaction, exclude the transaction from the blockchain. Thus, a member node may specify a pool address to receive block rewards generated by the member node by representing the pool address associated with the internal puzzle of the singleton on the blockchain.

[0195] 7. Blockchain expansion

[0196] The steps of method S100 record that during a first time period following the initial time period, by a first member node in a group of member nodes: in step S120, accessing a first challenge from a first version of the blockchain; in step S122, generating a first space proof from a group of space proofs in response to the first challenge; in step S124, broadcasting the first space proof on a distributed network; in step S126, generating a first block based on the first space proof, the first block including a block reward assigned to a singleton puzzle hash; and in step S128, broadcasting the first block on the distributed network.

[0197] Typically, nodes in a distributed network (e.g., member nodes in a reward pool, nodes excluded from a reward pool) can generate blocks to be appended to a blockchain based on a proof of space generated from a seeding file in response to a challenge, such as according to the methods described in U.S. patent application Ser. No. 17 / 320,144 or U.S. patent application Ser. No. 17 / 497,699.

[0198] 7.1 Questioning and obtaining

[0199] Step S120 of method S100 records accessing a first challenge from a first version of the blockchain.

[0200] Typically, upon allocating storage space in a storage device accessible to a member node (e.g., via generating a seeding file that occupies the storage space), the member node may: access a current version of the blockchain; and access challenges based on the current version of the blockchain.

[0201] In one implementation, in step S120, the member node may access (or receive) a challenge based on a previous block in the first version of the blockchain, the previous block including a previous proof-of-space and a previous proof-of-time. Thus, the member node may access or receive the challenge and look for the challenge in a seeding file stored on a storage device accessible to the member node.

[0202] 7.2 Space Proof Generation

[0203] The steps of method S100 record: in step S122, in response to a first challenge, generating a first space certificate from a set of space certificates; and in step S124, broadcasting the first space certificate on a distributed network.

[0204] Typically, in step S122, in response to accessing the challenge, the member node may generate a space certificate based on the challenge and the amount of allocated storage space, the space certificate indicating (or proving) the allocation of the amount of storage space. Additionally, in step S124, in response to generating the space certificate, the member node may broadcast the space certificate on the distributed network.

[0205] In one implementation, the pool server may: in step S122, generate a proof of space based on the challenge and the amount of storage space, the proof of space indicating an allocation of the amount of storage space; generate a quality characterizing the proof of space based on a quality function representing the proof of space and the challenge; and calculate a time delay based on the quality. Thus, when generating a proof of space in response to a challenge, a member node may calculate the quality of the proof of space to determine an amount of time (as measured by the proof of time generated by the time server) sufficient to add a block including the proof of space to the blockchain. For example, if a member node calculates a relatively high-quality proof of space, the time delay for generating a block including the proof of space is relatively short. However, if a member node calculates a relatively low-quality proof of space, the time delay for generating a block including the proof of space is relatively long. Thus, nodes in the distributed network that generate the highest-quality proof of space in response to a given challenge are able to generate blocks to be added to the blockchain first.

[0206] In another implementation, a member node may calculate the quality of a proof of space by performing a cryptographic hash of a challenge concatenated with components of the proof of space. For example, a member node may calculate the quality of a proof of space by finding a branch of a binary tree associated with the proof of space and hashing the branch with the challenge to generate a quality value for the proof of space. In this implementation, a member node may calculate the quality of the proof of space while accessing only a single branch of the proof of space, and in response to identifying that the quality of the proof of space exceeds a threshold quality, retrieve the remaining initial values ​​that make up the proof of space.

[0207] 7.3 Block Creation

[0208] The steps of method S100 record: in step S126, generating a first block based on the first space proof, the first block including a block reward allocated to the singleton puzzle hash; and in step S128, broadcasting the first block on the distributed network.

[0209] Typically, to generate a new block of data, a member node may maintain a transaction buffer of pending transactions transmitted from the distributed network and aggregated since the generation of a previous block.

[0210] In one implementation, in step S126, the member node may generate a block based on the generated proof of space, the block including: a set of transactions from the transaction buffer; and a block reward allocated to the singleton puzzle hash. More specifically, the member node may: create a data payload for a new block based on the transaction buffer (e.g., a set of transactions in the transaction buffer); calculate a cryptographic hash of a previous data block in the data chain; and sign the data block based on a private key associated with the proof of space.

[0211] In one implementation, in step S128, the member node may broadcast the new block on the distributed network. More specifically, the member node may broadcast the new block to other nodes in the distributed network for verification by these nodes and inclusion in each node's local copy of the blockchain.

[0212] 7.4 The next block

[0213] Typically, the member node may iteratively repeat steps S120, S122, S124, S126, and S128 of method S100 to create the next block and add it to the blockchain. For example, the member node may: in step S120, access a second challenge from a second version of the blockchain; in step S122, generate a second space proof from a set of space proofs in response to the second challenge; in step S124, broadcast the second space proof on the distributed network; in step S126, generate a second block based on the second space proof, the second block including a second block reward assigned to the singleton puzzle hash; and in step S128, broadcast the second block on the distributed network.

[0214] 8. Reward absorption

[0215] In general, an operator node may collect (or "absorb") block rewards generated by member nodes of a reward pool by: detecting a block reward assigned to a singleton puzzle hash; and submitting a transaction configured to spend the singleton (or remove the singleton from a set of extant singletons) and transfer the block reward from the first singleton puzzle hash to a pool address associated with the reward pool. More specifically, the operator node may: track a set of singletons on the blockchain indicating a pool address associated with the reward pool; and track block rewards at a set of singleton puzzle hashes associated with the set of singletons. Thus, upon detecting that a block reward is deposited at a singleton puzzle hash in a set of singleton puzzle hashes, the operator node may submit a transaction configured to retrieve the block reward from the singleton puzzle hash.

[0216] 8.1 Singleton Tracking

[0217] The steps of method S100 record that, during an initial period, an operator node: identifies a first set of singletons in a first version of the blockchain in step S130 .

[0218] Typically, an operator node may access a current version of the blockchain and identify a set of singletons, each of which includes an internal puzzle indicating a pool address associated with a reward pool.

[0219] In one implementation, the operator node may: access a current version of the blockchain; and identify, in step S130, a set of singletons in the current version of the blockchain, each singleton in the set of singletons comprising an external puzzle hash linking a corresponding singleton in the set of singletons to a corresponding singleton puzzle hash in a set of singleton puzzle hashes, and an internal puzzle hash defining a collection state of the corresponding singleton, the collection state of the corresponding singleton representing a corresponding owner address associated with a corresponding member node in the set of member nodes and a pool address associated with a reward pool.

[0220] For example, an operator node may identify a first singleton in a set of singletons in a first version of a blockchain. In this example, the first singleton may include: an outer puzzle hash linking the first singleton to the first singleton puzzle hash; and an inner puzzle hash defining a collection state of the first singleton, the collection state of the first singleton representing a first owner address of the first singleton (e.g., an address associated with a first member node in a set of member nodes) and a pool address associated with a reward pool.

[0221] Thus, by identifying a set of singletons including an internal puzzle hash that includes a pool address associated with a reward pool, the operator node may also identify a set of singleton puzzle hashes corresponding to the set of singletons. Thus, the operator node may track the set of singleton puzzle hashes to detect when a block reward has been allocated to a singleton puzzle hash in the set of singleton puzzle hashes.

[0222] 8.2 Reward Transfer

[0223] The steps of method S100 record that, during a first time period following the initial time period, by an operator node: in step S132, detecting a block reward assigned to a first singleton puzzle hash in a set of singleton puzzle hashes; in step S134, identifying a first singleton in a first set of singletons linked to the first singleton puzzle hash; and in step S136, submitting a first transaction transferring the block reward from the first singleton puzzle hash to a first pool address.

[0224] In one implementation, in step S132, the operator node may detect that a block reward is allocated to a first singleton puzzle hash in a set of singleton puzzle hashes tracked by the operator node. For example, the operator node may detect that a block reward is allocated to the first singleton puzzle hash based on a reward height associated with the first singleton puzzle hash (e.g., 1,750,000,000,000). In response to detecting the block reward allocated to the first singleton puzzle hash, in step S134, the operator node may identify a singleton (e.g., the first singleton) linked to the first singleton puzzle hash.

[0225] Typically, an operator node submits a transaction to retrieve a block reward from a singleton puzzle hash by spending the corresponding singleton and transferring the block reward associated with the singleton puzzle hash from the singleton puzzle hash to a pool address associated with a pool server. More specifically, an operator node may submit a transaction that is configured to: remove a singleton from a set of existing singletons (or "spend" a singleton); and generate a new singleton based on the removed (or "spent") singleton.

[0226] In one implementation, in step S136, the operator node may submit a transaction configured to transfer the block reward from the first singleton puzzle hash to the pool address. In particular, in step S136, the operator node may submit a transaction configured to: remove the first singleton from a set of singletons; and generate a second singleton based on the first singleton in the set of singletons. In this implementation, the operator node may submit a transaction further configured to generate a second singleton, the second singleton including an external puzzle hash linking the second singleton to the first singleton puzzle hash. For example, the operator node may generate a second singleton including an external puzzle hash based on the singleton puzzle hash and the transmitter ID, the external puzzle hash characterized by a hash value. In addition, the operator node may generate a second singleton including an internal puzzle hash, the internal puzzle hash defining a collection state of the second singleton representing an owner address (e.g., the same owner address represented in the internal puzzle of the first singleton) and a pool address (e.g., the same pool address represented in the internal puzzle of the first singleton).

[0227] Thus, in this implementation, the relationship between a singleton and iterations of the singleton puzzle hash is recorded across multiple blocks within the blockchain and can be traced back to the identified member node and singleton via the transmitter ID that is included in the multiple iterations of the singleton recorded on the blockchain.

[0228] In one variation, a member node associated with the first singleton, another member node participating in the reward pool, and / or any other node in the distributed network may submit a transaction configured to: remove the first singleton from a set of singletons; transfer the block reward from the first singleton puzzle hash to a pool address; and generate a second singleton. In this variation, any node in the distributed network of the extended blockchain may submit the aforementioned transaction configured to transfer the block reward from the singleton puzzle hash to the pool address specified by the singleton associated with the singleton puzzle hash.

[0229] Alternatively, in another variation, if the block reward remains allocated to the singleton hash puzzle for an amount of time exceeding a threshold amount of time, the member node may submit a transaction configured to transfer the block reward to another address (i.e., different from the pool address). More specifically, in response to detecting that the block reward is allocated to the first singleton puzzle hash for an amount of time exceeding a threshold amount of time (e.g., 30 blocks, 60 blocks), the member node may: submit a transaction to the distributed network to: remove the first singleton from a set of singletons; transfer the block reward from the first singleton puzzle hash to another address (e.g., a second pool address); and generate a second singleton. Thus, when the operator node fails to claim the block reward on behalf of the member node (and the reward pool) in a timely manner, the member node may still claim the block reward.

[0230] In another implementation, the operator node can retrieve the block reward from the singleton puzzle hash when the corresponding singleton is in the collect state and indicates a pool address associated with the reward pool. Additionally, the operator node can retrieve the block reward from the singleton puzzle hash when the corresponding singleton is in the transfer state and indicates a pool address associated with the reward pool. The collect state of a singleton and the transfer state of a singleton are further described below.

[0231] 8.2.1 Collection Status

[0232] In general, when the singleton associated with the singleton puzzle hash is in the gathering state, the operator nodes associated with the pool address represented by the singleton's internal puzzle hash are free to issue transactions to transfer block rewards from the singleton puzzle hash to the pool address. The singleton exists in the gathering state and is regenerated in the gathering state until a member node attempts to change the singleton's pool address, as described below.

[0233] 8.2.2 Transfer Status

[0234] Typically, a member node may cause a singleton to enter a transfer state by submitting a transaction configured to: spend the singleton; and replace the singleton with a new singleton defining an internal puzzle representing the transfer state. More specifically, a member node submits a transaction to the distributed network configured to: remove the singleton from a set of existing singletons; and generate a new singleton defining an internal puzzle that defines a transfer state representing a new pool address associated with a different reward pool. Thus, the member node notifies the operator node (and the rest of the distributed network) that the member node is switching from the initial pool address to the new pool address. Once the singleton enters the transfer state, the current operator node associated with the initial pool address may continue to collect block rewards from the associated singleton puzzle hash until the escape time indicated by the singleton's internal puzzle expires.

[0235] 9. Pool Switching

[0236] like Figure 3 As shown, the steps of method S100 record that, during a second time period following the initial time period, by a first member node: in step S139, access a second version of a blockchain including a set of singletons, the set of singletons including the first singleton; and, in step S140, submit a second transaction, the second transaction being configured to generate a second singleton in the set of singletons based on the first singleton, the second singleton including: an external puzzle hash linking the second singleton to the singleton puzzle hash; and an internal puzzle hash defining a transfer state of the second singleton, the transfer state of the second singleton representing an owner address, a first pool address, a second pool address associated with different reward pools, and an escape time.

[0237] Typically, a member node can switch the pool that participates in reward pooling. More specifically, the member node can modify the singleton corresponding to the member node (i.e., generate a new singleton indicating the transfer state) to indicate the new pool address, thereby directing block rewards to the new pool server.

[0238] In one implementation, the member node may: in step S139, access a second (i.e., current) version of a blockchain defining a set of singletons including a first singleton; and in step S140, submit a transaction configured to generate a second singleton in the set of singletons based on the first singleton, the second singleton including an internal puzzle hash defining a transition state of the second singleton, the transition state of the second singleton representing an owner address, a first pool address, a second pool address, and an escape time. More specifically, in step S140, the member node may submit a transaction to the distributed network, the transaction being configured to: remove the first singleton from the set of singletons; and generate a second singleton in the set of singletons, the second singleton including an external puzzle hash linking the second singleton to the first singleton puzzle hash. For example, an operator node may generate a singleton including an external puzzle hash based on the singleton puzzle hash and the transmitter ID, the external puzzle hash being characterized by a hash value.

[0239] In addition, the member node may generate a second singleton that includes an internal puzzle hash defining a transition state of the second singleton, the transition state of the second singleton representing an owner address (e.g., the same owner address as represented in the internal puzzle of the first singleton), a first pool address, a second pool address (e.g., a second pool address different from the first pool address represented in the internal puzzle of the first singleton), and an escape time. Thus, an operator node associated with the first pool address may still retrieve a block reward assigned to the first singleton puzzle hash until the escape time expires.

[0240] The member node ensures that the distributed network can enforce a delay time between the member node submitting a transaction configured to modify the pool address of the singleton (thereby redirecting the block reward generated by the member node) and the previous pool server being blocked from claiming the block reward by generating a singleton that includes an internal puzzle representing the escape time and ensuring that the distributed network can enforce a delay time between the member node submitting a transaction configured to modify the pool address of the singleton (thereby redirecting the block reward generated by the member node) and the previous pool server being blocked from claiming the block reward. The delay prevents the member node from leaving the reward pool when creating a block and obtaining the block reward in order to keep the block reward for themselves. In general, a member node can generate a singleton that includes an internal puzzle representing the escape time expressed in multiple blocks. For example, a member node can generate a singleton that defines an internal puzzle representing an escape time of 30 blocks. Therefore, in this example, the member node can submit a transaction that modifies the pool address of the singleton from the first pool address to the second pool address. However, the transaction will only take effect after 30 blocks are added to the blockchain, which will be further described below.

[0241] 9.1 Pending Escape Period

[0242] The steps of method S100 record that during a third time period spanning the second time period and the escape period, the escape period is after the second time period and exhibits an escape time length, by the first member node: in step S141, accessing a third version of the blockchain defining a set of singletons, the set of singletons including the second singleton; and in step S142, submitting a third transaction configured to generate a third singleton in the set of singletons based on the second singleton, the third singleton including a) an external puzzle hash linking the third singleton to the singleton puzzle hash, and b) defining an internal puzzle hash of the collection state of the third singleton representing the owner address and the second pool address.

[0243] Step S144 of method S100 states that, during a fourth time period following the third time period: accessing a fourth version of the blockchain, the fourth version of the blockchain omitting the third transaction.

[0244] Typically, the member node may submit a third transaction to the distributed network to generate a third singleton, which indicates a new pool address of a different reward pool and indicates a collection status. If the member node attempts to submit the transaction before the escape time indicated by the singleton (e.g., the second singleton including the escape time) expires, the distributed network will not accept the transaction as a valid transaction in the new block. Therefore, the distributed network enforces the escape time indicated by the singleton and prevents the member node from switching pools before the escape time expires.

[0245] In one implementation, the member node may: in step S141, access a third (i.e., current) version of the blockchain defining a set of singletons including the second singleton; and, in step S142, submit a transaction configured to remove the second singleton in a transferred state from the set of singletons, and generate a third singleton indicating the second pool address before the expiration of the escape time. In particular, the member node may submit a transaction to the distributed network during a third time period spanning the second time period and the escape period, the escape period being after the second time period and exhibiting the length of the escape time, the transaction being configured to: remove the second singleton from the set of singletons; and generate a third singleton in the set of singletons based on the second singleton, the third singleton including an external puzzle hash linking the second singleton to the singleton puzzle hash and an internal puzzle hash defining a collection state of the third singleton, the collection state of the third singleton representing the owner address and the second pool address.

[0246] However, because the member node submitted the transaction before the escape time expired, the nodes of the distributed network will reject the invalid transaction and, instead, extend the blockchain version that does not include the transaction. Therefore, during a fourth time period following the third time period (i.e., after the member node submitted the invalid transaction), the member node may access a fourth version of the blockchain in step S144, which omits the invalid transaction.

[0247] 9.2 Block absorption during the escape period

[0248] Step S130 of method S100 records that, during a second time period following the initial time period, by the operator node: identifying a set of singletons in a second version of the blockchain, the set of singletons including a second singleton, the second singleton including an external puzzle hash linking the second singleton to a second singleton puzzle hash in a set of singleton puzzle hashes, and an internal puzzle hash defining a transition state of the second singleton, the transition state of the second singleton representing a first pool address, a second pool address associated with a different reward pool, and an escape time.

[0249] The steps of method S100 record that during a third time period spanning the second time period and the escape period, the escape period being after the second time period and exhibiting an escape time length, by the operator node: in step S132, detecting a block reward assigned to a second singleton puzzle hash in a set of singleton puzzle hashes; in step S134, identifying a second singleton linked to the second singleton puzzle hash; and in step S136, submitting a second transaction configured to remove the second singleton from the set of singletons and transfer the block reward from the second singleton puzzle hash to the first pool address.

[0250] Typically, an operator node may continue to collect block rewards generated by a member node during an escape period in response to a member node switching pools. An operator node may collect block rewards in a similar (e.g., similar, identical) manner as described above.

[0251] For example, the operator node may: access a second version of the blockchain; and identify a set of singletons in the second version of the blockchain, the set of singletons including a second singleton, the second singleton including an external puzzle hash linking the second singleton to the singleton puzzle hash and an internal puzzle hash defining a transition state of the second singleton, the transition state of the second singleton representing a first pool address (i.e., associated with a reward pool), a second pool address associated with another reward pool, and an escape time. During a third time period spanning the second time period and an escape period, the escape period being after the second time period and exhibiting an escape time length, the operator node may: detect a block reward assigned to the singleton puzzle hash; identify the second singleton linked to the singleton puzzle hash; and submit a transaction to the distributed network, the transaction being configured to remove the second singleton from the set of singletons and transfer the block reward from the singleton puzzle hash to the first pool address.

[0252] In addition, the operator node may submit the transaction, which is further configured to: generate a third singleton in a set of singletons based on the second singleton, the third singleton comprising: an external puzzle hash linking the third singleton to the singleton puzzle hash; and an internal puzzle hash defining a transfer state of the third singleton representing the first pool address, the second pool address, and the escape time. Therefore, when a member node wins a block during the escape period of the switching reward pool, the operator node's transaction to transfer the block reward also removes the corresponding singleton and generates a new singleton including the escape time (i.e., resets the escape period). Therefore, the operator node can continue to collect block rewards on behalf of the member node until the new escape time expires.

[0253] 9.3 Completed Escape Period

[0254] The steps of method S100 record that during a fourth time period following a third time period spanning the second time period and the escape period, the escape period being after the second time period and exhibiting an escape time length, by the first member node: in step S145, accessing a third version of the blockchain defining a set of singletons, the set of singletons including the second singleton; and in step S146, submitting a third transaction configured to generate a third singleton in the set of singletons based on the second singleton, the third singleton including a) an external puzzle hash linking the third singleton to the singleton puzzle hash, and b) defining an internal puzzle hash of the collection state of the third singleton representing the owner address and the second pool address.

[0255] Step S148 of method S100 states that, during a fifth time period subsequent to the fourth time period: accessing a fourth version of the blockchain, the fourth version of the blockchain including the third transaction.

[0256] In one implementation, the member node may: in step S141, access a third (i.e., current) version of the blockchain defining a set of singletons including the second singleton; and, in step S142, submit a transaction configured to remove the second singleton in a transferred state from the set of singletons, and generate a third singleton indicating the second pool address after the escape time expires. In particular, the member node may submit a transaction to the distributed network during a fourth time period following a third time period spanning the second time period and the escape period, the escape period being after the second time period and exhibiting the length of the escape time, the transaction being configured to: remove the second singleton from the set of singletons; and generate a third singleton in the set of singletons based on the second singleton, the third singleton including an external puzzle hash linking the third singleton to the singleton puzzle hash and an internal puzzle hash defining a collection state of the third singleton, the collection state of the third singleton representing the owner address and the second pool address.

[0257] Because the member node submits the transaction after the escape time expires, the nodes of the distributed network will accept the transaction and will extend the blockchain version containing the transaction. Therefore, during the fifth time period following the fourth time period (i.e., after the member node submits the valid transaction), the member node can access the fourth version of the blockchain in step S148, and the fourth version of the blockchain includes the valid transaction.

[0258] In one variation, when generating a singleton indicating a transfer state, the member node may generate a singleton defining an internal puzzle indicating a new pool address, such that a new pool server associated with the new pool address is notified of the member node's intention to join the new pool server. In this implementation, the distributed network may automatically transition the singleton in the transfer state to a new singleton in the collection state in response to expiration of an escape time indicated by the singleton.

[0259] 10. Pooling Protocol

[0260] Typically, an operator node may execute a pooling protocol to distribute accumulated block rewards among member nodes of a reward pool (e.g., based on the amount of drive storage that each member node has allocated for extending a proof-of-space-based blockchain). More specifically, the operator node may: evaluate the amount of drive storage allocated by each member node by assigning the member node a difficulty level lower than the difficulty level of the blockchain consensus protocol; and receive partial proofs of space from the member node in response to a challenge derived from the blockchain. The operator node may then award points based on the number of partial proofs of space received from each member node and the difficulty level assigned to the member node during the transfer. Thus, the operator node may distribute pooled block rewards to member nodes of the reward pool based on the true ability of each member node to extend the blockchain, thereby maintaining a trustless transfer of pooled block rewards to a group of member nodes.

[0261] 10.1 Partial Space Proof

[0262] Typically, the operator node communicates with each member node in a set of member nodes via HTTP or another network communication protocol to set or adjust the respective difficulty of the portion of space proof for the respective member node.

[0263] Typically, to generate a partial proof of space, a member node may: receive a challenge based on the current version of the blockchain; retrieve the proof of space from a seeding file based on a difficulty level assigned to the member node by an operator node; and pass the proof of space directly to the operator node.

[0264] 10.1.1 Difficulty

[0265] Step S150 of method S100 records the difficulty of selecting a partial space proof for the first member node.

[0266] Typically, an operator node may select (or assign) a difficulty for a partial space proof for each member node in a set of member nodes. More specifically, the operator node may select a first difficulty as an initial difficulty for the partial space proof for the member node. Additionally, the operator node may also select a new difficulty as an adjustment to the initial difficulty (or a subsequently selected difficulty).

[0267] Typically, a member node generates a partial space proof in an amount of time proportional to the difficulty of the partial space proof. Therefore, the member node is rewarded with points proportional to the difficulty of the generated partial space proof.

[0268] In one implementation, in step S150, the operator node may select a difficulty for partial space proofs for member nodes based on a target rate of partial space proof generation. For example, the operator node may select a difficulty (e.g., 50, 100) for member nodes to achieve a target rate of generating 300 partial space proofs per day. The operator node may select a target average rate of partial space proofs based on the performance of the operator node (e.g., the maximum total rate of partial space proofs that the pool server can process divided by the total number of pool members).

[0269] In another implementation, the operator node may select a low initial difficulty (e.g., 5, 10, 50) for the partial proofs of space of the member nodes, and then adjust the difficulty based on the number of partial proofs of space received during the initial sampling period. More specifically, the operator node may select a low initial difficulty, and then adjust the difficulty based on a target rate of partial proofs of space generation (e.g., 300 proofs of space per day) and the number of partial proofs of space received during the initial sampling period.

[0270] In yet another implementation, the operator node may select an initial difficulty (e.g., 100, 200) for the partial space proofs for the member nodes based on the reported amount of storage allocated by the member nodes (e.g., 1 terabyte). Additionally, the operator node may select the difficulty for the partial space proofs for the member nodes based on the reported amount of storage allocated by the member nodes and a target rate of partial space proof generation (e.g., 300 partial space proofs per day). More specifically, the operator node may select the difficulty for the partial space proofs for the member nodes that corresponds to the target rate of partial space proof generation based on the amount of storage space allocated by the member nodes to seed files.

[0271] In addition, the operator node may individually select the difficulty of the partial space proof for each member node. Thus, the operator node may select a different difficulty for the partial space proof for each member node. For example, the operator node may set the difficulty for each member node in a group of member nodes to achieve a target rate for the partial space proof. In this example, the operator node may set a different difficulty for each member node to ensure that each member node sends the partial space proof to the operator node at approximately the target rate.

[0272] In one variation, a member node may select the difficulty of a portion of the space proof used for the member node. For example, a member node may communicate with an operator node via HTTP (or another network communication protocol) to select or adjust the difficulty of a portion of the space proof used for the member node.

[0273] 10.1.2 Partial Space Proof Submission

[0274] The steps of method S100 record that during a second time period following the initial time period, by the first member node: in step S152, accessing a second challenge from a second version of the blockchain; in step S154, generating a first portion of space proof corresponding to a first difficulty from a seeding file; and in step S156, sending the first portion of space proof to an operator node.

[0275] In one implementation, the member node may: in step S152, access (or receive) a challenge from the current version of the blockchain; in step S154, generate a partial space proof from the seeding file, the partial space proof corresponding to the difficulty selected for the member node; and in step S156, send the partial space proof to the operator node. The member node (and each member node in a group of member nodes) may iteratively perform steps S152, S154, and S156 of method S100 within a transfer period.

[0276] In one variation, a member node or operator node may select different difficulty levels for partial space proofs of a member node. More specifically, a member node or operator node may select different difficulty levels for partial space proofs of a member node during a transfer period and / or during a subsequent transfer period.

[0277] In one example, a member node may: access a first challenge from a first version of a blockchain; generate a first portion of space proof from a seeding file, the first portion of space proof corresponding to a first difficulty; and send the first portion of space proof to an operator node. The member node may then: access a second challenge from a second version of the blockchain; generate a second portion of space proof from a seeding file, the second portion of space proof corresponding to a second difficulty exceeding the first difficulty; and send the second portion of space proof to the operator node.

[0278] In another example, a member node may: access a first challenge from a first version of a blockchain; generate a first portion of space proof from a seeding file, the first portion of space proof corresponding to a first difficulty; and send the first portion of space proof to an operator node. The member node may then: access a second challenge from a second version of the blockchain; generate a second portion of space proof from a seeding file, the second portion of space proof corresponding to a second difficulty lower than the first difficulty; and send the second portion of space proof to the operator node.

[0279] 10.1.3 Receipt and Scoring of Partial Space Certificates

[0280] The steps of method S100 record that during a second time period following the initial time period, by an operator node: in step S160, a group of member nodes are identified based on a group of singleton nodes; in step S162, a first group of partial space proofs are received from a first member node in a group of member nodes; and in step S166, a first partial space proof score is calculated for the first member node.

[0281] In one implementation, in step S160, the operator node may identify a set of member nodes in the reward pool based on a set of singletons, each singleton in the set of singletons including an internal hash puzzle defining a pool address associated with the reward pool. Then, in step S162, the operator node may receive a partial space certificate from each member node in the set of member nodes. For example, the operator node may receive a first set of partial space certificates from a first member node in the set of member nodes.

[0282] In general, an operator node may calculate a corresponding partial space proof score for each member node in a set of member nodes. More specifically, an operator node may calculate a corresponding partial space proof score for each member node in a set of member nodes during a transfer period. An operator node may set any transfer period, which may be specified based on the number of blocks passed or in any other unit of time or measure of blockchain length. The operator node may tabulate a point score for each member node based on the number of partial space proofs received during the transfer period and the difficulty of the partial space proofs.

[0283] In one implementation, in step S166, the operator node may calculate a partial space proof score based on the number of partial space proofs in a set of partial space proofs multiplied by the difficulty assigned to the member node.

[0284] For example, the operator node may calculate a first partial space proof score (e.g., for the first member node) based on the number of partial space proofs in the first set of partial space proofs received from the first member node during the transfer period (e.g., 300) multiplied by the difficulty assigned to the first member node during the transfer period (e.g., 10). In this example, the operator node may calculate the first partial space proof score as 3000 (i.e., 300 times 10).

[0285] In another implementation, the operator node may: for each partial proof of space in a set of partial proofs of space, in step S164, calculate a corresponding point value based on the difficulty of the corresponding proof of space (e.g., a point value of 10 based on a proof of space characterized by a difficulty of 10, and a point value of 100 based on a proof of space characterized by a difficulty of 100); and in step S166, calculate a proof of space score based on the sum of the respective point values ​​during the transfer period. In this implementation, when a corresponding partial proof of space is received during the transfer period, the operator node may calculate the corresponding point value and the proof of space score.

[0286] Additionally, the operator node may verify the received partial space proof. The operator node may calculate a point value in response to verifying the partial space proof.

[0287] 10.2 Reward Transfer

[0288] Step S168 of method S100 records that, during a second time period following the initial time period, the operator node: transfers a first amount of block rewards in a first pool address to a first member node based on a first portion of the proof-of-space score.

[0289] Typically, upon completion of the transfer period, the operator node may distribute the accumulated block rewards retrieved by the operator node during the transfer period to each member node in a set of member nodes in proportion to each member node's partial proof-of-space score. The operator node may identify the current member nodes participating in the reward pool based on the state of the singleton on the blockchain, and may transfer the pooled block rewards based on the current member nodes of the reward pool.

[0290] In one implementation, in step S168, the operator node may transfer a corresponding block reward amount to each member node in a set of member nodes based on the corresponding partial proof of space score of the corresponding member node. More specifically, for each member node in the set of member nodes, the operator node may: in step S170, during the transfer period, calculate a corresponding share based on a ratio of the corresponding partial proof of space score for a set of member nodes to the total proof of space score (i.e., the sum of the partial proof of space scores for a set of members of the pool); and in step S172, calculate a corresponding block reward amount based on the corresponding share. In this implementation, the operator node may calculate the corresponding block reward amount as equal to the total amount of block rewards accumulated in the pool address (or a portion thereof) during the transfer period multiplied by the corresponding share. Thus, the operator node may fairly transfer to the member nodes block rewards that are proportional to the likelihood of each member node winning an actual block of the extended blockchain.

[0291] For example, the operator node may: calculate a first share corresponding to the first member node based on a ratio of a first portion of the proof-of-space score (e.g., 3,000) corresponding to the first member node to a total proof-of-space score (e.g., 100,000) for a group of member nodes in the reward pool during the transfer period; and calculate a first block reward amount for the first member node based on the first share. More specifically, the operator node may calculate the first block reward amount as a portion (e.g., 95%) of the total amount of block rewards accumulated in the pool address during the transfer period (1,750,000,000,000) multiplied by the corresponding share. In this example, the operator node may: calculate the first share as 0.03 (i.e., 3000 divided by 100000); and calculate the first block reward amount as 49,875,000 (i.e., 0.95 multiplied by 1,750,000,000,000 multiplied by 0.03). The operator node may transfer the first block reward amount to the first member node.

[0292] The systems and methods described herein may be at least partially embodied and / or implemented as a machine configured to receive a computer-readable medium storing computer-readable instructions. Instructions may be executed by a computer-executable component integrated with the following items: an application, a small application, a host, a server, a network, a website, a communication service, a communication interface, a hardware / firmware / software element of a user's computer or mobile device, a wristband, a smart phone, or any suitable combination thereof. Other systems and methods of embodiments may be at least partially embodied and / or implemented as a machine configured to receive a computer-readable medium storing computer-readable instructions. Instructions may be executed by a computer-executable component integrated with the above-mentioned types of devices and networks. Computer-readable instructions may be stored on any suitable computer-readable medium, such as RAM, ROM, flash memory, EEPROM, optical device (CD or DVD), hard drive, floppy disk drive, or any suitable device. The computer-executable component may be a processor, but any suitable dedicated hardware device may (optionally or additionally) execute instructions.

[0293] As those skilled in the art will recognize from the previous detailed description and from the accompanying drawings and claims, modifications and variations may be made to the embodiments of the invention without departing from the scope of the invention as defined in the appended claims.

Claims

1. A method, the method comprising: an operator node in a reward pool: Identifying a first singleton in a set of singletons in a first version of a blockchain, the first singleton comprising: - a first external puzzle hash, said first external puzzle hash linking said first singleton to a first singleton puzzle hash in a set of singleton puzzle hashes; as well as - a first inner puzzle hash, said first inner puzzle hash defining the following: a first owner address associated with a first member node in a set of member nodes in the reward pool; and a first pool address associated with the reward pool; and In response to detecting a block reward assigned to the first singleton puzzle hash, submitting a first transaction configured to: - removing said first singleton from said set of singletons; - generating a second singleton in the set of singletons based on the first singleton, the second singleton comprising: a second external puzzle hash that links the second singleton to the first singleton puzzle hash; and - A second inner puzzle hash, which defines the following items: ---the first owner's address; and ---the first pool address; and -Transferring the block reward from the first singleton puzzle hash to the first pool address.

2. The method according to claim 1: in, Identifying the first singleton includes identifying the set of singletons in the first version of the blockchain, each singleton in the set of singletons including: - an external puzzle hash that links a singleton in the set of singletons to a singleton puzzle hash in the set of singleton puzzle hashes; and - An inner puzzle hash that defines the following: -- said address associated with a member node in said set of member nodes; and --the first pool address; and Wherein, submitting the first transaction includes: - detecting said block reward allocated to said first singleton puzzle hash; - selecting said first singleton of said set of singletons that is linked to said first singleton puzzle hash; and - submitting the first transaction configured to transfer the block reward from the first singleton puzzle hash to the first pool address.

3. The method according to claim 1, further comprising: calculating a partial space proof score for a member node in the set of member nodes based on a set of partial space proofs associated with the member node; as well as Based on the partial space proof score, a certain amount of block rewards in the first pool address is transferred to the member node.

4. The method according to claim 3, wherein: Calculating the partial space proof score includes: calculating the partial space proof score based on the number of partial space proofs in the set of partial space proofs and the difficulty assigned to the member node.

5. The method according to claim 3, wherein: Calculating the partial space proof score includes: For each partial space proof in the set of partial space proofs, calculating a point value in a set of point values ​​based on the difficulty of the partial space proof; and The partial space proof score is calculated based on the set of point values.

6. The method according to claim 3, wherein: Transferring the certain amount of block rewards in the first pool address to the member node includes: calculating a share based on a ratio of the partial proof-of-space score to a total proof-of-space score for the set of member nodes; and The certain amount of block reward is calculated based on the share.

7. The method according to claim 1, further comprising: A difficulty of a portion of the proof space for the first member node is selected based on an amount of storage space allocated by the first member node to the seeding file.

8. The method according to claim 1: in, Submitting the first transaction includes: during a first time period, submitting the first transaction configured to generate the second singleton, the second singleton including the second internal puzzle hash defining a collection state of the second singleton; Also included is identifying, during a second time period subsequent to the first time period, a second singleton in the set of singletons in a second version of the blockchain, the second singleton comprising the second inner puzzle hash defining: - the transition state of the second singleton; - the first pool address; - a second pool address associated with a second reward pool; and -Escape time.

9. The method of claim 8, further comprising during a third time period spanning the second time period and during an escape period characterized by the escape time: detecting a second block reward assigned to the second singleton puzzle hash; and Submitting a second transaction configured to transfer the second block reward from the second singleton puzzle hash to the first pool address.

10. The method of claim 8, further comprising, during a third time period subsequent to the second time period and an escape period characterized by the escape time: detecting a second block reward assigned to a second singleton puzzle hash; identifying the second singleton in the set of singletons in a third version of the blockchain, the second singleton comprising the second inner puzzle hash defining a collected state of the second singleton; as well as Submitting a second transaction configured to transfer the second block reward from the second singleton puzzle hash to the second pool address.

11. The method according to claim 1, further comprising: The block reward assigned to the first singleton puzzle hash is detected based on a reward height associated with the first singleton puzzle hash.

12. The method according to claim 1, wherein: Submitting the first transaction includes submitting the first transaction configured to remove the first singleton from the set of singletons by spending the first singleton.

13. The method according to claim 1, wherein: Submitting the first transaction includes submitting the first transaction configured to generate the second singleton based on the first singleton puzzle hash and a transmitter identifier, the second singleton including the second external puzzle hash characterized by a hash value.

14. The method according to claim 1, further comprising: generating a block of a blockchain based on the proof of space, the block including the block reward assigned to the first singleton puzzle hash; as well as The block is broadcasted on the distributed network.

15. The method according to claim 1, further comprising: A seeding file is stored on a storage device, the seeding file defining the following items: - a set of space proofs; as well as - the first singleton puzzle hash; as well as Submitting an initial transaction, the initial transaction being configured to generate the first singleton based on the first singleton puzzle hash, the first singleton comprising: - linking said first singleton to said first external puzzle hash of said first singleton puzzle hash; as well as -The first inner puzzle hash.

16. A method, the method comprising: Detect the block reward assigned to the first singleton puzzle hash; Identifying a first singleton in a set of singletons that is linked to the first singleton puzzle hash, the first singleton comprising: - an external puzzle hash linking the first singleton to the first singleton puzzle hash; and - An inner puzzle hash that defines the following: an owner address associated with a member node in a set of member nodes in the reward pool; and - the pool address associated with the reward pool; and Submitting a transaction configured to transfer the block reward from the first singleton puzzle hash to the pool address.

17. The method according to claim 16, wherein: Submitting the transaction includes submitting the transaction further configured to: removing the first singleton from the set of singletons; as well as A second singleton in the set of singletons is generated based on the first singleton, the second singleton comprising: - a second external puzzle hash, said second external puzzle hash linking said second singleton to said first singleton puzzle hash; as well as - a second inner puzzle hash defining the owner address and the pool address.

18. The method according to claim 16, further comprising: calculating a partial space proof score for a member node in the set of member nodes based on a set of partial space proofs associated with the member node; as well as Based on the partial space proof score, a certain amount of block rewards in the pool address is transferred to the member node.

19. The method according to claim 18, wherein: Calculating the partial space proof score includes: calculating the partial space proof score based on the set of partial space proofs and the difficulty assigned to the member node.

20. A method, the method comprising: Detect the block reward assigned to the first singleton puzzle hash; Identifying a first singleton in a set of singletons that is linked to the first singleton puzzle hash, the first singleton comprising: - an external puzzle hash linking the first singleton to the first singleton puzzle hash; and - An inner puzzle hash that defines the following: an owner address associated with a first member node in a set of member nodes in the reward pool; and --The pool address associated with the reward pool; submitting a transaction configured to transfer the block reward from the first singleton puzzle hash to the pool address; receiving a first set of partial space certificates from the first member node; selecting a difficulty for the first member node based on an amount of storage space allocated by the first member node to seeding files; calculating a first partial space proof score for the first member node based on the first set of partial space proofs and the difficulty; and Based on the first portion of the space proof score, a certain amount of block rewards in the pool address is transferred to the first member node.

Images