WO2020259417A1 - Data analysis method and device for block chain - Google Patents

Abstract

A data analysis method and device for a block chain, being used for reducing the cost for analyzing data in a block chain and improving the performance of data analysis. Said method comprises: acquiring a smart contract of a user service, the smart contract comprising a construction method, an event method and a non-constant method which are used for creating and implementing the user service (S21); generating data analysis codes according to at least one method among the construction method, the event method and the non-constant method, the data analysis codes comprising event data analysis codes for analyzing event data of the user service and transaction data analysis codes for analyzing transaction data of the user service (S22); and using the data analysis codes to analyze data in all blocks in a block chain, so as to acquire the event data and the transaction data (S23).

Description

Data analysis method and device of blockchain

Cross references to related applications

This application claims the priority of a Chinese patent application filed with the Chinese Patent Office on June 24, 2019, the application number is 201910550186.0, and the application name is "a data analysis method and device for blockchain", the entire content of which is incorporated by reference In this application.

Technical field

The present invention relates to the field of Fintech, in particular to a data analysis method and device of a blockchain.

Background technique

The combination of Blockchain technology and the financial field has made the traditional financial industry gradually transforming into Finteh. In technology finance combined with blockchain technology, it is more important to process data in the blockchain (for example, contract account data, transaction data, and event data), such as analyzing data or synchronizing data.

For analyzing data, two solutions are currently proposed:

The first solution is to design a set of dedicated interfaces at the level of smart contracts. When business needs, the dedicated interfaces in the smart contracts are intelligently invoked to analyze the data in the blockchain.

The second solution: save the address of the data to be parsed on the blockchain in advance, and then call the relevant interface according to the address to obtain the data.

However, for the above-mentioned first solution, since the code of the dedicated interface needs to occupy a certain amount of storage space, especially when the number of dedicated interfaces is large, the dedicated interface will cause a large storage space overhead and cause higher costs. Moreover, when the dedicated interface is complicated, it may be necessary to call different interfaces multiple times to obtain data, resulting in poor performance. As for the second solution, since the address is for a specific smart contract, when there is a new business or smart contract change, it cannot be reused, and the code needs to be revised by the technical staff, and the second solution is getting For data, it is necessary to calculate the data address according to the addressing rules in the data structure definition, which increases the amount of calculation.

It can be seen that there are technical problems of high cost and poor performance in parsing data in the blockchain in the prior art.

Summary of the invention

The invention provides a block chain data analysis method and device, which are used to reduce the cost of analyzing data in the block chain and improve the performance of data analysis.

The first aspect of the present invention provides a block chain data analysis method, the method includes:

Acquiring a smart contract for a user service, the smart contract including a construction method, an event method, and a non-constant method for creating and realizing the user service;

According to at least one of the construction method, event method, and non-constant method, a data analysis code is generated. The data analysis code includes event data analysis code for analyzing event data of the user service and Transaction data analysis code for analyzing transaction data of the user service;

The data analysis code is used to analyze the data in each block in the blockchain to obtain the event data and the transaction data.

In the embodiment of the present application, the process of generating the event data analysis code and the transaction data analysis code has different generation methods depending on the method that it relies on.

In a possible implementation manner, generating the event data parsing code according to at least one of the construction method, event method, and non-constant method includes:

Compile the smart contract to obtain a JAVA contract file corresponding to the smart contract. The JAVA contract file includes at least an acquisition method for acquiring an event object in the event method and an event class corresponding to the event method And the binary code of the smart contract, the binary code of the smart contract includes at least the construction method, the event method, and the non-constant method each of which accesses the field type of the blockchain;

Load the JAVA contract file, and obtain the event class through reflection;

Through the first mapping relationship between the JAVA object and the first field type, the field in the event class with the same type as the first field is converted into a JAVA object, thereby obtaining the first POJO corresponding to the event class Object, the first field type is a field type used to access the blockchain in the event method;

The first POJO object is filled into a preset event data analysis template to generate the event data analysis code. The preset event data analysis function template at least includes a calling module, a first analysis module, and a first instantiation Module and a first storage module, the calling module is used to call the acquisition method, the first parsing module is used to parse the event object and obtain the parsed event data, the first instantiation module is used to The parsed event data is converted into a first POJO object instance, and the first storage module is used to insert the first POJO object instance into a database table, and the database table is used to store the event data and the transaction data.

Correspondingly, using the event data analysis code to analyze the data in each block in the blockchain to obtain the event data includes:

Acquiring one of the blocks in the blockchain, where the one of the blocks is any block in the blockchain;

Run the event data analysis code, obtain a list of event objects in the block through the calling module in the event data analysis code, the event object list including at least one value of the event object;

Parsing at least one value of the event object through the parsing module in the event data parsing code to obtain at least one parsed event data;

The at least one parsed event data is respectively converted into at least one first POJO object instance through the instantiation module in the event data analysis code, and the at least one first POJO object instance and the at least one parsed One-to-one correspondence of event data;

The at least one POJO object instance is inserted into the database table through the storage module in the event data analysis code.

In a possible implementation manner, generating the transaction data analysis code according to at least one of the construction method, the event method, and the non-constant method includes:

Compile the smart contract to obtain a JAVA contract file corresponding to the smart contract. The JAVA contract file includes at least the binary code and binary string of the smart contract, and the binary code of the smart contract includes at least the Each of the construction method and the non-constant method accesses the field type of the blockchain, and the binary string is the recursive length prefix code of the smart contract;

