WO2020220860A1

WO2020220860A1 - Blockchain system-based transaction processing method and apparatus

Info

Publication number: WO2020220860A1
Application number: PCT/CN2020/080520
Authority: WO
Inventors: 张开翔; 范瑞彬
Original assignee: 深圳前海微众银行股份有限公司
Priority date: 2019-04-28
Filing date: 2020-03-20
Publication date: 2020-11-05
Also published as: CN110070445A; CN110070445B

Abstract

A blockchain system-based transaction processing method and apparatus, wherein the method comprises: a first node in a blockchain system receiving a transaction request sent by a client device, and determining a conflict result of a first transaction comprised in the transaction request according to the identification of the first transaction, and then processing the first transaction according to the conflict result of the first transaction and a conflict processing instruction comprised in the transaction request. By means of performing conflict detection on the first transaction on the basis of the identification of the transaction, complete transaction data may not need to be compared, and thus the efficiency of transaction processing in the blockchain system may be improved. Moreover, the identification of the transaction and the conflict processing instruction may be set by the client device. Therefore, different conflict processing instructions may be set on the basis of different service scenarios and the requirements of the client device, that is, the described transaction processing method is more in line with actual circumstances.

Description

A transaction processing method and device based on block chain system

Cross references to related applications

This application claims the priority of a Chinese patent application filed with the Chinese Patent Office on April 28, 2019, the application number is 201910350093.3, and the application name is "a method and device for transaction processing based on a blockchain system". The reference is incorporated in this application.

Technical field

The present invention relates to the blockchain (blockchain) field in the technical field of financial technology (Fintech), and in particular to a transaction processing method and device based on a blockchain system.

Background technique

With the development of computer technology, more and more technologies are applied in the financial field. The traditional financial industry is gradually shifting to Fintech. Blockchain technology is no exception, but due to the security and real-time requirements of the financial industry , Also put forward higher requirements for technology. Generally, multiple nodes can be set in the blockchain system, and multiple nodes can communicate with each other. Generally speaking, the client device can send a transaction request to a certain node in the blockchain system, and the node receives the transaction request Later, transactions can be processed, and block information corresponding to the transaction can be generated through consensus with other nodes. In actual operation, due to the diversity of business types, the blockchain system will process a lot of transactions in a period of time. Therefore, how to deal with each transaction reasonably is very important for the development of the blockchain system.

In the prior art, after receiving the transaction request sent by the client, the node can usually parse the transaction request to obtain transaction data, such as the initiator of the transaction, the receiver of the transaction, and the type of business to which the transaction belongs; further, The node can compare the transaction data with the transaction data of the historical transaction processed by the blockchain system. If it is determined that the transaction conflicts with the historical transaction, the transaction can be processed according to the conflict processing instruction preset in the blockchain system. However, with this method, the amount of data included in the transaction data is large, and it may take a long time to complete the process of comparing the transaction data with the transaction data of the historical transaction. Under normal circumstances, the transaction in the blockchain system can be Frequent triggers, so the above methods may not be able to process multiple transactions in time, resulting in poor transaction processing efficiency in the blockchain system.

In summary, there is an urgent need for a transaction processing method based on a blockchain system to improve the efficiency of transaction processing in the blockchain system.

Summary of the invention

The embodiment of the present invention provides a transaction processing method and device based on a blockchain system to improve the efficiency of transaction processing in the blockchain system.

In the first aspect, an embodiment of the present invention provides a transaction processing method based on a blockchain system, and the method includes:

The first node in the blockchain system receives a transaction request sent by the client device, the transaction request includes the identification of the first transaction and a conflict processing instruction, and the conflict processing instruction includes when there is a conflict between the first transaction and a historical transaction The processing method for the first transaction, and/or the processing method for the first transaction when there is no conflict between the first transaction and the historical transaction; further, the first node according to the first transaction To determine the conflict result of the first transaction, and process the first transaction according to the conflict result of the first transaction and the conflict processing instruction, and the conflict result of the first transaction is used to indicate Whether there is a conflict between the first transaction and the historical transaction.

In the above technical solution, by setting the transaction identifier, the conflict detection of the first transaction can be performed by comparing the transaction identifier without comparing transaction data, so that the process of conflict detection for the transaction can be faster and the block The efficiency of transaction processing in the chain system; and, because the conflict processing instructions are set by the client device, different conflict processing instructions can be set based on different business scenarios and the requirements of the client device, that is, the above technical solutions The transaction processing method is more in line with the actual situation.

Optionally, the first node determining the conflict result of the first transaction according to the identifier of the first transaction includes: the first node first determines the first transaction according to the identifier of the first transaction Further, the first node obtains the identifier of the target historical transaction from the first preset database, and stores the identifier of the target historical transaction in a preset memory space; wherein, the first preset The database includes identifiers of the multiple historical transactions and key values of the multiple historical transactions, and the target historical transaction is a historical transaction whose key value matches the key value of the first transaction in the first preset database If the first node determines that there is a target historical transaction matching the identifier of the first transaction in the preset memory space, then it determines that the first transaction conflicts with the historical transaction.

In the above technical solution, since the response speed of the first preset database is generally slow, the above technical solution compares the identification of the first transaction with the identification of the target historical transaction stored in the first memory space in advance, instead of directly comparing Comparing the identifier of the first transaction with the identifier of the historical transaction stored in the first preset database can improve the response speed of the conflict detection process. On the one hand, filtering the target historical transaction in the first preset database based on the key value can reduce the memory occupied by the screening process and improve the screening efficiency; on the other hand, if there is an identifier with the first transaction in the preset memory space For matching target historical transactions, the conflict between the first transaction and the historical transaction can be directly determined, so that subsequent conflict detection processes can be avoided and the efficiency of conflict detection can be improved.

Optionally, the method further includes: if the first node determines that there is no target historical transaction that matches the identifier of the first transaction in the preset memory space, then inputting the identifier of the first transaction into the first preset Assume a filter model, the first preset filter model is obtained by training using transaction information of the multiple historical transactions, and the transaction information of each historical transaction includes the identifier, key value, transaction data, Conflict processing instructions and conflict times; further, if the output result of the first preset filtering model is that the first transaction does not conflict with the historical transaction, the first node determines that the first transaction does not exist with the historical transaction conflict.

In the above technical solution, after the first conflict detection is performed on the first transaction based on the target historical transaction in the memory, the first preset filtering model can be used to perform the second conflict detection on the first transaction, thereby improving the conflict detection performance. Accuracy; and the second conflict detection process can also be executed in a preset memory space, so that conflict detection can be avoided directly through historical transactions in the first preset database, thereby improving detection efficiency. That is to say, in the above technical solution, through two detection processes based on the preset memory space, a relatively large portion of conflicting transactions can be detected, which improves detection efficiency while improving detection accuracy.

Optionally, the method further includes: if the output result of the first preset filtering model is that the first transaction conflicts with the historical transaction, the first node compares the identifier of the first transaction with the The identification of one or more historical transactions in the first preset database is compared, and if it is determined that there is a historical transaction in the first preset database that matches the identification of the first transaction, then the first transaction is determined There is a conflict with a historical transaction; if it is determined that there is no historical transaction matching the identifier of the first transaction in the first preset database, it is determined that the first transaction does not conflict with the historical transaction.

In the above technical solution, if the conflict result of the first transaction is not detected based on the two conflict detection processes in the preset memory space, the conflict detection of the first transaction may be performed based on the historical transactions in the first preset database, thereby The conflict result of the first transaction can be obtained, and the detected conflict result of the first transaction is more accurate.

Optionally, the conflict processing instruction includes any one or more of the following: refusing to execute the first transaction when there is a conflict between the first transaction and a historical transaction, and executing when there is a conflict between the first transaction and a historical transaction Redirecting the first transaction to a fault-tolerant contract when there is a conflict between the first transaction, the first transaction and the historical transaction, and executing the first transaction when there is no conflict between the first transaction and the historical transaction; The first node processes the first transaction according to the conflict result of the first transaction and the conflict processing instruction, including: if there is no conflict between the first transaction and the historical transaction, and the conflict processing instruction is The first transaction is executed when there is no conflict between the first transaction and the historical transaction, or if there is a conflict between the first transaction and the historical transaction, and the conflict processing instruction is that the first transaction conflicts with the historical transaction When the first transaction is executed, the first node executes the first transaction; if the first transaction conflicts with historical transactions, and the conflict processing instruction is that the first transaction conflicts with historical transactions When redirecting the first transaction to the fault-tolerant contract, the first node obtains the address of the fault-tolerant contract included in the conflict processing instruction, and sends the address of the fault-tolerant contract to the client device; If there is a conflict between the first transaction and the historical transaction, and the conflict processing instruction is to refuse to execute the first transaction when there is a conflict between the first transaction and the historical transaction, the first node sends the conflict to the client device An indicator value, where the conflict indicator value is used to indicate that there is a conflict between the first transaction and the historical transaction.

In the above technical solution, the conflict processing instruction is set by the client device. Therefore, the conflict processing instruction that meets the actual situation can be set based on the requirements of the client device or the business scenario. Accordingly, the first transaction is processed based on the conflict processing instruction to enable The processing result of the first transaction meets the needs of the client device and can be more in line with actual conditions.

Optionally, the execution of the first transaction by the first node includes: if the first node determines that the number of nodes in the blockchain system that have reached a consensus on the first transaction is greater than or equal to a preset threshold , The block information corresponding to the first transaction is generated; the first node updates the first preset database and/or the preset memory space according to the transaction information of the first transaction.

In the above technical solution, by using the block information of the first transaction to update the first preset database and preset memory space, the updated first preset database and preset memory space can be used to perform conflict detection on the next transaction, thereby Make the transaction processing process meet real-time requirements and improve the accuracy of transaction processing.

Optionally, after the first node generates the block information corresponding to the first transaction, the method further includes: the first node sends the block information corresponding to the first transaction to the client device, and the The block information is used by the client device to correct the first transaction.

In the above technical solution, because the conflict processing instructions are set for the client device, there may be some conflicting transactions still being processed. By using the client device to correct the transaction after the transaction is processed, the transaction processing process can be avoided Major mistakes have occurred, improving the business processing capabilities and accuracy of the blockchain system.

Optionally, the first preset database further stores a first check value corresponding to the plurality of historical transaction data, and the first check value is the first node using a preset check algorithm to The multiple historical transaction data are verified; the first node generating block information corresponding to the first transaction includes: the first node generating initial block information corresponding to the first transaction, The bin point uses the preset check algorithm to check the first check value and the transaction information corresponding to the first transaction to obtain a second check value; further, the first node checks the The second check value is added to the initial block information to obtain the block information corresponding to the first transaction.

In the above technical solution, the first check value can be used to identify historical transactions processed by the blockchain system. After the first transaction is processed, the first check value is updated with the first transaction to obtain the second check value. On the one hand, multiple nodes in the blockchain system can achieve consensus based on the same second check value, thereby improving the accuracy of transaction processing in the blockchain system; on the other hand, it can enable the blockchain system to process During the transaction, the historical transactions processed by the blockchain system are updated in real time, thereby improving the accuracy of subsequent transactions.

Optionally, the first node updating the first preset database and/or the preset memory space according to the transaction information of the first transaction includes: the first node uses the first transaction Identifies updating the first preset filtering model to obtain a second preset filtering model, and updating the preset memory space and/or the first preset filtering model in the first preset database to the first 2. A preset filtering model; further, the first node adds the transaction information corresponding to the first transaction and the second check value to the first preset database, and uses the second calibration The verification value updates the first verification value in the preset memory space.

In the above technical solution, by using the block information of the first transaction to sequentially update the first preset filter model in the first preset database and the preset memory space, the historical transaction information, and the check value of the historical transaction, the pre-based It is assumed that the two conflict detection methods in the memory space and the sequential conflict detection method based on the first preset database perform conflict detection for the next transaction, so that the conflict detection for each transaction can be performed using the above method, and the efficiency of transaction processing is improved.

In the second aspect, an embodiment of the present invention provides a transaction processing method based on a blockchain system, the method including:

The client device sends a transaction request to the first node in the blockchain system, where the transaction request includes the identification of the first transaction and a conflict processing instruction; further, the client device receives the fault-tolerant contract sent by the first node According to the address of the fault-tolerant contract, call the fault-tolerant processing module to correct the first transaction.

Optionally, the method further includes: the client device receives block information corresponding to the first transaction sent by the first node; further, the client device obtains the block information and stores If it is determined that there is a historical transaction whose identifier matches the identifier of the first transaction in the second preset database of the client device, the fault-tolerant processing module is used according to the preset processing rule The first transaction is amended; the second preset database stores multiple historical transactions processed by the client device.

Optionally, the preset processing rules include any one or more of output log records, output transaction records of the second preset database, invalid transactions, cancel transactions, and freeze subsequent transactions.

In a third aspect, an embodiment of the present invention provides a transaction processing device based on a blockchain system, the device including:

The receiving module is configured to receive a transaction request sent by a client device, the transaction request including the identification of the first transaction and a conflict processing instruction; the conflict processing instruction includes the first transaction when there is a conflict between the first transaction and the historical transaction. A transaction processing method, and/or the processing method of the first transaction when there is no conflict between the first transaction and the historical transaction;

A conflict detection module, configured to determine a conflict result of the first transaction according to the identifier of the first transaction, and the conflict result of the first transaction is used to indicate whether there is a conflict between the first transaction and a historical transaction;

The processing module is configured to process the first transaction according to the conflict result of the first transaction and the conflict processing instruction.

Optionally, the conflict detection module is configured to: determine the key value of the first transaction according to the identifier of the first transaction; further, obtain the identifier of the target historical transaction from the first preset database, and compare all The identifier of the target historical transaction is stored in the preset memory space; the first preset database includes the identifier of the plurality of historical transactions and the key value of the plurality of historical transactions, and the target historical transaction is the A historical transaction whose key value matches the key value of the first transaction in the first preset database; if it is determined that there is a target historical transaction matching the identifier of the first transaction in the preset memory space, then the first transaction is determined There is a conflict between transactions and historical transactions.

Optionally, the conflict detection module is further configured to: if it is determined that there is no target historical transaction matching the identifier of the first transaction in the preset memory space, input the identifier of the first transaction into the first preset filter Model, the first preset filtering model is obtained by training using transaction information of the multiple historical transactions, and the transaction information of each historical transaction includes the identification, key value, transaction data, and conflict handling of each historical transaction Instruction, the number of conflicts; further, if the output result of the first preset filtering model is that the first transaction does not conflict with the historical transaction, it is determined that the first transaction does not conflict with the historical transaction.

Optionally, the conflict detection module is further configured to: if the output result of the first preset filtering model is that the first transaction conflicts with the historical transaction, compare the identifier of the first transaction with the first transaction. One or more historical transaction identifiers in a preset database are compared. If it is determined that there is a historical transaction matching the identifier of the first transaction in the first preset database, then the first transaction is determined to be the same as the historical transaction. There is a conflict in the transaction; if it is determined that there is no historical transaction matching the identifier of the first transaction in the first preset database, then it is determined that there is no conflict between the first transaction and the historical transaction.

Optionally, the conflict processing instruction includes any one or more of the following: refusing to execute the first transaction when there is a conflict between the first transaction and a historical transaction, and executing when there is a conflict between the first transaction and a historical transaction Redirecting the first transaction to a fault-tolerant contract when there is a conflict between the first transaction, the first transaction and the historical transaction, and executing the first transaction when there is no conflict between the first transaction and the historical transaction; The processing module is configured to: if the first transaction does not conflict with the historical transaction, and the conflict processing instruction is to execute the first transaction when the first transaction does not conflict with the historical transaction, or if the first transaction does not conflict with the historical transaction, There is a conflict between a transaction and a historical transaction, and the conflict processing instruction is to execute the first transaction when there is a conflict between the first transaction and the historical transaction, then the first transaction is executed; if the first transaction is in conflict with the historical transaction If there is a conflict, and the conflict processing instruction is to redirect the first transaction to a fault-tolerant contract when there is a conflict between the first transaction and the historical transaction, then obtain the address of the fault-tolerant contract included in the conflict processing instruction, and send it to The client device sends the address of the fault-tolerant contract; if the first transaction conflicts with the historical transaction, and the conflict processing instruction is that the first transaction conflicts with the historical transaction, refuse to execute the first transaction , Sending a conflict indication value to the client device, where the conflict indication value is used to indicate that the first transaction conflicts with the historical transaction.

Optionally, the processing module is configured to generate a block corresponding to the first transaction if it is determined that the number of nodes in the blockchain system that have reached a consensus on the first transaction is greater than or equal to a preset threshold Information; further, update the first preset database and/or the preset memory space according to the transaction information of the first transaction.

Optionally, after the processing module generates the block information corresponding to the first transaction, it is further configured to: send the block information corresponding to the first transaction to the client device, where the block information is used for The client device modifies the first transaction.

Optionally, the first preset database further stores a first check value corresponding to the plurality of historical transaction data, and the first check value is the first node using a preset check algorithm to The multiple historical transaction data are verified; the processing module is specifically configured to: generate initial block information corresponding to the first transaction; further, use the preset verification algorithm to verify the first The check value is checked against the transaction information corresponding to the first transaction to obtain a second check value, and the second check value is added to the initial block information to obtain the first transaction corresponding The block information.

Optionally, the processing module is configured to: use the identifier of the first transaction to update the first preset filter model to obtain a second preset filter model, and configure the preset memory space and/or the first The first preset filtering model in the preset database is updated to the second preset filtering model; further, the transaction information corresponding to the first transaction and the second check value are added to the first In a preset database, the second check value is used to update the first check value in the preset memory space.

In a fourth aspect, an embodiment of the present invention provides a transaction processing device based on a blockchain system, the device including:

A transceiver module, configured to send a transaction request to the first node in the blockchain system, the transaction request including the identification of the first transaction and a conflict processing instruction; and to receive the address of the fault-tolerant contract sent by the first node;

The processing module is configured to call the fault-tolerant processing module to correct the first transaction according to the address of the fault-tolerant contract.

Optionally, the receiving module is further configured to: receive block information corresponding to the first transaction sent by the first node; the processing module is further configured to: obtain the block information stored in the block information The identification of the first transaction, if it is determined that there is a historical transaction with an identification matching the identification of the first transaction in the second preset database of the client device, the fault-tolerant processing module is used to perform processing on the first The transaction is modified; the second preset database stores a plurality of historical transactions processed by the client device.

In a fifth aspect, embodiments of the present invention also provide a computer-readable storage medium, including instructions, which when run on a processor of a computer, cause the processor of the computer to execute any of the above-mentioned first and/or second aspects. The method described in one item.

In a sixth aspect, embodiments of the present invention also provide a computer program product, which when it runs on a processor of a computer, causes the processor of the computer to execute the method described in any one of the first aspect and/or the second aspect. .

These and other aspects of the application will be more concise and understandable in the description of the following embodiments.

Description of the drawings

In order to more clearly describe the technical solutions in the embodiments of the present invention, the following will briefly introduce the drawings needed in the description of the embodiments. Obviously, the drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, other drawings may be obtained from these drawings without creative labor.

FIG. 1 is a schematic diagram of a system architecture of a blockchain system provided by an embodiment of the present invention;

2 is a schematic diagram of a corresponding process flow of a transaction processing method based on a blockchain system provided by an embodiment of the present invention;

FIG. 3 is a schematic structural diagram of a client device and a first node provided in an embodiment of the present invention;

4 is a schematic structural diagram of a transaction processing device based on a blockchain system provided in an embodiment of the present invention;

Figure 5 is a schematic structural diagram of a transaction processing device based on a blockchain system provided in an embodiment of the present invention;

Figure 6 is a schematic structural diagram of a terminal device provided in an embodiment of the present invention;

FIG. 7 is a schematic structural diagram of a back-end device provided in an embodiment of the present invention.

Detailed ways

In order to make the objectives, technical solutions and advantages of the present invention clearer, the present invention will be further described in detail with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative work shall fall within the protection scope of the present invention.

In the field of financial technology (Fintech), a large number of transactions are usually involved. By using blockchain technology to process transactions, transactions between different nodes can be executed smoothly. Therefore, improving the efficiency of guaranteeing transaction processing in the blockchain system is particularly important for the development of the financial industry.

Figure 1 is a schematic diagram of a system architecture to which the transaction processing method in an embodiment of the present invention is applicable. As shown in Figure 1, the system architecture may include one or more nodes in the blockchain system (such as the one shown in Figure 1). Node 101, node 102, node 103, and node 104) and the client device 200. Among them, one or more nodes in the blockchain system can jointly maintain the blockchain system. The client device 200 can communicate with one or more nodes in the blockchain system by accessing the network.

In the embodiment of the present invention, the blockchain system may be a peer-to-peer (Peer To Peer, P2P) network composed of multiple nodes. P2P is an application layer protocol running on the Transmission Control Protocol (TCP) protocol. The nodes in the blockchain system can be equal to each other. There is no central node in the blockchain system, so each Nodes can connect to other nodes randomly.

Taking the transaction process between the client device 200 and the node 102 as an example, in specific implementation, the client device 200 can send a transaction request to the node 102. After receiving the transaction request, the node 102 can obtain the transaction data by parsing the transaction request. And can send transaction data to other nodes in the blockchain system (ie, node 101, node 103, and node 104). Further, nodes 101 to 104 can make a consensus based on the transaction data. If the consensus is passed, the block information corresponding to the transaction can be generated; if the consensus is not passed, the node 102 (or other nodes) can report to the client device 200 sends a transaction response message, the transaction response message is used to indicate that the transaction failed.

In the embodiment of the present invention, the nodes in the blockchain system may have multiple functions, such as routing function, transaction function, blockchain function, consensus function, etc. Specifically, the nodes in the blockchain system can transmit transaction data and other information sent by other nodes to more nodes to achieve communication between nodes; or, the nodes in the blockchain system can be used to support users Perform transactions; or, nodes in the blockchain system can be used to record all transactions in history; or, nodes in the blockchain system can generate new blocks in the blockchain by verifying and recording transactions. In practical applications, the routing function is a function that each node in the blockchain system must have, and other functions can be set by those skilled in the art according to actual needs.

It should be noted that a node in the blockchain system can be on a physical machine (server), and a node can specifically refer to a process or a series of processes running in the server. For example, the node 101 in the blockchain network may be a process running on a server, or it may also refer to the server where the node is located, which is not specifically limited.

Based on the system architecture shown in Fig. 1, Fig. 2 is a schematic diagram of a process corresponding to a transaction processing method based on a blockchain system provided by an embodiment of the present invention, and the method includes:

Step 201: The client device sets the identifier of the first transaction and the conflict processing instruction.

In the embodiment of the present invention, if the client device determines that the first transaction needs to be executed, it can set the identifier of the first transaction. In a possible implementation, the client device may set the identifier of the first transaction according to the business scenario to which the first transaction belongs, and the business scenario to which the first transaction belongs may include the business to which the first transaction belongs and the first transaction in the business. The process (ie business process). For example, in an example, the execution process of the order business may include creating an order process, storing an order process, querying an order process, etc. If the business process to which the first transaction belongs is an order creation process, the first transaction creation can be used to obtain The order number is used as the identification of the first transaction. The length of the order number can be set by those skilled in the art based on experience. For example, it can be variable-length data less than or equal to 256 bytes, or it can also be fixed-length data, which is not specifically limited. In another example, the execution process of the interactive data service may include a data transfer process between two parties, a data transfer process to other users, etc., if the business process to which the first transaction belongs is a data transfer process between the two parties, the identification of the first transaction may include The identification of the data sender, the identification of the data receiver and the check value of the data. For example, if the first transaction is a transaction in which user A ₁ transfers data to user A ₂ , the identification of the first transaction may include the address of user A ₁ , the address of user A ₂ , and the hash value of the data. Wherein, the address of the user A ₁ and/or the user A ₂ may be an account name, or may also be an email address, or may also be a user name, which is not specifically limited.

Further, the client device may also set a conflict processing instruction corresponding to the first transaction. The conflict processing instruction may include the processing method of the first transaction when the first transaction conflicts with the historical transaction, and/or the first transaction and the historical transaction How to handle the first transaction when there is no conflict. In an example, the handling of the first transaction when there is a conflict between the first transaction and the historical transaction may include executing the first transaction, redirecting the first transaction to a fault-tolerant contract, and refusing to execute any of the first transaction; When there is no conflict between a transaction and a historical transaction, the processing method for the first transaction may include executing the first transaction.

In a possible implementation manner, the conflict processing instruction sent by the client device may include a processing instruction value and additional data. Table 1 is a schematic table of several possible conflict handling instructions provided by the embodiment of the present invention.

Table 1: Schematic of several conflict handling instructions

冲突处理指令Conflict handling instructions	含义meaning
11	拒绝执行Refuse to execute
22	执行carried out
3：http://address/0x2893: http://address/0x289	重定向到容错合约Redirect to fault-tolerant contract
44	拒绝执行且发出告警Refuse to execute and issue an alert
55	执行且打印日志Execute and print log
00	执行carried out

As shown in Table 1, the embodiment of the present invention defines five conflict processing instructions when the first transaction conflicts with the historical transaction, which are "1", "2", and "3: http://address/0x289" , "4" and "5" also define a conflict processing instruction when there is no conflict between the first transaction and the historical transaction, namely "0". Among them, the additional data of the conflict processing instructions "0", "1", "2", "4", and "5" can all be empty, and the processing instruction value of the conflict processing instruction "3: http://address/0x289" It can be 3, and the additional data can be http://address/0x289. Specifically, if there is a conflict between the first transaction and the historical transaction, and the conflict processing instruction is "1", the first node may refuse to execute the first transaction; if the first transaction does not conflict with the historical transaction, and the conflict processing instruction is "0", or there is a conflict between the first transaction and the historical transaction, and the conflict processing instruction is "2", the first node can execute the first transaction; if the first transaction conflicts with the historical transaction, and the conflict processing instruction is "3" ", the first node can execute the first transaction, and can send the first transaction to the fault-tolerant processing device with the contract address http://address/0x289 for correction; if the first transaction conflicts with the historical transaction, and the conflict is handled If the instruction is "4", the first node can refuse to execute the first transaction and can issue an alarm message; if the first transaction conflicts with historical transactions, and the conflict processing instruction is "5", the first node can execute the first transaction. Transaction, and can print the log record of the first transaction conflict to facilitate subsequent troubleshooting.

It should be noted that the conflict described in the embodiment of the present invention is specifically a conflict of multiple transactions generated in the same business process. If the identifiers of multiple transactions generated in the same business process are the same, the multiple transactions may be Conflicting; if the identifiers of multiple transactions generated in the same process of different businesses are the same, or the identifiers of multiple transactions generated in different processes of the same business are the same, the multiple transactions are not in conflict. For example, transaction B ₁ is a transaction generated in the second process of business a ₁ , transaction B ₂ is a transaction generated in the second process of business a ₁ , and transaction B ₃ is a transaction generated in the first process of business a ₁ , Transaction B ₄ is a transaction generated in the second process of business a _2. Since transaction B ₁ and transaction B ₃ belong to different processes of the same business, even if the identifiers of transaction B ₁ and transaction B ₃ are the same, transaction B ₁ and Transaction B ₃ does not conflict; accordingly, since transaction B ₁ and transaction B ₄ belong to the same process of different businesses, even if the identifiers of transaction B ₁ and transaction B ₄ are the same, transaction B ₁ and transaction B ₄ do not conflict; and For transactions B ₁ and B ₂ , since transaction B ₁ and transaction B ₂ belong to the same process of the same business, if the identifiers of transaction B ₁ and transaction B ₂ are the same, transaction B ₁ and transaction B ₂ conflict.

Take the first transaction as the transaction that creates an order number as an example. Because the order numbers created by different transactions in the order creation process of the same business are different, the order number can uniquely identify a transaction; if the order numbers of different transactions are the same, it means Different transactions are in conflict. In order to generate non-conflicting order numbers, you can set the order numbers between adjacent transactions to be incremental, or you can add random number sequences or transaction hash values to different order numbers.

In the embodiment of the present invention, by taking the business scenario as the dimension, the client device can adopt the same identification setting method for transactions in the same business scenario, so that the transaction identifier can indicate that the transaction is included in multiple transactions in the same business scenario. That is to say, in the embodiment of the present invention, the transaction identifier is set by the client device, and the transaction conflict detection can be performed by comparing the transaction identifier without comparing the specific transaction data, so that the transaction can be conflicted The detection process is faster, and the efficiency of transaction processing in the blockchain system is improved; moreover, the conflict processing instructions can be set by the client device based on actual business scenarios, so that the transaction processing process can be more in line with actual needs.

Step 202: The client device sends a transaction request to the first node in the blockchain system.

Here, the client device may send a transaction request to the first node in various ways, for example, it may send a transaction request to the first node in a wired manner, or may also send a transaction request to the first node in a wireless manner, which is not specifically limited.

In an example, the transaction request may include the identification of the first transaction and the conflict processing instruction. In another example, the transaction request may include the identification of the first transaction, the conflict processing instruction, and the transaction data of the first transaction. The transaction data of the first transaction may include the key value, account number, contract address, etc. of the first transaction.

Step 203: The first node receives the transaction request sent by the client device, and determines the conflict result of the first transaction according to the identifier of the first transaction.

In specific implementation, the first node may parse the transaction request, and obtain the identifier of the first transaction and the conflict processing instruction (or the identifier of the first transaction, transaction data and the conflict processing instruction). Further, the first node may determine whether there is a conflict between the first transaction and the historical transaction according to the identifier of the first transaction; wherein, the historical transaction may include all transactions processed by the first node before receiving the transaction request of the first transaction . It should be noted that before the first node parses the transaction request, it can also send the transaction request to other nodes in the blockchain system so that other nodes can execute the first transaction. In this way, multiple nodes in the blockchain system The block consensus process can be performed after the first transaction is executed. The process of executing the first transaction by other nodes can be implemented with reference to the process of executing the first transaction by the first node, which will not be repeated here.

In the embodiment of the present invention, historical transactions may be stored in the first preset database of the first node. Based on the conflict handling instructions shown in Table 1, Table 2 is a schematic table of historical transactions stored in the first preset database. .

Table 2: An illustration of historical transactions stored in the first preset database

As shown in Table 2, the first preset database can store each historical transaction identifier, contract address, key value, transaction account number, conflict handling instructions, and conflict times. For example, the contract address of the historical transaction with the transaction identifier a ₁ x ₁ (for ease of description, referred to as historical transaction a ₁ x ₁ ) can be http://address/0x755, the key value can be 10.33, and the transaction account number can be Y ₁ , the conflict processing instruction can be 1 (that is, the historical transaction conflicts with the historical transaction before the historical transaction, and the historical transaction has been rejected), and the number of conflicts is 2 (that is, there are two conflicts).

Specifically, the contract address of the transaction can be the address on the blockchain of the contract that implements the business logic, and it can be a piece of fixed-length data, and the contract address of the transaction can be the identifier of the business to which the transaction belongs; as shown in Table 2, Historical transaction a ₁ x ₁ , historical transaction a ₄ x ₄ and historical transaction a ₆ x _{6 have} the same contract address, it can be explained that historical transaction a ₁ x ₁ , historical transaction a ₄ x ₄ and historical transaction a ₆ x ₆ belong to The business is the same. Correspondingly, the key value of the transaction can be a joint key value calculation of the contract address of the transaction and the transaction identifier. The key value can be binary data with a length of less than 255 bytes; the key value obtained based on the contract address and the transaction identifier , Can make the conflict detection process take the business process as the dimension. As shown in Table 2, historical transaction a ₁ x ₁ , historical transaction a ₄ x ₄ and historical transaction a ₆ x _{6 have} the same key value, which can explain historical transaction a ₁ x ₁ , historical transaction a ₄ x ₄ and historical transaction a ₆ x ₆ are transactions in the same process of the same business, for example, they can all be transactions in the process of creating an order. Historical transaction a ₁ x _1, for example, a transaction account transaction history ₁ x ₁ may be a hash value from the historical trading ₁ x _1, said first node can get to a transaction history based on historical trading account is ₁ x ₁ Transaction a ₁ x ₁ transaction information, such as the transaction initiator, transaction receiver, transaction processing receipt, the block to which the transaction belongs, and the block information corresponding to the transaction. The conflict processing instruction of historical transaction a ₁ x ₁ may refer to the conflict processing instruction configured by the client device sending historical transaction a ₁ x ₁ , and the number of conflicts may refer to the historical transaction a ₁ before the transaction request of the first transaction is received. x ₁ and the number of conflicting historical transaction database in the first pre-set for each transaction to determine the history of a ₁ x ₁ conflict once, the number of collisions historical trading a ₁ x ₁ can be incremented.

In a possible implementation, the first node may compare the identifier of the first transaction with the identifier of one or more historical transactions in the first preset database, and if it is determined that there is a first If it is determined that there is a conflict between the first transaction and the historical transaction, if it is determined that there is no historical transaction that matches the identifier of the first transaction in the first preset database, then the first transaction and the historical transaction can be determined There is no conflict. Taking the first preset database shown in Table 2 as an example, if the identifier of the first transaction is a ₁ x ₁ , it can be determined that there is a conflict between the first transaction and the historical transaction. If the identifier of the first transaction is a ₈ x ₈ , It can be determined that there is no conflict between the first transaction and the historical transaction.

In this implementation, by directly comparing the identifier of the first transaction with the identifier of the historical transaction in the first preset database, after a round of conflict detection process, it can be determined whether there is a conflict between the first transaction and the historical transaction. It can simplify the process of conflict detection and facilitate implementation.

In another possible implementation manner, the first node may sequentially perform one round of conflict detection or multiple rounds of conflict detection from the first round of conflict detection to the third round of conflict detection on the first transaction, where the first round of conflict detection The processes of the second round of conflict detection can all be executed in the preset memory space, and the process of the third round of conflict detection can be executed in the first preset database. The following specifically describes the implementation process of the first round of conflict detection to the third round of conflict detection.

The first round of conflict detection

In specific implementation, the first node can obtain the contract address of the first transaction from the transaction data of the first transaction, and then can perform a joint key value calculation on the identifier of the first transaction and the contract address of the first transaction to obtain the first transaction's contract address. Key value, and the target historical transaction matching the key value of the first transaction can be obtained from the first preset database; for example, referring to the first preset database shown in Table 2, if the key value of the first transaction 10.33, the target historical transaction can include historical transaction a ₁ x ₁ , historical transaction a ₄ x ₄ and historical transaction a ₆ x ₆ . Further, the first node may store the identifier of the target historical transaction in a preset memory space, or may also store all the information of the target historical transaction (ie transaction identifier, contract address, key value, transaction identifier) stored in the first preset database. The account number, conflict handling instructions, and conflict times) are stored in a preset memory space, which is not specifically limited. When performing the first round of conflict detection, the first node may compare the identifier of the first transaction with the identifier of the target historical transaction stored in the preset memory space, and if it is determined that there is a match in the preset memory space with the identifier of the first transaction If it is determined that there is no target historical transaction matching the identifier of the first transaction in the preset memory space, it can be determined that the second round of conflict detection can be performed.

In the first round of conflict detection, since the key value of the target historical transaction matches the key value of the first transaction, the target historical transaction and the first transaction can be transactions in the same process of the same business. On the one hand, by performing the first round of conflict detection on the first transaction based on the same target historical transaction as the business process to which the first transaction belongs, the number of comparison transactions in the conflict detection process can be reduced, and the efficiency of conflict detection can be improved. On the other hand, by storing the target historical transaction in the preset memory space in advance, the process of comparing transactions can be executed in the preset memory space instead of in the first preset database, thereby improving the response of the conflict detection process speed.

In the embodiment of the present invention, the first round of conflict detection can be applied to scenarios with a high possibility of conflict. If the detection result of the first round of conflict detection is a conflict, it can be determined that the first transaction is in conflict with the historical transaction. Round conflict detection can detect transactions with a high probability of conflict, thereby reducing the number of times to query historical transactions in the first preset database, improving the calculation speed of conflict detection, and saving system overhead.

The second round of conflict detection

In the embodiment of the present invention, the first preset filtering model may also be set in the first preset database. If the first node receives the transaction request of the first transaction sent by the client device, it may obtain the data in the first preset database. The first preset filter model is stored, and the first preset filter model is stored in the preset memory space. Correspondingly, if the detection result of the first round of conflict detection is that the first transaction does not conflict with the historical transaction (that is, there is no target historical transaction that matches the identifier of the first transaction in the preset memory space), the first node can transfer the first transaction The identification of a transaction is input into the first preset filtering model stored in the preset memory space.

Further, the first preset filtering model can perform a second round of conflict detection on the first transaction, and can output the conflict result of the first transaction; the conflict result of the first transaction can be any one of the first result and the second result The first result is used to indicate that there is no conflict between the first transaction and the historical transaction, and the second result is used to indicate that the first transaction may conflict with the historical transaction. In this way, after the first node inputs the first transaction into the first preset filtering model, if the output result is the first result, it can be determined that there is no conflict between the first transaction and the historical transaction; if the output result is the second result, it can be executed The third round of conflict detection.

In specific implementation, the model structure of the first preset filtering model can be set by those skilled in the art based on experience, and is not specifically limited. As an example, the first preset filtering model can be a model based on bits, such as a Bloom filter; according to experiments, it is found that if the memory of the Bloom filter is small, the output result will be misjudged as the second result. If the memory of the Bloom filter is large, it will cause a waste of system space. Therefore, the embodiment of the present invention has been experimentally determined that the memory of the Bloom filter is set to 200M and is based on transaction information of historical transactions in the last 3 years (including historical transaction identifiers, key values, transaction data, conflict processing instructions, conflicts When training the Bloom filter, the error rate of the output result of the Bloom filter can be less than 1%. By setting the memory size of the bloom filter and training the historical transactions of the bloom filter, you can save system space and improve the accuracy of the output results.

It should be noted that the above is only an exemplary simple description. Those skilled in the art can also set the memory of the Bloom filter and/or train the historical transaction of the Bloom filter according to actual needs. The above setting does not constitute a cost Limitations of the plan. In a specific implementation, the memory of the Bloom filter can be greater than 200M, or it can be less than 200M, such as 400M or 100M; accordingly, the historical transaction of the training Bloom filter can be the historical transaction in the last 2 years, or also It can be historical transactions within the last 5 years, and the specifics are not limited.

In the embodiment of the present invention, the second round of conflict detection can be applied to scenarios where the possibility of conflict is small. If the detection result of the second round of conflict detection is no conflict, it can be determined that there is no conflict between the first transaction and the historical transaction. The second round of conflict detection can detect transactions that are less likely to conflict. In the embodiment of the present invention, before the conflict detection is performed in the first preset database, the conflict results of most transactions can be obtained through the first round of conflict detection and the second round of conflict detection based on the preset memory space in advance, thereby The number of times to query historical transactions in the first preset database can be reduced, the calculation speed and efficiency of conflict detection can be improved, and system overhead can be saved.

The third round of conflict detection

If the output result of the second round of conflict detection is that the first transaction conflicts with the historical transaction (that is, the output of the first preset filtering model is that the first transaction conflicts with the historical transaction), the first node can perform the third round of conflict detection . Specifically, the first node may compare the identifier of the first transaction with the identifier of the historical transaction in the first preset database, and if it is determined that there is a historical transaction matching the identifier of the first transaction in the first preset database, then It can be determined that there is a conflict between the first transaction and the historical transaction; if it is determined that there is no historical transaction matching the identifier of the first transaction in the first preset database, it can be determined that there is no conflict between the first transaction and the historical transaction.

In the embodiment of the present invention, most of the conflicting transactions can be detected by using the first round of conflict detection and the second round of conflict detection, because both the first round of conflict detection and the second round of conflict detection are executed in the preset memory space , Which can make the response speed faster and improve the efficiency of conflict detection. Moreover, the third round of conflict detection can be applied to any scenario. If the conflict result of the first transaction is not obtained based on the first round of conflict detection and the second round of conflict detection, the first transaction can be compared with the first transaction based on the third round of conflict detection. The historical transactions in a preset database are compared, so that the conflict result of the first transaction can be obtained. In the embodiment of the present invention, by using the first round of conflict detection to the third round of conflict detection, it is possible to avoid directly querying historical transactions in the first preset database, thereby reducing system overhead and improving the efficiency of conflict detection. Accurate conflict results.

Step 204: The first node processes the first transaction according to the conflict result of the first transaction and the conflict processing instruction to obtain the processing result of the first transaction.

The following describes step 204 in detail in conjunction with Table 1 and Table 3. According to the conflict processing instructions shown in Table 1, Table 3 shows several processing methods that the first node executes on the first transaction according to the conflict results and conflict processing instructions of the first transaction. The schematic table.

Table 3: Schematic of several ways for the first node to process the first transaction

As shown in Table 1 and Table 3, if the conflict result of the first transaction and the conflict processing instruction satisfy any one of the first to fourth conditions shown below, the first node can execute the first transaction :

The first condition, the conflict result is that there is no conflict between the first transaction and the historical transaction, and the conflict processing instruction is that the first transaction is executed when there is no conflict between the first transaction and the historical transaction (ie "0");

The second condition, the conflict result is that the first transaction conflicts with the historical transaction, and the conflict processing instruction is that the first transaction is executed when there is a conflict between the first transaction and the historical transaction (ie "2");

The third condition, the conflict result is that the first transaction conflicts with the historical transaction, and the conflict processing instruction is that the first transaction conflicts with the historical transaction, redirect the first transaction to the fault-tolerant contract (ie "3");

The fourth condition is that the conflict result is that the first transaction conflicts with the historical transaction, and the conflict processing instruction is to execute the first transaction and print the log when there is a conflict between the first transaction and the historical transaction (ie, "5").

It should be noted that, if the conflict result of the first transaction and the conflict processing instruction satisfy the third condition, the first node can generate the first log after processing the first transaction, and can change the timestamp of the processing of the first transaction Information, transaction data, and conflict indication values are added to the first log, and then the first log is saved, so that the operation and maintenance personnel can perform troubleshooting work.

Correspondingly, if the conflict result of the first transaction and the conflict processing instruction satisfy the fifth condition or the sixth condition as shown below, the first node may refuse to execute the first transaction:

The fifth condition, the first transaction conflicts with the historical transaction, and the conflict processing instruction is to refuse to execute the first transaction when the first transaction conflicts with the historical transaction (ie "1");

The sixth condition is that the first transaction conflicts with the historical transaction, and the conflict processing instruction is that when the first transaction conflicts with the historical transaction, the first transaction is rejected and an alarm is issued (ie, "3").

It should be noted that if the conflict result of the first transaction and the conflict processing instruction satisfy the sixth condition, the first node can generate alarm information while refusing to process the first transaction, and can send the alarm information to the client device. In order to facilitate the operation and maintenance personnel to perform troubleshooting.

The following describes the specific implementation process of the first node processing the first transaction from two scenarios.

Situation One

In scenario 1, the first node can execute the first transaction, that is, the conflict result of the first transaction and the conflict processing instruction satisfy the first condition, or the second condition, or the third condition, or the fourth Kind of conditions.

In an example, if the first node determines to execute the first transaction, it may first update the target historical transaction included in the preset memory space. In an example, if there is no historical transaction with the same identifier of the first transaction in the preset memory space, the first node may add the first transaction to the preset memory space. In this way, the preset memory space includes The target historical transaction may include the first transaction. If the first node receives a second transaction with the same identifier as the first transaction during the execution of the first transaction, the second transaction can be determined through the first round of conflict detection It conflicts with the first transaction, so there is no need to execute a second transaction that is repeated with the first transaction. In another example, if there is a target historical transaction with the same identifier as the first transaction in the preset memory space, the first node may update the target historical transaction information stored in the preset database, for example, the target historical transaction may be updated The number of conflicts, conflict processing instructions, etc., in this way can make the preset filtering model determined based on the historical transactions in the preset memory space more accurate. In the embodiment of the present invention, by updating the preset memory space when the first transaction is determined to be executed, the transaction processing process of the first node can be made more efficient.

Further, the first node can communicate with other nodes in the blockchain system to execute the consensus process of the first transaction, if it is determined that the number of nodes that reach consensus on the first transaction in the blockchain system is greater than or equal to the preset threshold , The block information corresponding to the first transaction can be generated, and the block information corresponding to the first transaction can be used to update the first preset database and/or the preset memory space. For example, the first transaction can be updated according to the block information of the first transaction. A preset database may also update the preset memory space according to the block information of the first transaction, or may also update the first preset database and the preset memory space according to the block information of the first transaction, which is not specifically limited. Correspondingly, if it is determined that the number of nodes that have reached a consensus on the first transaction in the blockchain system is less than the preset threshold, a message indicating that the execution of the first transaction has failed may be sent to the client device. The preset threshold may be set by those skilled in the art based on experience, for example, it may be 3/4 of the number of nodes included in the blockchain system, which is not specifically limited.

In the embodiment of the present invention, there may be multiple ways to generate block information corresponding to the first transaction. In a possible implementation manner, the first preset database may store the first check value, and the first check The value may be obtained by verifying multiple historical transactions by the first node using a preset verification algorithm, for example, may be a hash value of multiple historical transactions. In specific implementation, before determining to execute the first transaction, the first node may obtain the first check value from the first preset database, and may store the first check value in the preset memory space; further, in In the process of executing the first transaction, the first node can generate the initial block information corresponding to the first transaction in advance, and can use a preset verification algorithm to verify the first verification value and the first transaction to obtain the second verification. Further, the first node can add the second check value to the initial block information, and can reach a consensus with other nodes in the blockchain system. If the consensus is passed, the corresponding value of the first transaction can be obtained Block information, and can use the second check value to update the first check value stored in the preset memory space.

In an example, a circular hash algorithm can be used to determine the second check value, and the program implementation process can be as follows:

Data[3]={data[0],data[1],data[2]};

HASH_NEW=HASH_DATA;

for(i=0; i<3; i++)

{HASH_NEW=hash(HASH_NEW+hash(Data[i]));}

HASH_DATA=HASH_NEW

According to the first line of program, the first node determines to execute transaction data[0], historical transaction data[1], and historical transaction data[2]; according to the second line of program, the first node can obtain the calibration stored in the preset memory space The verification value HASH_NEW; according to the third to fourth lines of the program, the first node can get the hash value of transaction data[0] to obtain the verification value hash(Data[1]) of transaction data[0], and then can The first check value HASH_NEW and the check value hash(Data[1]) of transaction data[0] take the hash value to obtain the check value of historical transactions including transaction data[0]; accordingly, the first The node can obtain the check value of historical transaction including transaction data[0] and transaction data[1] according to the check value of historical transaction including transaction data[0] and transaction data[1], and then can According to the check value of the historical transaction including transaction data[0] and transaction data[1] and transaction data[2], obtain transaction data[0], transaction data[1] and transaction data[2] The check value of the historical transaction; according to the fifth line of the program, the check value of the historical transaction including transaction data[0], transaction data[1] and transaction data[2] can be used to update the preset memory space The check value of historical transactions.

It should be noted that the foregoing is only an exemplary simple description, and the manner in which the cyclic hash algorithm is used to determine the second check value is only for the convenience of explaining the solution, and does not constitute a limitation on the solution. In specific implementation, the method for determining the second check value can be set by those skilled in the art based on experience. For example, the merkle root algorithm can be used to determine the second check value, or the acyclic hash algorithm can be used to determine the second check value. The details are not limited.

In the embodiment of the present invention, the first check value can be used to identify historical transactions processed by the blockchain system. After the first transaction is executed, the first check value is updated with the first transaction to obtain the second check value On the one hand, multiple nodes in the blockchain system can achieve consensus based on the same second check value, thereby improving the accuracy of transaction processing in the blockchain system; on the other hand, it can make the blockchain system in In the process of processing transactions, the historical transactions processed by the blockchain system are updated in real time, thereby improving the accuracy of subsequent processing transactions.

If the first node successfully executes the first transaction, the block information corresponding to the first transaction can be stored in the blockchain system. In this way, the processing result of the first transaction can include the block information corresponding to the first transaction. Further, the first node may use the block information according to the first transaction to update the first preset database and/or the preset memory space. In a possible implementation manner, the first node may use the identifier of the first transaction to train the first preset filtering model to obtain the second preset filtering model, and may use the first preset stored in the first preset database The filtering model is updated to the second preset filtering model; and the first node can add the transaction information corresponding to the first transaction to the first preset database, and can use the second check value determined above to update the first preset Set the first check value stored in the database; further, the first node can use the second preset filter model and the second check value to respectively update the first preset filter model and the first check value stored in the preset memory space. Value.

Correspondingly, if the first node does not successfully execute the first transaction (for example, the node consensus fails), the processing result of the first transaction may include first instruction information, and the first instruction information is used to indicate that the processing of the first transaction fails. In an example, since the first node has added the first transaction to the preset memory space when it determines to execute the first transaction, if the first transaction is not successfully executed, the first node may add the preset memory The first transaction stored in the space is deleted, thereby avoiding the subsequent acquisition of a transaction with the same identifier as the first transaction from failing the first round of conflict detection, ensuring the accuracy of subsequent transaction processing.

In the embodiment of the present invention, by using the block information of the first transaction to sequentially update the first preset filter model, historical transaction information and the check value of the historical transaction in the first preset database and the preset memory space, the verification value based on The updated preset memory space and the first preset database perform conflict detection for the next transaction, thereby improving the accuracy of conflict detection.

It should be noted that if the conflict result of the first transaction and the conflict processing instruction satisfy the fourth condition, the first node can also obtain the address of the fault-tolerant contract included in the transaction request after executing the first transaction, and can also obtain the address of the fault-tolerant contract included in the transaction request according to the The address of the fault-tolerant contract calls the fault-tolerant processing module to correct the first transaction. In this way, the processing result of the first transaction may also include the address of the fault-tolerant contract, and the address of the fault-tolerant contract is used to call the fault-tolerant processing module in the client device to correct the first transaction.

Situation two

In the second situation, the first node may refuse to execute the first transaction, that is, the conflict result of the first transaction and the conflict processing instruction can satisfy the fifth condition or the sixth condition.

In specific implementation, if the first node refuses to execute the first transaction, the first node may generate a conflict indicator code, the conflict indicator code is used to indicate that the first transaction conflicts with the historical transaction, and the first node has not executed the first transaction. Therefore, the processing result of the first transaction may include the conflict indicator code.

Step 205: The first node sends the first information or the second information to the client device.

In specific implementation, the processing result of the first transaction may include any one or more of the block information of the first transaction, the first instruction information, the conflict indicator code, and the address of the fault-tolerant contract. If the processing result of the first transaction includes the block information of the first transaction and/or the address of the fault-tolerant contract, indicating that the first transaction has been successfully executed by the first node, the first node may send the first information to the client device; if The processing result of the first transaction includes the first instruction information or the conflict instruction code, indicating that the first transaction has not been successfully executed by the first node, and the first node may send the second information to the client device.

In the embodiment of the present invention, the conflict processing instructions set by the client device include "execute the first transaction when the first node conflicts with the historical transaction", "redirect to the fault-tolerant module when the first node conflicts with the historical transaction" and " When the first node conflicts with the historical transaction, execute the first transaction and print the log. These three situations, that is, when the first transaction conflicts with the historical transaction, the first transaction may be successfully executed by the first node. Therefore, in order to avoid major business errors in the first transaction, the first node may send the first information to the client device after successfully executing the first transaction. In an example, the first information may include the block information of the first transaction and/or the address of the fault-tolerant contract. In this way, after receiving the first information, the client device can correct the first transaction according to the first information.

Correspondingly, if the processing result of the first transaction includes the first indication information, it means that the first transaction has passed the conflict detection but not successfully executed by the first node; if the processing result of the first transaction includes the conflict indication value, it means that A transaction failed the conflict processing instruction and was not successfully executed by the first node. Since the first transaction was not successfully executed, there will be no major business errors. Therefore, the first node may send the second information to the client device, and the second information may be used to indicate that the first transaction was not successfully executed.

Step 206: The client device receives the first information or the second information sent by the first node, and calls the fault-tolerant processing module to correct the first transaction.

In a specific implementation, a second preset database may be provided in the client device, and all historical transactions processed by the client device may be stored in the second preset database. In a possible implementation, if the client device receives the first information sent by the first node, it means that the first transaction has been successfully executed by the first node. In this way, the client device can pair The first transaction performs conflict detection to determine whether there is a conflict between the first transaction and the historical transaction processed by the client device. In an example, the client device can directly compare the identifier of the first transaction with the identifier of the historical transaction stored in the second preset database to determine whether there is a conflict between the first transaction and the historical transaction processed by the client device; In another example, the client device may sequentially perform the first round of conflict detection to the third round of conflict detection on the first transaction, so as to determine whether there is a conflict between the first transaction and the historical transaction processed by the client device. Here, the above two examples can be implemented with reference to the process of determining whether there is a conflict between the first transaction and the historical transaction processed by the first node in step 203, and the details are not repeated here.

Further, if there is no historical transaction with an identifier matching the identifier of the first transaction in the second preset database, it means that the client device has not previously processed a transaction with the same identifier as the first transaction; in this way, the client device can The first transaction is added to the second preset database. Correspondingly, if there is a historical transaction whose identifier matches the identifier of the first transaction in the second preset database, it means that the client device has previously processed the same transaction as the identifier of the first transaction; in this way, the client device can use fault tolerance The processing module corrects the first transaction according to the preset processing rules. The preset processing rules may include any one or more of output log records, output transaction records of the second preset database, invalid transactions, cancel transactions, and freeze subsequent transactions.

In specific implementation, the fault-tolerant processing module may prejudge the business process to which the first transaction belongs. If it is determined that the first transaction is a transaction in a non-critical business process, the fault-tolerant processing module may correct the first transaction in a variety of ways. In one example, the fault-tolerant processing module may obtain the log information and/or database information of the first transaction, and may send the log information and/or database information of the first transaction to the operation and maintenance personnel for maintenance; in another example, The fault-tolerant processing module can perform subsequent processing on the first transaction according to the address of the fault-tolerant contract and the preset processing rules set in the fault-tolerant contract. Since the transaction in the non-critical business process has a small impact on the business, the above-mentioned method is used to modify the transaction in the non-critical business process to improve the processing efficiency of the system.

Correspondingly, if it is determined that the first transaction is a transaction in a critical business process, the fault-tolerant processing module can correct the first transaction according to the business process to which the first transaction belongs. For example, if the first transaction to create a new order X, the fault-tolerant processing module may be the order of X state to the inactive state; if the first transaction to add revenue L _1, the fault-tolerant processing module in Q ₁ can account from the Account Q revenue minus ₁ L _1; if the first transaction for the account to the account Q ₂ Q ₁ transfer funds L _2, then the fault-tolerant processing module may be on account of capital Q ₂ Q ₁ L accounts returned; if the first transaction If asset N is abnormally drawn from account Q ₃ repeatedly, the fault-tolerant processing module can freeze account Q ₃ .

It should be noted that the foregoing is only an exemplary simple description, and the manners of modifying the first transaction listed therein are only for the convenience of explaining the solution, and do not constitute a limitation on the solution. In a specific implementation, the method for modifying the first transaction can be set by a person skilled in the art based on experience, or can be set according to actual business needs, which is not specifically limited.

In the embodiment of the present invention, because the conflict processing instruction is set by the client device, some conflicting transactions may still be processed. By sending block information to the client device after the transaction is processed, the client device The device corrects the transaction, so as to avoid major errors in the transaction processing process, and improve the business processing capability and accuracy of the blockchain system.

In another possible implementation manner, if the client device receives the second information sent by the first node, it can call the fault-tolerant processing module to obtain the relevant information of the first transaction, such as the timestamp of the first transaction, transaction data, Conflict results and conflict processing instructions, etc.; further, the fault-tolerant processing module can store relevant information of the first transaction in log information or database information, so that the operation and maintenance personnel can perform troubleshooting based on the log information or database information.

In the above-mentioned embodiment of the present invention, the first node in the blockchain system receives the transaction request sent by the client device, the transaction request includes the identification of the first transaction and the conflict processing instruction, and the conflict processing instruction includes the first transaction and the existence of historical transactions. The way to deal with the first transaction when there is a conflict, and/or the way to deal with the first transaction when there is no conflict between the first transaction and the historical transaction; further, the first node determines the first transaction according to the identifier of the first transaction The conflict result, and the first transaction is processed according to the conflict result of the first transaction and the conflict processing instruction; wherein the conflict result of the first transaction is used to indicate whether there is a conflict between the first transaction and the historical transaction. In the embodiment of the present invention, by setting the transaction identifier, the conflict detection of the first transaction can be performed by comparing the transaction identifier without comparing transaction data, thereby making the process of conflict detection for the transaction faster and improving The efficiency of transaction processing in the blockchain system; and, because the conflict processing instructions are set by the client device, different conflict processing instructions can be set based on different business scenarios and the requirements of the client device, that is, in the above technical solution The transaction processing method is more in line with the actual situation.

Based on the system architecture shown in FIG. 1 and the transaction processing method shown in FIG. 2, FIG. 3 is a schematic structural diagram of a client device and a first node according to an embodiment of the present invention. As shown in FIG. 3, the first node may be provided with a conflict detection unit, a transaction execution unit, and an update unit, and the conflict detection unit, the transaction execution unit, and the update unit may be connected in sequence. Moreover, a preset memory space, a first preset filtering model, and a first preset database may also be set in the first node; accordingly, a second preset database may be set in the client device.

The process of processing the first transaction based on the client device and the first node as shown in FIG. 3 may be as shown in the following steps 1 to 6:

Step 1. The client device sends a transaction request to the conflict detection unit provided in the first node, and the transaction request includes the identifier of the first transaction and the conflict processing instruction of the first transaction.

Step 2: After receiving the transaction request sent by the client device, the conflict detection unit obtains the identifier of the first transaction, and based on any one or more of the preset memory space, the first preset filtering model, and the first preset database Perform conflict detection on the first transaction. For example, in one example, the conflict detection unit may perform conflict detection on the first transaction based only on the preset memory space, or perform conflict detection on the first transaction based on the first preset filtering model only, or based only on the first preset database Perform conflict detection on the first transaction; in another example, the conflict detection unit may perform conflict detection on the first transaction based on the preset memory space and the first preset filtering model, or based on the preset memory space and the first preset database Perform conflict detection on the first transaction, or perform conflict detection on the first transaction based on the first preset filtering model and the first preset database; in another example, the conflict detection unit may be based on the preset memory space and the first preset database. The filter model and the first preset database perform conflict detection on the first transaction.

In a possible implementation manner, the conflict detection unit may perform the first round of conflict detection on the first transaction based on a preset memory space. If the first round of conflict detection determines that there is a historical transaction matching the identifier of the first transaction in the preset memory space, the conflict detection unit may determine that the first transaction conflicts with the historical transaction; if the first round of conflict detection determines the preset memory space If there is no historical transaction matching the identifier of the first transaction, the conflict detection unit may perform the second round of conflict detection on the first transaction based on the first preset filtering model. If the second round of conflict detection determines that the first transaction does not conflict with the historical transaction, the conflict detection unit can determine that the first transaction does not conflict with the historical transaction; if the second round of conflict detection determines that the first transaction conflicts with the historical transaction, then The conflict detection unit may perform a third round of conflict detection on the first transaction based on the first preset database. If the third round of conflict detection determines that there is a historical transaction matching the identification of the first transaction in the first preset database, the conflict detection unit may determine that the first transaction conflicts with the historical transaction; if the first round of conflict detection determines that the first predetermined Assuming that there is no historical transaction matching the identifier of the first transaction in the database, the conflict detection unit may determine that there is no conflict between the first transaction and the historical transaction.

If it is determined that there is a conflict between the first transaction and the historical transaction, and the conflict processing instruction is "refuse to execute the first transaction when there is a conflict between the first transaction and the historical transaction", the first node and the client device can perform the following steps 3.1 and 4.1:

Step 3.1: The conflict detection unit (or the first node) sends a conflict indication code to the client device.

Step 4.1: The client device receives the conflict indication code sent by the conflict detection unit, and calls the fault-tolerant processing module to perform conflict processing on the first transaction. In an example, the fault-tolerant processing module can obtain the time stamp, transaction data, and conflict indicator code of the first transaction, and can record the time stamp, transaction data, and conflict indicator code of the first transaction in log information or a database.

Correspondingly, if it is determined that there is no conflict between the first transaction and the historical transaction, and the conflict processing instruction is "execute the first transaction when there is no conflict between the first transaction and the historical transaction", or there is a conflict between the first transaction and the historical transaction, and the conflict is handled The instruction is "execute the first transaction when the first transaction conflicts with the historical transaction", or the first transaction conflicts with the historical transaction, and the conflict processing instruction is "redirect to the fault-tolerant processing module when the first transaction conflicts with the historical transaction" , The first node and the client device can perform the following step 3.2, step 4.2 to step 6:

Step 3.2: The conflict detection unit sends the first transaction to the transaction execution unit, so that the transaction execution unit executes the first transaction.

In specific implementation, the transaction execution unit can use the smart contract to execute the first transaction, and can reach consensus with other nodes in the blockchain system through the network. If the number of nodes that have reached a consensus is greater than or equal to the preset threshold, the transaction execution unit can generate block information corresponding to the first transaction, and can store the block information corresponding to the first transaction in the underlying blockchain; if If the number of nodes that have reached a consensus is less than the preset threshold, the transaction execution unit (or the first node) can send the first transaction execution failure information to the client device, so that the client device can call the fault-tolerant processing module to process the first transaction (the The process is not shown in Figure 3).

Step 4.2: After the transaction execution unit determines that the first transaction is successfully executed, it sends an update request to the update unit. The update request includes block information corresponding to the first transaction.

Step 5. After receiving the update request sent by the transaction execution unit, the update unit uses the block information corresponding to the first transaction to update the preset memory space, the first preset filter model, and the first preset database. Specifically, the update unit may add the first transaction to the preset memory space and the first preset database, and may update the first preset filtering model based on the historical transactions and the first transaction included in the first preset database.

Step 6. If the first node determines that the update of the preset memory space, the first preset filter model, and the first preset database is completed, it sends a transaction response message to the client device. The transaction response message includes the block corresponding to the first node information.

As shown in Figure 3, a second preset database may be set in the client device. If the client device receives the block information corresponding to the first node, the first node can be obtained from the block information corresponding to the first node. The identifier of the first node can be matched with the multiple historical transactions stored in the second preset database. If it is determined that there is no historical transaction with the same identifier as the first transaction in the second preset database, the client device can add the first transaction to the second preset database; if it is determined that the second preset database exists in the same For a historical transaction with the same transaction identifier, the client device can call the fault-tolerant processing module to correct the first transaction. The specific implementation process can be implemented with reference to step 206, which will not be repeated here.

In the embodiment of the present invention, by setting the conflict detection unit in the first node, the conflict detection process of the first transaction and the transaction execution process of the first transaction can be executed in two processes respectively, so that conflict detection and contract can be implemented. The decoupling of calculation and block consensus improves the efficiency of transaction processing.

Regarding the method flow illustrated in FIG. 2, the embodiment of the present invention also provides a transaction processing device based on a blockchain system, and the specific content of the device can be implemented with reference to the above method.

Figure 4 is a schematic structural diagram of a transaction processing device based on a blockchain system provided by an embodiment of the present invention, including:

The transceiver module 401 is configured to receive a transaction request sent by a client device. The transaction request includes an identifier of a first transaction and a conflict processing instruction; the conflict processing instruction includes a conflict between the first transaction and a historical transaction. The processing method of the first transaction, and/or the processing method of the first transaction when there is no conflict between the first transaction and the historical transaction;

The conflict detection module 402 is configured to determine the conflict result of the first transaction according to the identifier of the first transaction, and the conflict result of the first transaction is used to indicate whether there is a conflict between the first transaction and the historical transaction;

The processing module 403 is configured to process the first transaction according to the conflict result of the first transaction and the conflict processing instruction.

Optionally, the transaction request further includes the contract address of the first transaction; the conflict detection module 402 is configured to:

Determine the key value of the first transaction according to the identifier of the first transaction and the contract address of the first transaction;

Obtain the identifier of the target historical transaction from the first preset database, and store the identifier of the target historical transaction in a preset memory space; the first preset database includes the identifiers of multiple historical transactions and the multiple histories A key value of the transaction, where the target historical transaction is a historical transaction whose key value matches the key value of the first transaction in the first preset database;

If it is determined that there is a target historical transaction matching the identifier of the first transaction in the preset memory space, it is determined that the first transaction conflicts with the historical transaction.

Optionally, the conflict detection module 402 is further configured to:

If it is determined that there is no target historical transaction matching the identifier of the first transaction in the preset memory space, then the identifier of the first transaction is input into a first preset filtering model; the first preset filtering model is It is obtained by training using the transaction information of the multiple historical transactions, and the transaction information of each historical transaction includes the identification, key value, transaction data, conflict processing instruction and the number of conflicts of each historical transaction;

If the output result of the first preset filtering model is that there is no conflict between the first transaction and the historical transaction, it is determined that there is no conflict between the first transaction and the historical transaction.

Optionally, the conflict detection module 402 is further configured to:

If the output result of the first preset filtering model is that there is a conflict between the first transaction and the historical transaction, the identification of the first transaction is performed with the identification of multiple historical transactions in the first preset database In contrast, if it is determined that there is a historical transaction matching the identifier of the first transaction in the first preset database, it is determined that the first transaction conflicts with the historical transaction; if it is determined that there is no historical transaction in the first preset database If there is a historical transaction matching the identifier of the first transaction, it is determined that there is no conflict between the first transaction and the historical transaction.

Optionally, the conflict processing instruction when the first transaction does not conflict with the historical transaction includes executing the first transaction; the conflict processing instruction when the first transaction conflicts with the historical transaction includes any one of the following: reject Execute the first transaction, execute the first transaction, and redirect the first transaction to a fault-tolerant contract;

The processing module 403 is used to:

If there is no conflict between the first transaction and the historical transaction, and the conflict processing instruction is to execute the first transaction when there is no conflict between the first transaction and the historical transaction, or if the first transaction and the historical transaction There is a conflict, and the conflict processing instruction is to execute the first transaction when there is a conflict between the first transaction and the historical transaction, then the first transaction is executed; if the first transaction conflicts with the historical transaction, and all The conflict processing instruction is to redirect the first transaction to a fault-tolerant contract when there is a conflict between the first transaction and the historical transaction, then execute the first transaction, and obtain the address of the fault-tolerant contract included in the conflict processing instruction , Sending the address of the fault-tolerant contract to the client device; if the first transaction conflicts with the historical transaction, and the conflict processing instruction is that the first transaction conflicts with the historical transaction, the first transaction is rejected A transaction, a conflict indicator value is sent to the client device, and the conflict indicator value is used to indicate that the first transaction conflicts with the historical transaction.

Optionally, the processing module 403 is used to:

If it is determined that the number of nodes that reach a consensus on the first transaction in the blockchain system is greater than or equal to a preset threshold, generating block information corresponding to the first transaction;

Update the first preset database and/or the preset memory space according to the block information of the first transaction.

Optionally, after the processing module 403 generates the block information corresponding to the first transaction, it is further used to:

Sending the block information corresponding to the first transaction to the client device, where the block information corresponding to the first transaction is used by the client device to correct the first transaction.

Optionally, a first check value is stored in the first preset database, and the first check value is a check value stored in the first preset database by the first node using a preset check algorithm Obtained by verifying the multiple historical transactions;

The processing module 403 is specifically configured to:

Generating initial block information corresponding to the first transaction;

Verifying the first verification value and the first transaction using the preset verification algorithm to obtain a second verification value;

The second check value is added to the initial block information to obtain block information corresponding to the first transaction.

Optionally, the processing module 403 is used to:

Use the identifier of the first transaction to train the first preset filter model to obtain a second preset filter model, and use the preset memory space and/or the first preset in the first preset database The filtering model is updated to the second preset filtering model;

Add the first transaction to the first preset database, and use the second check value to update the preset memory space and/or the first calibration in the first preset database Value.

Figure 5 is a schematic structural diagram of a transaction processing device based on a blockchain system provided by an embodiment of the present invention, including:

The configuration module 501 is used to configure the identification of the first transaction and the conflict processing instruction;

The transceiver module 502 is configured to send a transaction request to the first node in the blockchain system, the transaction request including the identifier of the first transaction and the conflict processing instruction; and, to receive the fault tolerance sent by the first node The address of the contract;

The correction module 503 is configured to call the fault-tolerant processing module to correct the first transaction according to the address of the fault-tolerant contract.

Optionally, the transceiver module 502 is further configured to: receive block information corresponding to the first transaction sent by the first node;

The modification module 503 is further configured to: parse the block information corresponding to the first transaction to obtain the identifier of the first transaction; if it is determined that the identifier and the first transaction exist in the second preset database of the client device For a historical transaction that matches the transaction identifier, the fault-tolerant processing module is used to correct the first transaction in accordance with preset processing rules; the second preset database stores multiple histories processed by the client device transaction.

It can be seen from the foregoing that: in the foregoing embodiment of the present invention, the first node in the blockchain system receives the transaction request sent by the client device, the transaction request includes the identification of the first transaction and the conflict processing instruction, and the conflict processing instruction includes The method of processing the first transaction when there is a conflict between the first transaction and the historical transaction, and/or the method of processing the first transaction when there is no conflict between the first transaction and the historical transaction; further, the first node according to the first transaction Identification, to determine the conflict result of the first transaction, and process the first transaction according to the conflict result of the first transaction and the conflict processing instruction; wherein the conflict result of the first transaction is used to indicate whether there is a conflict between the first transaction and the historical transaction . In the embodiment of the present invention, by setting the transaction identifier, the conflict detection of the first transaction can be performed by comparing the transaction identifier without comparing transaction data, thereby making the process of conflict detection for the transaction faster and improving The efficiency of transaction processing in the blockchain system; and, because the conflict processing instructions are set by the client device, different conflict processing instructions can be set based on different business scenarios and the requirements of the client device, that is, in the above technical solution The transaction processing method is more in line with the actual situation.

Based on the same technical concept, an embodiment of the present invention provides a terminal device, as shown in FIG. 6, including at least one processor 1101 and a memory 1102 connected to the at least one processor. The embodiment of the present invention does not limit the processor. For the specific connection medium between 1101 and memory 1102, the connection between processor 1101 and memory 1102 in FIG. 6 is taken as an example. The bus can be divided into address bus, data bus, control bus, etc.

In the embodiment of the present invention, the memory 1102 stores instructions that can be executed by at least one processor 1101. By executing the instructions stored in the memory 1102, the at least one processor 1101 can execute the aforementioned transaction processing methods based on the blockchain system. Steps included.

Among them, the processor 1101 is the control center of the terminal device, which can use various interfaces and lines to connect various parts of the terminal device, and realize data by running or executing instructions stored in the memory 1102 and calling data stored in the memory 1102. deal with. Optionally, the processor 1101 may include one or more processing units, and the processor 1101 may integrate an application processor and a modem processor. The application processor mainly processes an operating system, a user interface, and an application program. The adjustment processor mainly processes instructions issued by operation and maintenance personnel. It is understandable that the foregoing modem processor may not be integrated into the processor 1101. In some embodiments, the processor 1101 and the memory 1102 may be implemented on the same chip, and in some embodiments, they may also be implemented on separate chips.

The processor 1101 may be a general-purpose processor, such as a central processing unit (CPU), a digital signal processor, an application specific integrated circuit (ASIC), a field programmable gate array or other programmable logic devices, discrete gates or transistors Logic devices and discrete hardware components can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of the present invention. The general-purpose processor may be a microprocessor or any conventional processor. The steps of the method disclosed in the embodiment of the transaction processing method based on the blockchain system can be directly embodied as executed by a hardware processor, or executed by a combination of hardware and software modules in the processor.

As a non-volatile computer-readable storage medium, the memory 1102 can be used to store non-volatile software programs, non-volatile computer-executable programs, and modules. The memory 1102 may include at least one type of storage medium, for example, it may include flash memory, hard disk, multimedia card, card-type memory, random access memory (Random Access Memory, RAM), static random access memory (Static Random Access Memory, SRAM), Programmable Read Only Memory (PROM), Read Only Memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), magnetic memory, disk , CD, etc. The memory 1102 is any other medium that can be used to carry or store desired program codes in the form of instructions or data structures and that can be accessed by a computer, but is not limited thereto. The memory 1102 in the embodiment of the present invention may also be a circuit or any other device capable of realizing a storage function, for storing program instructions and/or data.

Based on the same technical concept, an embodiment of the present invention provides a back-end device. As shown in FIG. 7, it includes at least one processor 1201 and a memory 1202 connected to the at least one processor. The embodiment of the present invention does not limit the processing. For the specific connection medium between the processor 1201 and the memory 1202, the connection between the processor 1201 and the memory 1202 in FIG. 7 is taken as an example. The bus can be divided into address bus, data bus, control bus, etc.

In the embodiment of the present invention, the memory 1202 stores instructions that can be executed by at least one processor 1201. By executing the instructions stored in the memory 1202, the at least one processor 1201 can execute the aforementioned transaction processing methods based on the blockchain system. Steps included.

Among them, the processor 1201 is the control center of the back-end equipment, which can use various interfaces and lines to connect to various parts of the back-end equipment, and by running or executing instructions stored in the memory 1202 and calling data stored in the memory 1202, Realize data processing. Optionally, the processor 1201 may include one or more processing units, and the processor 1201 may integrate an application processor and a modem processor, where the application processor mainly processes operating systems, application programs, etc., and the modem processor Mainly analyze the received instructions and analyze the received results. It can be understood that the foregoing modem processor may not be integrated into the processor 1201. In some embodiments, the processor 1201 and the memory 1202 may be implemented on the same chip, and in some embodiments, they may also be implemented on separate chips.

The processor 1201 may be a general-purpose processor, such as a central processing unit (CPU), a digital signal processor, an application specific integrated circuit (ASIC), a field programmable gate array or other programmable logic devices, discrete gates or transistors Logic devices and discrete hardware components can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of the present invention. The general-purpose processor may be a microprocessor or any conventional processor. The steps of the method disclosed in the embodiment of the transaction processing method based on the blockchain system can be directly embodied as executed by a hardware processor, or executed by a combination of hardware and software modules in the processor.

The memory 1202, as a non-volatile computer-readable storage medium, can be used to store non-volatile software programs, non-volatile computer-executable programs, and modules. The memory 1202 may include at least one type of storage medium, for example, may include flash memory, hard disk, multimedia card, card-type memory, random access memory (Random Access Memory, RAM), static random access memory (Static Random Access Memory, SRAM), Programmable Read Only Memory (PROM), Read Only Memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), magnetic memory, disk , CD, etc. The memory 1202 is any other medium that can be used to carry or store desired program codes in the form of instructions or data structures and that can be accessed by a computer, but is not limited thereto. The memory 1202 in the embodiment of the present invention may also be a circuit or any other device capable of realizing a storage function for storing program instructions and/or data.

The present invention is described with reference to flowcharts and/or block diagrams of methods, devices (systems), and computer program products according to embodiments of the present invention. It should be understood that each process and/or block in the flowchart and/or block diagram, and the combination of processes and/or blocks in the flowchart and/or block diagram can be implemented by computer program instructions. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing equipment to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing equipment are generated It is a device that realizes the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

These computer program instructions can also be stored in a computer-readable memory that can guide a computer or other programmable data processing equipment to work in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture including the instruction device. The device implements the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

These computer program instructions can also be loaded on a computer or other programmable data processing equipment, so that a series of operation steps are executed on the computer or other programmable equipment to produce computer-implemented processing, so as to execute on the computer or other programmable equipment. The instructions provide steps for implementing functions specified in a flow or multiple flows in the flowchart and/or a block or multiple blocks in the block diagram.

Although the preferred embodiments of the present invention have been described, those skilled in the art can make additional changes and modifications to these embodiments once they learn the basic creative concept. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments and all changes and modifications falling within the scope of the present invention.

Obviously, those skilled in the art can make various changes and modifications to the present invention without departing from the spirit and scope of the present invention. In this way, if these modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalent technologies, the present invention is also intended to include these modifications and variations.

Claims

A transaction processing method based on a blockchain system, characterized in that the method includes:

The first node in the blockchain system receives the transaction request sent by the client device, the transaction request includes the identification of the first transaction and the conflict processing instruction; the conflict processing instruction includes when the first transaction conflicts with the historical transaction The processing method for the first transaction, and/or the processing method for the first transaction when there is no conflict between the first transaction and the historical transaction;

The first node determines the conflict result of the first transaction according to the identifier of the first transaction, and the conflict result of the first transaction is used to indicate whether there is a conflict between the first transaction and the historical transaction;

The first node processes the first transaction according to the conflict result of the first transaction and the conflict processing instruction.
The method according to claim 1, wherein the transaction request further includes the contract address of the first transaction; the first node determines the conflict result of the first transaction according to the identifier of the first transaction, include:

The first node determines the key value of the first transaction according to the identifier of the first transaction and the contract address of the first transaction;

The first node obtains an identifier of a target historical transaction from a first preset database, and stores the identifier of the target historical transaction in a preset memory space; the first preset database includes a plurality of historical transaction identifiers and Key values of the multiple historical transactions, the target historical transaction is a historical transaction whose key value matches the key value of the first transaction in the first preset database;

If the first node determines that there is a target historical transaction matching the identifier of the first transaction in the preset memory space, it determines that there is a conflict between the first transaction and the historical transaction.
The method of claim 2, wherein the method further comprises:

If the first node determines that there is no target historical transaction matching the identifier of the first transaction in the preset memory space, input the identifier of the first transaction into the first preset filtering model; The preset filtering model is obtained by training using the transaction information of the multiple historical transactions, and the transaction information of each historical transaction includes the identifier, key value, transaction data, conflict processing instruction and the number of conflicts of each historical transaction;

If the output result of the first preset filtering model is that the first transaction does not conflict with the historical transaction, the first node determines that the first transaction does not conflict with the historical transaction.
The method according to claim 3, wherein the method further comprises:

If the output result of the first preset filtering model is that there is a conflict between the first transaction and the historical transaction, the first node compares the identifier of the first transaction with a plurality of items in the first preset database The identifiers of historical transactions are compared, and if it is determined that there is a historical transaction matching the identifier of the first transaction in the first preset database, it is determined that the first transaction conflicts with the historical transaction; If there is no historical transaction matching the identifier of the first transaction in the preset database, it is determined that there is no conflict between the first transaction and the historical transaction.
The method according to any one of claims 1 to 4, wherein the conflict processing instruction when there is no conflict between the first transaction and the historical transaction comprises executing the first transaction; the first transaction and the historical transaction The conflict handling instruction when there is a conflict in the transaction includes any one of the following: refusing to execute the first transaction, executing the first transaction, and redirecting the first transaction to a fault-tolerant contract;

The first node to process the first transaction according to the conflict result of the first transaction and the conflict processing instruction includes:

If there is no conflict between the first transaction and the historical transaction, and the conflict processing instruction is to execute the first transaction when there is no conflict between the first transaction and the historical transaction, or if the first transaction and the historical transaction If there is a conflict, and the conflict processing instruction is to execute the first transaction when there is a conflict between the first transaction and the historical transaction, the first node executes the first transaction; if the first transaction and the historical transaction are If there is a conflict, and the conflict processing instruction is to redirect the first transaction to a fault-tolerant contract when there is a conflict between the first transaction and the historical transaction, the first node executes the first transaction and obtains the The address of the fault-tolerant contract included in the conflict processing instruction sends the address of the fault-tolerant contract to the client device; if there is a conflict between the first transaction and the historical transaction, and the conflict processing instruction is the first transaction and When there is a conflict in the historical transaction and refuse to execute the first transaction, the first node sends a conflict indicator value to the client device, and the conflict indicator value is used to indicate that the first transaction conflicts with the historical transaction .
The method according to claim 5, wherein the execution of the first transaction by the first node comprises:

If the first node determines that the number of nodes that have reached a consensus on the first transaction in the blockchain system is greater than or equal to a preset threshold, generate block information corresponding to the first transaction;

The first node updates the first preset database and/or the preset memory space according to the block information of the first transaction.
The method according to claim 6, wherein after the first node generates the block information corresponding to the first transaction, the method further comprises:

The first node sends the block information corresponding to the first transaction to the client device, and the block information corresponding to the first transaction is used by the client device to correct the first transaction.
The method according to claim 6 or 7, wherein a first check value is stored in the first preset database, and the first check value is that the first node uses a preset check algorithm Obtained by verifying the multiple historical transactions stored in the first preset database;

The generation of block information corresponding to the first transaction by the first node includes:

Generating the initial block information corresponding to the first transaction by the first node;

The first node uses the preset check algorithm to check the first check value and the first transaction to obtain a second check value;

The first node adds the second check value to the initial block information to obtain block information corresponding to the first transaction.
The method according to claim 8, wherein the first node updating the first preset database and/or the preset memory space according to transaction information of the first transaction comprises:

The first node uses the identifier of the first transaction to train the first preset filtering model to obtain a second preset filtering model, and to set the preset memory space and/or all the data in the first preset database The first preset filtering model is updated to the second preset filtering model;

The first node adds the first transaction to the first preset database, and uses the second check value to update the preset memory space and/or the first preset database The first check value.
A transaction processing method based on a blockchain system, characterized in that the method includes:

The client device configures the identification of the first transaction and the conflict processing instruction;

Sending, by the client device, a transaction request to a first node in a blockchain system, the transaction request including the identifier of the first transaction and the conflict processing instruction;

The client device receives the address of the fault-tolerant contract sent by the first node, and calls the fault-tolerant processing module according to the address of the fault-tolerant contract to correct the first transaction.
The method according to claim 10, wherein the method further comprises:

Receiving, by the client device, block information corresponding to the first transaction sent by the first node;

The client device parses the block information corresponding to the first transaction to obtain the identifier of the first transaction;

If the client device determines that there is a historical transaction whose identifier matches the identifier of the first transaction in the second preset database of the client device, it uses the fault-tolerant processing module to perform processing on the first transaction according to preset processing rules. A transaction is corrected; the second preset database stores multiple historical transactions processed by the client device.
The method according to claim 11, wherein the preset processing rules include any one or any of output log records, output transaction records of the second preset database, invalid transactions, cancel transactions, and freeze subsequent transactions. Multiple.
A transaction processing device based on a blockchain system, characterized in that the device includes:

The transceiver module is configured to receive a transaction request sent by a client device, the transaction request including the identification of the first transaction and a conflict processing instruction; the conflict processing instruction includes a conflict between the first transaction and the historical transaction, the first transaction A transaction processing method, and/or the processing method of the first transaction when there is no conflict between the first transaction and the historical transaction;

A conflict detection module, configured to determine a conflict result of the first transaction according to the identifier of the first transaction, and the conflict result of the first transaction is used to indicate whether there is a conflict between the first transaction and a historical transaction;

The processing module is configured to process the first transaction according to the conflict result of the first transaction and the conflict processing instruction.
The device according to claim 13, wherein the transaction request further includes the contract address of the first transaction; the conflict detection module is configured to:

Determine the key value of the first transaction according to the identifier of the first transaction and the contract address of the first transaction;

Obtain the identifier of the target historical transaction from the first preset database, and store the identifier of the target historical transaction in a preset memory space; the first preset database includes the identifiers of multiple historical transactions and the multiple histories A key value of the transaction, where the target historical transaction is a historical transaction whose key value matches the key value of the first transaction in the first preset database;

If it is determined that there is a target historical transaction matching the identifier of the first transaction in the preset memory space, it is determined that the first transaction conflicts with the historical transaction.
The device according to claim 13, wherein the conflict detection module is further configured to:

If it is determined that there is no target historical transaction matching the identifier of the first transaction in the preset memory space, then the identifier of the first transaction is input into a first preset filtering model; the first preset filtering model is It is obtained by training using the transaction information of the multiple historical transactions, and the transaction information of each historical transaction includes the identification, key value, transaction data, conflict processing instruction and the number of conflicts of each historical transaction;

If the output result of the first preset filtering model is that there is no conflict between the first transaction and the historical transaction, it is determined that there is no conflict between the first transaction and the historical transaction.
The device according to claim 15, wherein the conflict detection module is further configured to:

If the output result of the first preset filtering model is that there is a conflict between the first transaction and the historical transaction, the identification of the first transaction is performed with the identification of multiple historical transactions in the first preset database In contrast, if it is determined that there is a historical transaction matching the identifier of the first transaction in the first preset database, it is determined that the first transaction conflicts with the historical transaction; if it is determined that there is no historical transaction in the first preset database If there is a historical transaction matching the identifier of the first transaction, it is determined that there is no conflict between the first transaction and the historical transaction.
The device according to any one of claims 13 to 16, wherein the conflict processing instruction when the first transaction does not conflict with the historical transaction comprises executing the first transaction; the first transaction and the historical transaction The conflict handling instruction when there is a conflict in the transaction includes any one of the following: refusing to execute the first transaction, executing the first transaction, and redirecting the first transaction to a fault-tolerant contract;

The processing module is used for:

If there is no conflict between the first transaction and the historical transaction, and the conflict processing instruction is to execute the first transaction when there is no conflict between the first transaction and the historical transaction, or if the first transaction and the historical transaction There is a conflict, and the conflict processing instruction is to execute the first transaction when there is a conflict between the first transaction and the historical transaction, then the first transaction is executed; if the first transaction conflicts with the historical transaction, and all The conflict processing instruction is to redirect the first transaction to a fault-tolerant contract when there is a conflict between the first transaction and the historical transaction, then execute the first transaction, and obtain the address of the fault-tolerant contract included in the conflict processing instruction , Sending the address of the fault-tolerant contract to the client device; if the first transaction conflicts with the historical transaction, and the conflict processing instruction is that the first transaction conflicts with the historical transaction, the first transaction is rejected A transaction, a conflict indicator value is sent to the client device, and the conflict indicator value is used to indicate that the first transaction conflicts with the historical transaction.
The device according to claim 17, wherein the processing module is configured to:

If it is determined that the number of nodes that reach a consensus on the first transaction in the blockchain system is greater than or equal to a preset threshold, generating block information corresponding to the first transaction;

Update the first preset database and/or the preset memory space according to the block information of the first transaction.
The device according to claim 18, wherein after the processing module generates the block information corresponding to the first transaction, it is further used for:

Sending the block information corresponding to the first transaction to the client device, where the block information corresponding to the first transaction is used by the client device to correct the first transaction.
The device according to claim 18 or 19, wherein a first check value is stored in the first preset database, and the first check value is that the first node uses a preset check algorithm Obtained by verifying the multiple historical transactions stored in the first preset database;

The processing module is specifically used for:

Generating initial block information corresponding to the first transaction;

Verifying the first verification value and the first transaction using the preset verification algorithm to obtain a second verification value;

The second check value is added to the initial block information to obtain block information corresponding to the first transaction.
The device according to claim 20, wherein the processing module is configured to:

Use the identifier of the first transaction to train the first preset filter model to obtain a second preset filter model, and use the preset memory space and/or the first preset in the first preset database The filtering model is updated to the second preset filtering model;

Add the first transaction to the first preset database, and use the second check value to update the preset memory space and/or the first calibration in the first preset database Value.
A transaction processing device based on a blockchain system, characterized in that the device includes:

The configuration module is used to configure the identification of the first transaction and conflict handling instructions;

The transceiver module is configured to send a transaction request to the first node in the blockchain system, the transaction request including the identifier of the first transaction and the conflict processing instruction; and to receive the fault-tolerant contract sent by the first node the address of;

The correction module is used to call the fault-tolerant processing module to correct the first transaction according to the address of the fault-tolerant contract.
The device of claim 22, wherein:

The transceiver module is further configured to: receive block information corresponding to the first transaction sent by the first node;

The correction module is further configured to: parse the block information corresponding to the first transaction to obtain the identifier of the first transaction; if it is determined that the identifier and the first transaction exist in the second preset database of the client device For historical transactions that match the transaction identifier, use the fault-tolerant processing module to correct the first transaction in accordance with preset processing rules; the second preset database stores multiple historical transactions processed by the client device .
The device according to claim 23, wherein the preset processing rules include any one or any of output log records, output transaction records of the second preset database, invalid transactions, cancel transactions, and freeze subsequent transactions. Multiple.
A computer-readable storage medium, characterized by comprising instructions, which when run on a processor of a computer, causes the processor of the computer to execute the method according to any one of claims 1 to 12.
A computer program product, characterized in that, when it runs on a processor of a computer, it causes the processor of the computer to execute the method according to any one of claims 1 to 12.