CN117519667A - Intelligent contract automatic generation method, management system and storage medium - Google Patents
Intelligent contract automatic generation method, management system and storage medium Download PDFInfo
- Publication number
- CN117519667A CN117519667A CN202311416825.7A CN202311416825A CN117519667A CN 117519667 A CN117519667 A CN 117519667A CN 202311416825 A CN202311416825 A CN 202311416825A CN 117519667 A CN117519667 A CN 117519667A
- Authority
- CN
- China
- Prior art keywords
- intelligent contract
- contract
- grammar
- language
- automatic generation
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 47
- 239000010410 layer Substances 0.000 claims description 31
- 230000006870 function Effects 0.000 claims description 18
- 238000004458 analytical method Methods 0.000 claims description 12
- 230000008569 process Effects 0.000 claims description 11
- 238000012545 processing Methods 0.000 claims description 10
- 238000006243 chemical reaction Methods 0.000 claims description 7
- 230000014509 gene expression Effects 0.000 claims description 6
- 239000002346 layers by function Substances 0.000 claims description 6
- 238000012795 verification Methods 0.000 claims description 5
- 230000005540 biological transmission Effects 0.000 claims description 2
- 238000012800 visualization Methods 0.000 claims description 2
- 238000005516 engineering process Methods 0.000 abstract description 6
- 238000007726 management method Methods 0.000 description 13
- 239000004744 fabric Substances 0.000 description 11
- 238000010276 construction Methods 0.000 description 7
- 238000009434 installation Methods 0.000 description 4
- 230000008520 organization Effects 0.000 description 4
- 238000010586 diagram Methods 0.000 description 3
- 238000012423 maintenance Methods 0.000 description 3
- 238000011161 development Methods 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- VEXZGXHMUGYJMC-UHFFFAOYSA-M Chloride anion Chemical compound [Cl-] VEXZGXHMUGYJMC-UHFFFAOYSA-M 0.000 description 1
- 238000012550 audit Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 239000003638 chemical reducing agent Substances 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000012938 design process Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000002474 experimental method Methods 0.000 description 1
- 238000002372 labelling Methods 0.000 description 1
- 238000005259 measurement Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 239000000203 mixture Substances 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000004806 packaging method and process Methods 0.000 description 1
- 238000012856 packing Methods 0.000 description 1
- 238000005086 pumping Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 239000002002 slurry Substances 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
- XLYOFNOQVPJJNP-UHFFFAOYSA-N water Substances O XLYOFNOQVPJJNP-UHFFFAOYSA-N 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/27—Replication, distribution or synchronisation of data between databases or within a distributed database system; Distributed database system architectures therefor
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/30—Information retrieval; Database structures therefor; File system structures therefor of unstructured textual data
- G06F16/31—Indexing; Data structures therefor; Storage structures
- G06F16/313—Selection or weighting of terms for indexing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Databases & Information Systems (AREA)
- Computing Systems (AREA)
- Data Mining & Analysis (AREA)
- Machine Translation (AREA)
Abstract
The present invention relates to the field of blockchain technologies, and in particular, to an intelligent contract automatic generation method, a management system, and a storage medium. The method comprises the steps of firstly receiving contract text information, and converting the contract text information into a structured language by using an ontology model; secondly, converting the structured language into a high-level intelligent contract language based on a preset SWRL semantic rule; and finally, based on a preset intelligent contract template, converting the high-level intelligent contract language into an intelligent contract code by using a grammar parser, automatically generating an intelligent contract, and constructing the grammar parser based on the LL (1) grammar. Compared with the prior art, the intelligent contract automatic generation method has the advantages of improving the intelligent contract automatic generation efficiency, improving the platform compatibility and the like.
Description
Technical Field
The present invention relates to the field of blockchain technologies, and in particular, to an intelligent contract automatic generation method, a management system, and a storage medium.
Background
With the development and progress of blockchain technology, a core technology in blockchain, namely intelligent contracts, is attracting attention. The technology automatically executes contracts on blockchains in the form of codes, and business personnel can realize automatic transactions based on intelligent contracts developed by program developers. At present, the main form of intelligent contracts in practical application is that business personnel manually extract information from the identical texts and write intelligent contract codes. The technology relates to cooperation among different fields of computers, laws and the like, and most of traditional professional field personnel lack programming capability, so that popularization and application of the blockchain are not facilitated. In addition, most businesses do not implement an automatic performance function, and contracts embodied in text types fail to implement formal expressions of computer languages, i.e., logical relationships within the contracts are not revealed; a huge gap exists between the programming language and the contract, and business personnel are difficult to write; there is a lack of means of intelligent conversion between contracts and executable intelligent contract code for textual classes. In the prior art, although some exploration is made on the automatic generation of the intelligent contract code, the problems of complicated generation process of the intelligent contract code, insufficient compatibility of a conversion platform and the like still exist.
Disclosure of Invention
The invention aims to overcome the defects of complicated intelligent contract code generation process and insufficient conversion platform compatibility in the prior art and provides an intelligent contract automatic generation method, a management system and a storage medium.
The aim of the invention can be achieved by the following technical scheme:
according to a first aspect of the present invention, there is provided an intelligent contract automatic generation method, comprising the steps of:
s1, receiving contract text information, and converting the contract text information into a structured language by using an ontology model;
s2, converting the structured language into a high-level intelligent contract language based on preset SWRL semantic rules;
s3, based on a preset intelligent contract template, converting the high-level intelligent contract language into an intelligent contract code by using a grammar parser, and automatically generating an intelligent contract, wherein the grammar parser is constructed based on an LL (1) grammar.
As a preferred technical solution, the conversion process of the intelligent contract code includes that after the grammar parser reads the SWRL semantic rule, based on a recursive descent analysis method, each expression in the LL (1) grammar is identified, and corresponding instance information, condition information and conclusion information are extracted.
As a preferred technical scheme, the verification process of the LL (1) grammar comprises the steps of writing an initial grammar according to the SWRL semantic rule, eliminating left recursion in the initial grammar, extracting left common factors, establishing a First set and a Follow set of the initial grammar, obtaining a select set, generating a corresponding prediction analysis table and verifying.
As a preferable technical scheme, the ontology model is constructed through OWL language.
As a preferred technical scheme, the feasibility of the OWL language is verified by Prot g software.
As a preferable technical scheme, the construction content of the ontology model comprises instance naming and attribute description.
As a preferable technical solution, the contract text information includes industry specification information.
As an optimal technical scheme, after the intelligent contract code is deployed to a blockchain network, the cloud server calls the intelligent contract code to read corresponding contract text information, so that quality specification examination is realized.
According to a second aspect of the present invention, there is provided an intelligent contract management system, the system comprising a data layer, a processing layer, a functional layer and an application layer, the data layer being configured to receive contract text information and generate SWRL semantic rules for use by the processing layer and the functional layer; the processing layer is used for providing an ontology modeler, a high-level intelligent language parser and an intelligent contract code generator for the functional layer to use; the function layer is used for executing the method, and transmitting data with the application layer, so that searching, editing and visualizing of the intelligent contract are realized.
According to a third aspect of the present invention, there is provided a storage medium having stored thereon a program which when executed implements the method.
Compared with the prior art, the invention has the following beneficial effects:
1. according to the method, after the high-level intelligent contract language is obtained based on the SWRL semantic rule, the SWRL language is automatically analyzed by directly utilizing the proposed semantic analyzer based on the LL (1) grammar, and the intelligent contract code is generated, so that the analysis and generation processes are independent of other software, the operation is convenient, the automatic generation efficiency of the intelligent contract is improved, and the method can be integrated into other platforms and has higher platform compatibility;
2. the invention utilizes the ontology model, SWRL semantic rules and the designed semantic analyzer to realize the conversion among unstructured contract text language, structured computer language, advanced intelligent contract language and intelligent contract code, further improves the intelligent degree of intelligent contract code generation, reduces the contract writing difficulty of non-computer professionals and the labor cost of blockchain maintenance, and reduces the obstruction of blockchain technical popularization.
Drawings
FIG. 1 is a schematic flow chart of the method of the present invention;
FIG. 2 is a schematic flow chart of a method according to an embodiment of the present invention;
FIG. 3 is a schematic diagram of an ontology model construction in an embodiment of the present invention;
fig. 4 is a schematic diagram of an application system structure of a method according to an embodiment of the present invention.
Detailed Description
The invention will now be described in detail with reference to the drawings and specific examples. The present embodiment is implemented on the premise of the technical scheme of the present invention, and a detailed implementation manner and a specific operation process are given, but the protection scope of the present invention is not limited to the following examples.
Examples
The embodiment provides an automatic intelligent contract generation method, which designs a grammar parser based on LL (1) grammar, parses SWRL (Semantic Web Rule Language) semantic rules by using a recursion descent analysis method, acquires contract rule information, and combines an intelligent contract template to generate an intelligent contract corresponding to a contract text. As shown in fig. 1, the method specifically includes the following steps:
and S1, receiving the contract text information, and converting the contract text information into a structured language by using an ontology model. For example, audit rule information for ready mixed concrete is received for which a corresponding ontology model is constructed using OWL (Ontology Web Language) to convert the contract text of the unstructured, natural language description into a structured, clear computer-readable (which can be solved and processed by the computing mechanism) contract. The main purpose of the ontology model construction is to achieve structuring of the contract text, but specific rule information in the contract cannot be expressed as computer-readable instructions.
And S2, converting the structured language into a high-level intelligent contract language based on preset SWRL semantic rules. Specifically, on the basis of constructing an ontology model, the expression of rule information in contract text is realized by using SWRL semantic rules.
And step S3, based on a preset intelligent contract template, converting the high-level intelligent contract language into an intelligent contract code by using a grammar parser constructed based on the LL (1) grammar, and automatically generating the intelligent contract. In other words, to further implement the computer-readable of SWRL semantic rules, a grammar parser needs to be designed based on LL (1) grammar. The design process comprises the steps of writing a corresponding initial grammar according to SWRL semantic rules, eliminating left recursion in the initial grammar, extracting left common factors, establishing a First set and a Follow set of the initial grammar, obtaining a select set, generating a corresponding prediction analysis table, and further verifying whether the grammar is an LL (1) grammar. The reason for the need for verification is that only LL (1) grammar is satisfied, semantic analysis can be performed using the recursive descent method. Wherein the First set and the Follow set are shown in table 1, and the predictive analysis table is shown in table 2.
When the initial grammar satisfies the LL (1) grammar, a recursion descent method is used to realize the identification of the grammar and a grammar parser is written according to the validated LL (1) grammar. And then, according to the output results of the intelligent contract template and the grammar parser created by the user, obtaining the intelligent contract code corresponding to the contract text.
TABLE 1First set and Follow set
Table 2 predictive analysis table
The method provided by the embodiment is applied to quality acceptance of ready-mixed concrete, and the implementation flow is shown in fig. 2. The specific description is as follows:
firstly, the step S1 is implemented, the ontology model is constructed on the concrete quality standard through OWL language, and the contract text expressed by natural language is converted into a structured contract, so that the knowledge utilization and propagation efficiency are improved. Specifically, related professionals need to build body models for concrete quality specifications in combination with actual requirements and conditions. The concrete construction content mainly comprises naming an instance, description of all object attributes of the instance and description of data attributes and other related descriptions, so that a complete instance is obtained. The OWL language is used for realizing the ontology model, and the Prot g software is used for verifying the feasibility of the OWL language corresponding to the ontology. As shown in FIG. 3, the build content of the ontology includes acceptance objects, construction methods, stages, quality constraints, quality problems, and resolution measures.
And secondly, implementing the step S2, expressing the corresponding concrete quality specification based on SWRL semantic rules, and obtaining the high-level intelligent contract language. The application of the high-level intelligent contract language can reduce the contract writing difficulty of non-computer personnel and reduce the learning cost of related business personnel. Specifically, on the basis of the already constructed OWL ontology, the corresponding concrete quality specifications are described against the expression in SWRL semantic rules. An example of a corresponding ontology is given for example in fig. 4: the ready-mixed concrete order 1 adopts a pumping mode (Constructed By), and in the field acceptance Stage (has Stage), three quality constraints, namely 60 (has Strength), 150 (has slurry) Slump and less than 0.2 (has chloride) are required to be met. The quality problem (has Hazard) found by practical acceptance is that the slump is smaller in actual measurement, and the corresponding Solution (has Solution) is to add the water reducer.
Again, the foregoing step S3 is implemented, utilizing the already developed syntax parser, to effect the conversion of the high-level smart contract language into executable smart contract code. The grammar parser reads the written SWRL semantic rules first, and then parses the grammar according to the LL (1) grammar capable of parsing the SWRL language. The grammar parser can automatically generate the executable intelligent contract codes from the high-level intelligent contract language, and reduces the labor cost of block chain maintenance. Specifically, the SWRL language is identified as Token (basic component of the SWRL language), and after each expression in the LL (1) grammar is successfully identified according to the LL (1) grammar by using a recursive descent analysis method, the instance name, the attribute name and the value of the condition, and the attribute name and the value of the conclusion in the SWRL semantic rule can be extracted. On the basis, the final intelligent contract is automatically generated according to the key information extracted by the constructed intelligent contract template and the grammar parser.
Next, a smart contract code is deployed onto Hyperledger Fabric (super ledger network), using a chain code, which is a generic container for deploying codes into Fabric blockchain networks. The method specifically comprises the following steps:
and in the chain code packaging step, after the chain code is compiled and passed in the Fabric network, the chain code is required to be packaged into a package packet with the end of out and cc for other peer nodes to use. The packing process first needs to enter the client container of the organization to pack the chain code directory into an out file.
Proposal construction and transmission steps, the client first executes the installation command of the chain code, and creates proposal structure, signs and transmits the proposal to the endorsement node.
And a legitimacy verification step, namely verifying the legitimacy of the proposal by an endorsement node. The endorsement node validates the proposal for the chain code installation and approves on behalf of the organization. When approved by the respective organization, the chain code may be installed on the channel.
And a proposal submitting step, wherein one organization submits the proposal of the just-received chain code, and the chain code is successfully installed in the Fabric network.
After the intelligent contract code deployment process is completed, the cloud server can call the intelligent contract code in the Fabric network, write the data in the memory into the Fabric network, or call the intelligent contract code to read the data in the Fabric network, and realize relevant quality specification examination. Specifically, when data is required to be written into the Fabric network, firstly, calling a related function in the intelligent contract code, taking the data to be written as parameters, enabling the Fabric network to execute the related code of the intelligent contract, enabling the execution result to be consensus, and if the consensus is successful, writing new data into a block of the Fabric network for broadcasting. After the updated data is written into the Fabric network, the related data information can be read by calling the query code related to the intelligent contract. The process comprises the following steps in program:
(1) The client creates a transaction proposal (chain code function and parameter, the parameter is the attribute of the concrete and the corresponding value) and sends the transaction proposal to the endorsement node;
(2) Executing a chain code by the endorsement node, generating a read-write operation set based on the read-write Key, and returning a proposal result to the client;
(3) The client submits the transaction to the ordering service, and the transaction content comprises a read-write operation set from proposal results;
(4) The sorting service encapsulates the sorted transactions into blocks;
(5) The block will be sent to the Commit Peer node;
(6) The Commit Peer node runs verification logic, adds the block to the blockchain on a memory or file system, and writes the valid transactions within the block to a status database;
(7) After the concrete related attributes are written, the intelligent contract codes related to quality specification examination in the chain codes are triggered, the related attribute values in the intelligent contracts are modified, and the result (whether compliance and solution) of the quality specification examination can be known through the attribute values.
Furthermore, the method can be combined with contract management and respectively used as different functional modules to be integrated in an intelligent contract automatic generation and management system. As shown in fig. 4, based on the proposed intelligent contract automatic generation method, an intelligent contract automatic generation and management system based on the proposed method can be designed. The various levels of participation in the system including operation include an application layer, a function layer (functions that the intelligent contract generation and management system should contain during construction of the intelligent contract generation and management system), a processing layer, and a data layer. The specific functions and specific compositions of each layer are as follows:
the data layer receives and provides data sources required by the system, mainly comprising contract text, industry specification and other types of file text, and is used for generating SWRL semantic rules.
The processing layer comprises three components of an ontology modeler, a high-level intelligent language parser and an intelligent contract code generator. The ontology modeler is used for realizing a program for constructing an ontology model through OWL language; the high-level intelligent language parser is a tool for carrying out grammar and semantic parsing on programming languages related to intelligent contracts; the intelligent contract code generator is used for receiving a structured ontology generated by user editing and generating intelligent contracts, and the function is used by a function layer.
The function layer comprises six functions of contract body creation, advanced intelligent contract writing guidance, contract automatic generation, contract debugging compiling, contract preview and contract installation and instantiation. "contract ontology creation" refers to the user's ability to edit SWRL semantic rules through "smart contract IDE" (Integrated Development Environment ) of "application layer" to convert unstructured contract text into structured ontologies. The advanced intelligent contract writing guide refers to SWRL semantic rules and intelligent contract editing prompts displayed in the blank in an intelligent contract IDE interface of an application layer, and the intelligent contract editing guide is used for providing simple courses for users. "contract auto-generation" means that the "processing layer" will generate and create a smart contract based on the "structured ontology" created by the user. "contract previews" refers to the specific content of various structured ontologies, intelligent contracts that a user can view by accessing the Web page of the "application layer". "contract installation and instantiation" means that a user can install and deploy an intelligent contract generated through the "contract auto-generation" function into a blockchain by accessing a Web page of an "application layer".
The application layer comprises two functions of intelligent contract IDE and contract management. In this embodiment, the intelligent contract IDE is implemented by using an open source project Monaco-editor as a prototype, and the contract management function is implemented based on a MySQL database and a jsp-based Web page.
The system can realize the following functions:
(1) In the intelligent contract IDE, compiling a contract text of a natural-like language based on SWRL semantic rules;
(2) Storing the contract text based on SWRL semantic rules into a database, converting the contract text into intelligent contracts by using a grammar parser, and storing the intelligent contracts in the database;
(3) The label labeling function is provided for the contract text generated by the user, the user can create a custom label on the front-end interface of the system, and label the contract text according to the label.
The system includes two applications, intelligent contract IDE and contract management. The intelligent contract IDE can realize multiple functions of intelligent contract writing, compiling, debugging and the like, and improves the writing efficiency of the advanced intelligent contract; the contract management application can realize searching, editing and visualization of intelligent contracts, and is convenient for later maintenance.
Further, the present embodiment also provides a storage medium having a program stored thereon, which when executed implements the foregoing method. Program code for carrying out methods of the present invention may be written in any combination of one or more programming languages. These program code may be provided to a processor or controller of a general purpose computer, special purpose computer, or other programmable data processing apparatus such that the program code, when executed by the processor or controller, causes the functions/operations specified in the flowchart and/or block diagram to be implemented. The program code may execute entirely on the machine, partly on the machine, as a stand-alone software package, partly on the machine and partly on a remote machine or entirely on the remote machine or server. In the context of the present invention, a computer-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
The foregoing describes in detail preferred embodiments of the present invention. It should be understood that numerous modifications and variations can be made in accordance with the concepts of the invention by one of ordinary skill in the art without undue burden. Therefore, all technical solutions which can be obtained by logic analysis, reasoning or limited experiments based on the prior art by the person skilled in the art according to the inventive concept shall be within the scope of protection defined by the claims.
Claims (10)
1. An intelligent contract automatic generation method is characterized by comprising the following steps:
s1, receiving contract text information, and converting the contract text information into a structured language by using an ontology model;
s2, converting the structured language into a high-level intelligent contract language based on preset SWRL semantic rules;
s3, based on a preset intelligent contract template, converting the high-level intelligent contract language into an intelligent contract code by using a grammar parser, and automatically generating an intelligent contract, wherein the grammar parser is constructed based on an LL (1) grammar.
2. The intelligent contract automatic generation method according to claim 1, wherein the intelligent contract code conversion process includes, after the grammar parser reads the SWRL semantic rules, identifying each expression in the LL (1) grammar based on a recursive descent analysis method, and extracting corresponding instance information, condition information, and conclusion information.
3. The intelligent contract automatic generation method according to claim 2, wherein the verification process of the LL (1) grammar includes writing an initial grammar according to the SWRL semantic rule, eliminating left recursion in the initial grammar and extracting left common factors, establishing a First set and a Follow set of the initial grammar, obtaining a select set, generating a corresponding prediction analysis table, and verifying.
4. The intelligent contract automatic generation method according to claim 1, wherein the ontology model is constructed by OWL language.
5. The intelligent contract automatic generation method according to claim 4, wherein the feasibility of the OWL language is verified by Prot g software.
6. The intelligent contract automatic generation method of claim 1, wherein the build content of the ontology model includes instance naming and attribute description.
7. The intelligent contract automatic generation method according to claim 1, wherein the contract text information includes industry specification information.
8. The method for automatically generating intelligent contracts according to claim 1, wherein after the intelligent contract codes are deployed to a blockchain network, a cloud server calls the intelligent contract codes to read corresponding contract text information, so that quality specification examination is achieved.
9. An intelligent contract management system is characterized by comprising a data layer, a processing layer, a functional layer and an application layer, wherein the data layer is used for receiving contract text information and generating SWRL semantic rules for the processing layer and the functional layer; the processing layer is used for providing an ontology modeler, a high-level intelligent language parser and an intelligent contract code generator for the functional layer to use; the function layer is used for executing the method as claimed in any one of claims 1-8 and carrying out data transmission with the application layer so as to realize searching, editing and visualization of the intelligent contract.
10. A storage medium having a program stored thereon, wherein the program, when executed, implements the method of any of claims 1-8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311416825.7A CN117519667A (en) | 2023-10-30 | 2023-10-30 | Intelligent contract automatic generation method, management system and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311416825.7A CN117519667A (en) | 2023-10-30 | 2023-10-30 | Intelligent contract automatic generation method, management system and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117519667A true CN117519667A (en) | 2024-02-06 |
Family
ID=89757617
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311416825.7A Pending CN117519667A (en) | 2023-10-30 | 2023-10-30 | Intelligent contract automatic generation method, management system and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117519667A (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110688151A (en) * | 2019-09-24 | 2020-01-14 | 暨南大学 | Safety translation and analysis method for Ether house identity intelligent contract |
| CN113191629A (en) * | 2021-04-28 | 2021-07-30 | 华中科技大学 | Intelligent contract generation method and device for quality acceptance of constructional engineering |
| US20230072988A1 (en) * | 2021-09-06 | 2023-03-09 | MphasiS Limited | System and a method for automatic generation of smart contracts across blockchain platforms |
-
2023
- 2023-10-30 CN CN202311416825.7A patent/CN117519667A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110688151A (en) * | 2019-09-24 | 2020-01-14 | 暨南大学 | Safety translation and analysis method for Ether house identity intelligent contract |
| CN113191629A (en) * | 2021-04-28 | 2021-07-30 | 华中科技大学 | Intelligent contract generation method and device for quality acceptance of constructional engineering |
| US20230072988A1 (en) * | 2021-09-06 | 2023-03-09 | MphasiS Limited | System and a method for automatic generation of smart contracts across blockchain platforms |
Non-Patent Citations (2)
| Title |
|---|
| 党文婕;黄宁: "编译器语法分析器(自上而下)模块的实现—LL(1)预测分析程序", 《数字化用户》, no. 28, 31 December 2018 (2018-12-31), pages 170 * |
| 朱岩;秦博涵;陈娥;刘国伟: "一种高级智能合约转化方法及竞买合约设计与实现", 《计算机学报》, vol. 44, no. 3, 31 March 2021 (2021-03-31), pages 652 - 668 * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US20140156282A1 (en) | Method and system for controlling target applications based upon a natural language command string | |
| Koller et al. | Sentence generation as a planning problem | |
| CN104156313A (en) | Method for automatically generating Web service testing case | |
| US11822909B2 (en) | Adapting existing source code snippets to new contexts | |
| CN106951305B (en) | Method for generating midCore script from QVT-R language based on model conversion | |
| CN115639980A (en) | Draggable front-end logic arrangement method and device for low-code platform | |
| CN110162297A (en) | A kind of source code fragment natural language description automatic generation method and system | |
| CN113849162A (en) | Code generation method combining model drive and deep neural network | |
| Jackson et al. | Towards a formal foundation for domain specific modeling languages | |
| CN112988163A (en) | Intelligent programming language adaptation method and device, electronic equipment and medium | |
| CN112632333A (en) | Query statement generation method, device, equipment and computer readable storage medium | |
| CN115469860B (en) | Method and system for automatically generating demand-to-software field model based on instruction set | |
| EP4145761A1 (en) | A system and a method for automatic generation of smart contracts across blockchain platforms | |
| Apvrille et al. | System Architects Are not Alone Anymore: Automatic System Modeling with AI | |
| CN117289938A (en) | Intelligent auxiliary system for software development | |
| CN117519667A (en) | Intelligent contract automatic generation method, management system and storage medium | |
| WO2023097750A1 (en) | Order booking method based on cross-terminal program generation system | |
| CN115374764A (en) | Demand model automatic generation method and system based on user story | |
| CN112507083B (en) | Anti-error rule base construction method based on scheduling anti-error field language | |
| CN114816356A (en) | System and method for generating HTTP request code based on interface document | |
| Dan et al. | Towards a formal behavioral semantics for UML interactions | |
| Kong Win Chang et al. | A semantics of core Erlang with handling of signals | |
| Chaudhary et al. | Intelligent virtual research environment for natural language processing (IvrE-NLP) | |
| KR100319776B1 (en) | Apparatus and method for software process modeling | |
| Gheri et al. | Case Studies in Formal Reasoning About Lambda-Calculus: Semantics, Church-Rosser, Standardization and HOAS |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |