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

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

@@ -1,260 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Schema = void 0;
-exports.deepEqual = deepEqual;
-const bigmap_1 = require("../tokens/bigmap");
-const createToken_1 = require("../tokens/createToken");
-const map_1 = require("../tokens/map");
-const or_1 = require("../tokens/or");
-const pair_1 = require("../tokens/pair");
-const ticket_1 = require("../tokens/ticket");
-const ticket_deprecated_1 = require("../tokens/ticket-deprecated");
-const token_1 = require("../tokens/token");
-const errors_1 = require("./errors");
-const schemaTypeSymbol = Symbol.for('taquito-schema-type-symbol');
-// collapse comb pair
-function collapse(val, prim = pair_1.PairToken.prim) {
-    if (Array.isArray(val)) {
-        return collapse({
-            prim: prim,
-            args: val,
-        }, prim);
-    }
-    const extended = val;
-    if (extended.prim === prim && extended.args && extended.args.length > 2) {
-        return {
-            ...extended,
-            args: [
-                extended.args?.[0],
-                {
-                    prim: prim,
-                    args: extended.args?.slice(1),
-                },
-            ],
-        };
-    }
-    return extended;
-}
-function deepEqual(a, b) {
-    if (a === undefined || b === undefined) {
-        return a === b;
-    }
-    const ac = collapse(a);
-    const bc = collapse(b);
-    return (ac.prim === bc.prim &&
-        ((ac.args === undefined && bc.args === undefined) ||
-            (ac.args !== undefined &&
-                bc.args !== undefined &&
-                ac.args.length === bc.args.length &&
-                ac.args.every((v, i) => deepEqual(v, bc.args?.[i] ?? {})))) &&
-        ((ac.annots === undefined && bc.annots === undefined) ||
-            (ac.annots !== undefined &&
-                bc.annots !== undefined &&
-                ac.annots.length === bc.annots.length &&
-                ac.annots.every((v, i) => v === bc.annots?.[i]))));
-}
-/**
- * @remarks Our current smart contract abstraction feature is currently in preview. Its API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
- */
-class Schema {
-    static isSchema(obj) {
-        return obj && obj[schemaTypeSymbol] === true;
-    }
-    /**
-     * @throws {@link InvalidRpcResponseError}
-     */
-    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');
-        }
-        let code = val.script.code;
-        while (code.length === 1 && Array.isArray(code[0])) {
-            code = code[0];
-        }
-        const storage = code.find((x) => 'prim' in x && x.prim === 'storage');
-        if (!storage || !Array.isArray(storage.args)) {
-            throw new errors_1.InvalidRpcResponseError(val, 'The response.script.code has an element of type {prim: "storage"}, but its args is not an array');
-        }
-        return new Schema(storage.args[0]);
-    }
-    isExpressionExtended(val) {
-        return 'prim' in val && Array.isArray(val.args);
-    }
-    constructor(val) {
-        this.val = val;
-        this[_a] = true;
-        this.root = (0, createToken_1.createToken)(val, 0);
-        if (this.root instanceof bigmap_1.BigMapToken) {
-            this.bigMap = this.root;
-        }
-        else if (this.isExpressionExtended(val) && val.prim === 'pair') {
-            const exp = val.args[0];
-            if (this.isExpressionExtended(exp) && exp.prim === 'big_map') {
-                this.bigMap = new bigmap_1.BigMapToken(exp, 0, createToken_1.createToken);
-            }
-        }
-    }
-    removeTopLevelAnnotation(obj) {
-        // PairToken and OrToken can have redundant top level annotation in their storage
-        if (this.root instanceof pair_1.PairToken || this.root instanceof or_1.OrToken) {
-            if (this.root.hasAnnotations() && typeof obj === 'object' && Object.keys(obj).length === 1) {
-                return obj[Object.keys(obj)[0]];
-            }
-        }
-        return obj;
-    }
-    Execute(val, semantics) {
-        const storage = this.root.Execute(val, semantics);
-        return this.removeTopLevelAnnotation(storage);
-    }
-    /**
-     * Validates that a value matches the schema type.
-     * Performs type checking with special handling for BigMap, Ticket, and nested Map tokens.
-     *
-     * @param val - The value to validate against the schema
-     * @returns Returns true if validation passes, false if validation fails
-     */
-    Typecheck(val) {
-        if (this.root instanceof bigmap_1.BigMapToken && Number.isInteger(Number(val))) {
-            return true;
-        }
-        if (this.root instanceof ticket_1.TicketToken && val.ticketer && val.value && val.amount) {
-            return true;
-        }
-        if (this.root instanceof ticket_deprecated_1.TicketDeprecatedToken && val.ticketer && val.value && val.amount) {
-            return true;
-        }
-        if (this.root instanceof map_1.MapToken && this.root.ValueSchema instanceof bigmap_1.BigMapToken) {
-            return true;
-        }
-        try {
-            this.root.EncodeObject(val);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * @throws {@link InvalidBigMapSchemaError}
-     * @throws {@link InvalidBigMapDiffError}
-     */
-    ExecuteOnBigMapDiff(diff, semantics) {
-        if (!this.bigMap) {
-            throw new errors_1.InvalidBigMapSchemaError('Big map schema is undefined');
-        }
-        if (!Array.isArray(diff)) {
-            throw new errors_1.InvalidBigMapDiffError(`Big map diff must be an array, got: ${JSON.stringify(diff)}`, diff);
-        }
-        const eltFormat = diff.map(({ key, value }) => ({ args: [key, value] }));
-        return this.bigMap.Execute(eltFormat, semantics);
-    }
-    /**
-     * @throws {@link InvalidBigMapSchemaError}
-     */
-    ExecuteOnBigMapValue(key, semantics) {
-        if (!this.bigMap) {
-            throw new errors_1.InvalidBigMapSchemaError('Big map schema is undefined');
-        }
-        return this.bigMap.ValueSchema.Execute(key, semantics);
-    }
-    /**
-     * @throws {@link InvalidBigMapSchemaError}
-     * @throws {@link BigMapEncodingError}
-     */
-    EncodeBigMapKey(key) {
-        if (!this.bigMap) {
-            throw new errors_1.InvalidBigMapSchemaError('Big map schema is undefined');
-        }
-        try {
-            return this.bigMap.KeySchema.ToBigMapKey(key);
-        }
-        catch (ex) {
-            throw new errors_1.BigMapEncodingError('key', ex, this.bigMap.KeySchema, key);
-        }
-    }
-    /**
-     * @throws TokenValidationError
-     * @throws {@link StorageEncodingError}
-     */
-    Encode(value, semantics) {
-        try {
-            return this.root.EncodeObject(value, semantics);
-        }
-        catch (ex) {
-            if (ex instanceof token_1.TokenValidationError) {
-                throw ex;
-            }
-            throw new errors_1.StorageEncodingError('storage object', ex, this.root, value, semantics);
-        }
-    }
-    /**
-     * Produce a representation of the storage schema.
-     * Note: Provide guidance on how to write the storage object for the origination operation with Taquito.
-     */
-    generateSchema() {
-        return this.removeTopLevelAnnotation(this.root.generateSchema());
-    }
-    /**
-     * Look up in top-level pairs of the storage to find a value matching the specified type
-     *
-     * @returns The first value found that match the type or `undefined` if no value is found
-     *
-     * @param storage storage to parse to find the value
-     * @param valueType type of value to look for
-     *
-     */
-    FindFirstInTopLevelPair(storage, valueType) {
-        return this.findValue(this.root['val'], storage, valueType);
-    }
-    // TODO check these type casts
-    /**
-     * @throws {@link MissingArgumentError}
-     */
-    findValue(schema, storage, valueToFind) {
-        if (deepEqual(valueToFind, schema)) {
-            return storage;
-        }
-        if (Array.isArray(schema) || schema.prim === 'pair') {
-            const sch = collapse(schema);
-            const strg = collapse(storage, 'Pair');
-            if (sch.args === undefined || strg.args === undefined) {
-                throw new errors_1.MissingArgumentError('Tokens have no arguments'); // unlikely
-            }
-            if (sch.args[0])
-                return (
-                // unsafe
-                this.findValue(sch.args[0], strg.args[0], valueToFind) ||
-                    this.findValue(sch.args[1], strg.args[1], valueToFind));
-        }
-    }
-    /**
-     * Look up the schema to find any occurrence of a particular token.
-     *
-     * @returns an array of tokens of the specified kind or an empty array if no token was found
-     *
-     * @param tokenToFind string representing the prim property of the token to find
-     *
-     * @example
-     * ```
-     * Useful to find all global constants in a script, an array of GlobalConstantToken is returned:
-     *
-     * const schema = new Schema(script);
-     * const allGlobalConstantTokens = schema.findToken('constant');
-     * ```
-     *
-     */
-    findToken(tokenToFind) {
-        const tokens = [];
-        return this.root.findAndReturnTokens(tokenToFind, tokens);
-    }
-}
-exports.Schema = Schema;
-_a = schemaTypeSymbol;

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

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

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

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewSchema = void 0;
-const createToken_1 = require("../tokens/createToken");
-const errors_1 = require("./errors");
-class ViewSchema {
-    /**
-     *
-     * Create an instance of ViewSchema for each view in a script
-     *
-     * @param val contract script obtained from the RPC
-     * @returns array of ViewSchema or empty array if there is no view in the contract
-     * @throws {@link InvalidScriptError}
-     */
-    static fromRPCResponse(val) {
-        const allViewSchema = [];
-        const views = val &&
-            val.script &&
-            Array.isArray(val.script.code) &&
-            val.script.code.filter((x) => x.prim === 'view');
-        if (views) {
-            views.forEach((view) => {
-                allViewSchema.push(new ViewSchema(view.args));
-            });
-        }
-        return allViewSchema;
-    }
-    /**
-     * @throws {@link InvalidScriptError}
-     */
-    constructor(viewArgs) {
-        if (!viewArgs) {
-            throw new errors_1.InvalidScriptError(viewArgs, 'the args are not defined');
-        }
-        if (viewArgs.length !== 4) {
-            throw new errors_1.InvalidScriptError(viewArgs, `there should be exactly 4 arguments`);
-        }
-        if (!('string' in viewArgs[0]) || !viewArgs[0]['string']) {
-            throw new errors_1.InvalidScriptError(viewArgs, `The first argument should be a string, representing the view name. It should be in the form: { string: 'viewName' }`);
-        }
-        this.viewName = viewArgs[0]['string'];
-        this.viewArgsType = viewArgs[1];
-        this.viewReturnType = viewArgs[2];
-        this.instructions = viewArgs[3];
-        this.rootArgsType = (0, createToken_1.createToken)(this.viewArgsType, 0);
-        this.rootReturnType = (0, createToken_1.createToken)(this.viewReturnType, 0);
-    }
-    /**
-     *
-     * Transform the view parameter into Michelson
-     *
-     * @param args parameter of the view in js format
-     * @returns parameter of the view in Michelson
-     * @throws {@link ParameterEncodingError}
-     */
-    encodeViewArgs(args) {
-        try {
-            return this.rootArgsType.EncodeObject(args);
-        }
-        catch (ex) {
-            throw new errors_1.ParameterEncodingError(this.viewName, undefined, args, ex);
-        }
-    }
-    /**
-     *
-     * Transform the view result from Michelson to readable data
-     *
-     * @param val result of the view in JSON Michelson
-     * @param semantics optional semantics to override the default decoding behavior
-     * @returns result of the view in a readable format
-     */
-    decodeViewResult(val, semantics) {
-        return this.rootReturnType.Execute(val, semantics);
-    }
-    /**
-     *
-     * Return the signature of the view parameter
-     */
-    extractArgsSchema() {
-        return this.rootArgsType.generateSchema();
-    }
-    /**
-     *
-     * Return the format of the view result
-     */
-    extractResultSchema() {
-        return this.rootReturnType.generateSchema();
-    }
-}
-exports.ViewSchema = ViewSchema;

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

@@ -1,36 +0,0 @@
-"use strict";
-/**
- * @packageDocumentation
- * @module @taquito/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/taquito-michelson-encoder/src/tokens/bigmap.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigMapToken = exports.BigMapValidationError = void 0;
-const michelson_map_1 = require("../michelson-map");
-const token_1 = require("./token");
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing Big Map types
- */
-class BigMapValidationError extends token_1.TokenValidationError {
-    constructor(value, token, message) {
-        super(value, token, message);
-        this.value = value;
-        this.token = token;
-        this.name = 'BigMapValidationError';
-    }
-}
-exports.BigMapValidationError = BigMapValidationError;
-class BigMapToken extends token_1.Token {
-    constructor(val, idx, fac) {
-        super(val, idx, fac);
-        this.val = val;
-        this.idx = idx;
-        this.fac = fac;
-    }
-    get ValueSchema() {
-        return this.createToken(this.val.args[1], 0);
-    }
-    get KeySchema() {
-        return this.createToken(this.val.args[0], 0);
-    }
-    generateSchema() {
-        return {
-            __michelsonType: BigMapToken.prim,
-            schema: {
-                key: this.KeySchema.generateSchema(),
-                value: this.ValueSchema.generateSchema(),
-            },
-        };
-    }
-    /**
-     * @throws {@link BigMapValidationError}
-     */
-    validate(value) {
-        if (!michelson_map_1.MichelsonMap.isMichelsonMap(value)) {
-            throw new BigMapValidationError(value, this, `Value ${JSON.stringify(value)} is not a MichelsonMap`);
-        }
-    }
-    objLitToMichelsonMap(val) {
-        if (val instanceof michelson_map_1.MichelsonMap)
-            return val;
-        if (typeof val === 'object') {
-            if (Object.keys(val).length === 0) {
-                return new michelson_map_1.MichelsonMap();
-            }
-            else {
-                return michelson_map_1.MichelsonMap.fromLiteral(val);
-            }
-        }
-        return val;
-    }
-    /**
-     * @throws {@link BigMapValidationError}
-     */
-    Encode(args) {
-        const val = this.objLitToMichelsonMap(args.pop());
-        this.validate(val);
-        return Array.from(val.keys())
-            .sort((a, b) => this.KeySchema.compare(a, b))
-            .map((key) => {
-            return {
-                prim: 'Elt',
-                args: [this.KeySchema.EncodeObject(key), this.ValueSchema.EncodeObject(val.get(key))],
-            };
-        });
-    }
-    /**
-     * @throws {@link BigMapValidationError}
-     */
-    EncodeObject(args, semantic) {
-        const val = this.objLitToMichelsonMap(args);
-        this.validate(val);
-        if (semantic && semantic[BigMapToken.prim]) {
-            return semantic[BigMapToken.prim](val, this.val);
-        }
-        return Array.from(val.keys())
-            .sort((a, b) => this.KeySchema.compare(a, b))
-            .map((key) => {
-            return {
-                prim: 'Elt',
-                args: [this.KeySchema.EncodeObject(key), this.ValueSchema.EncodeObject(val.get(key))],
-            };
-        });
-    }
-    /**
-     * @throws {@link InvalidMapTypeError} when the argument passed to val is an array but not a valid map type
-     * @throws {@link BigMapValidationError} when the value is invalid
-     */
-    Execute(val, semantic) {
-        if (semantic && semantic[BigMapToken.prim]) {
-            return semantic[BigMapToken.prim](val, this.val);
-        }
-        if (Array.isArray(val)) {
-            // Athens is returning an empty array for big map in storage
-            // Internal: In taquito v5 it is still used to decode big map diff (as if they were a regular map)
-            const map = new michelson_map_1.MichelsonMap(this.val);
-            val.forEach((current) => {
-                map.set(this.KeySchema.ToKey(current.args[0]), this.ValueSchema.Execute(current.args[1]));
-            });
-            return map;
-        }
-        else if ('int' in val) {
-            // Babylon is returning an int with the big map id in contract storage
-            return val.int;
-        }
-        else {
-            throw new BigMapValidationError(val, this, `Big map is expecting either an array (Athens) or an object with an int property (Babylon). Got ${JSON.stringify(val)}`);
-        }
-    }
-    findAndReturnTokens(tokenToFind, tokens) {
-        if (BigMapToken.prim === tokenToFind) {
-            tokens.push(this);
-        }
-        this.KeySchema.findAndReturnTokens(tokenToFind, tokens);
-        this.ValueSchema.findAndReturnTokens(tokenToFind, tokens);
-        return tokens;
-    }
-}
-exports.BigMapToken = BigMapToken;
-BigMapToken.prim = 'big_map';

package/dist/lib/taquito-michelson-encoder/src/tokens/bls12-381-fr.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bls12381frToken = exports.Bls12381frValidationError = void 0;
-const token_1 = require("./token");
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a BLS12-381 scalar field Fr
- */
-class Bls12381frValidationError extends token_1.TokenValidationError {
-    constructor(value, token, message) {
-        super(value, token, message);
-        this.value = value;
-        this.token = token;
-        this.name = 'Bls12381frValidationError';
-    }
-}
-exports.Bls12381frValidationError = Bls12381frValidationError;
-class Bls12381frToken extends token_1.Token {
-    constructor(val, idx, fac) {
-        super(val, idx, fac);
-        this.val = val;
-        this.idx = idx;
-        this.fac = fac;
-    }
-    /**
-     * @throws {@link Bls12381frValidationError}
-     */
-    validate(val) {
-        if (/^[0-9a-fA-F]*$/.test(val) && val.length % 2 === 0) {
-            return;
-        }
-        throw new Bls12381frValidationError(val, this, `Invalid bytes: ${JSON.stringify(val)}`);
-    }
-    convertUint8ArrayToHexString(val) {
-        return val.constructor === Uint8Array ? Buffer.from(val).toString('hex') : val;
-    }
-    /**
-     * @throws {@link Bls12381frValidationError}
-     */
-    Encode(args) {
-        let val = args.pop();
-        if (typeof val === 'number') {
-            return { int: val.toString() };
-        }
-        else {
-            val = this.convertUint8ArrayToHexString(val);
-            this.validate(val);
-            return { bytes: val };
-        }
-    }
-    /**
-     * @throws {@link Bls12381frValidationError}
-     */
-    EncodeObject(val, semantic) {
-        if (semantic && semantic[Bls12381frToken.prim]) {
-            return semantic[Bls12381frToken.prim](val);
-        }
-        if (typeof val === 'number') {
-            return { int: val.toString() };
-        }
-        else {
-            val = this.convertUint8ArrayToHexString(val);
-            this.validate(val);
-            return { bytes: val };
-        }
-    }
-    Execute(val) {
-        return val.bytes;
-    }
-    generateSchema() {
-        return {
-            __michelsonType: Bls12381frToken.prim,
-            schema: Bls12381frToken.prim,
-        };
-    }
-    findAndReturnTokens(tokenToFind, tokens) {
-        if (Bls12381frToken.prim === tokenToFind) {
-            tokens.push(this);
-        }
-        return tokens;
-    }
-}
-exports.Bls12381frToken = Bls12381frToken;
-// An element of the BLS12-381 scalar field Fr
-// see https://tezos.gitlab.io/michelson-reference/#type-bls12_381_fr
-Bls12381frToken.prim = 'bls12_381_fr';

package/dist/lib/taquito-michelson-encoder/src/tokens/bls12-381-g1.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bls12381g1Token = exports.Bls12381g1ValidationError = void 0;
-const token_1 = require("./token");
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a BLS12-381 curve G1
- */
-class Bls12381g1ValidationError extends token_1.TokenValidationError {
-    constructor(value, token, message) {
-        super(value, token, message);
-        this.value = value;
-        this.token = token;
-        this.name = 'Bls12381g1ValidationError';
-    }
-}
-exports.Bls12381g1ValidationError = Bls12381g1ValidationError;
-class Bls12381g1Token extends token_1.Token {
-    constructor(val, idx, fac) {
-        super(val, idx, fac);
-        this.val = val;
-        this.idx = idx;
-        this.fac = fac;
-    }
-    /**
-     * @throws {@link Bls12381g1ValidationError}
-     */
-    validate(val) {
-        if (/^[0-9a-fA-F]*$/.test(val) && val.length % 2 === 0) {
-            return;
-        }
-        throw new Bls12381g1ValidationError(val, this, `Invalid bytes: ${JSON.stringify(val)}`);
-    }
-    convertUint8ArrayToHexString(val) {
-        return val.constructor === Uint8Array ? Buffer.from(val).toString('hex') : val;
-    }
-    /**
-     * @throws {@link Bls12381g1ValidationError}
-     */
-    Encode(args) {
-        let val = args.pop();
-        val = this.convertUint8ArrayToHexString(val);
-        this.validate(val);
-        return { bytes: val };
-    }
-    /**
-     * @throws {@link Bls12381g1ValidationError}
-     */
-    EncodeObject(val, semantic) {
-        val = this.convertUint8ArrayToHexString(val);
-        this.validate(val);
-        if (semantic && semantic[Bls12381g1Token.prim]) {
-            return semantic[Bls12381g1Token.prim](val);
-        }
-        return { bytes: val };
-    }
-    Execute(val) {
-        return val.bytes;
-    }
-    generateSchema() {
-        return {
-            __michelsonType: Bls12381g1Token.prim,
-            schema: Bls12381g1Token.prim,
-        };
-    }
-    findAndReturnTokens(tokenToFind, tokens) {
-        if (Bls12381g1Token.prim === tokenToFind) {
-            tokens.push(this);
-        }
-        return tokens;
-    }
-}
-exports.Bls12381g1Token = Bls12381g1Token;
-// A point on the BLS12-381 curve G1
-// See https://tezos.gitlab.io/michelson-reference/#type-bls12_381_g1
-Bls12381g1Token.prim = 'bls12_381_g1';