CN113807968A

CN113807968A - Block chain user request processing method, device, request server and storage medium

Info

Publication number: CN113807968A
Application number: CN202111107700.7A
Authority: CN
Inventors: 王挺; 胡志鹏; 顾费勇; 曹崇瑞; 李刚锐; 胡志敏
Original assignee: Netease Hangzhou Network Co Ltd
Current assignee: Netease Hangzhou Network Co Ltd
Priority date: 2021-09-22
Filing date: 2021-09-22
Publication date: 2021-12-17
Anticipated expiration: 2041-09-22
Also published as: CN113807968B

Abstract

The invention provides a block chain user request processing method, a block chain user request processing device, a delegation server and a storage medium, and relates to the technical field of data processing. The user request processing method comprises the following steps: receiving at least one user processing request sent by a first client, wherein each user processing request is used for indicating a block link point to process first user identification information, and the first user identification information is identification information of a first user corresponding to the first client; merging the user processing requests received within a preset time period to obtain the user processing requests after merging; and calling the block chain nodes according to the user processing request after the merging processing so as to process the block chain nodes according to the user processing request after the merging processing. And merging the at least one user processing request, wherein the at least one user processing request only needs to call the blockchain once, so that the blockchain transaction pressure is reduced, and the transaction stability is improved.

Description

Block chain user request processing method, device, request server and storage medium

Technical Field

The present invention relates to the field of data processing technologies, and in particular, to a method and an apparatus for processing a block chain user request, a delegation server, and a storage medium.

Background

With the development of scientific technology, the block chain technology is also developed rapidly, the block chain is a shared database, and the data or information stored in the block chain has the characteristics of being incapable of being counterfeited, having trace in the whole process, being traceable, being transparent in disclosure and being maintained collectively, and the block chain is widely applied to multiple industries and fields. Interaction between the client and the blockchain to process data in the blockchain has also become a hot point of research.

In the related art, a client corresponding to each user may send a request to a delegation server, where the request is used to instruct a blockchain to process user identification information, and the delegation server may call the blockchain, where the blockchain processes the user identification information.

However, in the related art, when a plurality of clients all send user requests to the delegation server, the delegation server needs to call the blockchain for many times, and thus the problem of transaction exception due to overlarge transaction pressure of the blockchain is easily caused.

Disclosure of Invention

The present invention aims to provide a method, an apparatus, a delegation server and a storage medium for processing a blockchain user request, so as to solve the problem in the related art that when a plurality of clients all send user requests to the delegation server, the delegation server needs to call blockchains for a plurality of times, and thus, transaction pressure of blockchains is too high, which may cause transaction abnormality.

In order to achieve the above purpose, the embodiment of the present invention adopts the following technical solutions:

in a first aspect, an embodiment of the present invention provides a method for processing a block chain user request, which is applied to a delegation server, and includes:

receiving at least one user processing request sent by a first client, wherein each user processing request is used for indicating a block link node to process first user identification information, and the first user identification information is identification information of a first user corresponding to the first client;

merging the user processing requests received within a preset time period to obtain merged user processing requests;

and calling the block chain node according to the user processing request after the merging processing so as to enable the block chain node to process according to the user processing request after the merging processing.

Optionally, the merging the user processing requests received within the preset time period to obtain the merged user processing request includes:

and converging the user processing requests received in the preset time period to a queue to be uplink, so as to obtain the user processing requests after the merging processing.

Optionally, before the invoking the blockchain node according to the merged user processing request, the method further includes:

randomly generating operation identification information;

creating a target object according to the operation identification information, the user processing request and a preset thread waiting tool;

and saving the target object to the to-be-uplink queue.

Optionally, after the calling a blockchain node according to the merged user processing request, the method further includes:

if a first user identification information change event from the block chain node is monitored, analyzing the first user identification information change event to obtain an analysis result, wherein the analysis result comprises: the operation identification information and the first user identification information indicate that the processing is successful when the first user identification information changes the event;

and transmitting the result of successful processing to the first client through the target object according to the operation identification information and the first user identification information.

Optionally, the transmitting, according to the operation identification information and the first user identification information, the result of successful processing to the first client through the target object includes:

searching the target object according to the operation identification information to obtain a search result;

if the search result indicates that the target object is searched, writing the successfully processed result and the first user identification information into the target object;

and awakening the preset thread waiting tool in the target object to awaken a first user identification information thread, and transmitting the result of successful processing to the first client.

Optionally, the method further includes:

deleting the user identification document data corresponding to the first user identification information in the user identification cache list, and determining the deletion notification information.

And transmitting the deletion notification information to the first client through the first user identification information thread.

Optionally, the method further includes:

and if the searching result indicates that the target object is not searched, deleting the user identification document data corresponding to the first user identification information in the user identification cache list.