Load the JAVA contract file, parse the binary code, and obtain a transaction method, the transaction method including the construction method and the non-constant method;

Through the second mapping relationship between the JAVA object and the second field type, the field in the transaction method with the same type as the second field is converted into a JAVA object, thereby obtaining the second POJO corresponding to the transaction method Object, the second field type is a field type used to access the blockchain in the transaction method;

The second POJO object is filled with a preset transaction data analysis template to generate the transaction data analysis code. The preset transaction data analysis template includes at least a matching module, a second analysis module, a second instantiation module, and a first Two storage modules, the matching module is used to determine whether the transaction method is the construction method or the non-constant method, the second analysis module is used to parse the transaction method and obtain transaction data, the second The instantiation module is used to convert transaction data into a second POJO object instance, and the second storage module is used to insert the second POJO object instance into a database table that is used to store the event data and The transaction data.

In the embodiment of the present application, obtaining transaction data according to the transaction data analysis code may include but not limited to the following two situations:

In the first case, using the transaction data analysis code to analyze the data in each block in the blockchain to obtain the transaction data includes:

Acquiring one of the blocks in the blockchain, where the one of the blocks is any block in the blockchain;

Obtain the first transaction in the block through a preset transaction acquisition interface;

Run the transaction data analysis code, obtain the target field in the first transaction through the matching module in the transaction data analysis code, and determine the transaction type of the first transaction according to the target field, the transaction type including the first transaction A transaction type and a second transaction type, the first transaction type is a transaction type corresponding to the construction method, the second transaction type is a transaction type corresponding to the non-constant method, and the target field is used for Indicating the transaction partner of the first transaction;

When it is determined that the transaction type of the first transaction is the first transaction type, obtain the recursive length prefix code of the first transaction through the matching module, and determine whether the recursive length prefix code of the first transaction includes all The binary string;

If yes, the first remaining character string is parsed through the second parsing module in the transaction data analysis code to obtain the first transaction data of the first transaction, and the first remaining character string is the In the recursive length prefix encoding of the first transaction, the character string after removing the same symbol as the binary character string;

Convert the first transaction data into a second POJO object instance through the second instantiation module in the transaction data analysis code;

The second POJO object instance is inserted into the database table through the second storage module in the transaction data analysis code.

In the second case, after running the transaction data analysis code, the target field in the first transaction is obtained through the matching module in the transaction data analysis code, and the transaction type of the first transaction is determined according to the target field , The method further includes:

When the transaction type of the first transaction is the second transaction type, obtain the recursive length prefix code of the first transaction through the matching module, and determine whether the recursive length prefix code of the first transaction includes the The signature of the non-constant method corresponding to the transaction data analysis code;

If yes, the second remaining code is analyzed through the second analysis module in the transaction data analysis code to obtain the second transaction data of the first transaction, and the second remaining code is the first The code of the transaction removes the character string after the same symbol as the signature;

Converting the second transaction data into a second POJO object instance through the second instantiation module in the transaction data analysis code;

Insert the second POJO object instance into the database table through the second storage module in the transaction data analysis code.

A second aspect of the present invention provides an electronic device, including:

At least one processor; and,

A memory communicatively connected with the at least one processor; wherein,

The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor, so that the at least one processor can execute the blockchain data analysis method.

A third aspect of the present invention provides a non-transitory computer-readable storage medium, the non-transitory computer-readable storage medium stores computer instructions, and the computer instructions are used to make the computer execute the data analysis of the blockchain method.

In the fourth aspect of the present invention, a computing device includes: a memory for storing a computer program; a processor for calling the computer program stored in the memory, and executing various possible designs as in the first aspect according to the obtained program The method described in.

In the embodiment of the present invention, the code for analyzing data can be automatically generated according to the smart contract of the user's business. That is to say, for different user services, the user only needs to import the smart contract corresponding to each user's business. New interfaces or no need to pre-store the code for data analysis, which can reduce the storage space occupied by the code for data analysis, and can reduce the cost of parsing data in the blockchain. Moreover, the code generated according to the smart contract corresponds to the interface in the smart contract one-to-one. Therefore, during data analysis, there is no need to call multiple interfaces or calculate the address of the data to be parsed, which can improve data analysis. performance.

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, without creative work, other drawings can be obtained from these drawings.

FIG. 1 is a structural block diagram of a system architecture applicable to a data analysis method provided by an embodiment of the present invention;

FIG. 2 is a flowchart of a data analysis method of a blockchain provided by an embodiment of the present invention;

3 is a flowchart of generating event data analysis code in an embodiment of the present invention;

4 is a flowchart of generating transaction data analysis code in an embodiment of the present invention;

5 is a flowchart of analyzing event data in a block in an embodiment of the present invention;

FIG. 6 is a flowchart of analyzing transaction data of the first transaction in a block in an embodiment of the present invention;

FIG. 7 is a structural diagram of another example of data analysis of the blockchain provided in the embodiment of the present invention.

Detailed ways

The invention provides a block chain data analysis method and device, which are used to reduce the cost of analyzing data in the block chain and improve the performance of data analysis.

For ease of understanding, the following defines and explains the terms that may be involved in the embodiments of the present invention.

Blockchain: A chain composed of a series of blocks. In addition to recording the data of the block, each block also records the Hash value of the previous block. In this way, a chain is formed. There are two core concepts of the blockchain, one is cryptography and the other is decentralization. Based on these two concepts, the historical information on the blockchain cannot be tampered with. A block consists of a block header and a block body. The block header definition includes important fields such as the block height h, the hash value prevHash of the previous block, and the block body mainly stores transaction data.

Smart contract: It is a computer protocol designed to spread, verify or execute the contract in an information-based way. The execution process of the smart contract will be agreed and confirmed on the blockchain in the form of a transaction, which allows the absence of a third party Conduct trusted transactions, which are traceable and irreversible.

web3jsdk: The bridging layer for JAVA language to access the blockchain, and provides related application programming interfaces (Application Programming Interface, API) to access the blockchain.

Solidity: A high-level language for smart contracts, running on the Ethernet Virtual Machine (EVM), mainly used to write smart contracts.

JAVA: An object-oriented programming language for writing desktop applications, Web applications, distributed systems, and embedded system applications.

opcode: The operating instructions after the smart contract is compiled.

Event: A method type of smart contract that can store parameters in the transaction log to facilitate tracking of the execution of the smart contract.

Simple Java Objects (Plain Ordinary Java Object, POJO): Actually they are ordinary JavaBeans, which can be understood as interfaces, classes and objects in JAVA.

Recursive Length Prefix (RLP): It is an encoding rule that can be used to encode arbitrary nested binary array data. The result of RLP encoding is also a binary sequence, which is mainly used to serialize/deserialize data.

Application Binary Interface (ABI): describes the low interface between an application and an operating system, between an application and its library, or between components of an application.

It should be noted that the first and second in the embodiment of the present invention are only used to distinguish different objects, and do not indicate the importance or priority of each object.

Below, the application scenarios in the embodiments of the present invention are introduced.

FIG. 1 exemplarily shows a system architecture applicable to a data analysis method provided by an embodiment of the present invention. The system architecture may include a data analysis device 100 and a blockchain 200. It should be noted that in FIG. 1, the data analysis device 100 and the blockchain 200 are two independent modules. In other examples, the data analysis device 100 can also be installed in the blockchain 200, which is not used here. limit.

Among them, the blockchain 200 may include multiple blocks. For example, in the system architecture shown in FIG. 1, the blockchain 200 includes two blocks, namely block A and block B. In each block, multiple smart contracts can be set according to the user's business. For example, smart contract 1 is set in block A, and smart contract 2 is set in block B.

The data analysis device 100 can obtain and analyze any type of data in each block in the blockchain 200 through different interfaces. For example, it can obtain contract account data through a contract interface, and block data can be obtained through a block interface. These two kinds of data are not parsed. However, since the event data and transaction data in the blockchain rely on smart contracts and are relatively complicated, the data analysis device 100 needs to analyze these two types of data.

In the prior art, when analyzing event data or transaction data, either a dedicated interface corresponding to each smart contract is preset, or the address of the data to be parsed is stored in advance. For details, please refer to the first type described in the background art. The solution and the second solution will not be repeated here. However, using the methods in the prior art to analyze event data or transaction data has technical problems of high cost and poor performance.

In order to solve the above technical problems, the present invention provides a data analysis method for blockchain, which is applied to the data analysis device 100 shown in FIG. 1. Please refer to Figure 2 for the flow chart of the method, which is described as follows:

S21. Acquire a smart contract for a user service, where the smart contract includes a construction method, an event method, and a non-constant method for creating and realizing the user service.

In the specific implementation process, the data analysis device 100 may obtain the smart contract provided by the user through a preset interface, or may also obtain the smart contract in other ways, which is not limited in the embodiment of the present invention. Smart contracts can be written in different programming languages. For the convenience of explanation, the following uses smart contracts as smart contracts written in the Solidity programming language as an example.

As an example, assuming that the user service is to save user information (UserInfo), the UserInfo smart contract obtained by the data analysis device 100 may be as follows:

Contract UserInfo{

bytes32_userName;

uint8_sex;

function UserInfo(bytes32userName,uint8sex)public{

_userName=userName;

_sex=sex;

}

event modifyUserNameEvent(bytes32userName, uint8sex, address con);

function modifyUserName(bytes32userName)public returns(bytes32){

_userName=userName;

modifyUserNameEvent(_userName,_sex,address(this));

return_userName;

}

}

The UserInfo smart contract includes a construction method for creating an instance of the UserInfo smart contract, namely:

function UserInfo(bytes32userName,uint8sex)public{

_userName=userName;

_sex=sex;

}

And, an event method used to record the user's information after each user name modification, namely: event modifyUserNameEvent(bytes32userName, uint8sex, address con). And, a constant method for modifying the user's name, namely:

function modifyUserName(bytes32userName)public returns(bytes32){

_userName=userName;

modifyUserNameEvent(_userName,_sex,address(this));

return_userName;

}

In the above UserInfo smart contract, the smart contract only includes a composition method, an event method, and a non-constant method. It should be understood as an example of a smart contract, rather than restricting the smart contract to only include one construction method, An event method and a non-constant method. In actual use, a smart contract can also include multiple construction methods or multiple event methods or multiple non-constant methods, which will not be repeated here.

S22. Generate a data analysis code according to at least one of the construction method, the event method, and the non-constant method.

In the embodiment of the present invention, it is mainly used to analyze transaction data and event data in a block. Therefore, the generated data analysis code includes event data analysis code for analyzing the event data of the user service and The transaction data analysis code for analyzing the transaction data of the user service.

Below, the generation process of the event data analysis code and the generation process of the transaction data analysis code will be introduced respectively.

For the event data analysis code, please refer to Figure 3, which is a flowchart for generating event data analysis code. The flowchart is described as follows:

S31. Compile the smart contract to obtain a JAVA contract file corresponding to the smart contract.

Before generating the event data analysis code according to the smart contract, the smart contract must be compiled through the compiler to obtain the compiled contract file.

As an example, a smart contract can be compiled into a JAVA code file by a compiler. Continuing to take the smart contract as the UserInfo smart contract as an example, the code to compile the UserInfo smart contract can be as follows:

pragma solidity^0.4.7;

Contract UserInfo{

bytes32_userName;

uint8_sex;

function UserInfo(bytes32userName,uint8sex)public{

_userName=userName;

_sex=sex;

}

event modifyUserNameEvent(bytes32userName, uint8sex, address con);

function modifyUserName(bytes32userName)public returns(bytes32){

_userName=userName;

modifyUserNameEvent(_userName,_sex,address(this));

return_userName;

}

}

After compiling the UserInfo smart contract with the above code, the corresponding JAVA file is obtained, and the JAVA file is the JAVA contract file. Of course, depending on the programming language used for compilation, the contract file can also be other types of files. For example, if the PHP programming language is used to compile, a compiled PHP file is obtained, and the type of contract file is not limited here. For the convenience of explanation, in the following, the contract file is a JAVA file as an example.

In the embodiment of the present invention, the JAVA contract file includes at least an acquisition method for acquiring an event object in the event method, an event class corresponding to the event method, and the binary code of the smart contract. The binary code in the smart contract includes at least the construction method, the event method, and the non-constant method to access the field type of the blockchain.

Specifically, when the UserInfo smart contract is compiled with a JAVA compiler, a JAVA file including but not limited to the following contents can be obtained:

In the above JAVA file, getModifyUserNameEventEvents is the method used to obtain the event object in the event method, public static class ModifyUserNameEventResponse{} is the event class corresponding to the event method, String ABI is the binary code of the smart contract, and the ABI is Including the types, input parameters, output parameters of all methods in the smart contract, and the field types and field names used by each method to access the blockchain. The binary string is the RLP code of the smart contract and is used to The contract instance is signed. Of course, the JAVA file may also include other content, and no examples are given here.

S32. Load the JAVA contract file, and obtain the event class through reflection.

In the above JAVA file, the event class is modifyUserNameEvent class.

S33. Through the first mapping relationship between the JAVA object and the first field type, the field in the event class with the same type as the first field is converted into a JAVA object, so as to obtain the first field corresponding to the event class. A POJO object.

In the embodiment of the present invention, the first field type is the field type used to access the blockchain in the event method. As an example, the first field type may be a web3jsdk type.

Following the above example, after obtaining the modifyUserNameEvent class in the JAVA file, first locate the field in the modifyUserNameEvent class whose field type is the web3jsdk type. For example, the web3jsdk type field may include Bytes32, Uint8, and Address. Then, according to the first mapping relationship, the field is converted into a JAVA object. The first mapping relationship may be: Bytes32 corresponds to String, Uint8 corresponds to int, and Address corresponds to String. The first mapping relationship may be pre-stored in the data analysis apparatus 100. After converting the web3jsdk type field in the JAVA file into a JAVA object, the first POJO object corresponding to the modifyUserNameEvent class can be generated. For example, the code of the POJO object with modifyUserNameEvent class is as follows:

S34. Fill the first POJO object into a preset event data analysis template, and generate the event data analysis code.

The applicant has studied the event data analysis process and learned that: for all event data, the processing process is basically the same, which can be divided into the following steps: call the get function to obtain the event object, then parse the event object, and obtain the event data of the event object , And then convert the parsed event data into a JAVA object instance, thereby inserting the JAVA object instance into the database table. Therefore, in the embodiment of the present invention, the processing flow can be preset to multiple modules to form a preset event data analysis template, which is stored in the data analysis device 100, so that when the event in the smart contract to be analyzed is obtained After the object, directly fill the event object into the preset event data analysis template according to the field type, so as to obtain the event data analysis code for analyzing the event data in the smart contract. In this way, when analyzing event data in different smart contracts, you only need to obtain the corresponding smart contract, without adding new interfaces or re-modifying the code, the implementation method is simple, and secondary development is supported.

As an example, the preset event data analysis function template includes at least a calling module, a first analysis module, a first instantiation module, and a first storage module. Wherein, the calling module is used to call the obtaining method, the first parsing module is used to parse the event object and obtain the parsed event data, and the first instantiation module is used to convert the parsed event data into the first A POJO object instance, and the first storage module is used to insert the first POJO object instance into a database table, and the database table is used to store the event data and the transaction data.

For the transaction data analysis code, please refer to Figure 4, which is a flowchart of generating transaction data analysis code, which is described as follows:

S41. Compile the smart contract to obtain a JAVA contract file corresponding to the smart contract.

In the embodiment of the present invention, the JAVA contract file includes at least the binary code and the binary string of the smart contract, and the binary code includes at least the construction method and each of the non-constant methods. The field type of the blockchain, the binary string is the recursive length prefix code of the smart contract.

Step S41 is the same as step S31, and will not be repeated here.

S42. Load the JAVA contract file, parse the binary code, and obtain a transaction method.

