@tezos-x/octez.js-michelson-encoder 0.9.0

package/README.md

@@ -0,0 +1,140 @@
+# octez.js Michelson Encoder package
+
+*Documentation can be found [here](https://octez.js.io/docs/michelson_encoder)*
+*TypeDoc style documentation is available on-line [here](https://octez.js.io/typedoc/modules/_octez.js_michelson_encoder.html)*
+
+**Maintained by [Nomadic Labs](https://www.nomadic-labs.com/).**
+
+`@tezos-x/octez.js-michelson-encoder` provides a JavaScript abstraction based on Tezos Smart contract code, parameters, storage, and views.
+
+## General Information
+
+The Michelson-Encoder package aims to create an abstraction over the Michelson Language. It allows converting Michelson data into javascript-looking objects which are easier to use and reason about.
+
+Its integration into the main octez.js package makes it easier to write the storage when deploying a contract and the parameter when calling a contract entry-point or executing a view. It also provides an abstraction on the storage read value of the contract. 
+
+The `Schema` class is intended to represent the contract storage, while the `ParameterSchema` represents its entry points. The `Execute` method takes a parameter in Michelson format and converts it into the JavaScript abstraction. The `Encode` method does the opposite; it takes a JavaScript object as a parameter and converts it into Michelson data.
+
+## Install 
+```
+npm i --save @tezos-x/octez.js-michelson-encoder
+```
+
+## Usage
+
+## Example
+
+The constructor of the `Schema` class takes a Michelson type as a parameter which is retrieved from a Tezos Nodes RPC:
+
+```ts
+const storageType = {
+    prim: 'pair',
+    args: [
+        { prim: 'nat', annots: [ '%stored_counter' ] },
+        {
+            prim: 'pair',
+            args: [
+                { prim: 'nat', annots: [ '%threshold' ] },
+                { prim: 'list', args: [ { prim: 'key' } ], annots: [ '%keys' ] }
+            ]
+        }
+    ]
+};
+const storageSchema = new Schema(storageType);
+```
+
+The `Execute` method takes a Michelson value as a parameter and generates an abstraction in the form of a plain old javascript object:
+
+```ts
+// dataMichelson is the storage of a contract retrieved from the RPC
+const dataMichelson = {
+  "prim": "Pair",
+  "args": [
+    {
+      "int": "10"
+    },
+    {
+      "prim": "Pair",
+      "args": [
+        {
+          "int": "5"
+        },
+        [
+          {
+            "string": "edpkvS5QFv7KRGfa3b87gg9DBpxSm3NpSwnjhUjNBQrRUUR66F7C9g"
+          },
+          {
+            "string": "edpkuLxx9PQD8fZ45eUzrK3BhfDZJHhBuK4Zi49DcEGANwd2rpX82t"
+          }
+        ]
+      ]
+    }
+  ]
+};
+
+const data = storageSchema.Execute(dataMichelson);
+console.log(data);
+
+/* output:
+{
+  "stored_counter": "10",
+  "threshold": "5",
+  "keys": [
+    "edpkvS5QFv7KRGfa3b87gg9DBpxSm3NpSwnjhUjNBQrRUUR66F7C9g",
+    "edpkuLxx9PQD8fZ45eUzrK3BhfDZJHhBuK4Zi49DcEGANwd2rpX82t"
+  ]
+} 
+*/
+```
+
+Note that the Michelson type annotations represent the javascript object's keys.
+
+
+The `Encode` method takes a javascript object as a parameter and converts it into Michelson:
+
+```ts
+const data = storageSchema.Encode({
+  "stored_counter": "10",
+  "threshold": "5",
+  "keys": [
+    "edpkvS5QFv7KRGfa3b87gg9DBpxSm3NpSwnjhUjNBQrRUUR66F7C9g",
+    "edpkuLxx9PQD8fZ45eUzrK3BhfDZJHhBuK4Zi49DcEGANwd2rpX82t"
+  ]
+});
+
+console.log(data);
+
+/* output:
+{
+  "prim": "Pair",
+  "args": [
+    {
+      "int": "10"
+    },
+    {
+      "prim": "Pair",
+      "args": [
+        {
+          "int": "5"
+        },
+        [
+          {
+            "string": "edpkvS5QFv7KRGfa3b87gg9DBpxSm3NpSwnjhUjNBQrRUUR66F7C9g"
+          },
+          {
+            "string": "edpkuLxx9PQD8fZ45eUzrK3BhfDZJHhBuK4Zi49DcEGANwd2rpX82t"
+          }
+        ]
+      ]
+    }
+  ]
+} 
+*/
+```
+## Additional info
+
+See the top-level [https://github.com/trilitech/octez.js](https://github.com/trilitech/octez.js) file for details on reporting issues, contributing and versioning.
+
+## Disclaimer
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/lib/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingStateValue = exports.UnitValue = void 0;
+/**
+ * Symbol representing Unit value in Michelson
+ */
+exports.UnitValue = Symbol();
+/**
+ * Sapling state placeholder value
+ */
+exports.SaplingStateValue = {};

package/dist/lib/errors.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncodeTicketError = exports.NatValidationError = exports.MutezValidationError = exports.KeyHashValidationError = exports.IntValidationError = exports.BytesValidationError = exports.AddressValidationError = exports.SignatureValidationError = exports.ContractValidationError = exports.KeyValidationError = exports.ChainIDValidationError = exports.OrValidationError = exports.TokenComparisonError = exports.TokenArgumentValidationError = exports.BigMapValidationError = exports.SetValidationError = exports.MapValidationError = exports.ListValidationError = void 0;
+var list_1 = require("./tokens/list");
+Object.defineProperty(exports, "ListValidationError", { enumerable: true, get: function () { return list_1.ListValidationError; } });
+var map_1 = require("./tokens/map");
+Object.defineProperty(exports, "MapValidationError", { enumerable: true, get: function () { return map_1.MapValidationError; } });
+var set_1 = require("./tokens/set");
+Object.defineProperty(exports, "SetValidationError", { enumerable: true, get: function () { return set_1.SetValidationError; } });
+var bigmap_1 = require("./tokens/bigmap");
+Object.defineProperty(exports, "BigMapValidationError", { enumerable: true, get: function () { return bigmap_1.BigMapValidationError; } });
+var pair_1 = require("./tokens/pair");
+Object.defineProperty(exports, "TokenArgumentValidationError", { enumerable: true, get: function () { return pair_1.TokenArgumentValidationError; } });
+Object.defineProperty(exports, "TokenComparisonError", { enumerable: true, get: function () { return pair_1.TokenComparisonError; } });
+var or_1 = require("./tokens/or");
+Object.defineProperty(exports, "OrValidationError", { enumerable: true, get: function () { return or_1.OrValidationError; } });
+var chain_id_1 = require("./tokens/chain-id");
+Object.defineProperty(exports, "ChainIDValidationError", { enumerable: true, get: function () { return chain_id_1.ChainIDValidationError; } });
+var key_1 = require("./tokens/key");
+Object.defineProperty(exports, "KeyValidationError", { enumerable: true, get: function () { return key_1.KeyValidationError; } });
+var contract_1 = require("./tokens/contract");
+Object.defineProperty(exports, "ContractValidationError", { enumerable: true, get: function () { return contract_1.ContractValidationError; } });
+var signature_1 = require("./tokens/signature");
+Object.defineProperty(exports, "SignatureValidationError", { enumerable: true, get: function () { return signature_1.SignatureValidationError; } });
+var address_1 = require("./tokens/comparable/address");
+Object.defineProperty(exports, "AddressValidationError", { enumerable: true, get: function () { return address_1.AddressValidationError; } });
+var bytes_1 = require("./tokens/comparable/bytes");
+Object.defineProperty(exports, "BytesValidationError", { enumerable: true, get: function () { return bytes_1.BytesValidationError; } });
+var int_1 = require("./tokens/comparable/int");
+Object.defineProperty(exports, "IntValidationError", { enumerable: true, get: function () { return int_1.IntValidationError; } });
+var key_hash_1 = require("./tokens/comparable/key_hash");
+Object.defineProperty(exports, "KeyHashValidationError", { enumerable: true, get: function () { return key_hash_1.KeyHashValidationError; } });
+var mutez_1 = require("./tokens/comparable/mutez");
+Object.defineProperty(exports, "MutezValidationError", { enumerable: true, get: function () { return mutez_1.MutezValidationError; } });
+var nat_1 = require("./tokens/comparable/nat");
+Object.defineProperty(exports, "NatValidationError", { enumerable: true, get: function () { return nat_1.NatValidationError; } });
+var ticket_1 = require("./tokens/ticket");
+Object.defineProperty(exports, "EncodeTicketError", { enumerable: true, get: function () { return ticket_1.EncodeTicketError; } });

package/dist/lib/michelson-map.js

@@ -0,0 +1,198 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MichelsonMap = exports.MapTypecheckError = exports.InvalidMapTypeError = void 0;
+const storage_1 = require("./schema/storage");
+const fast_json_stable_stringify_1 = require("fast-json-stable-stringify");
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid map type being passed or used
+ */
+class InvalidMapTypeError extends octez_js_core_1.TaquitoError {
+    constructor(mapType, reason) {
+        super();
+        this.mapType = mapType;
+        this.reason = reason;
+        this.message = `The map type '${JSON.stringify(mapType)}' is invalid. Reason: ${reason}.`;
+        this.name = 'InvalidMapTypeError';
+    }
+}
+exports.InvalidMapTypeError = InvalidMapTypeError;
+// Retrieve a unique symbol associated with the key from the environment
+// Used in order to identify all object that are of type MichelsonMap even if they come from different module
+const michelsonMapTypeSymbol = Symbol.for('octez-michelson-map-type-symbol');
+/**
+ *
+ * @throws {@link InvalidMapTypeError} when the argument passed to mapType is not a valid map type
+ */
+function validateMapType(value) {
+    if (!('prim' in value)) {
+        throw new InvalidMapTypeError(value, `Missing 'prim' field`);
+    }
+    if (!['map', 'big_map'].includes(value.prim)) {
+        throw new InvalidMapTypeError(value, `The prim field should be 'map' or 'big_map'`);
+    }
+    if (!('args' in value)) {
+        throw new InvalidMapTypeError(value, `Missing 'args' field`);
+    }
+    if (!Array.isArray(value.args)) {
+        throw new InvalidMapTypeError(value, `The 'args' field should be an array`);
+    }
+    if (value.args.length !== 2) {
+        throw new InvalidMapTypeError(value, `The 'args' field should have 2 elements`);
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates a map type mismatch, where an attempt to set a key or value in a Map doesn't match the defined type of the Map
+ */
+class MapTypecheckError extends octez_js_core_1.TaquitoError {
+    constructor(value, type, objectType, reason) {
+        super();
+        this.value = value;
+        this.type = type;
+        this.reason = reason;
+        this.name = 'MapTypecheckError';
+        this.message = `The ${objectType} provided: ${JSON.stringify(value)} is not compatible with the expected michelson type: ${JSON.stringify(type)}. Reason: ${JSON.stringify(reason)}.`;
+        this.name = 'MapTypecheckError';
+    }
+}
+exports.MapTypecheckError = MapTypecheckError;
+/**
+ * @description Michelson Map is an abstraction over the michelson native map. It supports complex Pair as key
+ */
+class MichelsonMap {
+    // Used to check if an object is a michelson map.
+    // Using instanceof was not working for project that had multiple instance of octez.js dependencies
+    // as the class constructor is different
+    static isMichelsonMap(obj) {
+        return obj && obj[michelsonMapTypeSymbol] === true;
+    }
+    /**
+     * @param mapType If specified key and value will be type-checked before being added to the map
+     *
+     * @example new MichelsonMap({ prim: "map", args: [{prim: "string"}, {prim: "int"}]})
+     */
+    constructor(mapType) {
+        this.valueMap = new Map();
+        this.keyMap = new Map();
+        this[_a] = true;
+        if (mapType) {
+            this.setType(mapType);
+        }
+    }
+    setType(mapType) {
+        validateMapType(mapType);
+        this.keySchema = new storage_1.Schema(mapType.args[0]);
+        this.valueSchema = new storage_1.Schema(mapType.args[1]);
+    }
+    removeType() {
+        this.keySchema = undefined;
+        this.valueSchema = undefined;
+    }
+    static fromLiteral(obj, mapType) {
+        const map = new MichelsonMap(mapType);
+        Object.keys(obj).forEach((key) => {
+            map.set(key, obj[key]);
+        });
+        return map;
+    }
+    typecheckKey(key) {
+        if (!this.keySchema) {
+            return;
+        }
+        if (!this.keySchema.Typecheck(key)) {
+            throw new MapTypecheckError(key, this.keySchema, 'key', 'Type validation failed');
+        }
+    }
+    typecheckValue(value) {
+        if (!this.valueSchema) {
+            return;
+        }
+        if (!this.valueSchema.Typecheck(value)) {
+            throw new MapTypecheckError(value, this.valueSchema, 'value', 'Type validation failed');
+        }
+    }
+    /**
+     * @throws {@link MapTypecheckError} when the argument passed does not match the expected schema for value
+     */
+    assertTypecheckValue(value) {
+        this.typecheckValue(value);
+    }
+    /**
+     * @throws {@link MapTypecheckError} when the argument passed does not match the expected schema for key
+     */
+    assertTypecheckKey(key) {
+        this.typecheckKey(key);
+    }
+    serializeDeterministically(key) {
+        return (0, fast_json_stable_stringify_1.default)(key);
+    }
+    *keys() {
+        for (const [key] of this.entries()) {
+            yield key;
+        }
+    }
+    *values() {
+        for (const [, value] of this.entries()) {
+            yield value;
+        }
+    }
+    *entries() {
+        for (const key of this.valueMap.keys()) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            yield [this.keyMap.get(key), this.valueMap.get(key)];
+        }
+    }
+    get(key) {
+        this.assertTypecheckKey(key);
+        const strKey = this.serializeDeterministically(key);
+        return this.valueMap.get(strKey);
+    }
+    /**
+     *
+     * @description Set a key and a value in the MichelsonMap. If the key already exists, override the current value.
+     *
+     * @example map.set("myKey", "myValue") // Using a string as key
+     *
+     * @example map.set({0: "test", 1: "test1"}, "myValue") // Using a pair as key
+     *
+     * @warn The same key can be represented in multiple ways, depending on the type of the key. This duplicate key situation will cause a runtime error (duplicate key) when sending the map data to the Tezos RPC node.
+     *
+     * For example, consider a contract with a map whose key is of type boolean.  If you set the following values in MichelsonMap: map.set(false, "myValue") and map.set(null, "myValue").
+     *
+     * You will get two unique entries in the MichelsonMap. These values will both be evaluated as falsy by the MichelsonEncoder and ultimately rejected by the Tezos RPC.
+     */
+    set(key, value) {
+        this.assertTypecheckKey(key);
+        this.assertTypecheckValue(value);
+        const strKey = this.serializeDeterministically(key);
+        this.keyMap.set(strKey, key);
+        this.valueMap.set(strKey, value);
+    }
+    delete(key) {
+        this.assertTypecheckKey(key);
+        this.keyMap.delete(this.serializeDeterministically(key));
+        this.valueMap.delete(this.serializeDeterministically(key));
+    }
+    has(key) {
+        this.assertTypecheckKey(key);
+        const strKey = this.serializeDeterministically(key);
+        return this.keyMap.has(strKey) && this.valueMap.has(strKey);
+    }
+    clear() {
+        this.keyMap.clear();
+        this.valueMap.clear();
+    }
+    get size() {
+        return this.keyMap.size;
+    }
+    forEach(cb) {
+        for (const [key, value] of this.entries()) {
+            cb(value, key, this);
+        }
+    }
+}
+exports.MichelsonMap = MichelsonMap;
+_a = michelsonMapTypeSymbol;

package/dist/lib/octez.js-michelson-encoder.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * @packageDocumentation
+ * @module @tezos-x/octez.js-michelson-encoder
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = exports.VERSION = exports.SaplingStateValue = exports.UnitValue = void 0;
+__exportStar(require("./schema/storage"), exports);
+__exportStar(require("./schema/parameter"), exports);
+__exportStar(require("./schema/view-schema"), exports);
+__exportStar(require("./schema/event-schema"), exports);
+__exportStar(require("./schema/errors"), exports);
+__exportStar(require("./schema/types"), exports);
+__exportStar(require("./errors"), exports);
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "UnitValue", { enumerable: true, get: function () { return constants_1.UnitValue; } });
+Object.defineProperty(exports, "SaplingStateValue", { enumerable: true, get: function () { return constants_1.SaplingStateValue; } });
+__exportStar(require("./michelson-map"), exports);
+var version_1 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
+var token_1 = require("./tokens/token");
+Object.defineProperty(exports, "Token", { enumerable: true, get: function () { return token_1.Token; } });

package/dist/lib/schema/errors.js

@@ -0,0 +1,127 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingArgumentError = exports.StorageEncodingError = exports.BigMapEncodingError = exports.InvalidBigMapDiffError = exports.InvalidBigMapSchemaError = exports.InvalidRpcResponseError = exports.InvalidScriptError = exports.ParameterEncodingError = void 0;
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when encoding (transforming JS parameter into JSON Michelson) the parameter of the view
+ */
+class ParameterEncodingError extends octez_js_core_1.InvalidViewParameterError {
+    constructor(viewName, sigs, args, cause) {
+        super(viewName, sigs, args, cause);
+        this.viewName = viewName;
+        this.sigs = sigs;
+        this.args = args;
+        this.cause = cause;
+        this.name = 'ParameterEncodingError';
+        this.message = `Could not encode parameter ${JSON.stringify(args)} received for name "${viewName}" expecting one of the following signatures ${JSON.stringify(sigs)}`;
+    }
+}
+exports.ParameterEncodingError = ParameterEncodingError;
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid on-chain view found on the script
+ */
+class InvalidScriptError extends octez_js_core_1.TaquitoError {
+    constructor(script, reason) {
+        super();
+        this.script = script;
+        this.reason = reason;
+        this.name = 'InvalidScriptError';
+        let message = `Invalid on-chain view found in the following script.`;
+        if (reason) {
+            message += ` Reason: ${reason}.`;
+        }
+        message += `Script: ${JSON.stringify(script)}`;
+        this.message = message;
+    }
+}
+exports.InvalidScriptError = InvalidScriptError;
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid RPC response being passed or used
+ */
+class InvalidRpcResponseError extends octez_js_core_1.TaquitoError {
+    constructor(script, reason) {
+        super();
+        this.script = script;
+        this.reason = reason;
+        this.name = 'InvalidRpcResponseError';
+        let message = `Invalid RPC response passed as argument(s).`;
+        if (reason) {
+            message += ` Reason: ${reason}.`;
+        }
+        message += ` Received: ${JSON.stringify(script)}`;
+        this.message = message;
+    }
+}
+exports.InvalidRpcResponseError = InvalidRpcResponseError;
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid big map schema being passed or used
+ */
+class InvalidBigMapSchemaError extends octez_js_core_1.TaquitoError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidBigMapSchemaError';
+    }
+}
+exports.InvalidBigMapSchemaError = InvalidBigMapSchemaError;
+/**
+ *  @category Error
+ *  @description Error that indicates an invalid big map diff being passed or used
+ */
+class InvalidBigMapDiffError extends octez_js_core_1.TaquitoError {
+    constructor(message, value) {
+        super(message);
+        this.message = message;
+        this.value = value;
+        this.name = 'InvalidBigMapDiffError';
+    }
+}
+exports.InvalidBigMapDiffError = InvalidBigMapDiffError;
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when trying to encode big maps
+ */
+class BigMapEncodingError extends octez_js_core_1.TaquitoError {
+    constructor(obj, details, schema, value) {
+        super();
+        this.details = details;
+        this.schema = schema;
+        this.value = value;
+        this.name = 'BigMapEncodingError';
+        this.message = `Unable to encode the big map ${obj}. Schema is: ${JSON.stringify(schema)}. The ${obj} is: ${JSON.stringify(value)}. Error details: ${details}`;
+    }
+}
+exports.BigMapEncodingError = BigMapEncodingError;
+/**
+ *  @category Error
+ *  @description Error that indicates a failure when trying to encode storage
+ */
+class StorageEncodingError extends octez_js_core_1.TaquitoError {
+    constructor(obj, details, schema, value, semantics) {
+        super();
+        this.details = details;
+        this.schema = schema;
+        this.value = value;
+        this.semantics = semantics;
+        this.name = 'StorageEncodingError';
+        this.message = `Unable to encode ${obj}. The schema is: ${JSON.stringify(schema)}, the value is: ${JSON.stringify(value)}.${semantics ? `And the semantic is: ${JSON.stringify(semantics)}` : ''}. Error details: ${details}`;
+    }
+}
+exports.StorageEncodingError = StorageEncodingError;
+/**
+ *  @category Error
+ *  @description General error that indicates a function not being passed a necessary argument
+ */
+class MissingArgumentError extends octez_js_core_1.TaquitoError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'MissingArgumentError';
+    }
+}
+exports.MissingArgumentError = MissingArgumentError;