Optionally, the method further includes:

and deleting the user identification document data corresponding to the first user identification information in the user identification cache list if a first user identification information change event from the block chain node is monitored.

Optionally, the method further includes:

receiving a user query request sent by a second client, wherein the user query request comprises: second user identification information;

inquiring a local cache according to the second user identification information to obtain a local inquiry result;

and if the local query result indicates that the target user identification document data corresponding to the second user identification information is found, sending the target user identification document data to the second client.

Optionally, the querying a local cache according to the second user identification information to obtain a local query result includes:

and according to the second user identification information, obtaining the local query result through a user identification cache list, wherein the user identification cache list comprises a plurality of preset user identification document data.

Optionally, the method further includes:

if the local query result indicates that the target user identification document data is not found, calling the block chain node to acquire account information of the second user identification information;

recovering the target user identification document data according to the account information;

and transmitting the target user identification document data to the second client.

Optionally, the method further includes:

and caching the target user identification document data within a preset time length.

And updating the user identification cache list according to the user identification document data.

Optionally, the method further includes:

verifying the user processing request to obtain a verification result, wherein the verification result is used for indicating whether verification is successful;

the merging the user processing requests received within the preset time period to obtain the merged user processing request includes:

and according to the verification result, merging the at least one user processing request which is successfully verified to obtain a merged user processing request.

Optionally, the user processing request is a user creation request or a user modification request;

the user creating request is used for indicating to create the first user identification information, and the user changing request is used for indicating to change the first user identification information.

In a second aspect, an embodiment of the present invention further provides a device for processing a block chain user request, which is applied to a delegation server, and includes:

a receiving module, configured to receive at least one user processing request sent by a first client, where each user processing request is used to indicate a block link node to process first user identification information, and the first user identification information is identification information of a first user corresponding to the first client;

the processing module is used for carrying out merging processing on the user processing requests received within a preset time period to obtain the user processing requests after merging processing;

and the calling module is used for calling the block chain nodes according to the combined user processing request so as to enable the block chain nodes to process according to the combined user processing request.

Optionally, the processing module is further configured to converge the user processing request received within the preset time period to a to-be-uplink queue, so as to obtain the merged user processing request.

Optionally, the apparatus further comprises:

the generating module is used for randomly generating operation identification information;

the creating module is used for creating a target object according to the operation identification information, the user processing request and a preset thread waiting tool;

and the storage module is used for storing the target object into the queue to be uplink.

Optionally, the apparatus further comprises:

a first parsing module, configured to, if a first user identification information change event from the blockchain node is monitored, parse the first user identification information change event to obtain a parsing result, where the parsing result includes: the operation identification information and the first user identification information indicate that the processing is successful when the first user identification information changes the event;

and the first transmission module is used for transmitting the successful processing result to the first client through the target object according to the operation identification information and the first user identification information.

Optionally, the first transmission module is further configured to search the target object according to the operation identification information to obtain a search result; if the search result indicates that the target object is searched, writing the successfully processed result and the first user identification information into the target object; and awakening the preset thread waiting tool in the target object to awaken a first user identification information thread, and transmitting the result of successful processing to the first client.

Optionally, the apparatus further comprises:

and the first deleting module is used for deleting the user identification document data corresponding to the first user identification information in the user identification cache list and determining the deletion notification information.

And the second transmission module is used for transmitting the deletion notification information to the first client through the first user identification information thread.

Optionally, the apparatus further comprises:

and the second deleting module is used for deleting the user identification document data corresponding to the first user identification information in the user identification cache list if the searching result indicates that the target object is not searched.

Optionally, the apparatus further comprises:

and the second analysis module is used for deleting the user identification document data corresponding to the first user identification information in the user identification cache list if a first user identification information change event from the block chain node is monitored.

Optionally, the apparatus further comprises:

a first receiving module, configured to receive a user query request sent by a second client, where the user query request includes: second user identification information;

the query module is used for querying a local cache according to the second user identification information to obtain a local query result;

and the first sending module is configured to send the target user identification document data to the second client if the local query result indicates that the target user identification document data corresponding to the second user identification information is found.

Optionally, the query module is further configured to obtain the local query result through a user identifier cache list according to the second user identifier information, where the user identifier cache list includes a plurality of preset user identifier document data.

Optionally, the apparatus further comprises:

the acquisition module is used for calling the block chain node to acquire account information of the second user identification information if the local query result indicates that the target user identification document data is not found;

the recovery module is used for recovering the target user identification document data according to the account information;

and the second sending module is used for sending the target user identification document data to the second client.

Optionally, the apparatus further comprises:

and the cache module is used for caching the target user identification document data within a preset time length.

And the updating module is used for updating the user identification cache list according to the user identification document data.

Optionally, the apparatus further comprises:

the verification module is used for verifying the user processing request to obtain a verification result, and the verification result is used for indicating whether the verification is successful;

and the processing module is used for merging at least one user processing request which is successfully verified according to the verification result to obtain a merged user processing request.

Optionally, the user processing request is a user creation request or a user modification request; the user creating request is used for indicating to create the first user identification information, and the user changing request is used for indicating to change the first user identification information.

In a third aspect, an embodiment of the present invention further provides a delegation server, including: a memory storing a computer program executable by the processor, and a processor implementing the method of any of the first aspects when executing the computer program.

In a fourth aspect, an embodiment of the present invention further provides a storage medium, where a computer program is stored on the storage medium, and when the computer program is read and executed, the method of any one of the above first aspects is implemented.

The invention has the beneficial effects that: the embodiment of the invention provides a block chain user request processing method, which comprises the following steps: receiving at least one user processing request sent by a first client, wherein each user processing request is used for indicating a block link point to process first user identification information, and the first user identification information is identification information of a first user corresponding to the first client; merging the user processing requests received within a preset time period to obtain the user processing requests after merging; and calling the block chain nodes according to the user processing request after the merging processing so as to process the block chain nodes according to the user processing request after the merging processing. And merging the at least one user processing request, wherein the at least one user processing request only needs to call the blockchain once, so that the blockchain transaction pressure is reduced, and the transaction stability is improved.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings needed to be used in the embodiments will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present invention and therefore should not be considered as limiting the scope, and for those skilled in the art, other related drawings can be obtained according to the drawings without inventive efforts.

Fig. 1 is a schematic structural diagram of a user request processing system according to an embodiment of the present application;

fig. 2 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention;

fig. 3 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention;

fig. 4 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention;

fig. 5 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention;

fig. 6 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention;

fig. 7 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention;

fig. 8 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention;

fig. 9 is a schematic structural diagram of a block chain user request processing apparatus according to an embodiment of the present invention;

fig. 10 is a schematic structural diagram of a delegation server according to an embodiment of the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention.

Thus, the following detailed description of the embodiments of the present application, presented in the accompanying drawings, is not intended to limit the scope of the claimed application, but is merely representative of selected embodiments of the application. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.

In the description of the present application, it should be noted that if the terms "upper", "lower", etc. are used for indicating the orientation or positional relationship based on the orientation or positional relationship shown in the drawings or the orientation or positional relationship which is usually arranged when the product of the application is used, the description is only for convenience of describing the application and simplifying the description, but the indication or suggestion that the referred device or element must have a specific orientation, be constructed in a specific orientation and operation, and thus, cannot be understood as the limitation of the application.

Furthermore, the terms "first," "second," and the like in the description and in the claims, as well as in the drawings, are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

It should be noted that the features of the embodiments of the present application may be combined with each other without conflict.

The terms referred to in the examples of the present application are explained below:

distributed identity identification: distributed Identities (DID) are Decentralized verifiable digital Identifiers, and have the characteristics of being distributed, autonomously controllable, cross-chain multiplexing and the like. The entity can autonomously complete the registration, parsing, updating or revocation operations of the DID. The DID is specifically parsed into a DID Document including a unique id of the DID, a list of public keys and detailed information of the public keys (holder, encryption algorithm, key status, etc.), and other attribute descriptions of the DID holder.

The verifiable statement: verifiable Statements (VCs) provide a specification to describe certain attributes that an entity has, enabling evidence-based trust. The DID holder, through the VC, can prove to other entities (individuals, organizations, things, etc.) that certain attributes of himself are trustworthy.

The issuer: entities, such as hospitals, banks, universities, etc., that have subscriber data and can offer VCs.

The holder, i.e. the user: the holder requests, receives, and holds the entity of the VC from the issuer and presents the VC to the verifier. The opened VC can be stored by itself and is convenient for reuse.

Note that the holder may perform DID registration and DID document inquiry, the issuer may register the DID and become the issuer, the holder user applies for the VC, the issuer verifies the DID issued VC, the holder user provides the VC to the verifier, and the verifier verifies the holder/issuer/signature information, and the like, and the verifier may call the issuer to check the VC status.

Additionally, a holder may transfer one or more VCs to other holders; the holder may present one or more VCs to the verifier, and may optionally present VPs; the verifier can verify the authenticity of the presented VCs and VPs (here also including checking the revocation status of VCs); the issuer can revoke VC; the holder may delete the VC.

Fig. 1 is a schematic structural diagram of a user request processing system according to an embodiment of the present application, and as shown in fig. 1, the user request processing system may include: the system comprises a block chain 101, a plurality of user devices 102 and a request server 103, wherein each user device 102 is in communication connection with the request server 103, and the request server 103 is in communication connection with the block chain 101.

Each user device 102 may have a first client or a second client installed thereon, where the first client and the second client may be the same type of client or different types of clients. The number of the first clients and the number of the second clients may be multiple, and the multiple first clients and the multiple second clients may communicate with the delegation server 103.

The first client may be a holder client corresponding to the holder user, and the second client may be any one of a holder client, an issuer client, and a verifier client, where the issuer client is a client corresponding to the issuer and the verifier client is a client corresponding to the verifier.

In some embodiments, the at least one first client may send at least one user processing request to the delegation server 103; the delegation server 103 may receive the at least one user processing request, and perform merging processing on the user processing requests received within a preset time period to obtain a merged user processing request; then, according to the merged user processing request, the block link point 1011 in the block chain 101 is called, so that the block link point 1011 performs processing according to the merged user processing request.

The user processing request is used to instruct the block link point 1011 to process the first user identification information.

In the embodiment of the present application, the user device 102 may be a terminal device, and for example, may be any one of a smart phone, a desktop computer, a notebook computer, and a tablet computer. The block chain 101 refers to a system for performing data sharing between nodes, one block chain 101 may include a plurality of block link points 1011, the plurality of block chain nodes 1011 may refer to each server in the block chain 101, and certainly, one server in the block chain 101 may correspond to the plurality of block link points 1011.

The delegation server may be deployed with a plurality of delegation services, and optionally, the delegation server may execute the block chain user request processing method provided in the embodiment of the present application based on the delegation services, and the following explains the block chain user request processing method provided in the embodiment of the present application with the delegation server as an execution subject.

Fig. 2 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention, as shown in fig. 2, the method may include:

s101, receiving at least one user processing request sent by a first client.

Wherein each user processing request is used for indicating the block link point to process the first user identification information. The first user identification information is identification information of a first user corresponding to the first client.

In some implementations, the first client generates a first user processing request in response to an input processing operation and sends at least one user processing request to the delegation server, which can receive the at least one user processing request. Wherein the first client may be at least one different client.

Optionally, the first user identification information may be a distributed identity DID.

And S102, merging the user processing requests received within the preset time period to obtain the merged user processing requests.

The merged user processing request may be a batch user processing request.

In this embodiment of the present application, the delegation server may aggregate the user processing requests received within the preset time period, so as to implement merging processing on the user processing requests received within the preset time period, and obtain the user processing requests after the merging processing.

The preset time period may be 3s (seconds), may also be 5s, and may also be set according to actual conditions or empirical values, which is not specifically limited in the embodiments of the present application.

And S103, calling the block chain nodes according to the combined user processing request so that the block chain nodes are processed according to the combined user processing request.

In some embodiments, the proxy server may obtain the merged user processing request to be uplink transmitted, and merge uplink to invoke the contract uplink interface. Accordingly, the block link points in the block chain can be processed according to the merged user processing request.

In the embodiment of the application, the block link points can perform corresponding transactions according to different types of user processing requests, the blocks are taken out after the transactions are completed, the processing results are fed back to the entrusting server, and the entrusting server can feed back the processing results to the first client.

In addition, the at least one first client may synchronously wait for a processing result of the block link node pair with respect to the user processing request.

In summary, an embodiment of the present invention provides a method for processing a block chain user request, including: receiving at least one user processing request sent by a first client, wherein each user processing request is used for indicating a block link point to process first user identification information, and the first user identification information is identification information of a first user corresponding to the first client; merging the user processing requests received within a preset time period to obtain the user processing requests after merging; and calling the block chain nodes according to the user processing request after the merging processing so as to process the block chain nodes according to the user processing request after the merging processing. And merging the at least one user processing request, wherein the at least one user processing request only needs to call the blockchain once, so that the blockchain transaction pressure is reduced, and the transaction stability is improved.

Wherein the user creation request may include: creating parameters and signature data; the user change request may include: first user identification information, change parameters, signature data. The signature data may be data obtained after the first client signs the creation parameter or the change parameter by using a preset block chain signature algorithm through a private key.

Optionally, the preset block chain signature algorithm may be a Secp256k1 elliptic curve signature algorithm. The creation parameter or the change parameter is expressed as changeInfo, the private key may be expressed as privateKey, and the signature data may be expressed as Sign ═ secp256k1Sign (changeInfo, privateKey).

It should be noted that creating parameters or changing parameters includes: public key information (denoted as veridentiationmethod) of the first user identification information account, a holder, held service information, creation time, modification time, recovery account, and the like.

Optionally, the method may further include: and verifying the user processing request to obtain a verification result. Wherein the verification result is used for indicating whether the verification is successful.

In this embodiment of the present application, if the user processing request is a user creation request, information (veridentiationmethod. public keyhex) in the public key must be public key information corresponding to the block chain private key, and a signature is performed based on the current private key information, so as to ensure that the front block chain account has control over the created first user identification information. If the user processing request is a user change request, the public key corresponding to the signature data must exist in the public key information in the first user identification document.

In some embodiments, the delegation server may verify the signature data in the user processing request by using a preset verification algorithm, obtain, if the user processing request is a user creation request, the validity of the public key information in the creation parameter to verify the signature, return, if the verification is invalid, that the first client fails to verify, and wait for creating the first user identification information if the verification is valid. And if the user processing request is a user change request, acquiring the public key message in the first user identification information document on the block chain, and verifying the signature by using a corresponding algorithm. And verifying the validity of the signature, if the signature is verified to be invalid, returning the user to fail, and if the signature is verified to be valid, waiting for changing the first user identification information.

The preset verification algorithm may be represented as:

flag＝verifySecp256k1Signature(changeInfo，sign，publicKey)

optionally, the process of merging the user processing requests received within the preset time period in the step S102 to obtain the merged user processing request may include: and according to the verification result, merging the at least one user processing request which is successfully verified to obtain a user processing request after merging.

Optionally, the process of merging the user processing requests received within the preset time period in the step S102 to obtain the merged user processing request may include: and converging the user processing requests received in the preset time period to a queue to be uplink, and obtaining the user processing requests after combined processing.

In a possible embodiment, the delegation server may aggregate the user creation request and/or the user modification request that are successfully verified, and add the aggregated user creation request and/or user modification request to the pending uplink queue, so as to obtain a merged user processing request.

The implementation program code of the process is as follows:

// queue to be uplinked

ArrayBlockingQueue<DIDChange>waitOnChainQueue＝newArrayBlockin gQueue<DIDChange>(10000)；

// map of result to be obtained

Map<String,DIDChange>waitDIDChangeMap＝new HashMap<>()；

I/DID delegated service adds request to pending uplink queue and pending results map

public DIDChange addDIDChangeRequest(String did,String changeInfo){

// generating a unique number for this operation

String generateNumber＝GenerateUtils.generateOrderId(new Date())；

New object created this time

DIDChange didChange＝new DIDChange()；

didChange.setNumber(generateNumber)；

didChange.setDid(did)；

didChange.setChangeInfo(changeInfo)；

didChange.setCountDownLatch(new CountDownLatch(1))；

// join pending uplink queue and wait for map of result creation

waitDIDChangeMap.put(generateNumber，didChange)；

waitOnChainQueue.offer(didChange)；

return didChange；

}

In the embodiment of the application, the proxy server can continuously poll the to-be-uplink queue, acquire the N user processing requests after the merging processing, and call the contract uplink interface.

The implementation program code of the process is as follows:

// Polling get queue request

public void pollDIDBlocking(){

while(true){

// obtaining N at a time

List<DIDChange>list＝new ArrayList<>(waitOnChainQueue.size())；

waitOnChainQueue.drainTo(list)；

// performing uplink on N transactions

}

Optionally, fig. 3 is a flowchart illustrating a method for processing a blockchain user request according to an embodiment of the present invention, as shown in fig. 3, before the step of invoking a blockchain node according to a user processing request after merging processing in S103, the method may further include:

s301, randomly generating operation identification information.

The operation identification information may be a unique identification of the operation, and the operation identification information may be represented as generateNumber.

S302, creating a target object according to the operation identification information, the user processing request and the preset thread waiting tool.

The user processing request may include first user identification information of the operation, a creation parameter, or a modification parameter, among others.

In some embodiments, the delegation server creates the target object based on the operation identification information, the first user identification information of the operation, the creation/modification parameter, and the preset thread wait tool. Wherein, the thread waiting tool can be represented by CountDownLatch, and the target object can be represented by DIDCchange.

S303, the target object is stored in the queue to be uplink.

Wherein, the queue to be uplink may be denoted as waitOnChainQueue.

It should be noted that the delegation server may store the target object in the to-be-uplinked queue, and may also store the target object in the to-be-acquired result, where the operation identification information is used as a key, the target object DIDChange is used as a value, and the to-be-acquired result may be represented as map waitdidchange map.

In this embodiment, the proxy server may invoke a contractual uplink interface, where the uplink interface may be denoted as batchChangeDID, and the input parameters of the uplink interface may include: a first user identification information address list, a change message list and operation identification information. The first subscriber identity information address list may be represented as an identityList, and the change message list may be represented as a changeInfoList.

The block chain node may sequentially circulate the first user identification information address list, and if the first user identification information exists, the intelligent contract of the block chain node performs a change operation, performs respective changes of each first user identification information, and triggers a first user identification information change event, where the first user identification information may be denoted as didattributary changed. And if the first user identification information does not exist, the intelligent contract of the block link node executes a new adding operation, executes respective new addition of each first user identification information, and finally triggers a first user identification information change event.

The implementation program code of the process is as follows:

// did parameter event// did address// single information

event DIdAttributeChanged(address identity,string generateNumber)；

Creating or modifying the did identifier list did address in batch, changing info list change message, including creating information/public key message/authorized public key list, etc., unique single number list function batch change did (address [ ] identifier list, string [ ] changing info list, string [ ] generating number list) public of this operation

// circular did address

for(uint i＝0；i<identityList.length；i++){

address identity＝identityList[i]；

if(identity！＝0){

v/Change Business operation

DIdAttributeChanged(identity,generateNumberList[i])；

}else{

// new service operation

DIdAttributeChanged(identity,generateNumberList[i])；

}

Optionally, fig. 4 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention, as shown in fig. 4, after the step of invoking a block chain node according to a user processing request after merging processing in S103, the method may further include:

s401, if a first user identification information change event from a block chain node is monitored, analyzing the first user identification information change event to obtain an analysis result.

Wherein, the analysis result may include: and operating the identification information and the first user identification information, wherein the first user identification information change event indicates that the processing is successful.

In addition, the first subscriber identification information change event may include: first user identification information and operation identification information.

In some embodiments, after the transaction is completed and the block is released, the block link point sends a first user identification information change event to a delegation service subscribing to a current first user identification information contract in a delegation server; the entrusting server can monitor the first user identification information change event through the entrusting service and analyze the first user identification information change event to obtain an analysis result.

S402, according to the operation identification information and the first user identification information, a successfully processed result is transmitted to the first client through the target object.

In this embodiment of the application, the delegation server may determine the target object according to the operation identification information, and wait for the tool to be woken up based on the thread in the target object, which indicates that the first user identification information has a result created, and at this time, may return the target object to the user. If the new user identification is created, the first client can acquire the latest first user identification information; if the change is made, the first client may also obtain a successful change.

The implementation program code of the process is as follows:

// user thread waiting for results

public DIDChange waitDIDChangeResult(DIDChange didChange){

try{

didChange.getCountDownLatch().await()；

}catch(InterruptedException e){

e.printStackTrace()；

}

return didChange；

}

Optionally, fig. 5 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention, and as shown in fig. 5, the transmitting a successful processing result to the first client through the target object according to the operation identifier information in S402 may include:

s501, searching the target object according to the operation identification information to obtain a searching result.

The entrusted server can query the result to be obtained according to the operation identification information to obtain the search result. The search result may indicate whether the target object is found. And the key of the result to be obtained is the operation identification information, and the value is the target object.

And S502, if the search result indicates that the target object is searched, writing the successfully processed result and the first user identification information into the target object.

In some embodiments, the target object may include: the creation/modification is successful and the first subscriber identity information.

S503, awakening a preset thread waiting tool in the target object to awaken the first user identification information thread and transmit a result of successful processing to the first client.

In some embodiments, the target object may be returned to the user upon the thread in the target object waiting for the facility to wake up, indicating that the first user identification information has resulted in creation. If the new user identification is created, the first client can acquire the latest first user identification information; if the change is made, the first client may also obtain information of the successful change.

Optionally, fig. 6 is a schematic flowchart of a method for processing a block chain user request according to an embodiment of the present invention, and as shown in fig. 6, the parsing result further includes: first user identification information; the method further comprises the following steps:

s601, deleting the user identification document data corresponding to the first user identification information in the user identification cache list, and determining the deletion notification information.

S602, transmitting the deletion notification information to the first client through the first user identification information thread.

It should be noted that the user identifier cache list can be updated in time, accuracy of querying the user identifier cache list is improved, and the deletion notification information is transmitted to the first client, so that a user of the first client can know in time that the user identifier document data corresponding to the first user identifier information in the user identifier cache list is deleted.

Moreover, the entrusting service on the entrusting server can subscribe the did contract event of the current block chain node, so that the block chain node can conveniently subscribe the did change event through all subscribers, and the cache can be cleared and the user thread can be notified at the same time. This ensures that the did cache data queried by the user must be up-to-date.

Optionally, the method further includes: and if the searching result indicates that the target object is not searched, deleting the user identification document data corresponding to the first user identification information in the user identification cache list.

If the target object is found, it indicates that no corresponding user thread exists in the delegation server of the delegation server, and the first client does not need to be notified.

The implementation program code of the process is as follows:

// listening for event results

public void noticeBlockchainEvent(){

//event DIdAttributeChanged(address identity,string generateNumber)；

Acquisition event did-identity and generateNumber Generation sheet number

String generateNumber＝resolveGenerateNumberByEvent()；

String identity＝resolveDIDByEvent()；

Acquiring DIDCchange according to generateNumber, writing result, and waking up user to wait for thread

DIDChange didChange＝waitDIDChangeMap.get(generateNumber)；

if(didChange！＝null){

didChange.setDid(identity)；

didChange.setResult(true)；

didChange.getCountDownLatch().countDown()；

waitDIDChangeMap.remove(didChange)；

}

// flush cache according to did-identity

didCacheMap.remove(identity)；

}

Optionally, the method may further include:

and if a first user identification information change event from the block chain node is monitored, deleting the user identification document data corresponding to the first user identification information in the user identification cache list.

In some embodiments, if the first user identification information is changed, the delegation server notifies a delegation service of each subscription block event through a block chain subscription function, and the delegation service can monitor the first user identification information change event and analyze the first user identification information change event to obtain an analysis result; the analysis result may include: first user identification information; and deleting the user identification document data corresponding to the first user identification information in the user identification cache list.

In summary, through the block chain subscription function, the cache of the user identification document data corresponding to the first user identification information can be notified to be deleted in real time, so that the cache can be cleaned in time, the timeliness of the user identification document data in the cache list can be ensured, and the latest data queried from the cache list each time can be ensured.

Optionally, fig. 7 is a flowchart illustrating a method for processing a block chain user request according to an embodiment of the present invention, and as shown in fig. 7, a user query request sent by a second client is received, where the user query request includes: second user identification information; the method may further comprise:

s701, inquiring the local cache according to the second user identification information to obtain a local inquiry result.

S702, if the local query result indicates that the target user identification document data corresponding to the second user identification information is found, the target user identification document data is sent to the second client.

In the embodiment of the application, when the second client acquires the target user identification document data each time, the query performance is improved and the query pressure of the block chain is reduced through local cache query.

Optionally, the process of querying the local cache according to the second user identification information in S701 to obtain the local query result may include: and according to the second user identification information, obtaining a local query result through the user identification cache list.

The user identification cache list comprises a plurality of preset user identification document data. The user identification cache list may be denoted as didcache map.

In some embodiments, the user identifying the cache list may include: and the entrusted server can search target preset user identification information which is the same as the second user identification information, and takes preset user identification document data corresponding to the target preset user identification information as target user identification document data.

Optionally, fig. 8 is a schematic flowchart of a method for processing a block chain user request according to an embodiment of the present invention, and as shown in fig. 8, the method may further include:

s801, if the local query result indicates that the target user identification document data is not found, calling a block chain node to acquire account information of the second user identification information.

The delegation server can acquire account information from an account of the second user identification information.

In addition, the account information may include: public key, holder, held service information, creation time, modification time, recovery public key and other parameters.

And S802, restoring the identification document data of the target user according to the account information.

S803, the target user identification document data is transmitted to the second client.

It should be noted that, the delegation server may send the target user identification document data to the second client, and the second client may receive the target user identification document data, and then display and/or store the target user identification document data.

The implementation program code of the process is as follows:

// query did document through didCache map

public String queryDIDDocumentByDID(String did){

If a local cache of a didcache map exists, pull from the local cache

if(didCacheMap.containsKey(did)){

return didCacheMap.get(did)；

}else{

If not, then pull from the blockchain and put into cache

String dIDDocument＝queryByBlockChain(did)；

didCacheMap.put(did,dIDDocument)；

return dIDDocument；

}

Optionally, the method may further include: and caching the target user identification document data within a preset time length. And updating the user identification cache list according to the user identification document data.

Wherein, the entrusting server can store the user identification document data into the user identification cache list. In addition, the preset time length may be 5s, may also be 7s, and may also be set according to an actual requirement, which is not specifically limited in the embodiment of the present application.

In summary, an embodiment of the present invention provides a method for processing a block chain user request, where the method includes: receiving at least one user processing request sent by a first client, wherein each user processing request is used for indicating a block link point to process first user identification information, and the first user identification information is identification information of a first user corresponding to the first client; merging the user processing requests received within a preset time period to obtain the user processing requests after merging; and calling the block chain nodes according to the user processing request after the merging processing so as to process the block chain nodes according to the user processing request after the merging processing. The at least one user processing request received within the preset time period is merged, and the at least one user processing request only needs to call the block chain once, so that the transaction pressure of the block chain is reduced, and the transaction stability is improved.

And when the second client acquires the target user identification document data, the query performance is improved and the query pressure of the block chain is reduced through local cache query. By the block chain subscription event function, the user identification information cache can be deleted in real time, and the timeliness of the user identification information cache is guaranteed.

The following describes a block chain user request processing apparatus, a client server, a storage medium, and the like for executing the block chain user request processing method provided in the present application, and specific implementation processes and technical effects thereof are referred to in the related contents of the block chain user request processing method, and are not described in detail below.

Fig. 9 is a schematic structural diagram of a block chain user request processing apparatus according to an embodiment of the present invention, where the apparatus is applied to a client server, and as shown in fig. 9, the apparatus may include:

a receiving module 901, configured to receive at least one user processing request sent by a first client, where each user processing request is used to indicate a block link node to process first user identification information, where the first user identification information is identification information of a first user corresponding to the first client;

a processing module 902, configured to perform merging processing on the user processing requests received within a preset time period to obtain merged user processing requests;

a calling module 903, configured to call a block chain node according to the merged user processing request, so that the block chain node performs processing according to the merged user processing request.

Optionally, the processing module 902 is further configured to converge the user processing request received within the preset time period to a to-be-uplink queue, so as to obtain the merged user processing request.

Optionally, the apparatus further comprises:

the analysis module is configured to, if a first user identification information change event from the blockchain node is monitored, analyze the first user identification information change event to obtain an analysis result, where the analysis result includes: the operation identification information and the first user identification information indicate that the processing is successful when the first user identification information changes the event;

Optionally, the apparatus further comprises:

the processing module 902 is configured to perform merging processing on at least one successfully verified user processing request according to the verification result, so as to obtain a merged user processing request.

The above-mentioned apparatus is used for executing the method provided by the foregoing embodiment, and the implementation principle and technical effect are similar, which are not described herein again.

These above modules may be one or more integrated circuits configured to implement the above methods, such as: one or more Application Specific Integrated Circuits (ASICs), or one or more microprocessors (DSPs), or one or more Field Programmable Gate Arrays (FPGAs), among others. For another example, when one of the above modules is implemented in the form of a processing element scheduler code, the processing element may be a general-purpose processor, such as a Central Processing Unit (CPU) or other processor capable of calling program code. For another example, these modules may be integrated together and implemented in the form of a system-on-a-chip (SOC).

Fig. 10 is a schematic structural diagram of a delegation server according to an embodiment of the present invention, and as shown in fig. 10, the delegation server includes: a processor 1001 and a memory 1002. The memory 1002 is used for storing programs, and the processor 1001 calls the programs stored in the memory 1002 to execute the above method embodiments. The specific implementation and technical effects are similar, and are not described herein again.

Optionally, the invention also provides a program product, for example a computer-readable storage medium, comprising a program which, when being executed by a processor, is adapted to carry out the above-mentioned method embodiments.

In the embodiments provided in the present invention, it should be understood that the disclosed apparatus and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, or in a form of hardware plus a software functional unit.

The integrated unit implemented in the form of a software functional unit may be stored in a computer readable storage medium. The software functional unit is stored in a storage medium and includes several instructions to enable a computer device (which may be a personal computer, a server, or a network device) or a processor (processor) to execute some steps of the methods according to the embodiments of the present invention. And the aforementioned storage medium includes: a U disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disk, and other various media capable of storing program codes.

The above is only a preferred embodiment of the present invention, and is not intended to limit the present invention, and various modifications and changes will occur to those skilled in the art. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A block chain user request processing method is applied to a delegation server and comprises the following steps:

2. The method according to claim 1, wherein the merging the user processing requests received within a preset time period to obtain merged user processing requests includes:

3. The method of claim 2, wherein prior to said invoking blockchain nodes according to the merged processed user processing request, the method further comprises:

randomly generating operation identification information;

and saving the target object to the to-be-uplink queue.

4. The method of claim 3, wherein after the invoking a blockchain node according to the merged processed user processing request, the method further comprises:

5. The method according to claim 4, wherein the transmitting the result of successful processing to the first client through the target object according to the operation identification information and the first user identification information comprises:

6. The method of claim 5, further comprising:

deleting the user identification document data corresponding to the first user identification information in the user identification cache list, and determining deletion notification information;

7. The method of claim 5, further comprising:

8. The method according to claim 1 or 2, characterized in that the method further comprises:

9. The method of claim 1, further comprising:

10. The method of claim 9, wherein querying a local cache for local query results based on the second subscriber identity information comprises:

11. The method of claim 9, further comprising:

and sending the target user identification document data to the second client.

12. The method of claim 10, further comprising:

caching the target user identification document data within a preset time length;

13. The method of claim 1, further comprising:

14. The method of claim 1, wherein the user processing request is a user creation request or a user modification request;

15. A blockchain user request processing apparatus applied to a delegation server, comprising:

the system comprises a receiving module, a processing module and a processing module, wherein the receiving module is used for receiving at least one user processing request sent by a first client, and each user processing request is used for indicating a block link point to process first user identification information corresponding to the first client;

16. A delegation server, comprising: a memory storing a computer program executable by the processor, and a processor implementing the method of any of the preceding claims 1-14 when executing the computer program.

17. A storage medium having stored thereon a computer program which, when read and executed, implements the method of any of claims 1-14.