CN112434677B

CN112434677B - Contract auditing method, device, equipment and storage medium

Info

Publication number: CN112434677B
Application number: CN202110105468.7A
Authority: CN
Inventors: 叶玲玲
Original assignee: Alipay Hangzhou Information Technology Co Ltd
Current assignee: Alipay Hangzhou Information Technology Co Ltd
Priority date: 2021-01-26
Filing date: 2021-01-26
Publication date: 2021-05-18
Anticipated expiration: 2041-01-26
Also published as: CN112434677A

Abstract

The application provides a contract auditing method, a contract auditing device, contract auditing equipment and a storage medium. The method can include receiving an audit request initiated by a user for a target contract. And acquiring a target contract included by the audit request, and extracting keywords from the target contract and each standard contract in the standard contract library based on a trained keyword extraction model to obtain a first keyword of the target contract and a second keyword corresponding to each standard contract. And matching the first keywords with the second keywords corresponding to the standard contracts to obtain matching results corresponding to the second keywords. And determining a second keyword which has the highest matching degree with the first keyword from the matching result, and determining a standard contract corresponding to the second keyword as a standard contract matched with the target contract. And checking the terms included in the target contract based on the terms included in the standard contract.

Description

Contract auditing method, device, equipment and storage medium

Technical Field

The application relates to computer technology, in particular to a contract auditing method, device, equipment and storage medium.

Background

In judicial practice, dispute handling is usually required according to contract terms signed by both parties signing the contract. If the contract clauses conform to the judicial norms, the judicial judgment efficiency and the execution efficiency can be improved. Therefore, the contract terms of the contract to be signed need to be reviewed before the contract is signed.

At present, the mode of checking the information of the same clause mainly depends on manpower, so the problems of high checking error rate, low checking efficiency and the like can occur.

Disclosure of Invention

In view of this, the present application discloses a contract auditing method applied to a server, where the method includes:

receiving an auditing request initiated by a user aiming at a target contract;

acquiring a target contract included in the audit request, and extracting keywords from the target contract and each standard contract in the standard contract library based on a trained keyword extraction model to obtain a first keyword of the target contract and a second keyword corresponding to each standard contract;

matching the first keywords with second keywords corresponding to each standard contract to obtain matching results corresponding to each second keyword;

determining a second keyword with the highest matching degree with the first keyword from the matching result, and determining a standard contract corresponding to the second keyword as a standard contract matched with the target contract;

and checking the terms included in the target contract based on the terms included in the standard contract.

In an embodiment, the method further includes:

receiving an editing request initiated by a user for a target contract; wherein the contract edit request includes a contract type of the target contract;

in response to the contract editing request, determining a standard contract with the contract type consistent with the contract type from a maintained standard contract library;

and sending the standard contract to the user so that the user edits the target contract based on the standard contract.

The application discloses a contract auditing method, which is applied to a client side and comprises the following steps:

and sending a checking request aiming at the target contract to a server corresponding to the client based on checking operation of a user aiming at the target contract, so that after receiving the target contract, the server determines a standard contract matched with the target contract from a maintained standard contract library in response to the target contract, and checks the clause included in the target contract based on the clause included in the standard contract.

In an embodiment, the method further includes:

sending an editing request aiming at a target contract to the server side based on the editing operation of a user aiming at the target contract, so that the server side determines a standard contract with the contract type consistent with the contract type of the target contract from a maintained standard contract library in response to the editing request of the contract after receiving the editing request, and sends the standard contract to the client side;

and receiving the standard contract, and displaying the standard contract so that the user edits the target contract based on the standard contract.

The application also provides a contract auditing method based on the block chain, wherein the block chain is provided with an intelligent contract for driving the contract auditing; the method comprises the following steps:

receiving a first call transaction which is checked by a user aiming at a target contract;

responding to the first call transaction, calling auditing logic included in the intelligent contract to determine a standard contract matched with the target contract from a maintained standard contract library, and auditing terms included in the target contract based on terms included in the standard contract;

and acquiring a checking result of the intelligent contract on terms included by the target contract.

In an embodiment, the method further includes:

receiving a second calling transaction edited by the user aiming at the target contract;

and in response to the second invoking transaction, invoking editing logic included in the intelligent contract to determine a standard contract with a contract type consistent with the contract type from a maintained standard contract library, and sending the standard contract to the user so that the user edits the target contract based on the standard contract.

This application still provides a contract and examines device, is applied to the server side, and above-mentioned device includes:

the first receiving module is used for receiving an auditing request initiated by a user aiming at a target contract;

the first determining module is used for acquiring a target contract included by the auditing request, and extracting keywords from the target contract and each standard contract in the standard contract library based on a trained keyword extraction model to obtain a first keyword of the target contract and a second keyword corresponding to each standard contract;

and the auditing module is used for auditing the terms included in the target contract based on the terms included in the standard contract.

In an embodiment, the apparatus further includes:

the second receiving module is used for receiving an editing request initiated by a user aiming at the target contract; wherein the contract edit request includes a contract type of the target contract;

the second determining module is used for determining a standard contract with the contract type consistent with the contract type from a maintained standard contract library in response to the contract editing request;

and the first sending module is used for sending the standard contract to the user so that the user edits the target contract based on the standard contract.

This application still provides a contract auditing device, is applied to the client, and above-mentioned device includes:

and the second sending module is used for sending a checking request aiming at the target contract to a server corresponding to the client based on checking operation of a user aiming at the target contract, so that after receiving the target contract, the server responds to the target contract, determines a standard contract matched with the target contract from a maintained standard contract library, and checks terms included in the target contract based on terms included in the standard contract.

In an embodiment, the apparatus further includes:

a third sending module, configured to send an edit request for a target contract to the server based on an edit operation of a user for the target contract, so that after receiving the edit request, the server determines, in response to the contract edit request, a standard contract with a contract type that is consistent with that of the target contract from a maintained standard contract library, and sends the standard contract to the client;

and the third receiving module is used for receiving the standard contract and displaying the standard contract so that the user can edit the target contract based on the standard contract.

The application also provides a contract auditing device based on the block chain; the block chain is provided with an intelligent contract for driving contract auditing; the above-mentioned device includes:

the fourth receiving module is used for receiving a first calling transaction which is checked by a user aiming at the target contract;

a first calling module, which responds to the first calling transaction, calls the auditing logic included in the intelligent contract to determine a standard contract matched with the target contract from a maintained standard contract library, and audits the terms included in the target contract based on the terms included in the standard contract;

and the acquisition module acquires the auditing result of the intelligent contract on the terms included in the target contract.

In one illustrated embodiment, the intelligent contract includes editing logic for driving contract editing; the above-mentioned device still includes:

