CN115664652A

CN115664652A - Asynchronous dynamic consensus method based on fragmentation

Info

Publication number: CN115664652A
Application number: CN202211286969.0A
Authority: CN
Inventors: 陈祺; 李进; 李兴宇; 叶顺良; 陈畅
Original assignee: Guangzhou University
Current assignee: Guangzhou University
Priority date: 2022-10-20
Filing date: 2022-10-20
Publication date: 2023-01-31

Abstract

The invention discloses an asynchronous dynamic consensus method based on fragments, which comprises the following steps: 1) Leading election nodes to generate a fragmentation committee and entering a first era; 2) The committees internally form consensus, cross-fragment transaction processing blocks and form routing protocols among the committees; 3) Committee reconstruction further solves the problem of node storage space. The invention provides a slicing asynchronous dynamic consensus algorithm for a low earth orbit satellite, which has the following advantages: 1. firstly, the method provides an innovative idea for the state slicing system in many aspects, and the design idea and the system architecture have great reference value. For example, a processing mode of cross-segment transaction, a segment routing protocol, a committee reconstruction scheme, a multi-turn protocol of each era, and the like; 2. the method has the advantages that the performance of all aspects is remarkably improved, the ratio of the tolerable malicious nodes of the system is improved to 1/3, the throughput is improved to 7380tps, the transaction confirmation delay is reduced to the second level, and the robustness of the system is remarkably improved.

Description

Asynchronous dynamic consensus method based on fragments

Technical Field

The invention belongs to the field of electronic information security, and particularly relates to an asynchronous dynamic consensus method based on fragments.

Background

In a distributed network, ensuring distributed consistency (all nodes agree on the same proposal or data) is the most central and important issue. Due to the fact that a distributed network is provided with a plurality of nodes, communication delay is inevitable in the network, and the nodes can be in downtime, faults, failures and other complex conditions.

The block chain provides a better idea for solving the consistency problem of the distributed system, but the traditional block chain system has the problems of low throughput, low expansibility, high delay, low storage performance and Sybil attack, and is difficult to meet the requirements of high safety and high expandability. And fragmentation is the best scheme currently available to balance efficiency, security, scalability. There are also some schemes in the industry that use fragmentation techniques, and existing fragment-based blockchain protocols still require linear traffic (number of participants) per transaction, and therefore, only partially realize the potential benefits of fragmentation.

Therefore, how to design an efficient fragmentation dynamic consensus method in a large-scale application scenario is a technical problem that needs to be solved urgently by those skilled in the art.

Disclosure of Invention

The invention overcomes the defects of the prior art and provides an asynchronous dynamic consensus method based on fragments.

The purpose of the invention is realized by the following technical scheme:

s1, guiding election nodes to generate a fragmentation committee and entering a first era;

s2, forming consensus inside committees, performing cross-fragment transaction processing on blocks, and forming a routing protocol among the committees;

and S3, reconstructing by a committee, and solving the problem of node storage space.

Preferably, in S1, the method for electing nodes to form a root group includes:

s101, each initial participating node locally uses hard coding parameters and random seeds to create a random bipartite graph G (L, R), wherein L is a node, and R is a group; neighbors of each node in the R are randomly, independently and uniformly selected from the L, and change from level 0 to level 1 to form an initial group;

s102, a random character string S is generated by operating a distributed random number generation algorithm in an initial group, each node carries out hash operation on S and the ID of the subset, the hash value falls on a node in a certain interval, the subset is declared to be a selected node in a broadcast mode, other nodes in the group sign the ID and the character string S, and the nodes are proved to be the selected node; these selected nodes broadcast their own identity, including the certificate, to the entire network;

s103, forming a root group by the selected nodes;

s104, the root group is responsible for selecting members of a reference committee, and the reference committee randomly divides the set of all nodes into various slicing committees and then enters the first era.

Preferably, in step 2, the method for forming consensus in the committee comprises:

s201, in each turn of forming consensus, each committee selects a leader by using a time random source;

s202, collecting the transactions from the client by the leader and packaging the transactions into a block Bi;

s203, the leader broadcasts the block Bi by using an IDA-Gossip protocol and creates a block head Hi containing a merkle tree and the round times;

