WO2021239072A1

WO2021239072A1 - Method for creating node group in alliance chain network, and transaction method based on node group

Info

Publication number: WO2021239072A1
Application number: PCT/CN2021/096519
Authority: WO
Inventors: 杨文龙; 夏凝
Original assignee: 支付宝(杭州)信息技术有限公司
Priority date: 2020-05-28
Filing date: 2021-05-27
Publication date: 2021-12-02
Also published as: CN111383018A; CN112200575A; CN111383018B; CN112200575B

Abstract

A method for creating a node group in an alliance chain network, and a transaction method based on a node group. A manager of a first node in an alliance chain network can initiate a group creation transaction by means of an alliance chain account thereof, wherein the group creation transaction includes group creation sub-transactions. After the group creation transaction is broadcast to the alliance chain network, the first node creates a private chain locally according to the group creation sub-transactions when executing the group creation transaction, which is equivalent to creating a node group that includes the first node. Moreover, other nodes do not create a private chain locally when executing the group creation transaction. Finally, both the first node and the other nodes write the group creation transaction into a local alliance chain. By means of the method, the privacy of service data connected to a node can be protected.

Description

Create node group in alliance chain network, transaction method based on node group

Technical field

The embodiments of this specification relate to the field of information technology, and in particular to a method for creating node groups in a consortium chain network based on node groups.

Background technique

The alliance chain network, also known as the alliance type blockchain network, generally consists of multiple institutions as alliance members, and the nodes controlled by multiple institutions form the alliance chain network.

For each institution that is a member of the alliance, users of the institution’s docking can encapsulate the business data of the initiated business into a transaction (data structure specified by the blockchain protocol) and submit it to the corresponding node of the institution, and then the institution corresponds The nodes broadcast the transaction to the consortium chain network, and then each node in the consortium chain network writes the transaction into the local blockchain after a consensus on the transaction. In this way, it can be ensured that the business data written in the blockchain is difficult to be tampered with.

In order to pursue the non-tampering of service data, the existing operating mechanism of the alliance chain network causes the service data of any node to be disclosed to the entire network.

Summary of the invention

In order to solve the problem of the inability to protect the privacy of the business data of the node docking in the prior art, an embodiment of this specification provides a method for creating a node group in a consortium chain network and a transaction method based on the node group. The solution is as follows:

According to the first aspect of the embodiments of the present specification, there is provided a method for creating a node group in a consortium chain network, the consortium chain network including a plurality of nodes, and the method includes: a first node receives a first manager account Group creation transaction; the group creation transaction includes a group creation sub-transaction, the group creation sub-transaction includes a group public key; the first manager account is the manager of the first node registered in the alliance chain network The group public key is designated by the manager of the first node; the first node broadcasts the group creation transaction to the alliance chain network; the first node executes the group creation transaction, Including: creating a private chain locally, writing the creation sub-transaction into the local private chain, and using the group public key to encrypt the first node identifier; every other node except the first node is not In the case of creating a private chain, executing the group creation transaction includes: using the group public key to encrypt the first node identification; each node in the consortium chain network writes the group creation transaction and the corresponding execution result Enter the local consortium chain; the execution result corresponding to the group creation transaction includes the encrypted first node identifier.

According to a second aspect of the embodiments of the present specification, there is provided an anonymous registration method based on the node group created in the first aspect, including: the first node receives an anonymous registration transaction constructed by a corresponding user account; the anonymous registration transaction Contains an anonymous registration sub-transaction, the anonymous registration sub-transaction includes an anonymous public key and a signature generated by using the group private key corresponding to the group public key; wherein, the user account is the user connected to the first node in the consortium chain For an account registered in the network, the anonymous public key is specified by the user who is docking with the first node; the first node uses the set of public keys to pair the anonymous registration sub-transactions corresponding to the set of private keys The signature is verified, and if the verification is passed, the anonymous registration transaction is processed, including: reconstructing the anonymous registration transaction including the anonymous registration sub-transaction through the account of the first management party; The consortium chain network broadcasts the reconstructed anonymous registration transaction; the execution of the anonymous registration transaction by the first node includes: writing the anonymous registration sub-transaction into a local private chain; each node other than the first node Other nodes execute the reconstructed anonymous registration transaction without creating a private chain; each node in the consortium chain network writes the anonymous registration transaction into the local consortium chain.

According to a third aspect of the embodiments of the present specification, there is provided a transaction method based on the anonymous registration method described in the second aspect, including: the first node receives a business transaction constructed by a corresponding user account; the business transaction includes a business A sub-transaction, the business sub-transaction includes business data, a signature generated using the set of private keys, and a signature generated using the anonymous private key corresponding to the anonymous public key; the first node uses the set of public keys to The signature corresponding to the group private key in the business subtransaction is verified, and the anonymous public key corresponding to the user account is used to verify the signature corresponding to the anonymous private key in the business subtransaction. If passed, processing the business transaction includes: reconstructing a business transaction containing the hash value of the business sub-transaction through the account of the first management party; The constructed business transaction; the execution of the business transaction by the first node includes: writing the business sub-transaction into a local private chain; other nodes other than the first node have not created a private chain, Perform the reconstructed business transaction; each node in the alliance chain network writes the business transaction into the local alliance chain.

In the technical solution provided by the embodiment of this specification, the manager of the first node in the alliance chain network can initiate a group creation transaction through its own alliance chain account, and the group creation transaction includes group creation sub-transactions. After the group creation transaction is broadcast to the consortium chain network, when the first node executes the group creation transaction, it creates a sub-transaction according to the group and creates a private chain locally, which is equivalent to creating a node group containing the first node. When other nodes execute the group creation transaction, they will not create a private chain locally. Eventually, the first node and other nodes will write the set of created transactions into the local consortium chain.

In this way, when the first management party initiates a business transaction to the first node through its own consortium chain account, if the first node determines that the business sub-transaction contained in the business transaction carries the signature of the group private key, it is determined that the business sub-transaction specifies For the node group corresponding to the group private key, the content of the business sub-transaction cannot be disclosed to the alliance chain. Therefore, the first node will replace the business sub-transaction in the business transaction with a hash value before broadcasting to the alliance chain network. When a node executes a business transaction, it will write the business sub-transaction into the local private chain, and when other nodes in the alliance chain network except the first node execute business transactions, there is no business sub-transaction content in the business transaction ( It is a hash value), and there is no private chain locally, so it will not execute like the first node. Finally, each node in the alliance chain network will write the business transaction containing the hash value of the business sub-transaction into the local alliance chain.

Through the technical solutions provided by the embodiments of this specification, on the one hand, the plaintext of the service data of the first node docking will only be stored in the private chain of the node group where the first node is located, which protects the privacy of the first node's business data; on the other hand, On the one hand, the hash value of the business data corresponding to the first node will be stored in the alliance chain again, which has the effect of storing evidence (not tampering). In addition, since the first node identifier in the execution result corresponding to the group creation transaction is encrypted, each node in the consortium chain network does not locally store the actual identity information of the first node that creates the node group.

The above general description and the following detailed description are only exemplary and explanatory, and cannot limit the embodiments of this specification. In addition, any one of the embodiments of the present specification does not need to achieve all the above-mentioned effects.

Description of the drawings

Figure 1 is a schematic diagram of the structure of an existing blockchain system;

2 is a schematic diagram of the structure of a blockchain system provided by an embodiment of this specification;

3 is a schematic flowchart of a method for creating a node group in a consortium chain network provided by an embodiment of this specification;

FIG. 4 is a schematic diagram of a first node locally maintaining an alliance chain and a private chain provided by an embodiment of this specification;

FIG. 5 is a schematic flowchart of a method for anonymous registration based on node groups according to an embodiment of this specification;

FIG. 6 is a schematic flowchart of a transaction method based on an anonymous registration method provided by an embodiment of this specification;

FIG. 7 is a schematic flowchart of a method for joining a node group according to an embodiment of the present specification;

FIG. 8 is a schematic diagram of a second node locally maintaining an alliance chain and a private chain according to an embodiment of this specification;

FIG. 9 is a schematic flowchart of a node group-based anonymous registration method provided by an embodiment of this specification;

FIG. 10 is a schematic flowchart of a transaction method based on an anonymous registration method provided by an embodiment of this specification;

Fig. 11 is a schematic structural diagram of a device for configuring the method of the embodiment of this specification.

Detailed ways

Figure 1 is a schematic diagram of the structure of an existing blockchain system. As shown in Figure 1, in the prior art, the alliance chain account can send transactions through any node, the transaction contains business data, and the transaction will be broadcast to the entire network, so that each node will cache the transaction locally. In the consensus phase, nodes A to D generate blocks based on the consensus algorithm. There are several transactions in the block. Each node executes the transactions in the block generated by the consensus and writes the block to the local consortium chain (Equivalent to writing each transaction in the block to the local consortium chain), realizing transaction execution and transaction storage on the chain.

The blockchain system described in Figure 1 will open the business data of each node's docking in the consortium chain in plaintext, and all nodes in the consortium chain network can view each other's business data, which cannot realize the protection of business data privacy.

This solution is used to achieve data isolation between nodes in a consortium chain network (data isolation between node groups, or data isolation between nodes and node groups), so as to protect the business data connected to nodes privacy.

Here, the architecture of the blockchain system applied by this solution will be explained first. The blockchain system includes a consortium chain network. The consortium chain network is composed of multiple nodes. Each node is deployed with a block chain maintained by the consortium chain network. The chain is called the alliance chain). In addition to maintaining the local alliance chain, each node in the consortium chain network can also maintain at least one local private blockchain (for the convenience of description, it is called a private chain).

It should be noted that the so-called "private" in this article means that the node group is private, not that the node is private. The nodes that maintain the same private chain constitute a node group, and a node can create or join one or more than one node group. If a node group includes only one node, then the local private chain of this node is also the private chain maintained by this node group; if a node group includes more than one node, then each node in this node group has the local private chain The chains are the same, and the same private chain is the private chain maintained by this node group.

In this solution, any node can create or join a node group, the nodes in the same node group maintain the same private chain, and the plaintext of the business data of the nodes in the same node group can only be written into the private chain of the node group to realize the node Data isolation inside and outside the group.

Figure 2 is a schematic structural diagram of a blockchain system provided by an embodiment of this specification. As shown in Figure 2, the alliance chain network includes node A, node B, node C, and node D. Nodes A to D all maintain the same alliance chain locally. The same alliance chain is maintained by the alliance chain network. Blockchain. In addition, node A and node D belong to the same node group, maintain the same private chain 1, and share business data with each other. Node C creates a node group by itself, which includes only node C, and node C maintains private chain 2 (of course , It is also possible to allow nodes A, B, and D to subsequently join the node group), node B has not created or joined any node group, and the service data of node B docking will be shared with the entire network.

The business data of node A and node D will not be shared with node B and node C, and the data isolation between node group and node and node group is realized. The business data of node C will not be shared with other nodes, and data isolation between nodes is realized.

It can be seen that the architecture of the blockchain system in this scheme is actually a two-layer network nesting structure. The outer layer is a consortium chain network, and inside the consortium chain network, several private chain networks can be formed (a private chain network is one Node group).

In addition, some concepts that will appear in the description of this solution need to be explained.

Transaction: refers to the account registered on the alliance chain network (such as the manager account registered in the alliance chain network by the manager of a node, and the user account registered in the alliance network by the ordinary users served by the manager) The initiated transaction is a concept at the level of the alliance chain network. After the transaction is broadcast to each node in the alliance chain network, it will be further written into the alliance chain. For example, group creation transaction, group joining transaction, business transaction.

Sub-transaction: refers to the data structure nested within the transaction, which is a concept on the private chain network level. The sub-transaction will specify the private chain to be written into, and all nodes maintaining the private chain will write the sub-transaction into the private chain. For example, group creation sub-transaction, group joining sub-transaction, business sub-transaction.

As we all know, in the blockchain field, transactions are divided into execution-type transactions and deposit-type transactions. For execution-type transactions, nodes not only need to write the execution-type transaction into the blockchain, but also need to be based on some data parameters in the execution-type transaction. Perform the operation and get the execution result; for the deposit type transaction, the node does not need to execute, only the deposit type transaction will be written into the blockchain for deposit.

The transactions at the alliance chain level mentioned in this solution usually refer to execution transactions, while the sub-transactions at the private chain level are either deposit-certified transactions or execution transactions.

First node: For the convenience of description, a certain node that creates a node group in the alliance chain network is called the first node.

Second node: For the convenience of description, some other node in the alliance chain network that joins the node group created by the first node is called the second node.

In order to enable those skilled in the art to better understand the technical solutions in the embodiments of this specification, the technical solutions in the embodiments of this specification will be described in detail below in conjunction with the drawings in the embodiments of this specification. Obviously, the described implementation The examples are only a part of the embodiments in this specification, not all the embodiments. Based on the embodiments in this specification, all other embodiments obtained by a person of ordinary skill in the art should fall within the scope of protection.

The technical solutions provided by the embodiments of this specification will be described in detail below with reference to the accompanying drawings.

Fig. 3 is a schematic flowchart of a method for creating a node group in a consortium chain network provided by an embodiment of the present specification, including the following steps: S300: the first node receives the group creation transaction constructed by the first manager account.

The first manager account is an account registered by the manager of the first node in the alliance chain network. Generally speaking, the management party of a node is an organization (such as a bank) that provides business services to users. Usually, the centralized server of the node's manager will dock with several users. For users, the node manager provides a centralized service. The user initiates a business to the centralized server of the node manager, and the centralized server encapsulates the corresponding business data into the business transaction through the account of the first manager. Submit to the first node so that the alliance chain network can process and store business transactions.

As for the node group creation operation and the node group joining operation, it is usually initiated by the node's manager, not by the user who is docked by the node's manager.

In the embodiment of this specification, the group creation transaction includes the creation sub-transaction (of course, it usually contains other parameters), and the creation sub-transaction includes the group public key. The group public key is designated by the manager of the first node and is used as the creation The public key corresponding to the node group. It is understandable that since the administrator of the first node has designated the group public key, of course, it will also designate the group private key.

It should be noted here that the transaction is a well-known data structure in the field of blockchain technology. In addition to the data to be processed, the transaction usually also contains other parameters (such as the account address, the hash value of the transaction, and the account pair that initiated the transaction. The signature of the transaction, etc.), among which, other parameters in the transaction are not the focus of this solution. The following text will not emphasize other parameters, and only focus on the data contained in the transaction.

S302: The first node broadcasts the group creation transaction to the alliance chain network.

S304: The first node executes the group creation transaction.

S306: Every other node except the first node executes the group creation transaction without creating a private chain.

S308: Each node in the alliance chain network writes the group creation transaction and the corresponding execution result into the local alliance chain.