the fifth receiving module is used for receiving a second calling transaction edited by the user aiming at the target contract;

and the second calling module is used for calling the editing logic included in the intelligent contract in response to the second calling transaction so as to determine a standard contract with the contract type consistent with the contract type from a maintained standard contract library and send the standard contract to the user, so that the user edits the target contract based on the standard contract.

The present application further proposes an electronic device, comprising:

a processor;

a memory for storing the processor-executable instructions;

wherein the processor is configured to call the executable instructions stored in the memory to implement the contract auditing method as shown in any of the foregoing embodiments.

The present application also proposes a computer-readable storage medium, which stores a computer program for executing the contract auditing method according to any one of the foregoing embodiments.

In the foregoing scheme, in a first aspect, after receiving an audit request, keyword extraction may be performed on the target contract and each standard contract in the standard contract library based on a trained keyword extraction model, so as to obtain a first keyword of the target contract and a second keyword corresponding to each standard contract; matching the first keywords with second keywords corresponding to each standard contract to obtain matching results corresponding to each second keyword; and determining a second keyword which has the highest matching degree with the first keyword from the matching result so as to determine the standard contract corresponding to the second keyword as the standard contract matched with the target contract. After the standard contract matched with the target contract is determined, the terms included in the target contract can be checked based on the terms included in the standard contract, so that the terms of the target contract can be automatically checked. On one hand, because the manual participation is avoided in the contract auditing, the contract auditing efficiency is improved, and the auditing error rate is reduced. On the other hand, the target contract can be checked by taking the clause content as a dimension, so that the checking accuracy is improved.

In a second aspect, after receiving a first call transaction that a user checks a target contract, the first call transaction is responded to by a blockchain intelligent contract, and a checking logic included in the intelligent contract is called to determine a standard contract matched with the target contract from a maintained standard contract library.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the application.

Drawings

In order to more clearly illustrate one or more embodiments of the present application or technical solutions in the related art, the drawings needed to be used in the description of the embodiments or the related art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments described in one or more embodiments of the present application, and other drawings can be obtained by those skilled in the art without inventive exercise.

FIG. 1 is a method flow diagram illustrating a contract auditing method according to the present application;

FIG. 2 is a method flow diagram of a contract editing method shown herein;

FIG. 3 is a diagram of a contract signing scenario illustrated herein;

FIG. 4 is a contract signing flow diagram shown herein;

FIG. 5 is a method flow diagram illustrating a method of contract review according to the present application;

FIG. 6 is a schematic diagram of one type of intelligent contract creation shown herein;

FIG. 7 is a method flow diagram illustrating a method of contract review according to the present application;

fig. 8 is a schematic structural diagram of a contract auditing apparatus shown in the present application;

fig. 9 is a schematic diagram of a hardware structure of an electronic device shown in the present application.

Detailed Description

Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like numbers in different drawings represent the same or similar elements unless otherwise indicated. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present application. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the present application, as detailed in the appended claims.

The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the application. As used in this application and the appended claims, the singular forms "a", "an", and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It should also be understood that the term "and/or" as used herein refers to and encompasses any and all possible combinations of one or more of the associated listed items. It should also be understood that the word "if" as used herein may be interpreted as "at … …" or "at … …" or "in response to a determination," depending on the context.

The application aims to provide a contract auditing method. The method determines the standard contract matched with the target contract from the maintained standard contract library, and audits the clauses included in the target contract based on the clauses included in the standard contract, thereby realizing the automatic auditing of the clauses of the target contract. On one hand, because the manual participation is avoided in the contract auditing, the contract auditing efficiency is improved, and the auditing error rate is reduced. On the other hand, the target contract can be checked by taking the clause content as a dimension, so that the checking accuracy is improved.

Referring to fig. 1, fig. 1 is a flowchart illustrating a method of contract auditing according to the present application.

As shown in fig. 1, the method may include:

s102, receiving an auditing request initiated by a user aiming at a target contract.

S104, acquiring a target contract included in the audit request, and extracting keywords from the target contract and each standard contract in the standard contract library based on a trained keyword extraction model to obtain a first keyword of the target contract and a second keyword corresponding to each standard contract.

And S106, matching the first keywords with the second keywords corresponding to the standard contracts to obtain matching results corresponding to the second keywords.

And S108, determining a second keyword which has the highest matching degree with the first keyword from the matching result, and determining the standard contract corresponding to the second keyword as the standard contract matched with the target contract.

S110, based on the terms included in the standard contract, the terms included in the target contract are checked.

The contract auditing method can be applied to electronic equipment. The electronic device may execute the image processing method by installing a software system corresponding to the contract verification method. The type of the electronic device may be a notebook computer, a server, a mobile phone, a PAD terminal, etc., and is not particularly limited in this application.

It is understood that the above image processing method may be executed by only the client device or the server device, or may be executed by the client device and the server device in cooperation.

For example, the contract auditing method described above may be integrated with the client. After receiving the contract checking request, the client equipment carrying the client can provide calculation power through the hardware environment of the client equipment to execute the contract checking method.

For another example, the contract auditing method can be integrated into a contract management platform (the contract management platform is used for driving operations such as online edition, signing and automatic execution of contracts). After receiving the contract checking request, the server-side equipment carrying the contract management platform can provide calculation power through the hardware environment of the server-side equipment to execute the contract checking method.

For example, the contract auditing method can be divided into two tasks of initiating an auditing request and auditing the target contract. Wherein, the task of initiating the request can be integrated in the client and carried on the client device. The auditing task can be integrated in the server and carried with the server device. The client device may initiate a contract verification request to the server device after receiving a verification operation of the contracting party for the target contract. After receiving the contract checking request, the server device may execute the contract checking method on the target contract in response to the request.

The user may specifically refer to any person who has an audit requirement on the contract. For example, the user may be a contract contractor or a contract administrator, etc. The contract signing party may specifically refer to any party in the contract signing parties who need to sign the contract. For example, user a, user B, and user C need to sign a target contract. At this time, any one of the three parties may be used as a contractor to perform auditing for the target contract.

The target contract may be a to-be-audited contract. For example, in the aforementioned contract scenario online, the aforementioned target contract may be a contract to be signed.

The standard contract library may be a collection storing a plurality of standard contracts. The standard contract may be a standard contract with the normative provisions being accepted. For example, the standard contract may be a standard contract recommended by the highest judicial authority. For another example, the standard contract may be a standard contract that is selected and processed by several judicial authorities. In some examples, the standard contracts repository may be certified to the blockchain.

In the application, when the standard contract library is maintained, standard contracts of different contract types can be selected for maintenance, so that the applicability of the standard contract library is improved as much as possible. The maintenance method of the standard contract base is not particularly limited in the present application.

The contract type may be specifically a type determined by contract constraint content. For example, if the contract-bound content is a house rental, the contract type of the contract can be a house rental contract. If the contract-constrained content is a commodity trade, the contract type for the contract may be a trade contract. The contract type may be set according to requirements or not. The above contract types are not exhaustive in this application.

The term may specifically refer to a text content constrained by the contract term.

The following describes the present example by taking the execution subject as a server device (hereinafter referred to as a server).

When the contract is checked, the server may execute S102 to receive a checking request initiated by the user for the target contract.

In some examples, the server may provide an interface to the client, such as an API interface. And after receiving the auditing operation of the user for the target contract, the client can initiate an auditing request to the API interface. At this time, the server may send the audit request through the API interface.

In some examples, the server may directly provide an interface for the user, so that the user performs an auditing operation for the target contract based on the interface. After receiving the selection operation of the user, the server may determine that an audit request initiated by the user for a target contract is received.

After receiving the audit request, the server may determine, in response to the target contract, a standard contract matching the target contract from a standard contract library maintained by the server.

In some examples, S104 may be executed to perform keyword extraction on the target contract and each standard contract in the standard contract library based on the trained keyword extraction model, so as to obtain a first keyword of the target contract and a second keyword corresponding to each standard contract.

After the first keyword and the second keyword are obtained, S106 may be executed to match the first keyword with the second keyword corresponding to each standard contract, so as to obtain a matching result corresponding to each second keyword.

After obtaining a plurality of matching results, S108 may be executed to determine a second keyword having the highest matching degree with the first keyword from the matching results, and determine a standard contract corresponding to the second keyword as a standard contract matching the target contract.

The keyword extraction model may be a model constructed based on a neural network. Before the model is used, a plurality of training samples marked with keyword marking information can be used for training. The keyword annotation information can be set according to actual service requirements. For example, the keyword tagging information may be a contract topic or a contract type. The specific content of the keyword annotation information is not performed in the present application. After training is completed, the model can be used for extracting keywords.

In some examples, the contract type corresponding to the target contract may be determined first when performing this step.

In some examples, in determining the contract type of the target contract, a window may be provided to the user to allow the user to fill in the contract type of the target contract. Based on the filling operation for the user, the contract type of the target contract can be determined.

In some examples, to automatically determine the contract type, the target contract can be classified using a contract type classification model constructed based on a neural network to determine the contract type of the target contract.

It should be noted that the classification model may be trained based on several training samples labeled with contract types, and will not be described in detail here.

After determining the contract type of the target contract, the standard contract that is consistent with the contract type of the target contract in the maintained standard contract library may be determined as the standard contract matching the target contract.

In some examples, standard contract maintenance may be performed in the dimension of contract type when maintaining the standard contract library described above. At this time, when the matching standard contract is determined, the standard contract matching the contract type of the target contract may be directly searched for in the standard contract library, and the searched-for standard contract may be determined as the standard contract matching the target contract.

After determining the standard contract matching the target contract, the server may execute S110 to review the terms included in the target contract based on the terms included in the standard contract.

In some examples, the text extraction may be performed on the standard contract and the target contract through a pre-trained text extraction model, so as to obtain the clause content included in the standard contract and the clause content included in the target contract.

Then, the clause content included in the standard contract and the clause content included in the target contract can be matched, and if the clause content included in the standard contract and the clause content included in the target contract are matched, the examination is determined to be passed; otherwise, determining that the audit is not passed.

In some examples, the clause properties corresponding to the terms included in the standard contract may be determined as the target clause properties in sequence, and the following steps are performed:

determining whether said target contract includes terms of the nature of said target terms;

and if the target contract lacks the clause of the target clause property, generating a verification result based on the clause corresponding to the target clause property and included in the standard contract.

The term property specifically refers to a property of content division according to a term agreement. For example, if a certain piece of money is agreed to default liability, then the nature of the terms of the piece of money is the default liability. As another example, if a piece of agreement is on dispute resolution, the term of the piece may be in the nature of dispute resolution. For example, if a contract is made, the terms of the terms are contract.

The auditing result can be used for prompting the difference between the target contract and the standard contract. In some examples, in order to facilitate the user to modify the target contract, the review result may include a term included in the standard contract and corresponding to the target term property.

In executing S110, if the target contract includes the target clause property, further identifying a first clause included in the target contract and corresponding to the target clause property, and identifying a second clause included in the standard contract and corresponding to the target clause property;

extracting keywords from the first and second clauses to obtain a third keyword corresponding to the first clause and a fourth keyword corresponding to the second clause;

determining whether the third keyword matches the fourth keyword;

and if the third keyword and the fourth keyword fail to be matched, determining that the verification is not passed, and generating a verification result based on the second clause.

In some examples, when the first term included in the target contract is identified, which corresponds to the target term property, the target contract may be subjected to text processing by using an OCR recognition technology to identify the first term.

The OCR recognition technology may be specifically a technology for recognizing characters in a picture. If the target contract is uploaded in the form of a picture, the OCR recognition technology may be utilized to perform text processing on the picture corresponding to the target contract to recognize text content included in the target contract.

After the text content included in the target contract is identified, a phrase or a sentence including the property of the target clause may be searched for in the text content, and the phrase or the sentence is determined as the first clause.

It should be noted that the method for determining the second clause may refer to the method for determining the first clause, and will not be described in detail herein.

In some examples, when the first clause corresponding to the target clause property included in the target contract is identified, the target contract may be subjected to text processing based on a text recognition model constructed by a neural network, and the first clause is identified.

The text recognition model may be an NLP (natural language processing) model constructed based on a deep learning network. The text content included in the target contract can be identified through the text identification model, and the text content included in the target contract is identified.

It should be noted that the present application does not describe the specific structure and training method of the text recognition model. Reference is made to the related art with respect to the above description.

After the first clause and the second clause are identified, keyword extraction can be carried out on the first clause and the second clause to obtain a third keyword corresponding to the first clause and a fourth keyword corresponding to the second clause;

determining whether the third keyword matches the fourth keyword;

In some examples, if the target contract is not approved, the server may execute step S112 to send the approval result to the user, so that the user adjusts the target contract based on the approval result.

In some examples, when performing this step, the server may return the audit result to a client used by a user, so that the client displays the audit result to the user. The user can modify the target contract based on the auditing result. After the modification is finished, the user can continue to initiate an audit request for the modified contract.

In some examples, if the third keyword and the fourth keyword match successfully, it may be determined that the review for the target contract passes.

It should be noted that whether the keyword matching is successful or not may be determined by the developer according to the actual business situation. For example, the key indicator of successful matching may be a difference rate between the third key word and the fourth key word. If the difference rate does not reach a preset threshold value, the matching is considered to be successful; otherwise, the matching is considered to fail.

In the above scheme, after receiving the request for checking, the standard contract matching the target contract may be determined from the standard contract library maintained, and the terms included in the target contract are checked based on the terms included in the standard contract, thereby implementing automatic checking of the terms of the target contract. On one hand, because the manual participation is avoided in the contract auditing, the contract auditing efficiency is improved, and the auditing error rate is reduced. On the other hand, the target contract can be checked by taking the clause content as a dimension, so that the checking accuracy is improved.

In some examples, to assist the user in editing the target contract, the server may further match the user with a standard contract to enable the user to edit the target contract based on the standard contract.

Referring to fig. 2, fig. 2 is a flowchart illustrating a method of contract editing according to the present application.

As shown in fig. 2, the method may include:

s202, receiving an editing request initiated by a user aiming at a target contract; wherein the contract edit request includes a contract type of the target contract.

In some examples, when the user has a target contract editing requirement, the editing operation may be performed on the target contract through an interface provided for the user by a client corresponding to the user. In some examples, the user may select the contract type of the target contract when performing the editing operation.

After receiving the editing operation, the client may construct an editing request and send the editing request to the server.

After receiving the edit request, the server may execute step S204, and determine a standard contract with a contract type consistent with the contract type from a maintained standard contract library in response to the contract edit request.

It should be noted that, the method for performing this step may refer to the foregoing content, and is not described in detail herein.

After determining the standard contract with the contract type consistent with the contract type, the server may execute S206 to send the standard contract to the user, so that the user edits the target contract based on the standard contract.

In some examples, the server may send the standard contract to a client corresponding to the user. After receiving the standard contract, the client may display the standard contract to the user, so that the user edits the target contract based on the standard contract.

In some examples, in performing S204, a plurality of standard contracts having contract types consistent with the contract types described above may be determined from a maintained standard contract library. In this case, the server may send the plurality of identified standard contracts to the user, so that the user selects a target standard contract from the plurality of standard contracts, and edits the target contract based on the selected target standard contract.

In this example, the server may send the determined multiple standard contracts to the user for selection, so as to improve user experience.

The following describes the embodiments of the present application in conjunction with the scenario of online contract signing.

Referring to fig. 3, fig. 3 is a diagram illustrating a contract signing scenario according to the present application.

As shown in fig. 3, user a and user B need to contract through the contract management platform C. And the client sides corresponding to the user A and the user B are respectively in communication connection with the server side corresponding to the contract management platform C.

Referring to fig. 4, fig. 4 is a flow chart illustrating contract signing according to the present application.

When the user A and the user B have some contracts and signs, the user A can execute contract editing operation through an interface provided by the client A for the user A.

The client a may respond to the editing operation, execute S402, construct an editing request, and send the editing request to the server C.

After receiving the request, the server C may execute step S404, and determine a standard contract with a contract type consistent with the contract type from a standard contract library maintained in response to the contract editing request.

If the number of the determined standard contracts is multiple, the server C may execute step S406 to send the determined standard contracts to the client a.

After receiving the plurality of standard contracts, the client a may execute S408, which presents the plurality of standard contracts to the user, so that the user selects a target standard contract from the plurality of standard contracts, and edits the target contract based on the selected target standard contract.

After receiving the auditing operation of the user for the edited contract, the client a may execute S410, construct an auditing request, and send the auditing request to the server C.

After receiving the verification request, the server C may execute S412 to verify the contract terms of the target contract based on the contract terms of the previously matched standard contract.

If the audit is passed, the server C may execute step S416, and initiate a contract signing process to the server B after the signing request of the user a is verified. In some examples, the contract signing process may be implemented based on blockchain and smart contract techniques, which are not described in detail herein.

If the audit is not passed, the server C may execute 414, construct an audit result, and send the audit result to the client a.

After receiving the audit result, the client a may display the audit result to the user so that the user may correct the contract based on the audit result. After the user finishes the correction, the user can initiate the auditing process again.

In the above embodiment, on the one hand, the method can assist the user a in contract editing, thereby simplifying the contract editing process of the user a, and improving the normalization and editing efficiency of the contract edited by the user a. On the other hand, the method can realize automatic audit of the contract edited by the user A and feed back the audit result to the user A in real time so as to ensure the normalization of signing the contract.

Corresponding to the above embodiment, the application also provides a contract auditing method, which is applied to the client. The method enables the client and the server to interact, so that the contract auditing method disclosed by any one of the embodiments is realized.

In some examples, the client may send a request for checking a target contract to a server corresponding to the client based on a checking operation of a user for the target contract, so that the server determines, in response to the target contract, a standard contract matching the target contract from a standard contract library maintained after receiving the target contract, and checks terms included in the target contract based on terms included in the standard contract.

Referring to fig. 5, fig. 5 is a flowchart illustrating a method of contract auditing according to the present application.

As described above in fig. 5, the method may include:

s502, sending an editing request aiming at a target contract to the server side based on the editing operation of a user aiming at the target contract, so that after the server side receives the editing request, responding to the editing request of the contract, determining a standard contract with the contract type consistent with that of the target contract from a standard contract library maintained, and sending the standard contract to the client side;

s504, the standard contract is received, and the standard contract is displayed so that the user can edit the target contract based on the standard contract.

The application also provides a contract auditing method based on the block chain. The method enables the node device to execute the contract auditing method described in any one of the previous embodiments through a block chain technology.

The method can be applied to a contract auditing system constructed based on the block chain. The auditing system may include several node devices. The node device may be a client device corresponding to a user or a server device providing a service for the client.

The block chain technology, also called distributed ledger technology, is an emerging technology in which several computing devices participate in "accounting" together, and a complete distributed database is maintained together. The blockchain technology has been widely used in many fields due to its characteristics of decentralization, transparency, participation of each computing device in database records, and rapid data synchronization between computing devices.

Blockchains are generally divided into three types: public chain (Public Blockchain), Private chain (Private Blockchain) and alliance chain (Consortium Blockchain). In addition, there are various types of combinations, such as private chain + federation chain, federation chain + public chain, and other different combinations. The most decentralized of these is the public chain. The public chain is represented by bitcoin and ether house, and the participators joining the public chain can read the data record on the chain, participate in transaction, compete for accounting right of new blocks, and the like.

Furthermore, each participant (i.e., node) is free to join and leave the network and perform related operations. Private chains are the opposite, with the network's write rights controlled by an organization or organization and the data read rights specified by the organization. Briefly, a private chain can be a weakly centralized system with strictly limited and few participating nodes. This type of blockchain is more suitable for use within a particular establishment.

A federation chain is a block chain between a public chain and a private chain, and "partial decentralization" can be achieved. Each node in a federation chain typically has a physical organization or organization corresponding to it; participants jointly maintain blockchain operation by authorizing to join the network and forming a benefit-related alliance.

Whether public, private, or alliance, may provide the functionality of an intelligent contract. An intelligent contract on a blockchain is a contract that can be executed on a blockchain system triggered by a transaction. An intelligent contract may be defined in the form of code.

Taking the ethernet as an example, the support user creates and invokes some complex logic in the ethernet network, which is the biggest challenge of ethernet to distinguish from bitcoin blockchain technology. The core of the ethernet plant as a programmable blockchain is the ethernet plant virtual machine (EVM), each ethernet plant node can run the EVM. The EVM is a well-behaved virtual machine, which means that a variety of complex logic can be implemented through it. The user issuing and invoking smart contracts in the etherhouse is running on the EVM. In fact, what the virtual machine directly runs is virtual machine code (virtual machine bytecode, hereinafter referred to as "bytecode"). The intelligent contracts deployed on the blockchain may be in the form of bytecodes.

For example, as shown in fig. 6, after Bob sends a Transaction (Transaction) containing information to create an intelligent contract to the ethernet network, the EVM of node 1 may execute the Transaction and generate a corresponding contract instance. In fig. 6, "0 x68e12cf284 …" represents the address of the contract, the data field of the transaction holds the byte code, and the to field of the transaction is an empty account. After the agreement is achieved between the nodes through the consensus mechanism, the contract is successfully created, and the subsequent user can call the contract.

After the contract is created, a contract account corresponding to the intelligent contract appears on the blockchain and has a specific address, and the contract code and the account storage are stored in the contract account. The behavior of an intelligent contract is controlled by the contract code, while the account store (Storage) of the intelligent contract maintains the state of the contract. In other words, the intelligent contract causes a virtual account to be generated on the blockchain that contains the contract code and account storage.

As mentioned above, the data field containing the transaction that created the smart contract holds what may be the byte code of the smart contract. A bytecode consists of a series of bytes, each of which can identify an operation. Based on the multiple considerations of development efficiency, readability and the like, a developer can select a high-level language to write intelligent contract codes instead of directly writing byte codes. For example, a high-level language such as Solidity, Serpent, LLL, etc. is used. For intelligent contract code written in a high-level language, the intelligent contract code can be compiled by a compiler to generate byte codes which can be deployed on a blockchain.

Taking the Solidity language as an example, the contract written by the method is similar to a Class (Class) in an object-oriented programming language, and various members including state variables, functions, function modifiers, events and the like can be declared in one contract. A state variable is a value permanently stored in the account storage of a smart contract that is used to save the state of the contract.

In some examples, the blockchain deploys intelligent contracts to drive contract audits. The block chain may be a private chain, a public chain or a federation chain. The specific type of blockchain is not limited in this application. In some examples, the blockchain may be a judicial chain.

Referring to fig. 7, fig. 7 is a flowchart illustrating a method of contract auditing according to the present application.

As described above with reference to fig. 7, the node device may execute S706 to receive a first invocation transaction that is approved by the user for the target contract.

S708, responding to the first invoking transaction, invoking auditing logic included in the intelligent contract to determine a standard contract matched with the target contract from a maintained standard contract library, and auditing terms included in the target contract based on terms included in the standard contract.

And S710, obtaining the auditing result of the intelligent contract on the terms included in the target contract.

In this example, the node device may obtain the contract code of the intelligent contract through the contract address included in the first invocation transaction, and execute the obtained contract code in a locally-installed EVM environment to execute the method. It will be appreciated that in some examples, the EVM environment may specifically be a trusted execution environment, in which case the retrieved contract code may be executed in the trusted execution environment to increase the privacy level of the intelligent contract surrogate.

Then, the node device may issue the execution result of the contract code to a blockchain for storage; for example, in one example, the execution result may be written in a form of a log into a transaction receipt (receive) corresponding to the first invoked transaction; alternatively, in another example, the execution result may be stored in an account storage space corresponding to the smart contract.

In the scheme, the contract auditing is driven by the block chain intelligent contract, so that the auditing and traceability of the contract auditing process can be realized, and the credibility of the contract auditing method is increased.

In some examples, while determining a standard contract matching the target contract from a maintained standard contract library in response to the first invoking transaction, the node device may generate a contract determination event to determine a contract type corresponding to the target contract during running of the intelligent contract.

In some examples, the contract types described above may be obtained through interaction with a user.

For example, the node device may generate a contract type determination event for a client interacting with the user, so that the client interacts with the user to obtain the contract type of the target contract.

The node device may receive an event response returned by the client, thereby obtaining a contract type, and determine, in the maintained standard contract library, a standard contract that is consistent with the contract type of the target contract as a standard contract that matches the target contract.

In some examples, the contract type may be determined with the assistance of a trained keyword extraction model. The keyword extraction model may be deployed in an out-of-chain business system that interfaces with the blockchain.

In some examples, the method may further include interacting with the off-chain business system in response to the first invoking transaction, submitting the target contract and the standard contract in the standard contract library to the business system, extracting, by the off-chain business system, a first keyword from the target contract and a second keyword from the standard contract based on the keyword extraction model, and further submitting the extracted first keyword and the extracted second keyword to the intelligent contract.

After the intelligent contract receives the first keyword and the second keyword, the first keyword can be matched with the second keyword corresponding to each standard contract, and a matching result corresponding to each second keyword is obtained. And then determining a second keyword which has the highest matching degree with the first keyword from the matching result, and determining a standard contract corresponding to the second keyword as a standard contract matched with the target contract.

In some examples, a keyword extraction event corresponding to the target contract and a standard contract in the standard contract library may be generated in response to the first invoking transaction, so that the extralink business system extracts a first keyword from the target contract and a second keyword from the standard contract based on the keyword extraction model in response to the keyword extraction event, and further submits the extracted first keyword and second keyword to the smart contract.

In some examples, the node device may generate the keyword extraction event according to the target contract and a standard contract in the standard contract library in response to the first invocation transaction; and then, the event can be transmitted to the out-of-chain service system based on the modes of message pushing, message subscription, monitoring and the like.

The off-link service system may parse the keyword extraction event to obtain the target contract and the standard contract. The keyword extraction model may then be utilized to extract a first keyword from the target contract and a second keyword from the standard contract. The system may then return the extracted keywords to the smart contract in the format or component transaction agreed upon by the event mechanism.