After loading the JAVA file, obtain the ABI character string in the JAVA file, parse the ABI character string, and obtain the transaction method in the JAVA file. For example, you can get the name of the transaction method and parameter fields. The transaction method includes the construction method and the non-constant method in step S21, which will not be repeated here.

As another example, the transaction method can also be obtained from an operation instruction (opcode), for example, after obtaining the opcode in the JAVA file, the opcode is parsed to obtain the transaction method in the opcode.

In order to ensure the accuracy of the acquired transaction method, after acquiring the transaction method, you can determine whether the transaction method is a construction method or a non-constant method according to the name and/or parameter field of the acquired transaction method. If not, exit the process If yes, continue with the subsequent process.

S43. Through the second mapping relationship between the JAVA object and the second field type, the field in the transaction method with the same type as the second field is converted into a JAVA object, so as to obtain the second field corresponding to the transaction method. Two POJO objects, the second field type is the field type used to access the blockchain in the transaction method.

In the embodiment of the present invention, the second field type is the field type used to access the blockchain in the transaction method. As an example, the second field type may be the same as the first field type, for example, web3jsdk type, or the second field type may also be another type different from the first field type, which is not limited here.

Step S43 is similar to step S33 and will not be repeated here.

S44. Fill the second POJO object with a preset transaction data analysis template, and generate the transaction data analysis code.

Similar to the principle in step S34, the applicant obtains the transaction data processing process by studying the transaction data analysis process and is divided into steps: because transaction data analysis is more complicated, there is no way to directly locate it like event data (for example, different directly through get Function acquisition), the transaction can only be matched by the matching method, so as to determine whether the transaction method is a construction method or a non-constant method, and then analyze the encoding string of the transaction method (such as RLP encoding string) to obtain the transaction data of the transaction method, In this way, the parsed transaction data is converted into a POJO object instance, and the POJO object instance is inserted into the database table according to the field type. Therefore, in the embodiment of the present invention, the processing flow can be preset to multiple modules to form a preset transaction data analysis template, which is stored in the data analysis device 100, so that when the transaction in the smart contract to be analyzed is obtained After the method, the POJO object corresponding to the transaction method is directly filled into the preset transaction data analysis template, so as to obtain the transaction data analysis code used to analyze the transaction data in the smart contract.

As an example, the preset transaction data analysis template includes at least a matching module, a second analysis module, a second instantiation module, and a second storage module. Wherein, the matching module is used to determine whether the transaction method is the construction method or the non-constant method, the second analysis module is used to analyze the transaction method and obtain transaction data, and the second instantiation module is used to The transaction data is converted into a second POJO object instance, and the second storage module is used to insert the second POJO object instance into a database table.

It should be noted that when the smart contract includes both event methods and transaction methods, the data analysis device 100 may first generate the event data analysis code and then generate the transaction data analysis code; or it may first generate the transaction data analysis code and then regenerate The event data analysis code is generated, or the transaction data analysis code and the event data analysis code are generated in parallel, and the order of execution is not restricted here.

S23. Use the data analysis code to analyze the data in each block in the blockchain to obtain the data.

After obtaining the transaction data analysis code and event data analysis code corresponding to the smart contract, you can run the transaction data analysis code and event data analysis code to obtain the transaction data and event data corresponding to the smart contract in each block .

The method for obtaining event data and the method for obtaining transaction data are respectively described below.

For event data, please refer to Figure 5, which is a flowchart of using event data parsing code to obtain event data. The flowchart is described as follows:

S51. Obtain one of the blocks in the block chain, where the one block is any block in the block chain.

The data analysis device 100 can obtain each block in the block chain in turn. For example, taking the block chain shown in FIG. 1 as an example, block A is first obtained, and after analyzing the event data in block A, Get block B. Alternatively, the data analysis device 100 can also randomly acquire one of the blocks, which is not limited here. It should be noted that, for each block, the method of obtaining the event data in the block is the same. In the following, one of the blocks in the blockchain is used as an example for description.

S52. Run the event data analysis code, and obtain the event object list in the block through the calling module in the event data analysis code.

After the data analysis device 100 acquires a block, it calls the generated event data analysis code, and determines whether there is event data corresponding to the smart contract in the block by calling the module. It can be understood that if the corresponding module can be obtained by calling the module A list of event objects indicates that there is event data corresponding to the smart contract in the block, otherwise, the event data corresponding to the smart contract is not included.

For the aforementioned UserInfo smart contract, the calling module will obtain the corresponding event data list through the get function, for example, getModifyUserNameEventEvents, for example, List<ModifyUserNameEventResponse>. If the List<ModifyUserName--EventResponse> can be obtained, it indicates the block Event data exists in the block, otherwise, there is no event data in the block.

In the embodiment of the present invention, the event object list includes at least one value of the event object. For example, for the userName in the aforementioned UserInfo smart contract, at the first moment, the user sets userName as the first value, and at the second moment, the user sets userName as the second value, then the event object list corresponding to userName , It includes the first value and the second value.

In addition, it should be noted that, in the embodiment of the present invention, the UserInfo smart contract includes only one event method, so that the data analysis device 100 only generates one event data analysis code, but in actual use, a smart contract may include Multiple event methods, thus, the data analysis device 100 generates multiple event data analysis codes for one smart contract. In this case, when the data analysis device 100 analyzes event data in a block, it needs to traverse multiple event data analysis codes corresponding to the smart contract. If all event data analysis codes are run, the event data cannot be obtained. List, it means that there is no event data in the block, otherwise there is event data in the block.

