@stellar-expert/contract-wasm-interface-parser 2.0.1 → 3.1.0

package/README.md

@@ -20,97 +20,254 @@ Example output:
 
 ```json
 {
-  "unions": [
-    {
-      "name": "Asset",
+  "enums": {
+    "SubscriptionStatus": {
       "cases": {
-        "Stellar": [
-          "address"
-        ],
-        "Other": [
-          "symbol"
-        ]
-      }
-    }
-  ],
-  "structs": [
-    {
-      "name": "TickerAsset",
-      "fields": [
-        {
-          "name": "asset",
-          "type": "Asset",
-          "doc": "Short ticker name of the asset"
-        },
-        {
-          "name": "source",
-          "type": "string",
-          "doc": "Data provider ID"
-        }
-      ]
-    }
-  ],
-  "errors": [
-    {
-      "name": "Error",
-      "cases": [
-        {
-          "name": "AlreadyInitialized",
+        "Active": {
           "value": 0
         },
-        {
-          "name": "Unauthorized",
+        "Cancelled": {
+          "value": 2
+        },
+        "Suspended": {
           "value": 1
         }
-      ]
-    }
-  ],
-  "enums": [
-    {
-      "name": "SubscriptionStatus",
-      "cases": {
-        "Active": 0,
-        "Suspended": 1,
-        "Cancelled": 2
       }
     }
-  ],
-  "functions": [
-    {
-      "name": "config",
-      "inputs": [
-        {
-          "name": "config",
+  },
+  "errors": {
+    "AlreadyInitialized": {
+      "value": 0
+    },
+    "InvalidAmount": {
+      "value": 4
+    },
+    "InvalidHeartbeat": {
+      "value": 5
+    },
+    "InvalidSubscriptionStatusError": {
+      "value": 8
+    },
+    "InvalidThreshold": {
+      "value": 6
+    },
+    "NotInitialized": {
+      "value": 3
+    },
+    "SubscriptionNotFound": {
+      "value": 2
+    },
+    "Unauthorized": {
+      "value": 1
+    },
+    "WebhookTooLong": {
+      "value": 7
+    }
+  },
+  "functions": {
+    "admin": {
+      "inputs": {},
+      "outputs": [
+        "option<address>"
+      ]
+    },
+    "cancel": {
+      "inputs": {
+        "subscription_id": {
+          "type": "u64"
+        }
+      },
+      "outputs": []
+    },
+    "charge": {
+      "inputs": {
+        "subscription_ids": {
+          "type": "vec<u64>"
+        }
+      },
+      "outputs": []
+    },
+    "config": {
+      "inputs": {
+        "config": {
           "type": "ConfigData"
-          "doc": "New configuration data"
         }
-      ],
-      "outputs": [],
-      "doc": "Update contract confirguration"
-    },
-    {
-      "name": "set_fee",
-      "inputs": [
-        {
-          "name": "fee",
+      },
+      "outputs": []
+    },
+    "create_subscription": {
+      "inputs": {
+        "amount": {
+          "type": "u64"
+        },
+        "new_subscription": {
+          "type": "CreateSubscription"
+        }
+      },
+      "outputs": [
+        "tuple<u64,Subscription>"
+      ]
+    },
+    "deposit": {
+      "inputs": {
+        "amount": {
+          "type": "u64"
+        },
+        "from": {
+          "type": "address"
+        },
+        "subscription_id": {
           "type": "u64"
         }
-      ],
+      },
       "outputs": []
     },
-    {
-      "name": "get_subscription",
-      "inputs": [
-        {
-          "name": "subscription_id",
+    "fee": {
+      "inputs": {},
+      "outputs": [
+        "u64"
+      ]
+    },
+    "get_subscription": {
+      "inputs": {
+        "subscription_id": {
           "type": "u64"
         }
-      ],
+      },
       "outputs": [
         "Subscription"
       ]
+    },
+    "set_fee": {
+      "inputs": {
+        "fee": {
+          "type": "u64"
+        }
+      },
+      "outputs": []
+    },
+    "token": {
+      "inputs": {},
+      "outputs": [
+        "address"
+      ]
+    },
+    "trigger": {
+      "inputs": {
+        "timestamp": {
+          "type": "u64"
+        },
+        "trigger_hash": {
+          "type": "bytesn<32>"
+        }
+      },
+      "outputs": []
+    },
+    "update_contract": {
+      "inputs": {
+        "wasm_hash": {
+          "type": "bytesn<32>"
+        }
+      },
+      "outputs": []
+    },
+    "version": {
+      "inputs": {},
+      "outputs": [
+        "u32"
+      ]
+    }
+  },
+  "structs": {
+    "ConfigData": {
+      "fields": {
+        "admin": {
+          "type": "address"
+        },
+        "fee": {
+          "type": "u64"
+        },
+        "token": {
+          "type": "address"
+        }
+      }
+    },
+    "CreateSubscription": {
+      "fields": {
+        "asset1": {
+          "type": "TickerAsset"
+        },
+        "asset2": {
+          "type": "TickerAsset"
+        },
+        "heartbeat": {
+          "type": "u32"
+        },
+        "owner": {
+          "type": "address"
+        },
+        "threshold": {
+          "type": "u32"
+        },
+        "webhook": {
+          "type": "bytes"
+        }
+      }
+    },
+    "Subscription": {
+      "fields": {
+        "asset1": {
+          "type": "TickerAsset"
+        },
+        "asset2": {
+          "type": "TickerAsset"
+        },
+        "balance": {
+          "type": "u64"
+        },
+        "heartbeat": {
+          "type": "u32"
+        },
+        "last_charge": {
+          "type": "u64"
+        },
+        "owner": {
+          "type": "address"
+        },
+        "status": {
+          "type": "SubscriptionStatus"
+        },
+        "threshold": {
+          "type": "u32"
+        },
+        "webhook": {
+          "type": "bytes"
+        }
+      }
+    },
+    "TickerAsset": {
+      "fields": {
+        "asset": {
+          "type": "Asset"
+        },
+        "source": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "unions": {
+    "Asset": {
+      "cases": {
+        "Other": [
+          "symbol"
+        ],
+        "Stellar": [
+          "address"
+        ]
+      }
     }
-  ],
+  },
   "interfaceVersion": "85899345920",
   "rustVersion": "1.74.0",
   "sdkVersion": "20.5.0#9e2c3022b4355b224a7a814e13ba51761eeb14bb"

package/index.js

@@ -1,12 +1,12 @@
 import {xdr} from '@stellar/stellar-base'
-import {XdrReader} from './src/xdr-reader'
+import {parseSectionEntriesXdr} from './src/xdr-reader'
 import {WasmSectionReader} from './src/wasm-section-reader'
 import {parseContractMeta, parseSpec} from './src/xdr-spec-parser'
 
 /**
  * Parse contract metadata from WASM sections
  * @param {Buffer} rawWasm
- * @return {{}}
+ * @return {ParsedWasmMeta}
  */
 export function parseContractMetadata(rawWasm) {
     const wasmSectionReader = new WasmSectionReader(rawWasm)
@@ -18,21 +18,24 @@ export function parseContractMetadata(rawWasm) {
                 res.interfaceVersion = xdr.ScEnvMetaEntry.fromXDR(section.contents).value().toString()
                 break
             case 'contractmetav0':
-                Object.assign(res, parseContractMeta(parseEntries(section.contents, xdr.ScMetaEntry)))
+                Object.assign(res, parseContractMeta(parseSectionEntriesXdr(section.contents, xdr.ScMetaEntry)))
                 break
             case 'contractspecv0':
-                Object.assign(res, parseSpec(parseEntries(section.contents, xdr.ScSpecEntry)))
+                Object.assign(res, parseSpec(parseSectionEntriesXdr(section.contents, xdr.ScSpecEntry)))
                 break
         }
     }
     return res
 }
 
-function parseEntries(buffer, xdrContract) {
-    const reader = new XdrReader(buffer)
-    const entries = []
-    while (!reader.eof) {
-        entries.push(xdrContract.read(reader))
-    }
-    return entries
-}
+/**
+ * @typedef {{}} ParsedWasmMeta
+ * @property {{}} functions
+ * @property {{}} [errors]
+ * @property {{}} [enums]
+ * @property {{}} [structs]
+ * @property {{}} [unions]
+ * @property {string} rustVersion
+ * @property {string} sdkVersion
+ * @property {string} interfaceVersion
+ */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar-expert/contract-wasm-interface-parser",
-  "version": "2.0.1",
+  "version": "3.1.0",
   "description": "Contract interface metadata parser for binary WASM",
   "main": "index.js",
   "module": "./index.js",
@@ -8,6 +8,9 @@
     "type": "git",
     "url": "git+https://github.com/stellar-expert/contract-wasm-interface-parser.git"
   },
+  "scripts": {
+    "test": "jest"
+  },
   "author": "orbitlens <orbit@stellar.expert>",
   "license": "MIT",
   "peerDependencies": {

package/src/xdr-reader.js

@@ -1,4 +1,19 @@
-export class XdrReader {
+/**
+ *
+ * @param {Buffer} buffer
+ * @param {{read: function}} xdrContract
+ * @return {{}[]}
+ */
+export function parseSectionEntriesXdr(buffer, xdrContract) {
+    const reader = new XdrReader(buffer)
+    const entries = []
+    while (!reader.eof) {
+        entries.push(xdrContract.read(reader))
+    }
+    return entries
+}
+
+class XdrReader {
     /**
      * @constructor
      * @param {Buffer} source - Buffer containing serialized data

package/src/xdr-spec-parser.js

@@ -30,12 +30,13 @@ class SpecParser {
      */
     res
 
-    addSpec(key, descriptor, doc) {
+    addSpec(key, attr, parser) {
+        //this.parseFunction(attr), attr.doc
         let spec = this.res[key]
         if (spec === undefined) {
-            spec = this.res[key] = []
+            spec = this.res[key] = {}
         }
-        spec.push(this.withDocs(descriptor, doc))
+        parser.call(this, attr, spec)
     }
 
     parse(entries) {
@@ -44,19 +45,19 @@ class SpecParser {
             const {_attributes: attr} = value
             switch (spec._arm) {
                 case 'functionV0':
-                    this.addSpec('functions', this.parseFunction(attr), attr.doc)
+                    this.addSpec('functions', attr, this.parseFunction)
                     break
                 case 'udtStructV0':
-                    this.addSpec('structs', this.parseStruct(attr), attr.doc)
+                    this.addSpec('structs', attr, this.parseStruct)
                     break
                 case 'udtUnionV0':
-                    this.addSpec('unions', this.parseUnion(attr), attr.doc)
+                    this.addSpec('unions', attr, this.parseUnion)
                     break
                 case 'udtEnumV0':
-                    this.addSpec('enums', this.parseEnum(attr), attr.doc)
+                    this.addSpec('enums', attr, this.parseEnum)
                     break
                 case 'udtErrorEnumV0':
-                    this.addSpec('errors', this.parseError(attr), attr.doc)
+                    this.addSpec('errors', attr, this.parseError)
                     break
                 default:
                     console.log('Unknown spec type: ' + spec._arm)
@@ -66,57 +67,51 @@ class SpecParser {
         return this.res
     }
 
-    parseFunction(attr) {
-        return {
-            name: attr.name.toString(),
-            inputs: attr.inputs.map(i => this.parseParameter(i)),
+    parseFunction(attr, into) {
+        const inputs = {}
+        attr.inputs.forEach(i => this.parseParameter(i, inputs))
+        into[attr.name.toString()] = this.withDocs({
+            inputs,
             outputs: attr.outputs.map(o => this.parseParameterType(o))
-        }
+        }, attr)
     }
 
-    parseStruct(attr) {
-        return {
-            name: this.parseStructName(attr),
-            fields: attr.fields.map(f => this.parseParameter(f))
-        }
+    parseStruct(attr, into) {
+        const fields = {}
+        attr.fields.forEach(f => this.parseParameter(f, fields))
+        into[this.parseStructName(attr)] = this.withDocs({fields}, attr)
     }
 
-    parseUnion(attr) {
-        return {
-            name: this.parseStructName(attr),
-            cases: attr.cases.reduce((agg, c) => {
-                const value = c.value()
-                agg[value.name().toString()] = value.type ?
-                    value.type().map(t => this.parseParameterType(t)) :
-                    []
-                return agg
-            }, {})
-        }
+    parseUnion(attr, into) {
+        const cases = {}
+        attr.cases.forEach(c => {
+            const value = c.value()
+            cases[value.name().toString()] = value.type ?
+                value.type().map(t => this.parseParameterType(t)) :
+                []
+        })
+        into[this.parseStructName(attr)] = this.withDocs({cases}, attr)
     }
 
-    parseEnum(attr) {
-        return {
-            name: this.parseStructName(attr),
-            cases: attr.cases.reduce((agg, c) => {
-                const value = c.value()
-                if (value.name) {
-                    agg[value.name().toString()] = value.value()
-                } else {
-                    agg[c._attributes.name] = value
-                }
-                return agg
-            }, {})
-        }
+    parseEnum(attr, into) {
+        const cases = {}
+        attr.cases.forEach(c => {
+            const value = c.value()
+            if (value.name) {
+                cases[value.name().toString()] = value.value()
+            } else {
+                const attr = c._attributes
+                cases[attr.name.toString()] = this.withDocs({value}, attr)
+            }
+        })
+        into[this.parseStructName(attr)] = this.withDocs({cases}, attr)
     }
 
-    parseError(attr) {
-        return {
-            name: this.parseStructName(attr),
-            cases: attr.cases.map(c => ({
-                name: c.name().toString(),
-                value: c.value()
-            }))
-        }
+    parseError(attr, into) {
+        attr.cases.forEach(c => {
+            const attr = c._attributes
+            into[attr.name.toString()] = this.withDocs({value: attr.value}, attr)
+        })
     }
 
     parseParameterType(type) {
@@ -149,18 +144,14 @@ class SpecParser {
         return structName
     }
 
-    parseParameter(param) {
-        const {_attributes: attr} = param
-        const res = {
-            name: attr.name.toString(),
-            type: this.parseParameterType(attr.type)
-        }
-        return this.withDocs(res, attr.doc)
+    parseParameter(param, into) {
+        const attr = param._attributes
+        into[attr.name.toString()] = this.withDocs({type: this.parseParameterType(attr.type)}, attr)
     }
 
-    withDocs(descriptor, doc) {
-        if (doc?.length) {
-            descriptor.doc = doc.toString()
+    withDocs(descriptor, attr) {
+        if (attr.doc?.length) {
+            descriptor.doc = attr.doc.toString()
         }
         return descriptor
     }