and S204, starting a consensus protocol by the committee member aiming at the block header Hi.

Preferably, in S204, the leader adds a prompt tag to the block header Hi, and broadcasts Hi through the network; after each node receives the block header Hi, each node responds to the received block header Hi, adds a response label to Hi and broadcasts the response label through the network.

Preferably, if the node receives the block headers of different versions, the leader is malicious, and the node refuses the block by broadcasting a pending tag; on the contrary, if the node receives only one block header Hi and receives more than mf +1 response tags, it indicates that all committees agree on the block Bi; once the committees agree, each node that receives at least mf +1 response tags re-broadcasts the block header and adds a receipt tag and a content to prove that the node was selected.

Preferably, for messages between different committees, each sender only sends the messages to the nodes of the target committee which is known by the sender, and the nodes which receive the messages send the messages to other members of the committee through the IDA-gossip protocol; for the client user, the transaction need only be submitted to any one of the committees, and the committee that received the transaction will forward the transaction to the target committee via the Kademlia routing protocol.

Preferably, in S3, based on the cuckoo principle, the reference committee divides the committees into two categories, namely an active committee with a majority of active members and a passive committee with a majority of inactive members; when a new node joins, the reference committee randomly joins the node to any one of the active committees, and randomly joins a fixed number of nodes in that committee to a different passive committee, completing the reconstruction.

Preferably, in S3, based on the idea of state slicing, the storage space is reduced to 1/k of the original storage space, where k is the number of slices, and the storage space consumption of each slice is greatly reduced.

The invention provides a slicing asynchronous dynamic consensus algorithm for a low earth orbit satellite, which has the following advantages:

1. firstly, the method provides an innovative idea for the state slicing system in many aspects, and the design idea and the system architecture have great reference value. For example, a processing mode of cross-segment transaction, a segment routing protocol, a committee reconstruction scheme, a multi-turn protocol in each era, and the like;

2. the method has remarkable improvement on various performances, the ratio of the tolerable malicious nodes of the system is improved to 1/3, the throughput is improved to 7380tps, the transaction confirmation delay is reduced to the second level, and the robustness of the system is remarkably improved.

3. The method comprises a committee access control scheme based on the cuckoo principle, which can randomly add new nodes into the committee and resist the partition attack of an adaptive opponent.

Drawings

The invention is further illustrated by means of the attached drawings, but the embodiments in the drawings do not constitute any limitation to the invention, and for a person skilled in the art, other drawings can be obtained on the basis of the following drawings without inventive effort.

FIG. 1 is a flow chart of an asynchronous dynamic consensus method based on fragmentation according to the present invention;

FIG. 2 is a schematic diagram of the present invention including three important stages in a fast chain system;

FIG. 3 is a schematic diagram of the present invention using three phases of the epoch concept in the fast chain;

FIG. 4 is a flow chart of the present invention for electing a group of nodes to form a root group;

FIG. 5 is a schematic diagram of the three steps in which the Committee members of the present invention have agreed upon the block header Hi;

FIG. 6 is a graphical representation of the finite cuckoo principle classification of the present invention;

fig. 7 is a schematic diagram of the inter-employee message forwarding process of the present invention.

Detailed Description

A slice-based asynchronous dynamic consensus method is described in further detail below with reference to specific embodiments, which are only for comparison and explanation purposes, and the present invention is not limited to these embodiments.

As shown in fig. 1, an asynchronous dynamic consensus method based on fragmentation includes:

s1, guiding election nodes to generate a fragment committee and entering a first era;

As shown in fig. 2, the Bootstrapping phase is only run once at the start of the fast-link system, in order to create an initial random source and to randomly select a special committee called the reference committee. And then the members of the reference committee randomly distribute the nodes to form a slicing committee.

Preferably, as shown in fig. 3, in S1, the method for electing nodes to form a root group includes:

s101, each initial participating node locally uses a hard coding parameter and a random seed to create a random bipartite graph G (L, R), wherein L is a node, and R is a group; neighbors of each node in the R are randomly, independently and uniformly selected from the L, and change from level 0 to level 1 to form an initial group;

s102, a random character string S is generated by operating a distributed random number generation algorithm in an initial group, each node carries out hash operation on S and the ID of the subset, the hash value falls on a node in a certain interval, the subset is declared to be a selected node in a broadcast mode, other nodes in the group sign the ID and the character string S, and the nodes are proved to be the selected node; these selected nodes broadcast their identities, including certificates, throughout the network;

s103, the selected nodes form a root group;

and S104, the root group is responsible for selecting members of a reference committee, and the reference committee randomly divides the set of all nodes into various slicing committees and then enters the first era.

Preferably, in step 2, the method for forming consensus in committee comprises:

s203, broadcasting the block Bi by the leader by using an IDA-Gossip protocol, and creating a block head Hi containing a merkle tree and the round times;

Preferably, in S204, as shown in fig. 5, in the last step, the committee member agrees with the block header Hi according to the following three steps: the leader adds a prompt label to the block header Hi and broadcasts the Hi through the network; after each node receives the block header Hi, each node responds to the received block header Hi, adds a response label to Hi and broadcasts the response label through the network.

How to safely and quickly process cross-fragment transactions has been the biggest difficult problem faced by state fragmentation. Fragmenting the storage state means that each node in the system stores only a partial ledger rather than a complete ledger. The fast chain design is based on the UTXO model, and when a cross-slice transaction occurs, the system assigns the transaction to the corresponding committee according to the output hash of the transaction, and the committee receiving the transaction is called the output committee. Also, the transaction may have multiple inputs at the same time, each from a different segment, and the committee on which the inputs for the transaction are located is referred to as the input committee.

When a client submits a transaction and the system assigns the transaction to a corresponding output committee, the transaction may contain multiple inputs, and the inputs are stored in other committees. To verify the validity of the transaction, the verification node of the output committee must be able to verify the validity of each input. How to verify that the input from other tiles is valid? Omniridge and fastchain offer two completely different ideas.

In omnilegger's solution, the client first makes a request to the input committees, hoping that each input committee provides certification for its own asset. Each input committee checks the corresponding UTXO, and if the UTXO is correct, the corresponding UTXO is locked and the asset certificate is fed back to the client; if the UTXO is incorrect, the committee returns a reject message to the client. The client collects the asset credentials of all the input committees and submits them to the output committee. And after the output committee passes the verification, the client sends an unlock to commit command to complete the transaction.

Omni Ledger guarantees the atomicity of transaction processing in a cross-fragment transaction processing mode, but has the following obvious defects:

first, the client needs to broadcast transactions throughout the network and at least one credential needs to be generated and submitted for each transaction, which results in a large amount of communication overhead for the entire network.

Another problem is that the system is too client dependent, violating the light client principle. This also requires that the client must know the entire network structure.

In one embodiment, there is a transaction tx that has two inputs In1 and In2 and an output Out, and the two inputs and outputs belong to different Shard committees Shard1,2,3, respectively. Then the Leader of the output committee creates three new transactions, and the Leader of the output committee creates three new transactions in the processing flow of the transactions, which are respectively as follows:

1) Tx1, converting Input from Shard1 to Output of Shard 3;

2) Tx2, converting Input from Shard2 to Output of Shard 3;

3) Tx3, the input is the output of Tx1 and Tx2, and the output principle is the same.

The Leader of the output committee sends Tx1 and Tx2 to Shard1 and Shard2, respectively, via an inter-committee routing protocol. The leaders of Shard1 and Shard2 would then verify the validity of the respective transactions, respectively, and if valid, they would add the transactions to the ledger of the local fragment, respectively, and reply to Shard 3. Shard3, upon receiving all input committee replies, will add Tx3 to its ledger.

Wherein the request for acknowledgement between the fragments can be batch processed. The output board may batch-send UTXO transaction combinations belonging to the same input board to the input board at one time in each round. The input committee can also verify the validity of UTXO transaction in batches and give feedback to the output committee uniformly, so that the communication complexity between the committees can be greatly reduced.

Fast links require a routing scheme that enables clients and committee leaders to quickly find the committee that they should send the transaction. The conventional solutions are the following two:

1) Each node is made to store network information for all committee members. Thus, each node can quickly locate and communicate to any member's IP. Obviously, the expansibility of doing so is very weak, each node needs to be connected with a large number of nodes, and the application to a network of thousands of nodes is difficult.

2) Another solution is to have a reference committee take care of transaction routing. Each user or committee Leader obtains network information through a reference committee through which transactions are routed. However, this results in a reference committee that is too burdensome to handle, requiring a large number of communications, and risking overheating of a single segment.

Finally, the design idea of the Kademlia routing algorithm is used for reference by the routing protocol of the fast link. In short, each node stores the routing information of all nodes of the same committee members, and only stores the information of log (n) nodes belonging to log (n) committees closest to the committee in which the node belongs. That is, each node selects log (n) committees closest to the committee where the node is located, and then selects loglog (n) nodes from each committee, and only stores the information of the nodes, but not all the nodes in the network.

When newly added nodes are verified, the reference committee generates an epoch random source (epoch random) for the next epoch before the end of each epoch. In each era, while committee nodes were conducting transaction verification, other nodes wishing to join the network were locally seeking PoW solutions that had to rely on the random source of the previous era. The nodes are required to find PoW tiles in order to defend Sybil attech, i.e., witch attack. While the PoW solution must rely on the epoch random ness in order to avoid that the solution for the node is computed well in advance.

When era proceeded to the committee reconfiguration phase, all new nodes wishing to join the committee submitted their own found solutions to the reference committee, which was responsible for verifying the correctness of the PoW solution. How to correctly refer to the Leader of the committee will randomly assign new nodes to each committee according to the bounded cuckoo principle.

When generating a new epoch random source, members of the reference committee will also run the DRG protocol to agree on a non-biased random value during the reconstruction phase of each epoch. This random source is then included in a reference block (reference block) and sent to each member of the network. And the fast chain selection uses the ferdman's verifiable secret sharing protocol to generate this random source.

The steps of generating the random source are summarized as follows:

1) Selecting a prime order Pi for each reference committee node

2) Each node VSS-share gives all other members of the committee the number they choose.

3) Each node j will receive m shares from other nodes, P1j, P2j, P3j, \8230, pmj, respectively.

The steps of generating the random source are summarized as follows:

and finally, reconstructing a result by using a Lagrange interpolation technology through summation operation to obtain the epoch random.

The committee was reconstructed using the limited cuckoo principle that can address the partition attack. In the partitioned block chain system, a partition is easily attacked, that is, within a single partition, an offline or malicious node exceeds a tolerable proportion, or a protocol cannot be normally performed, and it is also possible to record wrong information on the partition account. In order to avoid such a zoning attack, committees must be shuffled periodically.

In the prior art, the committee reconfiguration method of the Elastico is to scatter all the committee nodes and reselect all the committees. However, this approach has two fatal drawbacks:

1) Re-election all committees is costly and takes a long time, resulting in a significant increase in the performance of the slicing system.

2) If nodes are always disorganized all the time, it is difficult to have a separate ledger for each committee location. The initial purpose of the state fragments is to store the account books in the fragments respectively, so that the storage space is reduced. But it is clear that the total way of disturbing the redistribution does not achieve the desired effect.

Therefore, in the state slicing system, all nodes in the system cannot be disturbed and all committees cannot be reconfigured, and only the committees can be finely adjusted. There is a need to find a protocol that can randomly join new nodes to a committee while also being resistant to partitioning attacks by adaptive adversaries. The solution of the fast chain is excellent, it is modified on the basis of Cuckoo rule, creating a limited Cuckoo rule to solve the above mentioned challenges.

The principle of cuckoo principle is simple, each node is randomly placed in a [0,1] interval, then the interval is divided into k areas, and a group of nodes in each area form a committee. When a new node joins, it is randomly placed in one location, and a fixed number of nodes in the same area are moved to different random areas. As shown in fig. 6, the reference committee, in each era of the limited cuckoo principle, divides the committees into two categories, an active committee with a majority of active members and a passive committee with a majority of inactive members. When a new node joins, the reference committee randomly joins the node to some active committee and a fixed number of nodes in that committee to a different passive committee, as shown in fig. 7.

The fast chain uses the idea of state fragmentation, so that each node in the system only needs to store all blocks of the fragment where the node is located and UTXO information, linear expansion is theoretically completed on a storage space, and the storage space is reduced to 1/k of the original storage space, wherein k is the number of the fragments.

However, such ideal situation cannot be achieved in practice, since it is known from the cross-slice transaction characteristics mentioned above that a single cross-slice transaction may be split into three or more transactions and stored in different slices, the effect of expanding the storage space is considered to be small.

Of course, this is also a characteristic of the UTXO model, and if the system uses an account-based model, and the user can only have an account in one slice, the storage space consumption of each slice can be greatly reduced, so that the account-based model is considered to be more suitable for the state slice system than the UTXO model.

Finally, it should be noted that the above embodiments are only used for illustrating the technical solutions of the present invention, and not for limiting the protection scope of the present invention, although the present invention is described in detail with reference to the preferred embodiments, it should be understood by those skilled in the art that modifications or equivalent substitutions can be made on the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention.

Claims

1. A slice-based asynchronous dynamic consensus method is characterized by comprising the following steps:

s2, forming consensus inside each committee, performing cross-segmentation transaction processing blocks, and forming routing protocols among different committees;

and S3, reconstructing by all committees, and solving the problem of node storage space.

2. The asynchronous and dynamic sharding-based consensus method according to claim 1, wherein in S1, the method for electing nodes to form a root group comprises:

s101, each initial participating node locally uses a hard coding parameter and a random seed to create a random bipartite graph G (L, R), wherein L is a node, and R is a group; neighbors of each node in the R are randomly, independently and uniformly selected from the L, and are changed from level 0 to level 1 to form an initial group;

s102, a random character string S is generated by operating a distributed random number generation algorithm in an initial group, each node carries out hash operation on S and the ID of the subset, the hash value falls into a node in a certain interval, the subset is declared to be a selected node in a broadcast mode, other nodes in the group sign the ID and the character string S, and the nodes are proved to be the selected node; these selected nodes broadcast their identities, including certificates, throughout the network;

s103, the selected nodes form a root group;

3. The asynchronous dynamic consensus method based on slices of claim 1, wherein in step 2, the method for committee internal consensus formation comprises:

s202, collecting transactions from the client and packaging the transactions into blocks Bi by the leader;

s204, starting a consensus protocol by the committee members aiming at the block header Hi.

4. A slice-based asynchronous dynamic consensus method as claimed in claim 3, wherein in S204, the leader adds a prompt tag to the block header Hi and broadcasts Hi via the network; after each node receives the block header Hi, each node responds to the received block header Hi, adds a response label to Hi and broadcasts the response label through the network.

5. A slice-based asynchronous dynamic consensus method according to claim 4, wherein if a node receives a block header of a different version, indicating that the leader is malicious, the node rejects the block by broadcasting a pending tag; on the contrary, if the node receives only one block header Hi and receives more than mf +1 response tags, it indicates that all committees agree on the block Bi; once the committees agree, each node that receives at least mf +1 response tags re-broadcasts the block header and adds a receipt tag and a content to prove that the node was selected.

6. A slice-based asynchronous dynamic consensus method according to claim 3, wherein for messages between different committees, each sender only sends messages to the nodes of the target committee he knows, and the nodes receiving the messages send messages to other members of the committee via said IDA-gossip protocol; for the client user, the transaction need only be submitted to any one of the committees, and the committee that received the transaction will forward the transaction to the target committee via the Kademlia routing protocol.

7. The slice-based asynchronous dynamic consensus method of claim 1, wherein in S3, based on the cuckoo principle, the reference committee divides the committees into two categories, namely an active committee with a majority of active members and a passive committee with a majority of inactive members; when a new node joins, the reference committee randomly joins the node to any one of the active committees, and randomly joins a fixed number of nodes in that committee to a different passive committee, completing the reconstruction.

8. The asynchronous and dynamic sharding-based consensus method according to claim 1, wherein in S3, based on the concept of state sharding, the storage space is reduced to 1/k, where k is the number of shards, so as to substantially reduce the storage space consumption of each shard.