S53: Parse at least one value of the event object through the parsing module in the event data parsing code to obtain at least one parsed event data.

After obtaining at least one value of the event object, the at least one value is analyzed by the parsing module, so as to obtain corresponding event data.

S54. Convert the at least one parsed event data into at least one first POJO object instance through the instantiation module in the event data analysis code.

Specifically, the at least one POJO first object instance corresponds to the at least one parsed event data in a one-to-one correspondence. For example, if the event object includes two values, the two values are parsed to obtain two event data, and then each event data is converted into a POJO object instance to obtain two first POJO object instances.

S55. Insert the at least one POJO object instance into the database table through the storage module in the event data analysis code.

After obtaining the first POJO object instance corresponding to each event data, insert the obtained first POJO object instance into the database table to complete the process of analyzing and synchronizing the event data.

For transaction data, please refer to Figure 6, which is a flow chart of using transaction data analysis code to obtain transaction data. The flow chart is described as follows:

S601. Obtain one of the blocks in the blockchain, where the one block is any block in the blockchain.

Step S601 is the same as step S51, and will not be repeated here.

S602. Obtain the first transaction in the block through a preset transaction acquisition interface.

The transaction acquisition interface is similar to that in the prior art, and will not be repeated here.

S603. Run the transaction data analysis code, obtain the target field in the first transaction through the matching module in the transaction data analysis code, and determine the transaction type of the first transaction according to the target field.

In the embodiment of the present invention, the transaction type includes a first transaction type and a second transaction type, the first transaction type is a transaction type corresponding to the construction method, and the second transaction type is related to the extraordinary transaction type. The transaction type corresponding to the volume method. The target field is used to indicate the transaction object of the first transaction. As an example, the target field is the To field. After obtaining the first transaction, run the transaction data analysis code to obtain the To field in the transaction, and determine whether it is null. If it is null, determine that the first transaction is the first transaction type, otherwise, determine the The first transaction is the second transaction type.

In the embodiment of the present application, when the transaction type of the first transaction is determined to be the first transaction type, step S604 to step S606 and step S610 are executed, and when the transaction type of the first transaction is determined to be the second transaction type, execute Step S607 to step S610.

In addition, similar to the event data analysis process, if the data analysis device 100 generates multiple transaction data analysis codes for a smart contract, the data analysis device 100 needs to traverse multiple transaction data analysis codes corresponding to the smart contract. In the embodiment, an example of running a transaction data analysis code is described.

S604. When the transaction type of the first transaction is the first transaction type, obtain the recursive length prefix code of the first transaction through the matching module, and determine whether the recursive length prefix code of the first transaction includes The binary string.

In the embodiment of the present invention, the storage format of the transaction data corresponding to the construction method is: binary+encode(data), where binary is the RLP encoded string of the smart contract, and encode is the encoding function of the transaction data. Therefore, when it is determined that the transaction type of the first transaction is the transaction type corresponding to the construction method, it is necessary to compare the binary strings of all smart contracts to determine which smart contract construction method corresponds to the transaction.

Specifically, the construction method in the aforementioned UserInfo smart contract is UserInfo(bytes32userName,uint8sex). When it is determined that the first transaction is the transaction corresponding to the construction method, the binary (length M) in the JAVA file of the UserInfo smart contract is obtained, and then the RLP code (length N) of the first transaction is obtained. The first M strings of the RLP code of the transaction are the same as the binary in the JAVA file, and the first transaction is obtained by executing the construction method of the UserInfo smart contract.

S605. When it is yes, parse the first remaining character string through the second parsing module in the transaction data analysis code to obtain the first transaction data of the first transaction, where the first remaining character string is In the recursive length prefix encoding of the first transaction, the character string after the same symbol as the binary character string is removed.

After determining that the first M character strings of the RLP code of the first transaction are the same as the binary in the JAVA file, remove the first M characters of the RLP code of the first transaction, that is, remove the binary header of the first transaction to obtain the length Is the first remaining string of (NM), and then decode(data) is performed on the first remaining string. The decode() operation is calculated according to the type offset of each field to obtain each of the first transaction The value of the field, the value of each field is at least one piece of first transaction data.

Specifically, the first transaction is obtained from the execution of the UserInfo smart contract construction method, and the values of the field userName and the field sex can be obtained by parsing, and then the values of these two fields are parsed, and the first transaction is obtained At least one first transaction data.

S606: Convert the first transaction data into a second POJO object instance through the second instantiation module in the transaction data analysis code.

Step S606 is similar to step S54 and will not be repeated here.

S607. When the transaction type of the first transaction is the second transaction type, obtain the recursive length prefix code of the first transaction through the matching module, and determine whether the recursive length prefix code of the first transaction includes The signature of the non-constant method corresponding to the transaction data analysis code.

In the embodiment of the present invention, the storage format of the transaction data corresponding to the non-constant method is: functionSignature+encode(data), where the functionSignature is the signature of the non-constant method. Therefore, when the transaction type of the first transaction is determined to be the transaction type corresponding to the non-constant method, it is necessary to compare the signatures of the non-constant method of all smart contracts to determine which non-constant method corresponds to the transaction.