package/dist/lib/schema/event-schema.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSchema = void 0;
+const storage_1 = require("./storage");
+class EventSchema {
+    constructor(tag, type) {
+        this.tag = tag;
+        this.type = type;
+    }
+    static fromMichelineValue(val) {
+        var _a, _b;
+        return new EventSchema((_a = val.annots) === null || _a === void 0 ? void 0 : _a[0], (_b = val.args) === null || _b === void 0 ? void 0 : _b[0]);
+    }
+    static fromRPCResponse(val) {
+        const allEventSchema = [];
+        val.script.code.forEach((code) => {
+            if (!('prim' in code) ||
+                code.prim !== 'code' ||
+                !('args' in code) ||
+                !code.args) {
+                return;
+            }
+            allEventSchema.push(...EventSchema.extractEventsRecursively(code.args));
+        });
+        return EventSchema.removeDuplicates(allEventSchema);
+    }
+    static removeDuplicates(events) {
+        const uniqueEvents = [];
+        events.forEach((event) => {
+            const idx = uniqueEvents.findIndex((e) => e.tag === event.tag && (0, storage_1.deepEqual)(e.type, event.type));
+            if (idx === -1) {
+                uniqueEvents.push(event);
+            }
+        });
+        return uniqueEvents;
+    }
+    static extractEventsRecursively(code) {
+        if (Array.isArray(code)) {
+            return code.flatMap((c) => EventSchema.extractEventsRecursively(c));
+        }
+        if (!('prim' in code)) {
+            return [];
+        }
+        if (code.prim === 'EMIT') {
+            return [EventSchema.fromMichelineValue(code)];
+        }
+        if (!('args' in code) || !code.args) {
+            return [];
+        }
+        return code.args.flatMap((c) => EventSchema.extractEventsRecursively(c));
+    }
+}
+exports.EventSchema = EventSchema;

package/dist/lib/schema/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });