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

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

@@ -0,0 +1,1756 @@
+"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;
+    }
+}