Specifically, the non-constant method in the aforementioned UserInfo smart contract is modifyUserName(bytes32userName). When it is determined that the first transaction is a transaction corresponding to a non-constant method, the signature of the modifyUserName (bytes32userName) method in the JAVA file of the UserInfo smart contract (length L) is obtained, and then the RLP code (length Is N). If the first L character strings of the RLP encoding of the first transaction are the same as the signature of the modifyUserName(bytes32userName) method, then the first transaction is obtained by executing the non-constant method of the UserInfo smart contract.

S608. If yes, analyze the second remaining code through the second analysis module in the transaction data analysis code to obtain the second transaction data of the first transaction, where the second remaining code is the In the encoding of the first transaction, the character string after the same symbol as the signature is removed.

After determining that the first L character strings of the RLP code of the first transaction are the same as the signature of the modifyUserName(bytes32userName) method, remove the first L characters of the RLP code of the first transaction, that is, remove the signature header of the first transaction, Obtain the second remaining string of length (NL), and then perform a decode(data) operation on the second remaining string to obtain the value of each field in the first transaction. The value of each field is at least one The first transaction data.

Specifically, the first transaction is obtained by executing the non-constant method of the UserInfo smart contract, and the values of the fields userName, sex, and address can be obtained by parsing, and then the values of these three fields are analyzed to obtain At least one piece of first transaction data in the first transaction.

S609: Convert the second transaction data into a second POJO object instance through the second instantiation module in the transaction data analysis code.

S610: Insert the second POJO object instance into the database table through the second storage module in the transaction data analysis code.

Steps S609 to S610 are similar to steps S54 to S55, and will not be repeated here.

In the above technical solution, the code for analyzing data is generated automatically according to the smart contract of the user's business. That is to say, for different user's business, only the user needs to import the smart contract corresponding to each user's business. Adding an interface or pre-storing the code for data analysis can reduce the storage space occupied by the code for data analysis, and can reduce the cost of parsing data in the blockchain. Moreover, the code generated according to the smart contract corresponds to the interface in the smart contract one-to-one. Therefore, during data analysis, there is no need to call multiple interfaces or calculate the address of the data to be parsed, which can improve data analysis. performance.

A third aspect of the present invention provides a block chain data analysis device. Please refer to FIG. 7, which is a structural diagram of the data analysis device. The data analysis device includes a processor 701, a transceiver 702, and a memory 703. The processor 701, the memory 703, and the transceiver 702 are connected through a bus interface;

The processor 701 controls the transceiver 702 to obtain a smart contract of a user service, and the smart contract includes a construction method, an event method, and a non-constant method for creating and realizing the user service;

The processor 701 generates data analysis code according to at least one of the construction method, the event method, and the non-constant method. The data analysis code includes event data analysis code for analyzing event data of the user service and Transaction data analysis code used to analyze the transaction data of the user service; and,

The data analysis code is used to analyze the data in each block in the blockchain to obtain the event data and the transaction data.

Optionally, the processor 701 may specifically be a central processing unit, an application specific integrated circuit (English: Application Specific Integrated Circuit, abbreviated as: ASIC), may be one or more integrated circuits used to control program execution, and may be used on-site The hardware circuit developed by the programmable gate array (English: Field Programmable Gate Array, referred to as FPGA) can be a baseband processor.

Optionally, the processor 701 may include at least one processing core.

Optionally, the electronic device further includes a memory 703. The memory 703 may include a read-only memory (English: Read Only Memory, abbreviated as: ROM), a random access memory (English: Random Access Memory, abbreviated as: RAM), and a disk storage. The memory 703 is used to store data required by the processor 701 during operation. The number of memories is one or more.

Since the data analysis device is proposed under the same concept as the data analysis method of the blockchain provided by the present invention, the various changes and methods of the data analysis method of the blockchain in the embodiments of FIGS. The specific embodiment is also applicable to the data analysis device of this embodiment. Through the foregoing detailed description of the data analysis method of the blockchain, those skilled in the art can clearly know the implementation process of the data analysis device in this embodiment, so for the sake of description The succinctness is not detailed here.

A fourth aspect of the present invention provides a computer device, which includes:

At least one processor, and,

A memory and a communication interface communicatively connected with the at least one processor;

Wherein, the memory stores instructions that can be executed by the at least one processor, and the at least one processor executes the instructions shown in FIGS. 2 to 6 through the communication interface by executing the instructions stored in the memory. The method in the example.

The fifth aspect of the present invention provides a computer-readable storage medium, the computer-readable storage medium stores computer instructions, and when the computer instructions run on a computer, the computer executes the steps shown in FIGS. 2-6 The method in the embodiment.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, systems, or computer program products. Therefore, the present invention may adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, the present invention may adopt the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, optical storage, etc.) containing computer-usable program codes.

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.

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 (9)

