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

package/dist/lib/taquito-michel-codec/src/michelson-typecheck.js

@@ -1,1756 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MichelsonInstructionError = void 0;
-exports.assertTypeAnnotationsValid = assertTypeAnnotationsValid;
-exports.contractSection = contractSection;
-exports.contractViews = contractViews;
-exports.contractEntryPoint = contractEntryPoint;
-exports.contractEntryPoints = contractEntryPoints;
-exports.assertContractValid = assertContractValid;
-exports.assertDataValid = assertDataValid;
-exports.functionType = functionType;
-exports.assertTypesEqual = assertTypesEqual;
-exports.isTypeAnnotationsValid = isTypeAnnotationsValid;
-exports.isContractValid = isContractValid;
-exports.isDataValid = isDataValid;
-exports.isTypeEqual = isTypeEqual;
-const michelson_types_1 = require("./michelson-types");
-const utils_1 = require("./utils");
-const base58_1 = require("./base58");
-const binary_1 = require("./binary");
-const michelson_validator_1 = require("./michelson-validator");
-class MichelsonInstructionError extends utils_1.MichelsonError {
-    /**
-     * @param val Value of a type node caused the error
-     * @param stackState Current stack state
-     * @param message An error message
-     */
-    constructor(val, stackState, message) {
-        super(val, message);
-        this.val = val;
-        this.stackState = stackState;
-        this.message = message;
-        this.name = 'MichelsonInstructionError';
-    }
-}
-exports.MichelsonInstructionError = MichelsonInstructionError;
-// 'sequence as a pair' edo syntax helpers
-function typeID(t) {
-    return Array.isArray(t) ? 'pair' : t.prim;
-}
-function typeArgs(t) {
-    return ('prim' in t ? t.args : t);
-}
-function assertScalarTypesEqual(a, b, field = false) {
-    if (typeID(a) !== typeID(b)) {
-        throw new utils_1.MichelsonTypeError(a, `types mismatch: ${typeID(a)} != ${typeID(b)}`, undefined);
-    }
-    const ann = [(0, utils_1.unpackAnnotations)(a), (0, utils_1.unpackAnnotations)(b)];
-    if (ann[0].t && ann[1].t && ann[0].t[0] !== ann[1].t[0]) {
-        throw new utils_1.MichelsonTypeError(a, `${typeID(a)}: type names mismatch: ${ann[0].t[0]} != ${ann[1].t[0]}`, undefined);
-    }
-    if (field && ann[0].f && ann[1].f && ann[0].f[0] !== ann[1].f[0]) {
-        throw new utils_1.MichelsonTypeError(a, `${typeID(a)}: field names mismatch: ${ann[0].f[0]} != ${ann[1].f}`, undefined);
-    }
-    if ((0, utils_1.isPairType)(a)) {
-        const aArgs = (0, utils_1.unpackComb)('pair', a);
-        const bArgs = (0, utils_1.unpackComb)('pair', b);
-        assertScalarTypesEqual(aArgs.args[0], bArgs.args[0], true);
-        assertScalarTypesEqual(aArgs.args[1], bArgs.args[1], true);
-        return;
-    }
-    switch (a.prim) {
-        case 'option':
-        case 'list':
-        case 'contract':
-        case 'set':
-        case 'ticket':
-            assertScalarTypesEqual(a.args[0], b.args[0]);
-            break;
-        case 'or':
-            assertScalarTypesEqual(a.args[0], b.args[0], true);
-            assertScalarTypesEqual(a.args[1], b.args[1], true);
-            break;
-        case 'lambda':
-        case 'map':
-        case 'big_map':
-            assertScalarTypesEqual(a.args[0], b.args[0]);
-            assertScalarTypesEqual(a.args[1], b.args[1]);
-            break;
-        case 'sapling_state':
-        case 'sapling_transaction':
-            if (parseInt(a.args[0].int, 10) !== parseInt(b.args[0].int, 10)) {
-                throw new utils_1.MichelsonTypeError(a, `${typeID(a)}: type argument mismatch: ${a.args[0].int} != ${b.args[0].int}`, undefined);
-            }
-    }
-}
-function assertStacksEqual(a, b) {
-    if (a.length !== b.length) {
-        throw new utils_1.MichelsonTypeError(a, `stack length mismatch: ${a.length} != ${b.length}`, undefined);
-    }
-    for (let i = 0; i < a.length; i++) {
-        assertScalarTypesEqual(a[i], b[i]);
-    }
-}
-function assertTypeAnnotationsValid(t, field = false) {
-    if (!Array.isArray(t)) {
-        const ann = (0, utils_1.unpackAnnotations)(t);
-        if ((ann.t?.length || 0) > 1) {
-            throw new utils_1.MichelsonTypeError(t, `${t.prim}: at most one type annotation allowed: ${t.annots}`, undefined);
-        }
-        if (field) {
-            if ((ann.f?.length || 0) > 1) {
-                throw new utils_1.MichelsonTypeError(t, `${t.prim}: at most one field annotation allowed: ${t.annots}`, undefined);
-            }
-        }
-        else {
-            if ((ann.f?.length || 0) > 0) {
-                throw new utils_1.MichelsonTypeError(t, `${t.prim}: field annotations aren't allowed: ${t.annots}`, undefined);
-            }
-        }
-    }
-    if ((0, utils_1.isPairType)(t)) {
-        const args = typeArgs(t);
-        for (const a of args) {
-            assertTypeAnnotationsValid(a, true);
-        }
-        return;
-    }
-    switch (t.prim) {
-        case 'option':
-        case 'list':
-        case 'contract':
-        case 'set':
-            assertTypeAnnotationsValid(t.args[0]);
-            break;
-        case 'or':
-            for (const a of t.args) {
-                assertTypeAnnotationsValid(a, true);
-            }
-            break;
-        case 'lambda':
-        case 'map':
-        case 'big_map':
-            assertTypeAnnotationsValid(t.args[0]);
-            assertTypeAnnotationsValid(t.args[1]);
-    }
-}
-// Data integrity check
-function _compareMichelsonData(t, a, b) {
-    if ((0, utils_1.isPairType)(t)) {
-        if ((0, utils_1.isPairData)(a) && (0, utils_1.isPairData)(b)) {
-            (0, michelson_validator_1.assertDataListIfAny)(a);
-            (0, michelson_validator_1.assertDataListIfAny)(b);
-            const tComb = (0, utils_1.unpackComb)('pair', t);
-            const aComb = (0, utils_1.unpackComb)('Pair', a);
-            const bComb = (0, utils_1.unpackComb)('Pair', b);
-            const x = _compareMichelsonData(tComb.args[0], aComb.args[0], bComb.args[0]);
-            if (x !== 0) {
-                return x;
-            }
-            return _compareMichelsonData(tComb.args[0], aComb.args[1], bComb.args[1]);
-        }
-    }
-    else {
-        switch (t.prim) {
-            case 'int':
-            case 'nat':
-            case 'mutez':
-                if ('int' in a && 'int' in b) {
-                    return new utils_1.LongInteger(a.int).cmp(new utils_1.LongInteger(b.int));
-                }
-                break;
-            case 'string':
-                if ('string' in a && 'string' in b) {
-                    const x = a.string.localeCompare(b.string);
-                    return x < 0 ? -1 : x > 0 ? 1 : 0;
-                }
-                break;
-            case 'bytes':
-                if ('bytes' in a && 'bytes' in b) {
-                    const aa = (0, utils_1.parseBytes)(a.bytes);
-                    const bb = (0, utils_1.parseBytes)(b.bytes);
-                    if (aa !== null && bb !== null) {
-                        return (0, utils_1.compareBytes)(aa, bb);
-                    }
-                }
-                break;
-            case 'bool':
-                if ('prim' in a &&
-                    'prim' in b &&
-                    (a.prim === 'True' || a.prim === 'False') &&
-                    (b.prim === 'True' || b.prim === 'False')) {
-                    return a.prim === b.prim ? 0 : a.prim === 'False' ? -1 : 1;
-                }
-                break;
-            case 'key':
-            case 'key_hash':
-            case 'address':
-            case 'signature':
-            case 'chain_id':
-                if (('string' in a || 'bytes' in a) && ('string' in b || 'bytes' in b)) {
-                    return (0, utils_1.compareBytes)('string' in a ? (0, base58_1.decodeBase58Check)(a.string) : (0, utils_1.parseBytes)(a.bytes) || [], 'string' in b ? (0, base58_1.decodeBase58Check)(b.string) : (0, utils_1.parseBytes)(b.bytes) || []);
-                }
-                break;
-            case 'timestamp':
-                if (('string' in a || 'int' in a) && ('string' in b || 'int' in b)) {
-                    const aa = (0, utils_1.parseDate)(a);
-                    const bb = (0, utils_1.parseDate)(b);
-                    if (aa !== null && bb !== null) {
-                        const x = aa.valueOf() - bb.valueOf();
-                        return x < 0 ? -1 : x > 0 ? 1 : 0;
-                    }
-                }
-                break;
-            case 'unit':
-                if ('prim' in a && 'prim' in b && a.prim === 'Unit' && b.prim === 'Unit') {
-                    return 0;
-                }
-        }
-    }
-    // Unlikely, types are expected to be verified before the function call
-    throw new utils_1.MichelsonTypeError(t, `${typeID(t)}: not comparable values: ${JSON.stringify(a)}, ${JSON.stringify(b)}`, undefined);
-}
-// Simplified version of assertMichelsonInstruction() for previously validated data
-function isFunction(d) {
-    if (!Array.isArray(d)) {
-        return false;
-    }
-    for (const v of d) {
-        if (!((Array.isArray(v) && isFunction(v)) || ('prim' in v && (0, michelson_validator_1.isInstruction)(v)))) {
-            return false;
-        }
-    }
-    return true;
-}
-function assertDataValidInternal(d, t, ctx) {
-    if ((0, utils_1.isPairType)(t)) {
-        if ((0, utils_1.isPairData)(d)) {
-            (0, michelson_validator_1.assertDataListIfAny)(d);
-            const dc = (0, utils_1.unpackComb)('Pair', d);
-            const tc = (0, utils_1.unpackComb)('pair', t);
-            assertDataValidInternal(dc.args[0], tc.args[0], ctx);
-            assertDataValidInternal(dc.args[1], tc.args[1], ctx);
-            return;
-        }
-        throw new utils_1.MichelsonTypeError(t, `pair expected: ${JSON.stringify(d)}`, d);
-    }
-    switch (t.prim) {
-        // Atomic literals
-        case 'int':
-            if ('int' in d && (0, utils_1.isDecimal)(d.int)) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `integer value expected: ${JSON.stringify(d)}`, d);
-        case 'nat':
-        case 'mutez':
-            if ('int' in d && (0, utils_1.isNatural)(d.int)) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `natural value expected: ${JSON.stringify(d)}`, d);
-        case 'string':
-            if ('string' in d) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `string value expected: ${JSON.stringify(d)}`, d);
-        case 'bytes':
-        case 'bls12_381_g1':
-        case 'bls12_381_g2':
-            if ('bytes' in d && (0, utils_1.parseBytes)(d.bytes) !== null) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `bytes value expected: ${JSON.stringify(d)}`, d);
-        case 'bool':
-            if ('prim' in d && (d.prim === 'True' || d.prim === 'False')) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `boolean value expected: ${JSON.stringify(d)}`, d);
-        case 'key_hash':
-            if ('string' in d &&
-                (0, utils_1.checkDecodeTezosID)(d.string, 'ED25519PublicKeyHash', 'SECP256K1PublicKeyHash', 'P256PublicKeyHash') !== null) {
-                return;
-            }
-            else if ('bytes' in d) {
-                try {
-                    (0, binary_1.decodePublicKeyHashBytes)(d);
-                    return;
-                }
-                catch (err) {
-                    // ignore message
-                }
-            }
-            throw new utils_1.MichelsonTypeError(t, `key hash expected: ${JSON.stringify(d)}`, d);
-        case 'timestamp':
-            if (('string' in d || 'int' in d) && (0, utils_1.parseDate)(d) !== null) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `timestamp expected: ${JSON.stringify(d)}`, d);
-        case 'address':
-            if ('string' in d) {
-                let address = d.string;
-                const ep = d.string.indexOf('%');
-                if (ep >= 0) {
-                    // trim entry point
-                    address = d.string.slice(0, ep);
-                }
-                if ((0, utils_1.checkDecodeTezosID)(address, 'ED25519PublicKeyHash', 'SECP256K1PublicKeyHash', 'P256PublicKeyHash', 'ContractHash', 'RollupAddress') !== null) {
-                    return;
-                }
-            }
-            else if ('bytes' in d) {
-                try {
-                    (0, binary_1.decodeAddressBytes)(d);
-                    return;
-                }
-                catch (err) {
-                    // ignore message
-                }
-            }
-            throw new utils_1.MichelsonTypeError(t, `address expected: ${JSON.stringify(d)}`, d);
-        case 'key':
-            if ('string' in d &&
-                (0, utils_1.checkDecodeTezosID)(d.string, 'ED25519PublicKey', 'SECP256K1PublicKey', 'P256PublicKey') !==
-                    null) {
-                return;
-            }
-            else if ('bytes' in d) {
-                try {
-                    (0, binary_1.decodePublicKeyBytes)(d);
-                    return;
-                }
-                catch (err) {
-                    // ignore message
-                }
-            }
-            throw new utils_1.MichelsonTypeError(t, `public key expected: ${JSON.stringify(d)}`, d);
-        case 'unit':
-            if ('prim' in d && d.prim === 'Unit') {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `unit value expected: ${JSON.stringify(d)}`, d);
-        case 'signature':
-            if ('bytes' in d ||
-                ('string' in d &&
-                    (0, utils_1.checkDecodeTezosID)(d.string, 'ED25519Signature', 'SECP256K1Signature', 'P256Signature', 'GenericSignature') !== null)) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `signature expected: ${JSON.stringify(d)}`, d);
-        case 'chain_id':
-            if ('bytes' in d || 'string' in d) {
-                const x = 'string' in d ? (0, base58_1.decodeBase58Check)(d.string) : (0, utils_1.parseBytes)(d.bytes);
-                if (x !== null) {
-                    return;
-                }
-            }
-            throw new utils_1.MichelsonTypeError(t, `chain id expected: ${JSON.stringify(d)}`, d);
-        // Complex types
-        case 'option':
-            if ('prim' in d) {
-                if (d.prim === 'None') {
-                    return;
-                }
-                else if (d.prim === 'Some') {
-                    assertDataValidInternal(d.args[0], t.args[0], ctx);
-                    return;
-                }
-            }
-            throw new utils_1.MichelsonTypeError(t, `option expected: ${JSON.stringify(d)}`, d);
-        case 'list':
-        case 'set':
-            if ((0, michelson_validator_1.assertDataListIfAny)(d)) {
-                //let prev: MichelsonData | undefined;
-                for (const v of d) {
-                    assertDataValidInternal(v, t.args[0], ctx);
-                }
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `${t.prim} expected: ${JSON.stringify(d)}`, d);
-        case 'or':
-            if ('prim' in d) {
-                if (d.prim === 'Left') {
-                    assertDataValidInternal(d.args[0], t.args[0], ctx);
-                    return;
-                }
-                else if (d.prim === 'Right') {
-                    assertDataValidInternal(d.args[0], t.args[1], ctx);
-                    return;
-                }
-            }
-            throw new utils_1.MichelsonTypeError(t, `union (or) expected: ${JSON.stringify(d)}`, d);
-        case 'lambda':
-            if (isFunction(d)) {
-                const ret = functionTypeInternal(d, [t.args[0]], ctx);
-                if ('failed' in ret) {
-                    throw new utils_1.MichelsonTypeError(t, `function is failed with error type: ${ret.failed}`, d);
-                }
-                if (ret.length !== 1) {
-                    throw new utils_1.MichelsonTypeError(t, 'function must return a value', d);
-                }
-                assertScalarTypesEqual(t.args[1], ret[0]);
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `function expected: ${JSON.stringify(d)}`, d);
-        case 'map':
-        case 'big_map':
-            if (Array.isArray(d)) {
-                //let prev: MichelsonMapElt | undefined;
-                for (const v of d) {
-                    if (!('prim' in v) || v.prim !== 'Elt') {
-                        throw new utils_1.MichelsonTypeError(t, `map elements expected: ${JSON.stringify(d)}`, d);
-                    }
-                    assertDataValidInternal(v.args[0], t.args[0], ctx);
-                    assertDataValidInternal(v.args[1], t.args[1], ctx);
-                }
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `${t.prim} expected: ${JSON.stringify(d)}`, d);
-        case 'bls12_381_fr':
-            if (('int' in d && (0, utils_1.isDecimal)(d.int)) || ('bytes' in d && (0, utils_1.parseBytes)(d.bytes) !== null)) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `BLS12-381 element expected: ${JSON.stringify(d)}`, d);
-        case 'sapling_state':
-            if (Array.isArray(d)) {
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `sapling state expected: ${JSON.stringify(d)}`, d);
-        case 'ticket':
-            if ('prim' in d && d.prim === 'Ticket') {
-                assertDataValidInternal(d.args[0], { prim: 'address' }, ctx);
-                assertTypesEqual(d.args[1], t.args[0]);
-                assertDataValidInternal(d.args[2], t.args[0], ctx);
-                assertDataValidInternal(d.args[3], { prim: 'nat' }, ctx);
-                return;
-            }
-            else if ((0, utils_1.isPairData)(d)) {
-                // backward compatibility
-                assertDataValidInternal(d, {
-                    prim: 'pair',
-                    args: [{ prim: 'address' }, t.args[0], { prim: 'nat' }],
-                }, ctx);
-                return;
-            }
-            throw new utils_1.MichelsonTypeError(t, `ticket expected: ${JSON.stringify(d)}`, d);
-        default:
-            throw new utils_1.MichelsonTypeError(t, `type ${typeID(t)} don't have Michelson literal representation`, d);
-    }
-}
-function instructionListType(inst, stack, ctx) {
-    let ret = stack;
-    let s = stack;
-    let i = 0;
-    for (const op of inst) {
-        const ft = functionTypeInternal(op, s, ctx);
-        ret = ft;
-        if ('failed' in ft) {
-            break;
-        }
-        s = ft;
-        i++;
-    }
-    if ('failed' in ret &&
-        ret.level == 0 &&
-        (!('prim' in ret.failed) || ret.failed.prim !== 'never') &&
-        i !== inst.length - 1) {
-        throw new MichelsonInstructionError(inst, ret, 'FAIL must appear in a tail position');
-    }
-    if (ctx?.traceCallback !== undefined) {
-        const trace = {
-            op: inst,
-            in: stack,
-            out: ret,
-        };
-        ctx.traceCallback(trace);
-    }
-    return 'failed' in ret ? { failed: ret.failed, level: ret.level + 1 } : ret;
-}
-function functionTypeInternal(inst, stack, ctx) {
-    const proto = ctx?.protocol || michelson_types_1.DefaultProtocol;
-    if (Array.isArray(inst)) {
-        return instructionListType(inst, stack, ctx);
-    }
-    const instruction = inst; // Make it const for type guarding
-    // make sure the stack has enough number of arguments of specific types
-    function args(n, ...typeIds) {
-        if (stack.length < typeIds.length + n) {
-            throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: stack must have at least ${typeIds.length} element(s)`);
-        }
-        let i = n;
-        for (const ids of typeIds) {
-            if (ids !== null && ids.length !== 0) {
-                let ii = 0;
-                while (ii < ids.length && ids[ii] !== typeID(stack[i])) {
-                    ii++;
-                }
-                if (ii === ids.length) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: stack type mismatch: [${i}] expected to be ${ids}, got ${typeID(stack[i])} instead`);
-                }
-            }
-            i++;
-        }
-        return stack.slice(n, typeIds.length + n);
-    }
-    function rethrow(fn) {
-        return (...args) => {
-            try {
-                return fn(...args);
-            }
-            catch (err) {
-                if (err instanceof utils_1.MichelsonError) {
-                    throw new MichelsonInstructionError(instruction, stack, err.message);
-                }
-                else {
-                    throw err;
-                }
-            }
-        };
-    }
-    function rethrowTypeGuard(fn) {
-        return (arg) => {
-            try {
-                return fn(arg);
-            }
-            catch (err) {
-                if (err instanceof utils_1.MichelsonError) {
-                    throw new MichelsonInstructionError(instruction, stack, err.message);
-                }
-                else {
-                    throw err;
-                }
-            }
-        };
-    }
-    const argAnn = rethrow(utils_1.unpackAnnotations);
-    const ensureStacksEqual = rethrow(assertStacksEqual);
-    const ensureTypesEqual = rethrow(assertScalarTypesEqual);
-    const ensureComparableType = rethrowTypeGuard(michelson_validator_1.assertMichelsonComparableType);
-    const ensurePackableType = rethrowTypeGuard(michelson_validator_1.assertMichelsonPackableType);
-    const ensureStorableType = rethrowTypeGuard(michelson_validator_1.assertMichelsonStorableType);
-    const ensurePushableType = rethrowTypeGuard(michelson_validator_1.assertMichelsonPushableType);
-    const ensureBigMapStorableType = rethrowTypeGuard(michelson_validator_1.assertMichelsonBigMapStorableType);
-    // unpack instruction annotations and assert their maximum number
-    function instructionAnn(num, opt) {
-        const a = argAnn(instruction, {
-            ...opt,
-            emptyFields: num.f !== undefined && num.f > 1,
-            emptyVar: num.v !== undefined && num.v > 1,
-        });
-        const assertNum = (a, n, type) => {
-            if (a && a.length > (n || 0)) {
-                throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: at most ${n || 0} ${type} annotations allowed`);
-            }
-        };
-        assertNum(a.f, num.f, 'field');
-        assertNum(a.t, num.t, 'type');
-        assertNum(a.v, num.v, 'variable');
-        return a;
-    }
-    // also keeps annotation class if null is provided
-    function annotate(tt, a) {
-        const tx = tt;
-        const t = Array.isArray(tx) ? { prim: 'pair', args: tx } : tx;
-        const src = argAnn(t);
-        const ann = a.v !== undefined || a.t !== undefined || a.f !== undefined
-            ? [
-                ...((a.v === null ? src.v : a.v) || []),
-                ...((a.t === null ? src.t : a.t) || []),
-                ...((a.f === null ? src.f : a.f) || []),
-            ]
-            : undefined;
-        const { annots: _annots, ...rest } = t;
-        return { ...rest, ...(ann && ann.length !== 0 && { annots: ann }) };
-    }
-    // shortcut to copy at most one variable annotation from the instruction to the type
-    function annotateVar(t, def) {
-        const ia = instructionAnn({ v: 1 });
-        return annotate(t, {
-            v: ia.v !== undefined ? ia.v : def !== undefined ? [def] : null,
-            t: null,
-        });
-    }
-    // annotate CAR/CDR/UNPAIR/GET
-    function annotateField(arg, field, insAnn, n, defField) {
-        const fieldAnn = argAnn(field).f?.[0]; // field's field annotation
-        const insFieldAnn = insAnn.f?.[n];
-        if (insFieldAnn !== undefined &&
-            insFieldAnn !== '%' &&
-            fieldAnn !== undefined &&
-            insFieldAnn !== fieldAnn) {
-            throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: field names doesn't match: ${insFieldAnn} !== ${fieldAnn}`);
-        }
-        const insVarAnn = insAnn.v?.[n]; // nth instruction's variable annotation
-        const varAnn = argAnn(arg).v?.[0]; // instruction argument's variable annotation
-        return annotate(field, {
-            t: null,
-            v: insVarAnn
-                ? insVarAnn === '@%'
-                    ? fieldAnn
-                        ? ['@' + fieldAnn.slice(1)]
-                        : undefined
-                    : insVarAnn === '@%%'
-                        ? varAnn
-                            ? ['@' + varAnn.slice(1) + '.' + (fieldAnn ? fieldAnn.slice(1) : defField)]
-                            : fieldAnn
-                                ? ['@' + fieldAnn.slice(1)]
-                                : undefined
-                        : [insVarAnn]
-                : null,
-        });
-    }
-    // comb helper functions
-    function getN(src, n, i = n) {
-        const p = (0, utils_1.unpackComb)('pair', src);
-        if (i === 1) {
-            return [p.args[0]];
-        }
-        else if (i === 2) {
-            return p.args;
-        }
-        const right = p.args[1];
-        if ((0, utils_1.isPairType)(right)) {
-            return [p.args[0], ...getN(right, n, i - 1)];
-        }
-        else {
-            throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: at least ${n} fields are expected`);
-        }
-    }
-    function getNth(src, n, i = n) {
-        if (i === 0) {
-            return src;
-        }
-        const p = (0, utils_1.unpackComb)('pair', src);
-        if (i === 1) {
-            return p.args[0];
-        }
-        const right = p.args[1];
-        if ((0, utils_1.isPairType)(right)) {
-            return getNth(right, n, i - 2);
-        }
-        else if (i === 2) {
-            return right;
-        }
-        throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: at least ${n + 1} fields are expected`);
-    }
-    function updateNth(src, x, n, i = n) {
-        if (i === 0) {
-            return x;
-        }
-        const p = (0, utils_1.unpackComb)('pair', src);
-        if (i === 1) {
-            return {
-                ...p,
-                args: [x, p.args[1]],
-            };
-        }
-        const right = p.args[1];
-        if ((0, utils_1.isPairType)(right)) {
-            return {
-                ...p,
-                args: [p.args[0], updateNth(right, x, n, i - 2)],
-            };
-        }
-        else if (i === 2) {
-            return {
-                ...p,
-                args: [p.args[0], x],
-            };
-        }
-        throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: at least ${n + 1} fields are expected`);
-    }
-    const varSuffix = (a, suffix) => [
-        '@' + (a.v ? a.v[0].slice(1) + '.' : '') + suffix,
-    ];
-    function branchType(br0, br1) {
-        if ('failed' in br0 || 'failed' in br1) {
-            return 'failed' in br0 ? br1 : br0;
-        }
-        else {
-            ensureStacksEqual(br0, br1);
-            return br0;
-        }
-    }
-    const retStack = ((instruction) => {
-        switch (instruction.prim) {
-            case 'DUP': {
-                const n = instruction.args ? parseInt(instruction.args[0].int, 10) : 1;
-                if (n === 0) {
-                    throw new MichelsonInstructionError(instruction, stack, 'DUP 0 is forbidden');
-                }
-                const s = args(n - 1, null)[0];
-                if (typeID(s) === 'ticket') {
-                    throw new MichelsonInstructionError(instruction, stack, "ticket can't be DUPed");
-                }
-                return [s, ...stack];
-            }
-            case 'SWAP': {
-                const s = args(0, null, null);
-                instructionAnn({});
-                return [s[1], s[0], ...stack.slice(2)];
-            }
-            case 'SOME':
-                return [
-                    annotate({ prim: 'option', args: [args(0, null)[0]] }, instructionAnn({ t: 1, v: 1 })),
-                    ...stack.slice(1),
-                ];
-            case 'UNIT':
-                return [annotate({ prim: 'unit' }, instructionAnn({ v: 1, t: 1 })), ...stack];
-            case 'PAIR': {
-                const n = instruction.args ? parseInt(instruction.args[0].int, 10) : 2;
-                if (n < 2) {
-                    throw new MichelsonInstructionError(instruction, stack, `PAIR ${n} is forbidden`);
-                }
-                const s = args(0, ...new Array(n).fill(null));
-                const ia = instructionAnn({ f: n, t: 1, v: 1 }, { specialFields: true });
-                const trim = (s) => {
-                    const i = s.lastIndexOf('.');
-                    return s.slice(i > 0 ? i + 1 : 1);
-                };
-                const retArgs = s.map((v, i) => {
-                    const va = argAnn(v);
-                    const f = ia.f && ia.f.length > i && ia.f[i] !== '%'
-                        ? ia.f[i] === '%@'
-                            ? va.v
-                                ? ['%' + trim(va.v?.[0] || '')]
-                                : undefined
-                            : [ia.f[i]]
-                        : undefined;
-                    return annotate(v, { v: null, t: null, f });
-                });
-                return [
-                    annotate({
-                        prim: 'pair',
-                        args: retArgs,
-                    }, { t: ia.t, v: ia.v }),
-                    ...stack.slice(n),
-                ];
-            }
-            case 'UNPAIR': {
-                const n = instruction.args ? parseInt(instruction.args[0].int, 10) : 2;
-                if (n < 2) {
-                    throw new MichelsonInstructionError(instruction, stack, `UNPAIR ${n} is forbidden`);
-                }
-                const s = args(0, ['pair'])[0];
-                const ia = instructionAnn({ f: 2, v: 2 }, { specialVar: true });
-                const fields = getN(s, n);
-                return [
-                    ...fields.map((field, i) => annotateField(s, field, ia, i, i === 0 ? 'car' : 'cdr')),
-                    ...stack.slice(1),
-                ];
-            }
-            case 'CAR':
-            case 'CDR': {
-                const s = (0, utils_1.unpackComb)('pair', args(0, ['pair'])[0]);
-                const field = s.args[instruction.prim === 'CAR' ? 0 : 1];
-                const ia = instructionAnn({ f: 1, v: 1 }, { specialVar: true });
-                return [
-                    annotateField(s, field, ia, 0, instruction.prim.toLocaleLowerCase()),
-                    ...stack.slice(1),
-                ];
-            }
-            case 'CONS': {
-                const s = args(0, null, ['list']);
-                ensureTypesEqual(s[0], s[1].args[0]);
-                return [annotateVar({ prim: 'list', args: [s[1].args[0]] }), ...stack.slice(2)];
-            }
-            case 'SIZE':
-                args(0, ['string', 'list', 'set', 'map', 'bytes']);
-                return [annotateVar({ prim: 'nat' }), ...stack.slice(1)];
-            case 'MEM': {
-                const s = args(0, null, ['set', 'map', 'big_map']);
-                ensureComparableType(s[0]);
-                ensureTypesEqual(s[0], s[1].args[0]);
-                return [annotateVar({ prim: 'bool' }), ...stack.slice(2)];
-            }
-            case 'GET':
-                if (instruction.args) {
-                    // comb operation
-                    const n = parseInt(instruction.args[0].int, 10);
-                    const s = args(0, ['pair'])[0];
-                    return [annotateVar(getNth(s, n)), ...stack.slice(1)];
-                }
-                else {
-                    // map operation
-                    const s = args(0, null, ['map', 'big_map']);
-                    ensureComparableType(s[0]);
-                    ensureTypesEqual(s[0], s[1].args[0]);
-                    return [annotateVar({ prim: 'option', args: [s[1].args[1]] }), ...stack.slice(2)];
-                }
-            case 'UPDATE':
-                if (instruction.args) {
-                    // comb operation
-                    const n = parseInt(instruction.args[0].int, 10);
-                    const s = args(0, null, ['pair']);
-                    return [annotateVar(updateNth(s[1], s[0], n)), ...stack.slice(2)];
-                }
-                else {
-                    // map operation
-                    const s0 = args(0, null, ['bool', 'option']);
-                    ensureComparableType(s0[0]);
-                    if (s0[1].prim === 'bool') {
-                        const s1 = args(2, ['set']);
-                        ensureTypesEqual(s0[0], s1[0].args[0]);
-                        return [
-                            annotateVar({
-                                prim: 'set',
-                                args: [annotate(s0[0], { t: null })],
-                            }),
-                            ...stack.slice(3),
-                        ];
-                    }
-                    const s1 = args(2, ['map', 'big_map']);
-                    ensureTypesEqual(s0[0], s1[0].args[0]);
-                    if (s1[0].prim === 'map') {
-                        return [
-                            annotateVar({
-                                prim: 'map',
-                                args: [annotate(s0[0], { t: null }), annotate(s0[1].args[0], { t: null })],
-                            }),
-                            ...stack.slice(3),
-                        ];
-                    }
-                    ensureBigMapStorableType(s0[1].args[0]);
-                    return [
-                        annotateVar({
-                            prim: 'big_map',
-                            args: [annotate(s0[0], { t: null }), annotate(s0[1].args[0], { t: null })],
-                        }),
-                        ...stack.slice(3),
-                    ];
-                }
-            case 'GET_AND_UPDATE': {
-                const ia = instructionAnn({ v: 2 });
-                const s = args(0, null, ['option'], ['map', 'big_map']);
-                ensureComparableType(s[0]);
-                ensureTypesEqual(s[0], s[2].args[0]);
-                ensureTypesEqual(s[1].args[0], s[2].args[1]);
-                const va = ia.v?.map((v) => (v !== '@' ? [v] : undefined));
-                if (s[2].prim === 'map') {
-                    return [
-                        annotate({ prim: 'option', args: [s[2].args[1]] }, { v: va?.[0] }),
-                        annotate({
-                            prim: 'map',
-                            args: [annotate(s[0], { t: null }), annotate(s[1].args[0], { t: null })],
-                        }, { v: va?.[1] }),
-                        ...stack.slice(3),
-                    ];
-                }
-                ensureBigMapStorableType(s[1].args[0]);
-                return [
-                    annotate({ prim: 'option', args: [s[2].args[1]] }, { v: va?.[0] }),
-                    annotate({
-                        prim: 'big_map',
-                        args: [annotate(s[0], { t: null }), annotate(s[1].args[0], { t: null })],
-                    }, { v: va?.[1] }),
-                    ...stack.slice(3),
-                ];
-            }
-            case 'EXEC': {
-                const s = args(0, null, ['lambda']);
-                ensureTypesEqual(s[0], s[1].args[0]);
-                return [annotateVar(s[1].args[1]), ...stack.slice(2)];
-            }
-            case 'APPLY': {
-                const s = args(0, null, ['lambda']);
-                ensureStorableType(s[0]);
-                ensurePushableType(s[0]);
-                if (!(0, utils_1.isPairType)(s[1].args[0])) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: function's argument must be a pair: ${typeID(s[1].args[0])}`);
-                }
-                const pt = s[1].args[0];
-                ensureTypesEqual(s[0], typeArgs(pt)[0]);
-                return [
-                    annotateVar({ prim: 'lambda', args: [typeArgs(pt)[1], s[1].args[1]] }),
-                    ...stack.slice(2),
-                ];
-            }
-            case 'FAILWITH': {
-                const s = args(0, null)[0];
-                if (!(0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PtEdo2Zk)) {
-                    ensurePackableType(s);
-                }
-                return { failed: s, level: 0 };
-            }
-            case 'NEVER':
-                args(0, ['never']);
-                return { failed: { prim: 'never' }, level: 0 };
-            case 'RENAME':
-                return [annotateVar(args(0, null)[0]), ...stack.slice(1)];
-            case 'CONCAT': {
-                const s0 = args(0, ['string', 'list', 'bytes']);
-                if (s0[0].prim === 'list') {
-                    if (typeID(s0[0].args[0]) !== 'string' && typeID(s0[0].args[0]) !== 'bytes') {
-                        throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: can't concatenate list of ${typeID(s0[0].args[0])}'s`);
-                    }
-                    return [annotateVar(s0[0].args[0]), ...stack.slice(1)];
-                }
-                const s1 = args(1, ['string', 'bytes']);
-                if (s0[0].prim !== s1[0].prim) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: can't concatenate ${s0[0].prim} with ${s1[0].prim}`);
-                }
-                return [annotateVar(s1[0]), ...stack.slice(2)];
-            }
-            case 'SLICE':
-                return [
-                    annotateVar({ prim: 'option', args: [args(0, ['nat'], ['nat'], ['string', 'bytes'])[2]] }, '@slice'),
-                    ...stack.slice(3),
-                ];
-            case 'PACK': {
-                const s = args(0, null)[0];
-                ensurePackableType(s);
-                return [annotateVar({ prim: 'bytes' }, '@packed'), ...stack.slice(1)];
-            }
-            case 'ADD': {
-                const s = args(0, ['nat', 'int', 'timestamp', 'mutez', 'bls12_381_g1', 'bls12_381_g2', 'bls12_381_fr'], ['nat', 'int', 'timestamp', 'mutez', 'bls12_381_g1', 'bls12_381_g2', 'bls12_381_fr']);
-                if ((s[0].prim === 'nat' && s[1].prim === 'int') ||
-                    (s[0].prim === 'int' && s[1].prim === 'nat')) {
-                    return [annotateVar({ prim: 'int' }), ...stack.slice(2)];
-                }
-                else if ((s[0].prim === 'int' && s[1].prim === 'timestamp') ||
-                    (s[0].prim === 'timestamp' && s[1].prim === 'int')) {
-                    return [annotateVar({ prim: 'timestamp' }), ...stack.slice(2)];
-                }
-                else if ((s[0].prim === 'int' ||
-                    s[0].prim === 'nat' ||
-                    s[0].prim === 'mutez' ||
-                    s[0].prim === 'bls12_381_g1' ||
-                    s[0].prim === 'bls12_381_g2' ||
-                    s[0].prim === 'bls12_381_fr') &&
-                    s[0].prim === s[1].prim) {
-                    return [annotateVar(s[0]), ...stack.slice(2)];
-                }
-                throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: can't add ${s[0].prim} to ${s[1].prim}`);
-            }
-            case 'SUB': {
-                const s = (0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PsiThaCa)
-                    ? args(0, ['nat', 'int', 'timestamp', 'mutez'], ['nat', 'int', 'timestamp', 'mutez'])
-                    : args(0, ['nat', 'int', 'timestamp'], ['nat', 'int', 'timestamp']);
-                if (((s[0].prim === 'nat' || s[0].prim === 'int') &&
-                    (s[1].prim === 'nat' || s[1].prim === 'int')) ||
-                    (s[0].prim === 'timestamp' && s[1].prim === 'timestamp')) {
-                    return [annotateVar({ prim: 'int' }), ...stack.slice(2)];
-                }
-                else if (s[0].prim === 'timestamp' && s[1].prim === 'int') {
-                    return [annotateVar({ prim: 'timestamp' }), ...stack.slice(2)];
-                }
-                else if (s[0].prim === 'mutez' && s[1].prim === 'mutez') {
-                    return [annotateVar({ prim: 'mutez' }), ...stack.slice(2)];
-                }
-                throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: can't subtract ${s[0].prim} from ${s[1].prim}`);
-            }
-            case 'SUB_MUTEZ': {
-                const _s = args(0, ['mutez'], ['mutez']);
-                return [annotateVar({ prim: 'option', args: [{ prim: 'mutez' }] }), ...stack.slice(2)];
-            }
-            case 'MUL': {
-                const s = args(0, ['nat', 'int', 'mutez', 'bls12_381_g1', 'bls12_381_g2', 'bls12_381_fr'], ['nat', 'int', 'mutez', 'bls12_381_g1', 'bls12_381_g2', 'bls12_381_fr']);
-                if ((s[0].prim === 'nat' && s[1].prim === 'int') ||
-                    (s[0].prim === 'int' && s[1].prim === 'nat')) {
-                    return [annotateVar({ prim: 'int' }), ...stack.slice(2)];
-                }
-                else if ((s[0].prim === 'nat' && s[1].prim === 'mutez') ||
-                    (s[0].prim === 'mutez' && s[1].prim === 'nat')) {
-                    return [annotateVar({ prim: 'mutez' }), ...stack.slice(2)];
-                }
-                else if (((s[0].prim === 'bls12_381_g1' ||
-                    s[0].prim === 'bls12_381_g2' ||
-                    s[0].prim === 'bls12_381_fr') &&
-                    s[1].prim === 'bls12_381_fr') ||
-                    ((s[0].prim === 'nat' || s[0].prim === 'int') && s[0].prim === s[1].prim)) {
-                    return [annotateVar(s[0]), ...stack.slice(2)];
-                }
-                else if (((s[0].prim === 'nat' || s[0].prim === 'int') && s[1].prim === 'bls12_381_fr') ||
-                    ((s[1].prim === 'nat' || s[1].prim === 'int') && s[0].prim === 'bls12_381_fr')) {
-                    return [annotateVar({ prim: 'bls12_381_fr' }), ...stack.slice(2)];
-                }
-                throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: can't multiply ${s[0].prim} by ${s[1].prim}`);
-            }
-            case 'EDIV': {
-                const res = (a, b) => ({
-                    prim: 'option',
-                    args: [{ prim: 'pair', args: [{ prim: a }, { prim: b }] }],
-                });
-                const s = args(0, ['nat', 'int', 'mutez'], ['nat', 'int', 'mutez']);
-                if (s[0].prim === 'nat' && s[1].prim === 'nat') {
-                    return [annotateVar(res('nat', 'nat')), ...stack.slice(2)];
-                }
-                else if ((s[0].prim === 'nat' || s[0].prim === 'int') &&
-                    (s[1].prim === 'nat' || s[1].prim === 'int')) {
-                    return [annotateVar(res('int', 'nat')), ...stack.slice(2)];
-                }
-                else if (s[0].prim === 'mutez' && s[1].prim === 'nat') {
-                    return [annotateVar(res('mutez', 'mutez')), ...stack.slice(2)];
-                }
-                else if (s[0].prim === 'mutez' && s[1].prim === 'mutez') {
-                    return [annotateVar(res('nat', 'mutez')), ...stack.slice(2)];
-                }
-                throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: can't euclideally divide ${s[0].prim} by ${s[1].prim}`);
-            }
-            case 'ABS':
-                args(0, ['int']);
-                return [annotateVar({ prim: 'nat' }), ...stack.slice(1)];
-            case 'ISNAT':
-                args(0, ['int']);
-                return [annotateVar({ prim: 'option', args: [{ prim: 'nat' }] }), ...stack.slice(1)];
-            case 'INT':
-                args(0, ['nat', 'bls12_381_fr', 'bytes']);
-                return [annotateVar({ prim: 'int' }), ...stack.slice(1)];
-            case 'BYTES':
-                args(0, ['nat', 'int']);
-                return [annotateVar({ prim: 'bytes' }), ...stack.slice(1)];
-            case 'NAT':
-                args(0, ['bytes']);
-                return [annotateVar({ prim: 'nat' }), ...stack.slice(1)];
-            case 'NEG': {
-                const s = args(0, ['nat', 'int', 'bls12_381_g1', 'bls12_381_g2', 'bls12_381_fr'])[0];
-                if (s.prim === 'nat' || s.prim === 'int') {
-                    return [annotateVar({ prim: 'int' }), ...stack.slice(1)];
-                }
-                return [annotateVar(s), ...stack.slice(1)];
-            }
-            case 'LSL':
-            case 'LSR':
-                args(0, ['nat', 'bytes'], ['nat', 'bytes']);
-                return [annotateVar({ prim: 'nat' }), ...stack.slice(2)];
-            case 'OR':
-            case 'XOR': {
-                const s = args(0, ['nat', 'bytes', 'bool'], ['nat', 'bytes', 'bool']);
-                if (s[0].prim !== s[1].prim) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: both arguments must be of the same type: ${s[0].prim}, ${s[1].prim}`);
-                }
-                return [annotateVar(s[1]), ...stack.slice(2)];
-            }
-            case 'AND': {
-                const s = args(0, ['nat', 'bytes', 'bool', 'int'], ['nat', 'bytes', 'bool']);
-                if ((s[0].prim !== 'int' || s[1].prim !== 'nat') && s[0].prim !== s[1].prim) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: both arguments must be of the same type: ${s[0].prim}, ${s[1].prim}`);
-                }
-                return [annotateVar(s[1]), ...stack.slice(2)];
-            }
-            case 'NOT': {
-                const s = args(0, ['nat', 'bytes', 'bool', 'int'])[0];
-                if (s.prim === 'bool') {
-                    return [annotateVar({ prim: 'bool' }), ...stack.slice(1)];
-                }
-                return [annotateVar({ prim: 'int' }), ...stack.slice(1)];
-            }
-            case 'COMPARE': {
-                const s = args(0, null, null);
-                ensureComparableType(s[0]);
-                ensureComparableType(s[1]);
-                return [annotateVar({ prim: 'int' }), ...stack.slice(2)];
-            }
-            case 'EQ':
-            case 'NEQ':
-            case 'LT':
-            case 'GT':
-            case 'LE':
-            case 'GE':
-                args(0, ['int']);
-                return [annotateVar({ prim: 'bool' }), ...stack.slice(1)];
-            case 'SELF': {
-                if (ctx?.contract === undefined) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: contract required`);
-                }
-                const ia = instructionAnn({ f: 1, v: 1 });
-                const ep = contractEntryPoint(ctx.contract, ia.f?.[0]);
-                if (ep === null) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: contract has no entrypoint ${ep}`);
-                }
-                return [
-                    annotate({ prim: 'contract', args: [ep] }, { v: ia.v ? ia.v : ['@self'] }),
-                    ...stack,
-                ];
-            }
-            case 'TRANSFER_TOKENS': {
-                const s = args(0, null, ['mutez'], ['contract']);
-                ensureTypesEqual(s[0], s[2].args[0]);
-                return [annotateVar({ prim: 'operation' }), ...stack.slice(3)];
-            }
-            case 'SET_DELEGATE': {
-                const s = args(0, ['option'])[0];
-                if (typeID(s.args[0]) !== 'key_hash') {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: key hash expected: ${typeID(s.args[0])}`);
-                }
-                return [annotateVar({ prim: 'operation' }), ...stack.slice(1)];
-            }
-            case 'IMPLICIT_ACCOUNT':
-                args(0, ['key_hash']);
-                return [annotateVar({ prim: 'contract', args: [{ prim: 'unit' }] }), ...stack.slice(1)];
-            case 'NOW':
-                return [annotateVar({ prim: 'timestamp' }, '@now'), ...stack];
-            case 'AMOUNT':
-                return [annotateVar({ prim: 'mutez' }, '@amount'), ...stack];
-            case 'BALANCE':
-                return [annotateVar({ prim: 'mutez' }, '@balance'), ...stack];
-            case 'CHECK_SIGNATURE':
-                args(0, ['key'], ['signature'], ['bytes']);
-                return [annotateVar({ prim: 'bool' }), ...stack.slice(3)];
-            case 'BLAKE2B':
-            case 'SHA256':
-            case 'SHA512':
-            case 'KECCAK':
-            case 'SHA3':
-                args(0, ['bytes']);
-                return [annotateVar({ prim: 'bytes' }), ...stack.slice(1)];
-            case 'HASH_KEY':
-                args(0, ['key']);
-                return [annotateVar({ prim: 'key_hash' }), ...stack.slice(1)];
-            case 'SOURCE':
-                return [annotateVar({ prim: 'address' }, '@source'), ...stack];
-            case 'SENDER':
-                return [annotateVar({ prim: 'address' }, '@sender'), ...stack];
-            case 'ADDRESS': {
-                const s = args(0, ['contract'])[0];
-                const ia = instructionAnn({ v: 1 });
-                return [
-                    annotate({ prim: 'address', [michelson_types_1.refContract]: s }, { v: ia.v ? ia.v : varSuffix(argAnn(s), 'address') }),
-                    ...stack.slice(1),
-                ];
-            }
-            case 'SELF_ADDRESS': {
-                const addr = { prim: 'address' };
-                if (ctx?.contract !== undefined) {
-                    addr[michelson_types_1.refContract] = {
-                        prim: 'contract',
-                        args: [contractSection(ctx.contract, 'parameter').args[0]],
-                    };
-                }
-                return [annotateVar(addr, '@address'), ...stack];
-            }
-            case 'CHAIN_ID':
-                return [annotateVar({ prim: 'chain_id' }), ...stack];
-            case 'DROP': {
-                instructionAnn({});
-                const n = instruction.args !== undefined ? parseInt(instruction.args[0].int, 10) : 1;
-                args(n - 1, null);
-                return stack.slice(n);
-            }
-            case 'DIG': {
-                instructionAnn({});
-                const n = parseInt(instruction.args[0].int, 10);
-                return [args(n, null)[0], ...stack.slice(0, n), ...stack.slice(n + 1)];
-            }
-            case 'DUG': {
-                instructionAnn({});
-                const n = parseInt(instruction.args[0].int, 10);
-                return [...stack.slice(1, n + 1), args(0, null)[0], ...stack.slice(n + 1)];
-            }
-            case 'NONE':
-                assertTypeAnnotationsValid(instruction.args[0]);
-                return [
-                    annotate({ prim: 'option', args: [instruction.args[0]] }, instructionAnn({ t: 1, v: 1 })),
-                    ...stack,
-                ];
-            case 'LEFT':
-            case 'RIGHT': {
-                const s = args(0, null)[0];
-                const ia = instructionAnn({ f: 2, t: 1, v: 1 }, { specialFields: true });
-                const va = argAnn(s);
-                const children = [
-                    annotate(s, {
-                        t: null,
-                        v: null,
-                        f: ia.f && ia.f.length > 0 && ia.f[0] !== '%'
-                            ? ia.f[0] === '%@'
-                                ? va.v
-                                    ? ['%' + va.v[0].slice(1)]
-                                    : undefined
-                                : ia.f
-                            : undefined,
-                    }),
-                    annotate(instruction.args[0], {
-                        t: null,
-                        f: ia.f && ia.f.length > 1 && ia.f[1] !== '%' ? ia.f : undefined,
-                    }),
-                ];
-                return [
-                    annotate({
-                        prim: 'or',
-                        args: instruction.prim === 'LEFT' ? children : [children[1], children[0]],
-                    }, { t: ia.t, v: ia.v }),
-                    ...stack.slice(1),
-                ];
-            }
-            case 'NIL':
-                assertTypeAnnotationsValid(instruction.args[0]);
-                return [
-                    annotate({ prim: 'list', args: [instruction.args[0]] }, instructionAnn({ t: 1, v: 1 })),
-                    ...stack,
-                ];
-            case 'UNPACK':
-                args(0, ['bytes']);
-                assertTypeAnnotationsValid(instruction.args[0]);
-                return [
-                    annotateVar({ prim: 'option', args: [instruction.args[0]] }, '@unpacked'),
-                    ...stack.slice(1),
-                ];
-            case 'CONTRACT': {
-                const s = args(0, ['address'])[0];
-                assertTypeAnnotationsValid(instruction.args[0]);
-                const ia = instructionAnn({ v: 1, f: 1 });
-                const contract = s[michelson_types_1.refContract];
-                if (contract !== undefined) {
-                    const ep = contractEntryPoint(contract, ia.f?.[0]);
-                    if (ep === null) {
-                        throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: contract has no entrypoint ${ep}`);
-                    }
-                    ensureTypesEqual(ep, instruction.args[0]);
-                }
-                return [
-                    annotate({ prim: 'option', args: [{ prim: 'contract', args: [instruction.args[0]] }] }, { v: ia.v ? ia.v : varSuffix(argAnn(s), 'contract') }),
-                    ...stack.slice(1),
-                ];
-            }
-            case 'CAST': {
-                instructionAnn({});
-                const s = args(0, null)[0];
-                assertTypeAnnotationsValid(instruction.args[0]);
-                ensureTypesEqual(instruction.args[0], s);
-                return [instruction.args[0], ...stack.slice(1)];
-            }
-            case 'IF_NONE': {
-                instructionAnn({});
-                const s = args(0, ['option'])[0];
-                const tail = stack.slice(1);
-                const br0 = functionTypeInternal(instruction.args[0], tail, ctx);
-                const br1 = functionTypeInternal(instruction.args[1], [annotate(s.args[0], { t: null, v: varSuffix(argAnn(s), 'some') }), ...tail], ctx);
-                return branchType(br0, br1);
-            }
-            case 'IF_LEFT': {
-                instructionAnn({});
-                const s = args(0, ['or'])[0];
-                const va = argAnn(s);
-                const lefta = argAnn(s.args[0]);
-                const righta = argAnn(s.args[1]);
-                const tail = stack.slice(1);
-                const br0 = functionTypeInternal(instruction.args[0], [
-                    annotate(s.args[0], {
-                        t: null,
-                        v: varSuffix(va, lefta.f ? lefta.f[0].slice(1) : 'left'),
-                    }),
-                    ...tail,
-                ], ctx);
-                const br1 = functionTypeInternal(instruction.args[1], [
-                    annotate(s.args[1], {
-                        t: null,
-                        v: varSuffix(va, righta.f ? righta.f[0].slice(1) : 'right'),
-                    }),
-                    ...tail,
-                ], ctx);
-                return branchType(br0, br1);
-            }
-            case 'IF_CONS': {
-                instructionAnn({});
-                const s = args(0, ['list'])[0];
-                const va = argAnn(s);
-                const tail = stack.slice(1);
-                const br0 = functionTypeInternal(instruction.args[0], [
-                    annotate(s.args[0], { t: null, v: varSuffix(va, 'hd') }),
-                    annotate(s, { t: null, v: varSuffix(va, 'tl') }),
-                    ...tail,
-                ], ctx);
-                const br1 = functionTypeInternal(instruction.args[1], tail, ctx);
-                return branchType(br0, br1);
-            }
-            case 'IF': {
-                instructionAnn({});
-                args(0, ['bool']);
-                const tail = stack.slice(1);
-                const br0 = functionTypeInternal(instruction.args[0], tail, ctx);
-                const br1 = functionTypeInternal(instruction.args[1], tail, ctx);
-                return branchType(br0, br1);
-            }
-            case 'MAP': {
-                const s = args(0, ['list', 'map', 'option'])[0];
-                const tail = stack.slice(1);
-                const elt = s.prim === 'map' ? { prim: 'pair', args: s.args } : s.args[0];
-                const body = functionTypeInternal(instruction.args[0], [annotate(elt, { t: null, v: varSuffix(argAnn(s), 'elt') }), ...tail], ctx);
-                if ('failed' in body) {
-                    if (!('prim' in body.failed) || body.failed.prim !== 'never') {
-                        throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: FAIL is not allowed in MAP`);
-                    }
-                    return { failed: body.failed, level: body.level + 1 };
-                }
-                if (body.length < 1) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: function must return a value`);
-                }
-                ensureStacksEqual(body.slice(1), tail);
-                return s.prim === 'list'
-                    ? [annotateVar({ prim: 'list', args: [body[0]] }), ...tail]
-                    : s.prim === 'map'
-                        ? [annotateVar({ prim: 'map', args: [s.args[0], body[0]] }), ...tail]
-                        : [annotateVar({ prim: 'option', args: [body[0]] }), ...tail];
-            }
-            case 'ITER': {
-                instructionAnn({});
-                const s = args(0, ['set', 'list', 'map'])[0];
-                const tail = stack.slice(1);
-                const elt = s.prim === 'map' ? { prim: 'pair', args: s.args } : s.args[0];
-                const body = functionTypeInternal(instruction.args[0], [annotate(elt, { t: null, v: varSuffix(argAnn(s), 'elt') }), ...tail], ctx);
-                if ('failed' in body) {
-                    return { failed: body.failed, level: body.level + 1 };
-                }
-                ensureStacksEqual(body, tail);
-                return tail;
-            }
-            case 'LOOP': {
-                instructionAnn({});
-                args(0, ['bool']);
-                const tail = stack.slice(1);
-                const body = functionTypeInternal(instruction.args[0], tail, ctx);
-                if ('failed' in body) {
-                    return { failed: body.failed, level: body.level + 1 };
-                }
-                ensureStacksEqual(body, [{ prim: 'bool' }, ...tail]);
-                return tail;
-            }
-            case 'LOOP_LEFT': {
-                instructionAnn({});
-                const s = args(0, ['or'])[0];
-                const tail = stack.slice(1);
-                const body = functionTypeInternal(instruction.args[0], [annotate(s.args[0], { t: null, v: varSuffix(argAnn(s), 'left') }), ...tail], ctx);
-                if ('failed' in body) {
-                    return { failed: body.failed, level: body.level + 1 };
-                }
-                ensureStacksEqual(body, [s, ...tail]);
-                return [annotate(s.args[1], { t: null, v: instructionAnn({ v: 1 }).v }), ...tail];
-            }
-            case 'DIP': {
-                instructionAnn({});
-                const n = instruction.args.length === 2 ? parseInt(instruction.args[0].int, 10) : 1;
-                args(n - 1, null);
-                const head = stack.slice(0, n);
-                const tail = stack.slice(n);
-                // ternary operator is a type guard so use it instead of just `instruction.args.length - 1`
-                const body = instruction.args.length === 2
-                    ? functionTypeInternal(instruction.args[1], tail, ctx)
-                    : functionTypeInternal(instruction.args[0], tail, ctx);
-                if ('failed' in body) {
-                    return { failed: body.failed, level: body.level + 1 };
-                }
-                return [...head, ...body];
-            }
-            case 'CREATE_CONTRACT': {
-                const ia = instructionAnn({ v: 2 });
-                const s = args(0, ['option'], ['mutez'], null);
-                if (typeID(s[0].args[0]) !== 'key_hash') {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: key hash expected: ${typeID(s[0].args[0])}`);
-                }
-                if (ensureStorableType(s[2])) {
-                    assertContractValid(instruction.args[0]);
-                    assertScalarTypesEqual(contractSection(instruction.args[0], 'storage').args[0], s[2]);
-                }
-                const va = ia.v?.map((v) => (v !== '@' ? [v] : undefined));
-                return [
-                    annotate({ prim: 'operation' }, { v: va?.[0] }),
-                    annotate({
-                        prim: 'address',
-                        [michelson_types_1.refContract]: {
-                            prim: 'contract',
-                            args: [contractSection(instruction.args[0], 'parameter').args[0]],
-                        },
-                    }, { v: va?.[1] }),
-                    ...stack.slice(3),
-                ];
-            }
-            case 'PUSH':
-                assertTypeAnnotationsValid(instruction.args[0]);
-                assertDataValidInternal(instruction.args[1], instruction.args[0], {
-                    ...ctx,
-                    contract: undefined,
-                });
-                return [annotateVar(instruction.args[0]), ...stack];
-            case 'EMPTY_SET':
-                assertTypeAnnotationsValid(instruction.args[0]);
-                ensureComparableType(instruction.args[0]);
-                return [
-                    annotate({ prim: 'set', args: instruction.args }, instructionAnn({ t: 1, v: 1 })),
-                    ...stack,
-                ];
-            case 'EMPTY_MAP':
-                assertTypeAnnotationsValid(instruction.args[0]);
-                ensureComparableType(instruction.args[0]);
-                assertTypeAnnotationsValid(instruction.args[1]);
-                return [
-                    annotate({ prim: 'map', args: instruction.args }, instructionAnn({ t: 1, v: 1 })),
-                    ...stack,
-                ];
-            case 'EMPTY_BIG_MAP':
-                assertTypeAnnotationsValid(instruction.args[0]);
-                ensureComparableType(instruction.args[0]);
-                assertTypeAnnotationsValid(instruction.args[1]);
-                ensureBigMapStorableType(instruction.args[0]);
-                return [
-                    annotate({ prim: 'big_map', args: instruction.args }, instructionAnn({ t: 1, v: 1 })),
-                    ...stack,
-                ];
-            case 'LAMBDA_REC':
-            case 'LAMBDA': {
-                assertTypeAnnotationsValid(instruction.args[0]);
-                assertTypeAnnotationsValid(instruction.args[1]);
-                const s = [instruction.args[0]];
-                if (instruction.prim === 'LAMBDA_REC') {
-                    s.push({ prim: 'lambda', args: [instruction.args[0], instruction.args[1]] });
-                }
-                const body = functionTypeInternal(instruction.args[2], s, {
-                    ...ctx,
-                    contract: undefined,
-                });
-                if ('failed' in body) {
-                    return { failed: body.failed, level: body.level + 1 };
-                }
-                if (body.length !== 1) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: function must return a value`);
-                }
-                ensureTypesEqual(instruction.args[1], body[0]);
-                return [
-                    annotateVar({ prim: 'lambda', args: [instruction.args[0], instruction.args[1]] }),
-                    ...stack,
-                ];
-            }
-            case 'LEVEL':
-                return [annotateVar({ prim: 'nat' }, '@level'), ...stack];
-            case 'TOTAL_VOTING_POWER':
-                return [annotateVar({ prim: 'nat' }), ...stack];
-            case 'VOTING_POWER':
-                args(0, ['key_hash']);
-                return [annotateVar({ prim: 'nat' }), ...stack.slice(1)];
-            case 'TICKET': {
-                const s = args(0, null, ['nat'])[0];
-                ensureComparableType(s);
-                if ((0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PtLimaPtL)) {
-                    return [
-                        annotate({ prim: 'ticket', args: [s] }, instructionAnn({ t: 1, v: 1 })),
-                        ...stack.slice(2),
-                    ];
-                }
-                else {
-                    return [
-                        annotateVar({
-                            prim: 'option',
-                            args: [annotate({ prim: 'ticket', args: [s] }, instructionAnn({ t: 1, v: 1 }))],
-                        }),
-                        ...stack.slice(2),
-                    ];
-                }
-            }
-            case 'JOIN_TICKETS': {
-                const s = (0, utils_1.unpackComb)('pair', args(0, ['pair'])[0]);
-                if (typeID(s.args[0]) !== 'ticket') {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: ticket expected: ${typeID(s.args[0])}`);
-                }
-                ensureTypesEqual(s.args[0], s.args[1]);
-                return [
-                    annotateVar({
-                        prim: 'option',
-                        args: [annotate(s.args[0], { t: null })],
-                    }),
-                    ...stack.slice(1),
-                ];
-            }
-            case 'SPLIT_TICKET': {
-                const s = args(0, ['ticket'], ['pair']);
-                const p = (0, utils_1.unpackComb)('pair', s[1]);
-                if (typeID(p.args[0]) !== 'nat') {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: nat expected: ${typeID(p.args[0])}`);
-                }
-                ensureTypesEqual(p.args[0], p.args[1]);
-                return [
-                    annotateVar({
-                        prim: 'option',
-                        args: [
-                            {
-                                prim: 'pair',
-                                args: [annotate(s[0], { t: null }), annotate(s[0], { t: null })],
-                            },
-                        ],
-                    }),
-                    ...stack.slice(2),
-                ];
-            }
-            case 'READ_TICKET': {
-                const ia = instructionAnn({ v: 2 });
-                const s = args(0, ['ticket'])[0];
-                const va = ia.v?.map((v) => (v !== '@' ? [v] : undefined));
-                return [
-                    annotate({
-                        prim: 'pair',
-                        args: [{ prim: 'address' }, annotate(s.args[0], { t: null }), { prim: 'nat' }],
-                    }, { v: va?.[0] }),
-                    annotate(s, { v: va?.[1], t: null }),
-                    ...stack.slice(1),
-                ];
-            }
-            case 'PAIRING_CHECK': {
-                const p = args(0, ['list'])[0].args[0];
-                if (!(0, utils_1.isPairType)(p)) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: pair expected: ${typeID(p)}`);
-                }
-                const c = (0, utils_1.unpackComb)('pair', p);
-                if (typeID(c.args[0]) !== 'bls12_381_g1') {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: bls12_381_g1 expected: ${typeID(c.args[0])}`);
-                }
-                if (typeID(c.args[1]) !== 'bls12_381_g2') {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: bls12_381_g2 expected: ${typeID(c.args[1])}`);
-                }
-                return [annotateVar({ prim: 'bool' }), ...stack.slice(1)];
-            }
-            case 'SAPLING_EMPTY_STATE':
-                return [
-                    annotate({ prim: 'sapling_state', args: [instruction.args[0]] }, instructionAnn({ v: 1, t: 1 })),
-                    ...stack,
-                ];
-            case 'SAPLING_VERIFY_UPDATE': {
-                const s = args(0, ['sapling_transaction'], ['sapling_state']);
-                if (parseInt(s[0].args[0].int, 10) !== parseInt(s[1].args[0].int, 10)) {
-                    throw new MichelsonInstructionError(instruction, stack, `${instruction.prim}: sapling memo size mismatch: ${s[0].args[0].int} != ${s[1].args[0].int}`);
-                }
-                return (0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PtJakarta)
-                    ? [
-                        annotateVar({
-                            prim: 'option',
-                            args: [
-                                {
-                                    prim: 'pair',
-                                    args: [{ prim: 'int' }, annotate(s[1], { t: null })],
-                                },
-                            ],
-                        }),
-                        ...stack.slice(2),
-                    ]
-                    : [
-                        annotateVar({
-                            prim: 'option',
-                            args: [
-                                {
-                                    prim: 'pair',
-                                    args: [
-                                        { prim: 'bytes' },
-                                        {
-                                            prim: 'pair',
-                                            args: [{ prim: 'int' }, annotate(s[1], { t: null })],
-                                        },
-                                    ],
-                                },
-                            ],
-                        }),
-                        ...stack.slice(2),
-                    ];
-            }
-            case 'OPEN_CHEST':
-                args(0, ['chest_key'], ['chest'], ['nat']);
-                return [
-                    annotateVar({ prim: 'or', args: [{ prim: 'bytes' }, { prim: 'bool' }] }),
-                    ...stack.slice(3),
-                ];
-            case 'VIEW': {
-                const s = args(0, null, ['address']);
-                ensurePushableType(s[0]);
-                return [annotateVar({ prim: 'option', args: [instruction.args[1]] }), ...stack.slice(2)];
-            }
-            case 'MIN_BLOCK_TIME':
-                return [annotateVar({ prim: 'nat' }), ...stack];
-            case 'EMIT': {
-                const ia = instructionAnn({ f: 1, t: 1 });
-                if (instruction.args) {
-                    const s = args(0, null);
-                    ensureTypesEqual(s[0], instruction.args[0]);
-                    return [annotate({ prim: 'operation' }, ia), ...stack.slice(1)];
-                }
-                return [annotate({ prim: 'operation' }, ia), ...stack.slice(1)];
-            }
-            case 'IS_IMPLICIT_ACCOUNT':
-                args(0, ['address']);
-                return [annotateVar({ prim: 'option', args: [{ prim: 'key_hash' }] }), ...stack.slice(1)];
-            case 'INDEX_ADDRESS':
-                args(0, ['address']);
-                return [annotateVar({ prim: 'nat' }), ...stack.slice(1)];
-            case 'GET_ADDRESS_INDEX':
-                args(0, ['address']);
-                return [annotateVar({ prim: 'option', args: [{ prim: 'nat' }] }), ...stack.slice(1)];
-            default:
-                throw new utils_1.MichelsonError(instruction, `unexpected instruction: ${instruction.prim}`);
-        }
-    })(instruction);
-    if (ctx?.traceCallback !== undefined) {
-        const trace = {
-            op: instruction,
-            in: stack,
-            out: retStack,
-        };
-        ctx.traceCallback(trace);
-    }
-    return retStack;
-}
-function contractSection(contract, section) {
-    for (const s of contract) {
-        if (s.prim === section) {
-            return s;
-        }
-    }
-    throw new utils_1.MichelsonError(contract, `missing contract section: ${section}`);
-}
-function contractViews(contract) {
-    const views = {};
-    for (const s of contract) {
-        if (s.prim === 'view') {
-            views[s.args[0].string] = s;
-        }
-    }
-    return views;
-}
-function isContract(v) {
-    if (Array.isArray(v)) {
-        for (const s of v) {
-            if ('prim' in s && (s.prim === 'parameter' || s.prim === 'storage' || s.prim === 'code')) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function contractEntryPoint(src, ep) {
-    ep = ep || '%default';
-    const entryPoint = contractEntryPoints(src).find((x) => x[0] === ep);
-    if (entryPoint !== undefined) {
-        return entryPoint[1];
-    }
-    else if (ep === '%default') {
-        return isContract(src) ? contractSection(src, 'parameter').args[0] : src;
-    }
-    return null;
-}
-function isOrType(t) {
-    return Array.isArray(t) || t.prim === 'or';
-}
-function contractEntryPoints(src) {
-    if (isContract(src)) {
-        const param = contractSection(src, 'parameter');
-        const ch = contractEntryPoints(param.args[0]);
-        const a = (0, utils_1.unpackAnnotations)(param);
-        return a.f ? [[a.f[0], param.args[0]], ...ch] : ch;
-    }
-    if (isOrType(src)) {
-        const args = typeArgs(src);
-        const getArg = (n) => {
-            const a = (0, utils_1.unpackAnnotations)(args[n]);
-            if (typeID(args[n]) === 'or') {
-                const ch = contractEntryPoints(args[n]);
-                return a.f ? [[a.f[0], args[n]], ...ch] : ch;
-            }
-            return a.f ? [[a.f[0], args[n]]] : [];
-        };
-        return [...getArg(0), ...getArg(1)];
-    }
-    return [];
-}
-// Contract validation
-function assertContractValid(contract, ctx) {
-    const assertSection = (parameter, storage, ret, code) => {
-        assertTypeAnnotationsValid(parameter, true);
-        assertTypeAnnotationsValid(storage);
-        const arg = {
-            prim: 'pair',
-            args: [
-                { ...parameter, ...{ annots: ['@parameter'] } },
-                { ...storage, ...{ annots: ['@storage'] } },
-            ],
-        };
-        const out = functionTypeInternal(code, [arg], { ...ctx, ...{ contract } });
-        if ('failed' in out) {
-            return out;
-        }
-        try {
-            assertStacksEqual(out, [ret]);
-        }
-        catch (err) {
-            if (err instanceof utils_1.MichelsonError) {
-                throw new MichelsonInstructionError(code, out, err.message);
-            }
-            else {
-                throw err;
-            }
-        }
-        return out;
-    };
-    const parameter = contractSection(contract, 'parameter').args[0];
-    const storage = contractSection(contract, 'storage').args[0];
-    const code = contractSection(contract, 'code').args[0];
-    const expected = {
-        prim: 'pair',
-        args: [{ prim: 'list', args: [{ prim: 'operation' }] }, storage],
-    };
-    const ret = assertSection(parameter, storage, expected, code);
-    for (const view of Object.values(contractViews(contract))) {
-        assertSection(view.args[1], storage, view.args[2], view.args[3]);
-    }
-    return ret;
-}
-// Exported wrapper functions
-function assertDataValid(d, t, ctx) {
-    assertTypeAnnotationsValid(t);
-    assertDataValidInternal(d, t, ctx || null);
-}
-function functionType(inst, stack, ctx) {
-    for (const t of stack) {
-        assertTypeAnnotationsValid(t);
-    }
-    if (ctx?.contract !== undefined) {
-        for (const typesec of ['parameter', 'storage']) {
-            const sec = contractSection(ctx.contract, typesec).args[0];
-            assertTypeAnnotationsValid(sec);
-        }
-    }
-    return functionTypeInternal(inst, stack, ctx || null);
-}
-function assertTypesEqual(a, b, field = false) {
-    if (Array.isArray(a)) {
-        // type guards don't work for parametrized generic types
-        for (const v of a) {
-            assertTypeAnnotationsValid(v);
-        }
-        for (const v of b) {
-            assertTypeAnnotationsValid(v);
-        }
-    }
-    else {
-        assertTypeAnnotationsValid(a);
-        assertTypeAnnotationsValid(b);
-    }
-    assertScalarTypesEqual(a, b, field);
-}
-function isTypeAnnotationsValid(t, field = false) {
-    try {
-        assertTypeAnnotationsValid(t, field);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function isContractValid(contract, ctx) {
-    try {
-        return assertContractValid(contract, ctx);
-    }
-    catch {
-        return null;
-    }
-}
-function isDataValid(d, t, ctx) {
-    try {
-        assertDataValid(d, t, ctx);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function isTypeEqual(a, b, field = false) {
-    try {
-        assertTypesEqual(a, b, field);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}