In some examples, the target contract and the standard contracts in the standard contract library may be sent to the off-chain business system through a jointed president program in response to the first call transaction, so that the off-chain business system extracts keywords from the target contract and the standard contracts in the standard contract library based on the keyword extraction model while acquiring the target contract and the standard contracts, and further submits the extracted keywords to the intelligent contract through the president program.

In some examples, the node device may construct a predictive engine call transaction based on the target contract and the standard contract, so that the predictive engine program sends the target contract and the standard contract to the off-link business system in response to the transaction. It is to be understood that the calling transaction may include a certification address corresponding to the target contract and the standard contract, so that the off-link business system and/or the predicting machine program obtains the target contract and the standard contract based on the certification address.

The off-link business system may extract a first keyword from the target contract and a second keyword from the standard contract using the keyword extraction model. The system may then return the extracted keywords to the intelligent contract in the format agreed upon by the predictive machine program.

Other embodiments of the contract auditing method implemented based on the node device are described below, and it is understood that the implementation process of the following examples can refer to the foregoing embodiments, and is not described in detail herein.

In some examples, when the terms included in the target contract are checked based on the terms included in the standard contract, the term properties corresponding to the terms included in the standard contract may be sequentially determined as the target term properties, and the following steps are performed:

In some examples, the method further comprises:

if the target contract includes the target clause property, further identifying a first clause included in the target contract corresponding to the target clause property and identifying a second clause included in the standard contract corresponding to the target clause property;

determining whether the third keyword matches the fourth keyword;

Then, S710 may be executed to obtain a result of checking the terms included in the target contract by the intelligent contract.

In some examples, when the first clause included in the target contract and corresponding to the target clause property is identified, the target contract may be subjected to text processing by using an OCR recognition technology or a text recognition model constructed based on a neural network, so as to identify text content included in the target contract;

in the text content, a phrase or a sentence including the target clause property is determined, and the phrase or the sentence is determined as the first clause.

In some examples, the method further comprises:

and if the audit is not passed, sending the audit result to the user so that the user adjusts the target contract based on the audit result.

In some examples, the method further comprises:

and if the verification is passed, initiating a signing flow aiming at the target contract.

In some examples, the intelligent contracts include editing logic for driving contract editing.

The node device may perform S702, and receive a second invocation transaction edited by the user for the target contract.

And S704, in response to the second invoking transaction, invoking an editing logic included in the intelligent contract to determine a standard contract with a contract type consistent with the contract type from a maintained standard contract library, and sending the standard contract to the user, so that the user edits the target contract based on the standard contract.

In this example, the node device may obtain the smart contract through a contract address included in the second invocation transaction, and perform the method in a locally-installed EVM environment. It is to be appreciated that in some examples, the EVM environment described above is a trusted execution environment.

And then the node equipment can store the execution result into an account corresponding to the intelligent contract.

In some examples, the method further comprises:

if a plurality of standard contracts with the contract types consistent with the contract types are determined from the maintained standard contract library;

and sending the determined plurality of standard contracts to the user so that the user selects a target standard contract from the plurality of standard contracts and edits the target contract based on the selected target standard contract.

The application also provides a contract auditing device. The device is applied to the server side.

Referring to fig. 8, fig. 8 is a schematic structural diagram of a contract auditing apparatus shown in the present application.

As shown in fig. 8, the apparatus 800 includes:

a first receiving module 810, which receives an audit request initiated by a user for a target contract;

a first determining module 820, configured to obtain a target contract included in the audit request, and perform keyword extraction on the target contract and each standard contract in the standard contract library based on a trained keyword extraction model to obtain a first keyword of the target contract and a second keyword corresponding to each standard contract;

the auditing module 830 audits the terms included in the target contract based on the terms included in the standard contract.

In an embodiment, the first determining module 820 includes:

the first determining submodule determines the contract type corresponding to the target contract;

determining a standard contract which is consistent with the contract type of the target contract in a maintained standard contract library as a standard contract matched with the target contract;

or the like, or, alternatively,

extracting keywords from the target contract and each standard contract in the standard contract library based on a keyword extraction model constructed by a neural network to obtain first keywords of the target contract and second keywords corresponding to each standard contract;

and determining a second keyword which has the highest matching degree with the first keyword from the matching result, and determining a standard contract corresponding to the second keyword as a standard contract matched with the target contract.

In an illustrated embodiment, the auditing module 830 includes:

the execution module determines the clause properties corresponding to the clauses included in the standard contract as target clause properties in turn, and executes:

In an embodiment shown, the executing module further includes: ,

an identification module, configured to further identify a first clause included in the target contract and corresponding to the target clause property, and identify a second clause included in the standard contract and corresponding to the target clause property, if the target contract includes the target clause property;

an extraction module, configured to extract keywords from the first and second entries to obtain a third keyword corresponding to the first entry and a fourth keyword corresponding to the second entry;

a matching module for determining whether the third keyword is matched with the fourth keyword;

In an embodiment, the identification module includes:

performing text processing on the target contract by using an OCR (optical character recognition) technology or a text recognition model constructed based on a neural network, and recognizing text content included in the target contract;

In an embodiment, the apparatus 800 further includes:

the adjusting module 840 sends the audit result to the user if the audit is not passed, so that the user adjusts the target contract based on the audit result.

In an embodiment, the apparatus 800 further includes:

and the initiating module 850, if the audit is passed, initiating a signing flow aiming at the target contract.

In an embodiment, the apparatus 800 further includes:

a second receiving module 860, which receives an editing request initiated by the user for the target contract; wherein the contract edit request includes a contract type of the target contract;

a second determining module 870, for determining a standard contract with a contract type consistent with the contract type from a standard contract library maintained in response to the contract editing request;

the first sending module 880 sends the standard contract to the user so that the user edits the target contract based on the standard contract.

In an embodiment, the apparatus 800 further includes:

a fourth sending module, if a plurality of standard contracts with the contract types consistent with the contract types are determined from the maintained standard contract library;

The present application further provides a contract auditing apparatus 900, which is applied to a client, where the apparatus 900 includes:

the second sending module 910 sends an audit request for a target contract to a server corresponding to the client based on an audit operation of a user for the target contract, so that the server executes a contract audit method as shown in any one of the foregoing embodiments after receiving the target contract.

In some examples, the second sending module 910 sends, based on a checking operation of a user for a target contract, a checking request for the target contract to a server corresponding to the client, so that after receiving the target contract, the server determines, in response to the target contract, a standard contract matching the target contract from a standard contract library maintained by the server, and checks terms included in the target contract based on terms included in the standard contract.

In an embodiment, the apparatus 900 further includes:

a third sending module 920, configured to send an edit request for a target contract to the server based on an edit operation of a user for the target contract, so that the server performs a contract auditing method according to any one of the foregoing embodiments after receiving the edit request.

In some examples, the third sending module 920 sends an edit request for a target contract to the server based on an edit operation of a user for the target contract, so that after receiving the edit request, the server determines, in response to the contract edit request, a standard contract with a contract type that is consistent with the contract type of the target contract from a maintained standard contract library, and sends the standard contract to the client;

the third receiving module 930 receives the standard contract and displays the standard contract to enable the user to edit the target contract based on the standard contract.

The application also provides a contract auditing device 100 based on the block chain. The block chain deploys intelligent contracts for driving contract auditing to enable the device to execute a contract auditing method as shown in any one of the embodiments.

In some examples, the apparatus 100 described above includes:

the fourth receiving module 110 receives a first invocation transaction that is checked by a user for a target contract;

the first invoking module 120, in response to the first invoking transaction, invokes auditing logic included in the intelligent contract to determine a standard contract matching the target contract from a maintained standard contract library, and audits terms included in the target contract based on terms included in the standard contract.

The obtaining module 130 obtains a result of checking the terms included in the target contract by the intelligent contract.

In some embodiments, the first calling module 120 includes:

in response to the first invoking transaction, interacting with the off-chain business system, submitting the target contract and the standard contract in the standard contract library to the business system, so as to extract a first keyword from the target contract and a second keyword from the standard contract by the off-chain business system based on the keyword extraction model, and further submitting the extracted first keyword and the extracted second keyword to the intelligent contract;

In some embodiments, the first calling module 120 includes:

generating a keyword extraction event corresponding to the target contract and a standard contract in the standard contract library in response to the first call transaction, so that the off-link business system extracts a first keyword from the target contract and a second keyword from the standard contract based on the keyword extraction model in response to the keyword extraction event, and further submits the extracted first keyword and second keyword to the intelligent contract; alternatively, the first and second electrodes may be,

and in response to the first call transaction, sending the target contract and the standard contracts in the standard contract library to the off-chain service system through the butted presbyope program, so that the off-chain service system extracts keywords from the target contract and the standard contracts in the standard contract library based on the keyword extraction model while acquiring the target contract and the standard contracts, and further submits the extracted keywords to the intelligent contract through the presbyope program.

In some embodiments, the first calling module 120 includes:

and determining the clause properties corresponding to the clauses included in the standard contract as target clause properties in sequence, and executing:

In some illustrated embodiments, the apparatus 100 further comprises:

In some embodiments shown, the identification module comprises:

In some illustrated embodiments, the apparatus 100 further comprises:

and the adjusting module is used for sending the auditing result to the user if the auditing is not passed so as to enable the user to adjust the target contract based on the auditing result.

In some illustrated embodiments, the apparatus 100 further comprises:

and the initiating module initiates a signing flow aiming at the target contract if the audit is passed.

In some illustrated embodiments, the smart contracts include editing logic for driving contract editing; the above apparatus 100 further comprises:

In some illustrated embodiments, the apparatus 100 further comprises:

the sending module is used for determining a plurality of standard contracts with contract types consistent with the contract types from the maintained standard contract library;

The embodiment of the contract auditing device shown in the application can be applied to electronic equipment. Accordingly, the present application discloses an electronic device, which may comprise: a processor.

A memory for storing processor-executable instructions.

Wherein the processor is configured to call the executable instructions stored in the memory to implement the contract auditing method as shown in any of the above embodiments.

Referring to fig. 9, fig. 9 is a schematic diagram of a hardware structure of an electronic device shown in the present application.

As shown in fig. 9, the electronic device may include a processor for executing instructions, a network interface for making network connection, a memory for storing operation data for the processor, and a nonvolatile memory for storing instructions corresponding to the contract auditing apparatus.

The embodiment of the contract auditing device can be realized by software, or by hardware or a combination of hardware and software. Taking a software implementation as an example, as a logical device, the device is formed by reading, by a processor of the electronic device where the device is located, a corresponding computer program instruction in the nonvolatile memory into the memory for operation. In terms of hardware, in addition to the processor, the memory, the network interface, and the nonvolatile memory shown in fig. 9, the electronic device in which the apparatus is located in the embodiment may also include other hardware according to an actual function of the electronic device, which is not described again.

It is understood that, in order to increase the processing speed, the corresponding command of the contract auditing device may also be directly stored in the memory, which is not limited herein.

The present application provides a computer-readable storage medium, in which a computer program is stored, where the computer program is used to execute the contract auditing method shown in any one of the above embodiments.

One skilled in the art will recognize that one or more embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, one or more embodiments of the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, one or more embodiments of the present application may take the form of a computer program product (which may include, but is not limited to, disk storage, CD-ROM, optical storage, and the like) embodied as described above in one or more computer-usable storage media having computer-usable program code embodied therein.

"and/or" in this application means having at least one of the two, for example, "a and/or B" may include three schemes: A. b, and "A and B".

The embodiments in the present application are described in a progressive manner, and the same and similar parts among the embodiments can be referred to each other, and each embodiment focuses on the differences from the other embodiments. In particular, for the data processing apparatus embodiment, since it is substantially similar to the method embodiment, the description is relatively simple, and for the relevant points, reference may be made to part of the description of the method embodiment.

The foregoing description of specific embodiments of the present application has been presented. Other embodiments are within the scope of the following claims. In some cases, the acts or steps recited in the claims may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.

Embodiments of the subject matter and functional operations described in this application may be implemented in the following: digital electronic circuitry, tangibly embodied computer software or firmware, computer hardware that may include the structures disclosed in this application and their structural equivalents, or combinations of one or more of them. Embodiments of the subject matter described in this application can be implemented as one or more computer programs, i.e., one or more modules encoded in tangible, non-transitory program carriers that execute on or control the operation of data processing apparatus. Alternatively or additionally, the program instructions may be encoded in an artificially generated propagated signal, e.g., a machine-generated electrical, optical, or electromagnetic signal, that is generated to encode information for transmission to suitable receiver apparatus for execution by the data processing apparatus. The computer storage medium may be a machine-readable storage device, a machine-readable storage substrate, a random or serial access memory device, or a combination of one or more of them.

The processes and logic flows described in this application can be performed by one or more programmable computers executing one or more computer programs to perform corresponding functions by operating on input data and generating output. The processes and logic flows described above can also be performed by, and apparatus can also be implemented as, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit).

Computers suitable for executing computer programs may include, for example, general and/or special purpose microprocessors, or any other type of central processing unit. Generally, a central processing unit will receive instructions and data from a read-only memory and/or a random access memory. The basic components of a computer may include a central processing unit for implementing or executing instructions and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto-optical disks, or optical disks. However, a computer does not necessarily have such a device. Moreover, a computer may be embedded in another device, e.g., a mobile telephone, a Personal Digital Assistant (PDA), a mobile audio or video player, a game console, a Global Positioning System (GPS) receiver, or a portable storage device such as a Universal Serial Bus (USB) flash drive, to name a few.

Computer-readable media suitable for storing computer program instructions and data can include all forms of non-volatile memory, media and memory devices, including by way of example semiconductor memory devices (e.g., EPROM, EEPROM, and flash memory devices), magnetic disks (e.g., internal hard disk or removable disks), magneto-optical disks, and CD ROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in, special purpose logic circuitry.

Although this application contains many specific implementation details, these should not be construed as limiting the scope of any disclosure or of what may be claimed, but rather as merely describing features of particular disclosed embodiments. Certain features that are described in this application in the context of separate embodiments can also be implemented in combination in a single embodiment. In other instances, features described in connection with one embodiment may be implemented as discrete components or in any suitable subcombination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a subcombination or variation of a subcombination.

Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. In some cases, multitasking and parallel processing may be advantageous. Moreover, the separation of various system modules and components in the embodiments described above should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.

Thus, particular embodiments of the subject matter have been described. Other embodiments are within the scope of the following claims. In some cases, the actions recited in the claims can be performed in a different order and still achieve desirable results. Further, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some implementations, multitasking and parallel processing may be advantageous.

The above description is only for the purpose of illustrating the preferred embodiments of the present application and is not intended to limit the present application to the particular embodiments of the present application, and any modifications, equivalents, improvements, etc. made within the spirit and principles of the present application should be included within the scope of the present application.

Claims

1. A contract auditing method is applied to a server, wherein the server is a block chain; the block chain is provided with an intelligent contract used for driving contract auditing; a trained keyword extraction model is deployed in an out-of-chain service system butted with the block chain; the method comprises the following steps:

in response to the first invoking transaction, interacting with the off-chain business system, submitting the target contract and standard contracts in a maintained standard contract library to the off-chain business system for extracting, by the off-chain business system, a first keyword from the target contract and a second keyword from the standard contract based on the keyword extraction model, and further submitting the extracted first keyword and the second keyword to the intelligent contract;

and auditing the terms included in the target contract based on the terms included in the standard contract.

2. The method of claim 1, wherein reviewing terms included in the target contract based on terms included in the standard contract comprises:

determining whether the target contract includes terms of the target term nature;

and if the target contract lacks the terms of the target term property, generating a checking result based on the terms corresponding to the target term property and included in the standard contract.

3. The method of claim 2, further comprising:

extracting keywords of the first clause and the second clause to obtain a third keyword corresponding to the first clause and a fourth keyword corresponding to the second clause;

determining whether the third keyword matches the fourth keyword;

and if the third keyword and the fourth keyword fail to be matched, determining that the examination is not passed, and generating an examination result based on the second term.

4. The method of claim 3, the identifying a first term included in the target contract that corresponds to the target term property, comprising:

in the text content, determining a phrase or sentence including the target clause property, and determining the phrase or sentence as the first clause.

5. The method of claim 4, further comprising:

6. The method of claim 5, further comprising:

and if the verification is passed, initiating a signing process aiming at the target contract.

7. The method of claim 1, further comprising:

in response to the contract editing request, determining a standard contract with a contract type consistent with the contract type from a maintained standard contract library;

8. The method of claim 7, further comprising:

if a plurality of standard contracts with contract types consistent with the contract types are determined from the maintained standard contract library;

and sending the determined plurality of standard contracts to the user, so that the user selects a target standard contract from the plurality of standard contracts, and editing the target contract based on the selected target standard contract.

9. The method of claim 1, wherein a trained keyword extraction model is deployed in an out-of-chain business system interfacing with the blockchain;

the determining, from a maintained library of standard contracts, a standard contract that matches the target contract in response to the first invoked transaction, comprising:

in response to the first invoking transaction, interacting with the off-chain business system, submitting the target contract and the standard contract in the standard contract library to the off-chain business system to extract a first keyword from the target contract and a second keyword from the standard contract by the off-chain business system based on the keyword extraction model, and further submitting the extracted first keyword and the extracted second keyword to the intelligent contract;

10. The method of claim 9, the interacting with the off-chain business system in response to the first invoking transaction, submitting the target contract and standard contracts in the standard contracts repository to the business system for extraction by the off-chain business system of a first keyword from the target contract and a second keyword from the standard contract based on the keyword extraction model, and further submitting the extracted first keyword and second keyword to the smart contract, comprising:

and in response to the first call transaction, sending the target contract and the standard contracts in the standard contract library to the off-chain business system through a jointed presbyope program, so that the off-chain business system extracts keywords from the target contract and each standard contract in the standard contract library based on the keyword extraction model while acquiring the target contract and the standard contracts, and further submits the extracted keywords to the intelligent contract through the presbyope program.

11. The method of claim 1, the smart contract comprising editing logic for driving contract editing; the method further comprises the following steps:

12. The method of claim 11, further comprising:

13. A contract auditing device is applied to a server, wherein the server is a block chain; the block chain is provided with an intelligent contract used for driving contract auditing; a trained keyword extraction model is deployed in an out-of-chain service system butted with the block chain; the device comprises:

the first receiving module is used for receiving a first calling transaction which is checked by a user aiming at a target contract;

a first determining module, which responds to the first call transaction, interacts with the off-chain business system, submits the target contract and standard contracts in a standard contract library maintained to the off-chain business system, extracts a first keyword from the target contract and a second keyword from the standard contract by the off-chain business system based on the keyword extraction model, and further submits the extracted first keyword and the extracted second keyword to the intelligent contract;

and the auditing module audits the terms included in the target contract based on the terms included in the standard contract.

14. The apparatus of claim 13, further comprising:

15. The apparatus of claim 13, the smart contract comprising editing logic to drive contract editing; the device further comprises:

and the second calling module is used for calling the editing logic included by the intelligent contract in response to the second calling transaction so as to determine a standard contract with the contract type consistent with the contract type from a maintained standard contract library and send the standard contract to the user, so that the user edits the target contract based on the standard contract.

16. An electronic device, comprising:

a processor;

a memory for storing the processor-executable instructions;

wherein the processor is configured to invoke executable instructions stored in the memory to implement the contract auditing method of any of claims 1-12.

17. A computer-readable storage medium, which stores a computer program for executing the contract auditing method of any one of claims 1-12.