A block chain data analysis method, characterized in that the method includes: Acquiring a smart contract for a user service, the smart contract including a construction method, an event method, and a non-constant method for creating and realizing the user service; According to at least one of the construction method, event method, and non-constant method, a data analysis code is generated. The data analysis code includes event data analysis code for analyzing event data of the user service and Transaction data analysis code for analyzing transaction data of the user service; The data analysis code is used to analyze the data in each block in the blockchain to obtain the event data and the transaction data. The method according to claim 1, wherein generating the event data analysis code according to at least one of the construction method, the event method, and the non-constant method includes: Compile the smart contract to obtain a JAVA contract file corresponding to the smart contract. The JAVA contract file includes at least an acquisition method for acquiring an event object in the event method and an event class corresponding to the event method And the binary code of the smart contract, the binary code of the smart contract includes at least the construction method, the event method, and the non-constant method each of which accesses the field type of the blockchain; Load the JAVA contract file, and obtain the event class through reflection; Through the first mapping relationship between the JAVA object and the first field type, the field in the event class with the same type as the first field is converted into a JAVA object, thereby obtaining the first POJO corresponding to the event class Object, the first field type is a field type used to access the blockchain in the event method; The first POJO object is filled into a preset event data analysis template to generate the event data analysis code. The preset event data analysis function template at least includes a calling module, a first analysis module, and a first instantiation Module and a first storage module, the calling module is used to call the acquisition method, the first parsing module is used to parse the event object and obtain the parsed event data, the first instantiation module is used to The parsed event data is converted into a first POJO object instance, and the first storage module is used to insert the first POJO object instance into a database table, and the database table is used to store the event data and the transaction data. The method according to claim 2, wherein using the event data analysis code to analyze the data in each block in the blockchain to obtain the event data comprises: Acquiring one of the blocks in the blockchain, where the one of the blocks is any block in the blockchain; Run the event data analysis code, obtain a list of event objects in the block through the calling module in the event data analysis code, the event object list including at least one value of the event object; Parsing at least one value of the event object through the parsing module in the event data parsing code to obtain at least one parsed event data; The at least one parsed event data is respectively transformed into at least one first POJO object instance through the instantiation module in the event data analysis code, and the at least one first POJO object instance and the at least one parsed event data One-to-one correspondence of event data; The at least one POJO object instance is inserted into the database table through the storage module in the event data analysis code. The method of claim 1, wherein generating the transaction data analysis code according to at least one of the construction method, event method, and non-constant method includes: Compile the smart contract to obtain a JAVA contract file corresponding to the smart contract. The JAVA contract file includes at least the binary code and binary string of the smart contract, and the binary code includes at least the construction method and Each of the non-constant methods accesses the field type of the blockchain, and the binary string is the recursive length prefix code of the smart contract; Load the JAVA contract file, parse the binary code, and obtain a transaction method, the transaction method including the construction method and the non-constant method; Through the second mapping relationship between the JAVA object and the second field type, the field in the transaction method with the same type as the second field is converted into a JAVA object, thereby obtaining the second POJO corresponding to the transaction method Object, the second field type is a field type used to access the blockchain in the transaction method; The second POJO object is filled into a preset transaction data analysis template to generate the transaction data analysis code. The preset transaction data analysis template includes at least a matching module, a second analysis module, a second instantiation module, and The second storage module, the matching module is used to determine whether the transaction method is the construction method or the non-constant method, the second analysis module is used to analyze the transaction method and obtain transaction data, the first The second instantiation module is used to convert transaction data into a second POJO object instance, and the second storage module is used to insert the second POJO object instance into a database table, the database table is used to store the event data And the transaction data. The method according to claim 4, wherein using the transaction data analysis code to analyze the data in each block in the blockchain to obtain the transaction data comprises: Acquiring one of the blocks in the blockchain, where the one of the blocks is any block in the blockchain; Obtain the first transaction in the block through a preset transaction acquisition interface; Run the transaction data analysis code, obtain the target field in the first transaction through the matching module in the transaction data analysis code, and determine the transaction type of the first transaction according to the target field, the transaction type including the first transaction A transaction type and a second transaction type, the first transaction type is a transaction type corresponding to the construction method, the second transaction type is a transaction type corresponding to the non-constant method, and the target field is used for Indicating the transaction partner of the first transaction; When it is determined that the transaction type of the first transaction is the first transaction type, obtain the recursive length prefix code of the first transaction through the matching module, and determine whether the recursive length prefix code of the first transaction includes all The binary string; If yes, the first remaining character string is parsed through the second parsing module in the transaction data analysis code to obtain the first transaction data of the first transaction, and the first remaining character string is the In the recursive length prefix encoding of the first transaction, the character string after removing the same symbol as the binary character string; Convert the first transaction data into a second POJO object instance through the second instantiation module in the transaction data analysis code; The second POJO object instance is inserted into the database table through the second storage module in the transaction data analysis code. The method according to claim 5, wherein when the transaction data analysis code is run, the target field in the first transaction is obtained through the matching module in the transaction data analysis code, and the target field is determined according to the target field. After the transaction type of the first transaction is described, the method further includes: When the transaction type of the first transaction is the second transaction type, obtain the recursive length prefix code of the first transaction through the matching module, and determine whether the recursive length prefix code of the first transaction includes the The signature of the non-constant method corresponding to the transaction data analysis code; If yes, the second remaining code is analyzed through the second analysis module in the transaction data analysis code to obtain the second transaction data of the first transaction, and the second remaining code is the first The code of the transaction removes the character string after the same symbol as the signature; Converting the second transaction data into a second POJO object instance through the second instantiation module in the transaction data analysis code; The second POJO object instance is inserted into the database table through the second storage module in the transaction data analysis code. An electronic device, characterized in that it comprises: At least one processor; and, A memory communicatively connected with the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor, so that the at least one processor can execute the method according to any one of claims 1 to 6 . A non-transitory computer-readable storage medium, wherein the non-transitory computer-readable storage medium stores computer instructions, and the computer instructions are used to make the computer execute the method described in any one of claims 1 to 6 . A computer device, characterized in that it comprises: Memory, used to store computer programs; The processor is configured to call a computer program stored in the memory, and execute the method according to any one of claims 1 to 6 according to the obtained program.

Images