From the perspective of the alliance chain network, the first node will broadcast the group creation transaction to the entire network after accepting the group creation transaction initiated by the first manager account. Based on the consensus algorithm, each node in the alliance chain network will package the group creation transaction into a block (understandably, there will be other transactions in the block, and other transactions may not be other group creation transactions, but may also be group join transactions or Business transactions). After this consensus generates a block, each node needs to execute each transaction in the block and write the block to the local consortium chain. It should be noted here that nodes usually execute transactions based on locally deployed smart contracts or firmware.

Since the first node is the subject of creating the node group this time, only the first node can create a private chain locally, and other nodes cannot create a private chain locally. This means that the first node performs the group creation transaction in a different way than other nodes.

When the first node executes the group creation transaction, it creates a private chain locally, extracts the group creation sub-transactions embedded in the group creation transaction, and writes it to the local private chain, and uses the group public key to pair the first The node ID is encrypted.

Every other node except the first node will not create a private chain when executing a group creation transaction. In fact, the group creation transaction is executed without creating a private chain, and the group public key pair is used. The first node ID is encrypted. Other nodes can perform the group creation transaction "symbolicly" (in addition, as long as the group public key is used to encrypt the first node identification), in order to realize the group creation transaction between the first node and other nodes Different execution methods can be implemented as follows: Two group creation transaction execution logics can be deployed on each node, corresponding to two different logic trigger conditions. The group creation transaction execution logic 1 is to create a private chain locally, write the group creation sub-transaction into the local private chain, and use the group public key to encrypt the first node ID, and the corresponding trigger condition is that the execution node is The node that accepts and broadcasts the group creation transaction; the group creation transaction execution logic 2 does not actually execute any execution logic of the group creation transaction, as long as the group public key is used to encrypt the first node ID, and its corresponding trigger condition The execution node is not the node that accepts and broadcasts group creation transactions. It is worth emphasizing here that this manual does not specifically limit the group creation transaction execution logic 2, as long as it satisfies the “symbolic” execution of the group creation transaction without creating a private chain.

It is understandable that the execution result of the group creation transaction will of course be written into the alliance chain, and the execution result of each node written into the alliance chain is of course the same. In terms of specific implementation, the group creation transaction execution logic 1 and the group creation transaction execution logic 2 can be set to generate a certain execution result logic, and the execution result corresponding to the group creation transaction can be set to include the group public key and encryption After the first node identification, in order to deposit the public key corresponding to the node group created by the exchange of the certificate group creation exchange and the encrypted identity of the node that created the node group.

It is understandable that the so-called writing the execution result into the consortium chain (or private chain) in this article does not necessarily mean storing the execution result in the consortium chain (or private chain) in plaintext, but it may also mean storing the execution result in the local plaintext, and The hash value of the plaintext of the execution result is anchored to the consortium chain (private chain).

The above description of the transaction created by the "symbolic" execution group is also applicable to the situation of "symbolic" execution of other transactions. When referring to the "symbolic" execution in the following text, the specific principles will not be repeated. It is worth emphasizing that when performing anonymous registration transactions and business transactions symbolically, the node ID does not need to be encrypted.

In addition, in practical applications, more than one node group may be created in the consortium chain network. In this case, the group public key of the node group can be used as a unique identifier to distinguish different node groups, or a separate group can be set for the node group Logo.

Specifically, the group creation sub-transaction may also include a group identifier, and accordingly, the execution result corresponding to the group creation transaction may also include the group identifier.

In the embodiment of this specification, the group creation sub-transaction may also include a signature generated using the group private key. In this way, the first node can verify this signature before broadcasting the group creation transaction to the entire network. If the verification passes , It means that the group creation transaction is authorized and initiated by the holder of the group private key, and the node group can be created based on the group creation transaction.

In the embodiment of this specification, it can be understood that the first node writes the group creation sub-transaction into the locally created private chain. Actually, the first node will package the private chain creation block (wherein usually It also includes several groups of sub-transactions or business transactions accepted after the creation of the private chain and written into the locally created private chain.

It can be seen that for the group creation transaction and its embedded group creation sub-transaction, the group creation transaction is packaged into a certain alliance chain block and written into the alliance chain, and the group creation sub-transaction is packaged into the local private chain of the first node. Genesis block. In order to clarify the association relationship between this alliance chain block and this private chain block, and to facilitate access to records, the first node can write in the private chain block (specifically in the block header) that encapsulates the group creation sub-transaction The input pointer object is used to point to the consortium chain block encapsulating the group creation transaction.

Fig. 4 is a schematic diagram of a first node locally maintaining an alliance chain and a private chain provided by an embodiment of this specification. As shown in Figure 4, the private chain creation block (packaged with group creation sub-transactions) of the first node’s local private chain points to a certain consortium chain block in the locally maintained consortium chain through the pointer object. The consortium chain area A group creation transaction is packaged in the block.

The node group in this solution can include only one node, and this node can write the business data of its own docking into the local private chain in plain text. To this end, firstly, how to perform anonymous registration of users and how to conduct transactions when there is only one node in the node group is described.

In practical applications, the user connecting with the first node may not entrust the first node to initiate business transactions as an agent, but the user himself registers an account in the alliance chain network and initiates business transactions through his own alliance chain network. In this case, users have a need for anonymity and do not want to disclose their identity in the consortium chain network. To this end, FIG. 5 is a schematic flowchart of a node group-based anonymous registration method provided by an embodiment of this specification, including the following steps: S500: the first node receives the anonymous registration transaction constructed by the corresponding user account.

The anonymous registration transaction includes an anonymous registration sub-transaction, the anonymous registration sub-transaction includes an anonymous public key and a signature generated using the group private key corresponding to the group public key; wherein, the user account is the first node docking The account of the user registered in the consortium chain network, and the anonymous public key is specified by the user who is docked with the first node.

It is understandable that at the level of the alliance chain network, since anonymous registration transactions are initiated by user accounts, anonymous registration transactions actually contain the identity information of the user account.

S502: The first node uses the group public key to verify the signature corresponding to the group private key in the anonymous registration sub-transaction, and if the verification is passed, the anonymous registration transaction is processed.

The processing includes: reconstructing an anonymous registration transaction including the anonymous registration sub-transaction through the first management party account. The effect of this processing is that the first node reconstructs the anonymous registration transaction with its own identity, so that the identity information of the user account can be stripped off.

S504: The first node broadcasts the reconstructed anonymous registration transaction to the alliance chain network.

Since the identity information of the user account has been stripped from the anonymous registration transaction, the first node broadcasts the anonymous registration transaction to the entire network, and the identity information of the user account will not be leaked.

S506: The first node executes the anonymous registration transaction.

Specifically, the first node writes the anonymous registration sub-transaction into the local private chain. In this way, it is equivalent to anonymously registering users at the private chain network level. At the level of the private chain network, the user can use the signature generated by the anonymous private key to initiate business sub-transactions.

S508: Every other node except the first node executes the reconstructed anonymous registration transaction without creating a private chain.

Every other node except the first node symbolically executes the reconstructed anonymous registration transaction without creating a private chain.

S510: Each node in the consortium chain network writes the reconstructed anonymous registration transaction into the local consortium chain.

In addition, the anonymous registration sub-transaction may also include a signature generated using the anonymous private key corresponding to the anonymous public key to prove that the initiator of the anonymous registration sub-transaction holds the anonymous private key.

Correspondingly, the first node can use the anonymous public key to verify the signature corresponding to the anonymous private key in the anonymous registration subtransaction, and if the first node verifies the signature corresponding to the anonymous private key If the signature verification is passed, the anonymous registration sub-transaction is processed.

In addition, although the user is registered anonymously, in order to subsequently audit the business transaction initiated by the user with an anonymous identity, the first node can establish and store the correspondence between the anonymous public key and the user account locally, so that only the first node The node can grasp the real identity of the user corresponding to the registered anonymous public key.

In addition, the first node may write a pointer object in the private chain block encapsulating the anonymous registration sub-transaction for pointing to the consortium chain block encapsulating the reconstructed anonymous registration transaction.

FIG. 6 is a schematic flowchart of a transaction method based on an anonymous registration method provided by an embodiment of the present specification, including the following steps: S600: the first node receives a business transaction constructed by a corresponding user account.

The business transaction includes a business sub-transaction, and the business sub-transaction includes business data, a signature generated using the set of private keys, and a signature generated using an anonymous private key corresponding to the anonymous public key.

Business sub-transactions can be either a certificate-based transaction or an execution-type transaction. When the business sub-transaction is a certificated transaction, the business data is the result of the data obtained by the manager after performing the operation according to the business request; when the business sub-transaction is an execution transaction, the business data is the business request itself, and the nodes in the node group need Business sub-transactions are executed at the private chain network level, and the execution results are obtained. Both the business sub-transactions and the execution results will be written into the private chain.

The function of including the signature corresponding to the group private key in the business sub-transaction is to prove that the business sub-transaction has the right to call the nodes in the node group to process the transaction. In addition, when there is more than one node group in the alliance chain network, the business sub-transaction may also include a group identifier, which is used to indicate the node group to be called by the business sub-transaction. The first node uses the group public key corresponding to the group identifier to verify the signature in the service sub-transaction.

The function of including the signature corresponding to the anonymous private key in the business sub-transaction is to prove that the business sub-transaction is authorized and initiated by the user account corresponding to the anonymous public key.

S602: The first node uses the group public key to verify the signature corresponding to the group private key in the service sub-transaction, and uses the anonymous public key corresponding to the user account to verify the signature corresponding to the group private key in the service sub-transaction. The signature of the anonymous private key is verified, and if all verifications are passed, the business transaction is processed.

The processing includes: reconstructing a business transaction including a hash value of the business sub-transaction through the account of the first management party. On the one hand, business data involves data privacy and cannot be shared outside the node group. On the other hand, at the alliance chain network level, business transactions that include business sub-transactions need to be written into the alliance chain. Through the above processing, the first node can obtain To the plaintext of the business sub-transaction, other nodes can only obtain the hash value of the business sub-transaction. At the same time, the user account information that initiates the business transaction will not be leaked to other nodes other than the first node.

The first node may perform the above-mentioned processing on the business transaction after judging that there is a corresponding relationship between the anonymous public key and the user account according to the correspondence between the anonymous public key stored locally and the user account .

S604: The first node broadcasts the processed business transaction to the alliance chain network.

S606: The first node executes the business transaction.

When the first node executes the business transaction, if it finds that the business sub-transaction is a certificated transaction, it will write the business sub-transaction into the local private chain, and if it finds that the business sub-transaction is an execution-type transaction, it will execute the business Sub-transactions and get the corresponding execution sub-results, and write the business sub-transactions and the corresponding execution sub-results into the local private chain.

S608: Other nodes in the alliance chain network execute the business transaction without creating a private chain.

Here, other nodes actually "symbolic" perform the business transaction.

S610: Each node in the consortium chain network writes the business transaction into the local consortium chain.

In addition, the first node may write a pointer object in the private chain block encapsulating the business subtransaction for pointing to the consortium chain block encapsulating the processed business transaction.

The following describes how to join a node group. It should be noted that you can refer to the previous description of the principle of creating a node group to understand the latter, and the parts of the same principle will not be repeated.

Fig. 7 is a schematic flowchart of a method for joining a node group provided by an embodiment of the present specification, including the following steps:

S700: The second node receives the group join transaction constructed by the account of the second management party.

The group joining transaction includes a group joining sub-transaction that includes a signature generated using a group private key corresponding to the group public key; the second manager account is the manager of the second node The account registered in the alliance chain network.

After the first node creates the node group, the manager of the second node may allow the second node to also join the node group to share service data with the first node. The manager of the first node can provide the group private key to the manager of the second node offline.

S702: The second node uses the group public key to verify the signature of the group addition sub-transaction, and if the verification is passed, broadcast the group addition transaction to the consortium chain network.

S704: The second node executes the group joining transaction.

Specifically, the second node creates a private chain locally, uses the group public key to encrypt the second node identification, and obtains data from other nodes that store the same private chain (such as the first node and other nodes that have joined the same node group). ) Synchronize historical data of the private chain, and write the group addition sub-transaction into the local private chain.

S706: Other nodes storing the same private chain execute the group joining transaction.

Specifically, other nodes storing the same private chain use the group public key to encrypt the second node identifier, and write the group addition sub-transaction into the local private chain.

S708: Other nodes in the consortium chain network that do not store the same private chain perform the group joining transaction without creating a private chain.

The other nodes that do not store the same private chain in the consortium chain network refer to other nodes that join the node group, and use the group public key to encrypt the second node identifier.

S710: Each node in the alliance chain network writes the group joining transaction and the corresponding execution result into the local alliance chain.

The execution result corresponding to the group joining transaction may include the encrypted second node identifier.

Further, the group joining transaction further includes a group identification, and the second node uses the group public key corresponding to the group identification to verify the signature of the group joining sub-transaction.

In addition, the second node and other nodes storing the same private chain write a pointer object in the private chain block encapsulating the group joining sub-transaction for pointing to the alliance chain area encapsulating the group joining transaction Piece.

Fig. 8 is a schematic diagram of a second node locally maintaining an alliance chain and a private chain provided by an embodiment of this specification. As shown in Figure 8, the second node requests to join the node group after the first node has maintained the private chain for a period of time. Before that, the private chain maintained by the first node stores two private chain blocks, and the group joins the sub-transaction. It is packaged into the third private chain block, and at the same time, the third private chain block is also related to a certain consortium chain block that is packaged to join the transaction.

The node group in this solution can include more than one node, and each node in the same node group can share its own docking service data. Here is a description of how to trade when the node group includes more than one node. It should be noted that you can refer to the previous description of the principle description of how to trade when only one node is included in the node group to understand the latter, and the parts of the same principle will not be repeated.

FIG. 9 is a schematic flowchart of a method for anonymous registration based on a node group provided by an embodiment of the present specification, including the following steps: S900: the second node receives an anonymous registration transaction constructed by a corresponding user account.

The anonymous registration transaction includes an anonymous registration sub-transaction, the anonymous registration sub-transaction includes an anonymous public key and a signature generated using the set of private keys; wherein, the user account is a user connected to the second node in the alliance chain For the account registered in the network, the anonymous public key is designated by the user corresponding to the second node.

S902: The second node uses the group public key to verify the signature corresponding to the group private key in the anonymous registration sub-transaction, and if the verification is passed, the anonymous registration transaction is processed.

The processing includes: reconstructing an anonymous registration transaction including the anonymous registration sub-transaction through the second management party account.

S904: The second node broadcasts the processed anonymous registration transaction to the alliance chain network.

S906: The second node executes the anonymous registration transaction with other nodes storing the same private chain.

Specifically, the second node and other nodes storing the same private chain write the anonymous registration sub-transaction into the local private chain.

S908: In the consortium chain network, other nodes that do not store the same private chain perform the reconstructed anonymous registration transaction without creating a private chain.

S910: Each node in the consortium chain network writes the anonymous registration transaction into the local consortium chain.

In addition, the anonymous registration sub-transaction may also include a signature generated using the anonymous private key corresponding to the anonymous public key. In this way, the second node may use the anonymous public key to pair the anonymous registration sub-transaction corresponding to The signature of the anonymous private key is verified. Correspondingly, if the second node passes the verification of the signature corresponding to the anonymous private key, the anonymous registration transaction is processed.

The second node may establish and store the correspondence between the anonymous public key and the user account locally.

Fig. 10 is a schematic flowchart of a transaction method based on an anonymous registration method provided by an embodiment of the present specification, including: S1000: a second node receives a business transaction constructed by a corresponding user account.

S1002: The second node uses the group public key to verify the signature corresponding to the group private key in the business sub-transaction, and uses the anonymous public key to verify the signature corresponding to the anonymous private key in the business sub-transaction. The signature of the key is verified, and if the verifications are all passed, the business sub-transaction is sent to other nodes in the same node group, and the business transaction is processed.

Since the node group includes not only the second node, but also at least the first node (there may be more nodes), therefore, the second node needs to send the business sub-transactions in the accepted business transactions to the private chain network level Other nodes in the same node group.

In addition, the second node also needs to reconstruct the business transaction including the hash value of the business sub-transaction through the second manager account. In this way, the user account information that initiates the business transaction will not be leaked to nodes other than the first node.

The second node may perform the above-mentioned processing on the business transaction after judging that there is a corresponding relationship between the anonymous public key and the user account according to the correspondence between the anonymous public key stored locally and the user account .

S1004: The second node broadcasts the processed business transaction to the alliance chain network.

S1006: The second node executes the business transaction with other nodes storing the same private chain.

S1008: Other nodes that do not store the same private chain in the consortium chain network perform the processed business transaction without creating a private chain.

S1010: Each node in the consortium chain network writes the processed business transaction into the local consortium chain.

Specifically, if the business sub-transaction is a certificate-deposit type transaction, the second node and other nodes storing the same private chain write the business sub-transaction into the local private chain. If the business sub-transaction is an execution type transaction, the second node executes the business sub-transaction with other nodes storing the same private chain, and writes the business sub-transaction and the corresponding execution sub-result into the local private chain.

Further, the business sub-transaction further includes a group identification, and the second node may use the group public key corresponding to the group identification to verify the signature in the business sub-transaction.

Further, the second node and other nodes storing the same private chain write a pointer object in the private chain block encapsulating the business sub-transaction for pointing to the alliance chain area encapsulating the processed business transaction Piece.

In addition, for each other node storing the same private chain, if the other node determines to receive the business sub-transaction, it returns a signature to the second node. In this way, if the second node determines that the number of received signatures of other nodes meets the preset distributed fault tolerance condition, then the business transaction is processed.

The condition of distributed fault tolerance is that the number of signatures received reaches the specified number. For example, if the number of nodes in the same node group is not less than 4, the specified number can be 2f+1, where f=(N-1)/3, and N is the number of nodes in the node group.

In addition, the embodiment of the present specification also provides a blockchain system, including a consortium chain network, the consortium chain network includes a plurality of nodes; a first node, which receives a group creation transaction constructed by an account of a first manager; and the group creation The transaction includes a group creation sub-transaction, the group creation sub-transaction includes a group public key; the first manager account is an account registered in the alliance chain network by the manager of the first node; the group public key Is designated by the manager of the first node; broadcasting the group creation transaction to the alliance chain network; executing the group creation transaction includes: creating a private chain locally, and writing the creation sub-transaction to the local Private chain, and use the group public key to encrypt the first node identification; every other node except the first node executes the group creation transaction without creating a private chain, including: using all The group public key encrypts the first node identification; each node in the alliance chain network writes the group creation transaction and the corresponding execution result into the local alliance chain; the execution result corresponding to the group creation transaction includes The encrypted first node identifier.

The first node receives an anonymous registration transaction constructed by a corresponding user account; the anonymous registration transaction includes an anonymous registration sub-transaction, the anonymous registration sub-transaction includes an anonymous public key and uses the group private key corresponding to the group public key The generated signature; wherein the user account is an account registered in the consortium chain network of the user docking with the first node, and the anonymous public key is specified by the user docking with the first node; using the group public The key verifies the signature corresponding to the set of private keys in the anonymous registration sub-transaction, and if the verification is passed, the anonymous registration transaction is processed, including: reconstructing the signature that contains all the private keys through the account of the first management party. The anonymous registration transaction of the anonymous registration sub-transaction; broadcasting the reconstructed anonymous registration transaction to the alliance chain network; executing the anonymous registration transaction includes: writing the anonymous registration sub-transaction into a local private chain; Every other node except a node, without creating a private chain, executes the reconstructed anonymous registration transaction; each node in the consortium chain network writes the anonymous registration transaction into the local consortium chain.

The first node receives a business transaction constructed by a corresponding user account; the business transaction includes a business sub-transaction, the business sub-transaction includes business data, a signature generated using the set of private keys, and the anonymous public key The signature generated by the corresponding anonymous private key; using the group public key to verify the signature corresponding to the group private key in the business subtransaction, and using the anonymous public key corresponding to the user account to verify the business subtransaction The signature corresponding to the anonymous private key in is verified, and if the verifications are all passed, then the business transaction is processed, including: reconstructing a hash value containing the business sub-transaction through the first manager account Broadcasting the reconstructed business transaction to the alliance chain network; executing the business transaction includes: writing the business sub-transaction into the local private chain; nodes other than the first node, in The reconstructed business transaction is executed without creating a private chain; each node in the consortium chain network writes the business transaction into the local consortium chain.

The second node receives the group joining transaction constructed by the account of the second manager; the group joining transaction includes a group joining sub-transaction, and the group joining sub-transaction includes a signature generated using the group private key corresponding to the group public key; The second manager account is an account registered by the manager of the second node in the alliance chain network; the group public key is used to verify the signature of the group joining the sub-transaction, and if the verification passes, then Broadcasting the group joining transaction to the alliance chain network; executing the group joining transaction includes: creating a private chain locally, using the group public key to encrypt the second node identifier, and downloading from other nodes that store the same private chain The node synchronizes the historical data of the private chain, and writes the group addition sub-transaction into the local private chain; other nodes that store the same private chain, execute the group addition transaction, including: using the group public key to pair the second node The identification is encrypted, and the group joining sub-transaction is written into the local private chain; other nodes of the same private chain are not stored in the consortium chain network, and the group joining transaction is executed without creating a private chain , Including: using the group public key to encrypt the second node identifier; each node in the consortium chain network writes the group joining transaction and the corresponding execution result into the local consortium chain; the group joining transaction The corresponding execution result includes the encrypted second node identifier.

The second node receives an anonymous registration transaction constructed by a corresponding user account; the anonymous registration transaction includes an anonymous registration sub-transaction, and the anonymous registration sub-transaction includes an anonymous public key and a signature generated using the set of private keys; wherein , The user account is an account registered in the consortium chain network of the user docking with the second node, and the anonymous public key is specified by the user corresponding to the second node; and the group public key is used to pair the anonymous The signature corresponding to the set of private keys in the registration sub-transaction is verified, and if the verification is passed, the anonymous registration transaction is processed, including: reconstructing the anonymous registration sub-transaction containing the anonymous registration through the account of the second management party The anonymous registration transaction; broadcast the reconstructed anonymous registration transaction to the alliance chain network; the second node and other nodes that store the same private chain, execute the anonymous registration transaction, including: register the anonymous sub-transaction Write to the local private chain; other nodes of the same private chain are not stored in the consortium chain network, and the reconstructed anonymous registration transaction is executed if the private chain is not created; in the consortium chain network Each node writes the anonymous registration transaction into the local consortium chain.

The second node receives a business transaction constructed by a corresponding user account; the business transaction includes a business sub-transaction, the business sub-transaction includes business data, a signature generated using the set of private keys, and the anonymous public key The signature generated by the corresponding anonymous private key; using the group public key to verify the signature corresponding to the group private key in the business sub-transaction, and using the anonymous public key to verify the signature corresponding to the group private key in the business sub-transaction The signature of the anonymous private key is verified, and if the verifications are all passed, the business sub-transaction is sent to other nodes in the same node group, and the business transaction is processed, including: passing the second management party Account reconstruction includes the business transaction of the hash value of the business sub-transaction; broadcasts the reconstructed business transaction to the alliance chain network; the second node executes the business transaction with other nodes storing the same private chain , Including: writing the business sub-transaction into a local private chain; other nodes of the same private chain are not stored in the consortium chain network, and executing the reconstructed business transaction without creating a private chain; so Each node in the consortium chain network writes the reconstructed business transaction into the local consortium chain.

The embodiment of the present specification also provides a computer device, which at least includes a memory, a processor, and a computer program stored in the memory and capable of running on the processor, wherein the processor implements the node in the embodiment of the present specification when the program is executed. Function.

FIG. 11 shows a more specific hardware structure diagram of a computing device provided by an embodiment of this specification. The device may include a processor 1110, a memory 1120, an input/output interface 1130, a communication interface 1140, and a bus 1150. The processor 1110, the memory 1120, the input/output interface 1130, and the communication interface 1040 realize the communication connection between each other in the device through the bus 1050.

The processor 1110 can be implemented by a general CPU (Central Processing Unit, central processing unit), microprocessor, application specific integrated circuit (Application Specific Integrated Circuit, ASIC), one or more integrated circuits, etc., for executing related programs, In order to realize the technical solutions provided in the embodiments of this specification.

The memory 1120 may be implemented in the form of ROM (Read Only Memory), RAM (Random Access Memory, random access memory), static storage device, dynamic storage device, etc. The memory 1120 can store an operating system and other application programs. When the technical solutions provided in the embodiments of the present specification are implemented by software or firmware, the related program codes are stored in the memory 1120 and called and executed by the processor 1110.

The input/output interface 1130 is used to connect an input/output module to realize information input and output. The input/output/module can be configured in the device as a component (not shown in the figure), or can be connected to the device to provide corresponding functions. The input device may include a keyboard, a mouse, a touch screen, a microphone, various sensors, etc., and an output device may include a display, a speaker, a vibrator, an indicator light, and the like.

The communication interface 1140 is used to connect a communication module (not shown in the figure) to realize the communication interaction between the device and other devices. The communication module can realize communication through wired means (such as USB, network cable, etc.), or through wireless means (such as mobile network, WIFI, Bluetooth, etc.).

The bus 1150 includes a path to transmit information between various components of the device (for example, the processor 1110, the memory 1120, the input/output interface 1130, and the communication interface 1140).

It should be noted that although the above device only shows the processor 1110, the memory 1120, the input/output interface 1130, the communication interface 1140, and the bus 1150, in the specific implementation process, the device may also include the necessary equipment for normal operation. Other components. In addition, those skilled in the art can understand that the above-mentioned device may also include only the components necessary to implement the solutions of the embodiments of the present specification, and not necessarily include all the components shown in the figures.

The embodiment of this specification also provides a computer-readable storage medium on which a computer program is stored, and when the program is executed by a processor, the function of the node in the embodiment of this specification is realized.

Computer-readable media includes permanent and non-permanent, removable and non-removable media, and information storage can be realized by any method or technology. Information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, CD-ROM, digital versatile disc (DVD) or other optical storage, Magnetic cassettes, magnetic tape disk storage or other magnetic storage devices or any other non-transmission media can be used to store information that can be accessed by computing devices. According to the definition in this article, computer-readable media does not include transitory media, such as modulated data signals and carrier waves.

From the description of the foregoing implementation manners, it can be known that those skilled in the art can clearly understand that the embodiments of this specification can be implemented by means of software plus a necessary general hardware platform. Based on this understanding, the technical solutions of the embodiments of this specification essentially or the part that contributes to the existing technology can be embodied in the form of a software product, and the computer software product can be stored in a storage medium, such as ROM/RAM, magnetic Disks, optical discs, etc., include a number of instructions to make a computer device (maybe a personal computer, service device, or network device, etc.) execute the methods described in the various embodiments or some parts of the embodiments of this specification.

The systems, methods, modules, or units explained in the foregoing embodiments may be specifically implemented by computer chips or entities, or implemented by products with certain functions. A typical implementation device is a computer. The specific form of the computer can be a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email receiving and sending device, and a game console. , Tablet computers, wearable devices, or a combination of any of these devices.

The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, as for the device embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and for related parts, please refer to the part of the description of the method embodiment. The device embodiments described above are only illustrative, and the modules described as separate components may or may not be physically separated. When implementing the embodiments of this specification, the functions of the modules can be the same or Implemented in multiple software and/or hardware. Some or all of the modules can also be selected according to actual needs to achieve the objectives of the solutions of the embodiments. Those of ordinary skill in the art can understand and implement it without creative work.

The above are only specific implementations of the embodiments of this specification. It should be pointed out that for those of ordinary skill in the art, without departing from the principle of the embodiments of this specification, several improvements and modifications can be made. These Improvements and retouching should also be regarded as the protection scope of the embodiments of this specification.

Claims

A method for creating a node group in a consortium chain network, the consortium chain network including a plurality of nodes, and the method includes:

The first node receives a group creation transaction constructed by a first manager account; the group creation transaction includes a group creation sub-transaction, and the group creation sub-transaction includes a group public key; the first manager account is the first node The account registered by the administrator of the consortium chain network; the group public key is designated by the administrator of the first node;

The first node broadcasts the group creation transaction to the alliance chain network;

The execution of the group creation transaction by the first node includes: creating a private chain locally, writing the creation sub-transaction into the local private chain, and encrypting the first node identifier using the group public key;

The execution of the group creation transaction by every other node except the first node without creating a private chain includes: encrypting the first node identifier by using the group public key;

Each node in the alliance chain network writes the group creation transaction and the corresponding execution result into the local alliance chain; the execution result corresponding to the group creation transaction includes the encrypted first node identifier.
The method according to claim 1, wherein the group creation sub-transaction further includes a group identification;

The execution result corresponding to the group creation transaction also includes the group identifier.
The method according to claim 1, wherein the group creation sub-identifier further comprises a signature generated using the group private key corresponding to the group public key;

The broadcasting of the group creation transaction to the alliance chain network by the first node includes:

The first node uses the group public key to verify the signature in the group creation sub-transaction, and if the verification passes, broadcasts the group creation transaction to the consortium chain network.
The method of claim 1, further comprising:

The first node writes a pointer object in the private chain block encapsulating the group creation sub-transaction for pointing to the consortium chain block encapsulating the group creation transaction.
An anonymous registration method based on the node group created according to any one of claims 1 to 4, comprising:

The first node receives an anonymous registration transaction constructed by a corresponding user account; the anonymous registration transaction includes an anonymous registration sub-transaction, the anonymous registration sub-transaction includes an anonymous public key, and is generated using the group private key corresponding to the group public key The signature of; wherein, the user account is an account registered in the alliance chain network of the user docking with the first node, and the anonymous public key is specified by the user docking with the first node;

The first node uses the group public key to verify the signature corresponding to the group private key in the anonymous registration sub-transaction, and if the verification is passed, then the anonymous registration transaction is processed, including: passing the The account of the first management party reconstructs the anonymous registration transaction including the anonymous registration sub-transaction;

The first node broadcasts the reconstructed anonymous registration transaction to the consortium chain network;

The execution of the anonymous registration transaction by the first node includes: writing the anonymous registration sub-transaction into a local private chain;

Each other node except the first node executes the reconstructed anonymous registration transaction without creating a private chain;

Each node in the consortium chain network writes the anonymous registration transaction into the local consortium chain.
The method according to claim 5, wherein the anonymous registration sub-transaction further comprises a signature generated using an anonymous private key corresponding to the anonymous public key;

The method also includes:

The first node uses the anonymous public key to verify the signature corresponding to the anonymous private key in the anonymous registration sub-transaction;

The processing of the anonymous registration sub-transaction by the first node includes:

If the first node passes the verification of the signature corresponding to the anonymous private key, then the anonymous registration sub-transaction is processed.
The method of claim 5, further comprising:

The first node establishes and stores the correspondence between the anonymous public key and the user account locally.
The method of claim 5, further comprising:

The first node writes a pointer object in the private chain block encapsulating the anonymous registration sub-transaction for pointing to the consortium chain block encapsulating the reconstructed anonymous registration transaction.
A transaction method based on the anonymous registration method of any one of claims 5-8, comprising:

The first node receives a business transaction constructed by a corresponding user account; the business transaction includes a business sub-transaction, the business sub-transaction includes business data, a signature generated using the set of private keys, and a corresponding anonymous public key The signature generated by the anonymous private key;

The first node uses the group public key to verify the signature corresponding to the group private key in the service sub-transaction, and uses the anonymous public key corresponding to the user account to verify the signature corresponding to the group private key in the service sub-transaction Verifying the signature of the anonymous private key, and if the verifications are all passed, processing the business transaction includes: reconstructing a business transaction containing the hash value of the business sub-transaction through the account of the first management party;

The first node broadcasts the reconstructed business transaction to the alliance chain network;

The execution of the business transaction by the first node includes: writing the business sub-transaction into a local private chain;

Other nodes other than the first node execute the reconstructed business transaction without creating a private chain;

Each node in the alliance chain network writes the business transaction into the local alliance chain.
The method according to claim 9, wherein the business sub-transaction further includes a group identification;

The first node using the group public key to verify the signature corresponding to the group private key in the service sub-transaction includes:

The first node uses the group public key corresponding to the group identification to verify the signature corresponding to the group private key in the service sub-transaction.
The method of claim 9, processing the business transaction, comprising:

The first node processes the business transaction after judging that there is a correspondence between the anonymous public key and the user account.
The method according to claim 9, further comprising:

The first node writes a pointer object in the private chain block encapsulating the business sub-transaction for pointing to the consortium chain block encapsulating the reconstructed business transaction.
A method for joining a node group created based on any one of claims 1 to 4, comprising:

The second node receives the group joining transaction constructed by the account of the second managing party; the group joining transaction includes a group joining sub-transaction, and the group joining sub-transaction includes a signature generated using the group private key corresponding to the group public key; The second manager account is an account registered by the manager of the second node in the alliance chain network;

The second node uses the group public key to verify the signature of the group addition subtransaction, and if the verification passes, broadcasts the group addition transaction to the consortium chain network;

The second node executing the group joining transaction includes: creating a private chain locally, using the group public key to encrypt the second node identification, synchronizing private chain historical data from other nodes that store the same private chain, and Write the group addition sub-transaction into the local private chain;

Executing the group joining transaction by other nodes storing the same private chain includes: using the group public key to encrypt the second node identifier, and writing the group joining sub-transaction into the local private chain;

The execution of the group joining transaction by other nodes that do not store the same private chain in the consortium chain network without creating a private chain includes: encrypting a second node identifier by using the group public key;

Each node in the alliance chain network writes the group joining transaction and the corresponding execution result into the local alliance chain; the execution result corresponding to the group joining transaction includes the encrypted second node identifier.
The method according to claim 13, wherein the group joining transaction further includes a group identification;

The second node using the group public key to verify the signature of the group joining transaction includes:

The group public key corresponding to the group identifier is used to verify the signature of the group joining transaction.
The method of claim 13, further comprising:

The second node and other nodes storing the same private chain write a pointer object in the private chain block encapsulating the group joining transaction, for pointing to the consortium chain block encapsulating the group joining transaction.
An anonymous registration method based on the node group according to any one of claims 13-15, comprising:

The second node receives an anonymous registration transaction constructed by a corresponding user account; the anonymous registration transaction includes an anonymous registration sub-transaction, and the anonymous registration sub-transaction includes an anonymous public key and a signature generated using the set of private keys; wherein, The user account is an account registered in the alliance chain network of the user who is docked with the second node, and the anonymous public key is designated by the user corresponding to the second node;

The second node uses the group public key to verify the signature corresponding to the group private key in the anonymous registration sub-transaction, and if the verification is passed, then the anonymous registration transaction is processed, including: passing the The account of the second management party reconstructs the anonymous registration transaction including the anonymous registration sub-transaction;

The second node broadcasts the reconstructed anonymous registration transaction to the alliance chain network;

The second node executing the anonymous registration transaction with other nodes storing the same private chain includes: writing the anonymous registration sub-transaction into a local private chain;

Other nodes that do not store the same private chain in the consortium chain network perform the reconstructed anonymous registration transaction without creating a private chain;

Each node in the consortium chain network writes the anonymous registration transaction into the local consortium chain.
The method of claim 16, wherein the anonymous registration sub-transaction further comprises a signature generated using an anonymous private key corresponding to the anonymous public key;

The method also includes:

The second node uses the anonymous public key to verify the signature corresponding to the anonymous private key in the anonymous registration sub-transaction;

The processing of the anonymous registration transaction by the second node includes:

If the signature verification corresponding to the anonymous private key is passed, the anonymous registration transaction is processed.
The method of claim 16, further comprising:

The second node establishes and stores the correspondence between the anonymous public key and the user account locally.
A transaction method based on the anonymous registration method of any one of claims 16-18, comprising:

The second node receives a business transaction constructed by a corresponding user account; the business transaction includes a business sub-transaction, the business sub-transaction includes business data, a signature generated using the set of private keys, and a corresponding anonymous public key The signature generated by the anonymous private key;

The second node uses the group public key to verify the signature corresponding to the group private key in the service sub-transaction, and uses the anonymous public key to verify the signature corresponding to the anonymous private key in the service sub-transaction. The signature of the key is verified. If the verifications are passed, the business sub-transaction is sent to other nodes in the same node group, and the business transaction is processed, including: reconstructing the business transaction through the second manager account. The business transaction of the hash value of the business sub-transaction;

The second node broadcasts the reconstructed business transaction to the alliance chain network;

The second node executing the business transaction with other nodes storing the same private chain includes: writing the business sub-transaction into a local private chain;

Other nodes that do not store the same private chain in the consortium chain network perform the reconstructed business transaction without creating a private chain;

Each node in the alliance chain network writes the reconstructed business transaction into the local alliance chain.
The method of claim 19, wherein the business sub-transaction further includes a group identification;

The second node using the group public key to verify the signature corresponding to the group private key in the service sub-transaction includes:

The second node uses the group public key corresponding to the group identifier to verify the signature corresponding to the group private key in the service sub-transaction.
The method of claim 19, processing the business transaction, comprising:

The second node processes the business transaction after judging that there is a correspondence between the anonymous public key and the user account.
The method of claim 19, further comprising:

The second node and other nodes storing the same private chain write a pointer object in the private chain block encapsulating the business sub-transaction for pointing to the alliance chain block encapsulating the processed business transaction .
The method of claim 19, further comprising:

For each other node storing the same private chain, if the other node receives the business sub-transaction, return a signature to the second node;

The processing of the business transaction by the second node includes:

If the second node determines that the number of received signatures of other nodes meets a preset distributed fault tolerance condition, then the business transaction is processed.
A blockchain system includes a consortium chain network, and the consortium chain network includes a plurality of nodes;

The first node receives a group creation transaction constructed by a first manager account; the group creation transaction includes a group creation sub-transaction, and the group creation sub-transaction includes a group public key; the first manager account is the first The account registered by the node's manager in the alliance chain network; the group public key is designated by the manager of the first node; broadcast the group creation transaction to the alliance chain network; execute the group creation The transaction includes: creating a private chain locally, writing the creation sub-transaction into the local private chain, and encrypting the first node identifier using the set of public keys;

For every other node except the first node, executing the group creation transaction without creating a private chain includes: encrypting the first node identifier by using the group public key;

Each node in the alliance chain network writes the group creation transaction and the corresponding execution result into the local alliance chain; the execution result corresponding to the group creation transaction includes the encrypted first node identifier.
The system according to claim 24, wherein the first node receives an anonymous registration transaction constructed by a corresponding user account; the anonymous registration transaction includes an anonymous registration sub-transaction, and the anonymous registration sub-transaction includes an anonymous public key and a user account. The signature generated by the group private key corresponding to the group public key; wherein, the user account is an account registered in the consortium chain network of the user docked by the first node, and the anonymous public key is docked by the first node Specified by the user; using the group public key to verify the signature corresponding to the group private key in the anonymous registration sub-transaction, and if the verification is passed, the anonymous registration transaction is processed, including: passing the first An administrator account, reconstructing an anonymous registration transaction including the anonymous registration sub-transaction; broadcasting the reconstructed anonymous registration transaction to the alliance chain network; executing the anonymous registration transaction, including: writing the anonymous registration sub-transaction Enter the local private chain;

Every other node except the first node executes the reconstructed anonymous registration transaction without creating a private chain;

Each node in the consortium chain network writes the anonymous registration transaction into the local consortium chain.
The system according to claim 25, wherein the first node receives a business transaction constructed by a corresponding user account; the business transaction includes a business sub-transaction, the business sub-transaction includes business data, and is generated using the set of private keys The signature of the anonymous public key, the signature generated using the anonymous private key corresponding to the anonymous public key; the use of the group public key to verify the signature corresponding to the group private key in the business sub-transaction, and the use of the signature corresponding to the user account The anonymous public key verifies the signature corresponding to the anonymous private key in the business sub-transaction, and if the verifications are all passed, the business transaction is processed, including: reconstructing the signature through the first manager account The business transaction of the hash value of the business sub-transaction; broadcasting the reconstructed business transaction to the alliance chain network; executing the business transaction includes: writing the business sub-transaction into a local private chain;

Nodes other than the first node execute the reconstructed business transaction without creating a private chain;

Each node in the alliance chain network writes the business transaction into the local alliance chain.
The system according to claim 24, wherein the second node receives the group joining transaction constructed by the account of the second manager; the group joining transaction includes a group joining sub-transaction, and the group joining sub-transaction includes using the group public key to correspond to The signature generated by the group private key of the group; the second manager account is the account registered by the manager of the second node in the consortium chain network; the group public key is used to add the group to the sub-transaction The signature is verified, and if the verification is passed, the group joining transaction is broadcast to the alliance chain network; executing the group joining transaction includes: creating a private chain locally, and encrypting the second node identification using the group public key , Synchronizing the historical data of the private chain from other nodes storing the same private chain, and writing the group addition sub-transaction into the local private chain;

For other nodes storing the same private chain, executing the group joining transaction includes: using the group public key to encrypt the second node identifier, and writing the group joining sub-transaction into the local private chain;

If other nodes of the same private chain are not stored in the consortium chain network, executing the group joining transaction without creating a private chain includes: using the group public key to encrypt a second node identifier;

Each node in the alliance chain network writes the group joining transaction and the corresponding execution result into the local alliance chain; the execution result corresponding to the group joining transaction includes the encrypted second node identifier.
The system according to claim 27, wherein the second node receives an anonymous registration transaction constructed by a corresponding user account; the anonymous registration transaction includes an anonymous registration sub-transaction, and the anonymous registration sub-transaction includes an anonymous public key and a user account. The signature generated by the set of private keys; wherein, the user account is an account registered in the alliance chain network of the user docking with the second node, and the anonymous public key is specified by the user corresponding to the second node; use The group public key verifies the signature corresponding to the group private key in the anonymous registration sub-transaction, and if the verification is passed, the anonymous registration transaction is processed, including: through the second management party account, Reconstruct an anonymous registration transaction including the anonymous registration sub-transaction; broadcast the reconstructed anonymous registration transaction to the alliance chain network;

The execution of the anonymous registration transaction by the second node and other nodes storing the same private chain includes: writing the anonymous registration sub-transaction into a local private chain;

If other nodes of the same private chain are not stored in the consortium chain network, if the private chain has not been created, execute the reconstructed anonymous registration transaction;

Each node in the consortium chain network writes the anonymous registration transaction into the local consortium chain.
The system according to claim 28, wherein the second node receives a business transaction constructed by a corresponding user account; the business transaction includes a business sub-transaction, the business sub-transaction includes business data, and the set of private keys is used to generate The signature of the anonymous public key, the signature generated using the anonymous private key corresponding to the anonymous public key; the use of the group public key to verify the signature corresponding to the group of private keys in the business sub-transaction, and the use of the anonymous public key pair The signature corresponding to the anonymous private key in the business sub-transaction is verified, and if the verifications are all passed, the business sub-transaction is sent to other nodes in the same node group, and the business transaction is processed, It includes: reconstructing a business transaction including the hash value of the business sub-transaction through the account of the second management party; broadcasting the reconstructed business transaction to the alliance chain network;

The execution of the business transaction by the second node and other nodes storing the same private chain includes: writing the business sub-transaction into a local private chain;

If other nodes of the same private chain are not stored in the consortium chain network, the reconstructed business transaction is executed without creating a private chain;

Each node in the alliance chain network writes the reconstructed business transaction into the local alliance chain.
A computer device comprising a memory, a processor, and a computer program stored on the memory and running on the processor, wherein the processor implements the function of the node in claims 1-23 when the program is executed.