@taquito/wallet-connect 24.3.0-beta.0 → 24.3.0-beta.2

package/dist/lib/taquito-michelson-encoder/src/michelson-map.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 = __importDefault(require("fast-json-stable-stringify"));
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates an invalid map type being passed or used
+ */
+class InvalidMapTypeError extends 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('taquito-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
+ *  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 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;
+/**
+ * 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 taquito 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);
+    }
+    /**
+     *
+     * 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
+     *
+     * @remarks 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/taquito-michelson-encoder/src/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 core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates a failure when encoding (transforming JS parameter into JSON Michelson) the parameter of the view
+ */
+class ParameterEncodingError extends 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
+ *  Error that indicates an invalid on-chain view found on the script
+ */
+class InvalidScriptError extends 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
+ *  Error that indicates an invalid RPC response being passed or used
+ */
+class InvalidRpcResponseError extends 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
+ *  Error that indicates an invalid big map schema being passed or used
+ */
+class InvalidBigMapSchemaError extends core_1.TaquitoError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidBigMapSchemaError';
+    }
+}
+exports.InvalidBigMapSchemaError = InvalidBigMapSchemaError;
+/**
+ *  @category Error
+ *  Error that indicates an invalid big map diff being passed or used
+ */
+class InvalidBigMapDiffError extends core_1.TaquitoError {
+    constructor(message, value) {
+        super(message);
+        this.message = message;
+        this.value = value;
+        this.name = 'InvalidBigMapDiffError';
+    }
+}
+exports.InvalidBigMapDiffError = InvalidBigMapDiffError;
+/**
+ *  @category Error
+ *  Error that indicates a failure when trying to encode big maps
+ */
+class BigMapEncodingError extends 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
+ *  Error that indicates a failure when trying to encode storage
+ */
+class StorageEncodingError extends 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
+ *  General error that indicates a function not being passed a necessary argument
+ */
+class MissingArgumentError extends core_1.TaquitoError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'MissingArgumentError';
+    }
+}
+exports.MissingArgumentError = MissingArgumentError;

package/dist/lib/taquito-michelson-encoder/src/schema/event-schema.js

@@ -0,0 +1,52 @@
+"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) {
+        return new EventSchema(val.annots?.[0], val.args?.[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/taquito-michelson-encoder/src/schema/parameter.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterSchema = void 0;
+const createToken_1 = require("../tokens/createToken");
+const token_1 = require("../tokens/token");
+const or_1 = require("../tokens/or");
+const option_1 = require("../tokens/option");
+const errors_1 = require("./errors");
+/**
+ * @remarks Our current smart contract abstraction feature is currently in preview. It's API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
+ */
+class ParameterSchema {
+    /**
+     *
+     * Create an instance of ParameterSchema from a contract script
+     *
+     * @param val contract script obtained from the RPC
+     * @returns ParameterSchema
+     * @throws {InvalidRpcResponseError} If the RPC response is invalid
+     */
+    static fromRPCResponse(val) {
+        if (!val) {
+            throw new errors_1.InvalidRpcResponseError(val, 'the RPC response is empty');
+        }
+        if (!val.script) {
+            throw new errors_1.InvalidRpcResponseError(val, 'the RPC response has no script');
+        }
+        if (!Array.isArray(val.script.code)) {
+            throw new errors_1.InvalidRpcResponseError(val, 'The response.script.code should be an array');
+        }
+        const parameter = val.script.code.find((x) => 'prim' in x && x.prim === 'parameter');
+        if (!parameter) {
+            throw new errors_1.InvalidRpcResponseError(val, `The response.script.code should have an element of type {prim: "parameter"}`);
+        }
+        if (!Array.isArray(parameter.args)) {
+            throw new errors_1.InvalidRpcResponseError(val, `The response.script.code has an element of type {prim: "parameter"}, but its args is not an array`);
+        }
+        return new ParameterSchema(parameter.args[0]);
+    }
+    /**
+     * Check if the Contract parameter is multiple entry point or not
+     */
+    get isMultipleEntryPoint() {
+        return (this.root instanceof or_1.OrToken ||
+            (this.root instanceof option_1.OptionToken && this.root.subToken() instanceof or_1.OrToken));
+    }
+    /**
+     * Check if the Contract parameter has an annotation or not
+     */
+    get hasAnnotation() {
+        if (this.isMultipleEntryPoint) {
+            return Object.keys(this.generateSchema())[0] !== '0';
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Return the schema of the parameter of a specific entry point
+     * @throws InvalidTokenError
+     */
+    constructor(val) {
+        this.root = (0, createToken_1.createToken)(val, 0);
+    }
+    /**
+     * Returns the javascript object equivalent of the Micheline value provided
+     */
+    Execute(val, semantics) {
+        return this.root.Execute(val, semantics);
+    }
+    /**
+     * Returns a micheline formatted object for the values provided
+     * @throws TokenValidationError
+     * @throws {@link ParameterEncodingError}
+     */
+    Encode(...args) {
+        try {
+            return this.root.Encode(args.reverse());
+        }
+        catch (ex) {
+            if (ex instanceof token_1.TokenValidationError) {
+                throw ex;
+            }
+            throw new errors_1.ParameterEncodingError('Unable to encode parameter', this.root, args, ex);
+        }
+    }
+    /**
+     * Returns a micheline formatted object for the javascript object provided
+     * @throws TokenValidationError
+     * @throws {@link ParameterEncodingError}
+     */
+    EncodeObject(value, semantics) {
+        try {
+            return this.root.EncodeObject(value, semantics);
+        }
+        catch (ex) {
+            if (ex instanceof token_1.TokenValidationError) {
+                throw ex;
+            }
+            throw new errors_1.ParameterEncodingError('Unable to encode parameter object', this.root, value, ex);
+        }
+    }
+    /**
+     * Produce a schema grouping together all the entry points of a contract.
+     */
+    generateSchema() {
+        return this.root.generateSchema();
+    }
+    ExtractSignatures() {
+        return this.root.ExtractSignature();
+    }
+}
+exports.ParameterSchema = ParameterSchema;