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

package/dist/lib/taquito-michel-codec/src/macros.js

@@ -0,0 +1,551 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacroError = void 0;
+exports.expandMacros = expandMacros;
+const core_1 = require("@taquito/core");
+const michelson_types_1 = require("./michelson-types");
+/**
+ *  @category Error
+ *  Error that indicates macros failed to be expanded
+ */
+class MacroError extends core_1.TaquitoError {
+    constructor(prim, message) {
+        super();
+        this.prim = prim;
+        this.message = message;
+        this.name = 'MacroError';
+    }
+}
+exports.MacroError = MacroError;
+function assertArgs(ex, n) {
+    if ((n === 0 && ex.args === undefined) || ex.args?.length === n) {
+        return true;
+    }
+    throw new MacroError(ex, `macro ${ex.prim} expects ${n} arguments, was given ${ex.args?.length}`);
+}
+function assertNoAnnots(ex) {
+    if (ex.annots === undefined) {
+        return true;
+    }
+    throw new MacroError(ex, `unexpected annotation on macro ${ex.prim}: ${ex.annots}`);
+}
+function assertIntArg(ex, arg) {
+    if ('int' in arg) {
+        return true;
+    }
+    throw new MacroError(ex, `macro ${ex.prim} expects int argument`);
+}
+function parsePairUnpairExpr(p, expr, annotations, agg) {
+    let i = 0;
+    let ai = 0;
+    const ann = [null, null];
+    // Left expression
+    let lexpr;
+    if (i === expr.length) {
+        throw new MacroError(p, `unexpected end: ${p.prim}`);
+    }
+    let c = expr[i++];
+    switch (c) {
+        case 'P': {
+            const { r, n, an } = parsePairUnpairExpr(p, expr.slice(i), annotations.slice(ai), agg);
+            lexpr = r;
+            i += n;
+            ai += an;
+            break;
+        }
+        case 'A':
+            if (ai !== annotations.length) {
+                ann[0] = annotations[ai++];
+            }
+            break;
+        default:
+            throw new MacroError(p, `${p.prim}: unexpected character: ${c}`);
+    }
+    // Right expression
+    let rexpr;
+    if (i === expr.length) {
+        throw new MacroError(p, `unexpected end: ${p.prim}`);
+    }
+    c = expr[i++];
+    switch (c) {
+        case 'P': {
+            const { r, n, an } = parsePairUnpairExpr(p, expr.slice(i), annotations.slice(ai), agg);
+            rexpr = r.map(([v, a]) => [v + 1, a]);
+            i += n;
+            ai += an;
+            break;
+        }
+        case 'I':
+            if (ai !== annotations.length) {
+                ann[1] = annotations[ai++];
+            }
+            break;
+        default:
+            throw new MacroError(p, `${p.prim}: unexpected character: ${c}`);
+    }
+    return { r: agg(lexpr, rexpr, [0, ann]), n: i, an: ai };
+}
+function parseSetMapCadr(p, expr, vann, term) {
+    const c = expr[0];
+    switch (c) {
+        case 'A':
+            return expr.length > 1
+                ? [
+                    { prim: 'DUP' },
+                    {
+                        prim: 'DIP',
+                        args: [
+                            [{ prim: 'CAR', annots: ['@%%'] }, parseSetMapCadr(p, expr.slice(1), [], term)],
+                        ],
+                    },
+                    { prim: 'CDR', annots: ['@%%'] },
+                    { prim: 'SWAP' },
+                    { prim: 'PAIR', annots: ['%@', '%@', ...vann] },
+                ]
+                : term.a;
+        case 'D':
+            return expr.length > 1
+                ? [
+                    { prim: 'DUP' },
+                    {
+                        prim: 'DIP',
+                        args: [
+                            [{ prim: 'CDR', annots: ['@%%'] }, parseSetMapCadr(p, expr.slice(1), [], term)],
+                        ],
+                    },
+                    { prim: 'CAR', annots: ['@%%'] },
+                    { prim: 'PAIR', annots: ['%@', '%@', ...vann] },
+                ]
+                : term.d;
+        default:
+            throw new MacroError(p, `${p.prim}: unexpected character: ${c}`);
+    }
+}
+function trimLast(a, v) {
+    let l = a.length;
+    while (l > 0 && a[l - 1] === v) {
+        l--;
+    }
+    return a.slice(0, l);
+}
+function filterAnnotations(a) {
+    const fields = [];
+    const rest = [];
+    if (a !== undefined) {
+        for (const v of a) {
+            (v.length !== 0 && v[0] === '%' ? fields : rest).push(v);
+        }
+    }
+    return { fields, rest };
+}
+function mkPrim({ prim, annots, args }) {
+    return {
+        prim,
+        ...(annots && { annots }),
+        ...(args && { args }),
+    };
+}
+const pairRe = /^P[PAI]{3,}R$/;
+const unpairRe = /^UNP[PAI]{2,}R$/;
+const cadrRe = /^C[AD]{2,}R$/;
+const setCadrRe = /^SET_C[AD]+R$/;
+const mapCadrRe = /^MAP_C[AD]+R$/;
+const diipRe = /^DI{2,}P$/;
+const duupRe = /^DU+P$/;
+function expandMacros(ex, opt) {
+    const proto = opt?.protocol || michelson_types_1.DefaultProtocol;
+    function mayRename(annots) {
+        return annots !== undefined ? [{ prim: 'RENAME', annots }] : [];
+    }
+    switch (ex.prim) {
+        // Compare
+        case 'CMPEQ':
+        case 'CMPNEQ':
+        case 'CMPLT':
+        case 'CMPGT':
+        case 'CMPLE':
+        case 'CMPGE':
+            if (assertArgs(ex, 0)) {
+                return [{ prim: 'COMPARE' }, mkPrim({ prim: ex.prim.slice(3), annots: ex.annots })];
+            }
+            break;
+        case 'IFEQ':
+        case 'IFNEQ':
+        case 'IFLT':
+        case 'IFGT':
+        case 'IFLE':
+        case 'IFGE':
+            if (assertArgs(ex, 2)) {
+                return [
+                    { prim: ex.prim.slice(2) },
+                    mkPrim({ prim: 'IF', annots: ex.annots, args: ex.args }),
+                ];
+            }
+            break;
+        case 'IFCMPEQ':
+        case 'IFCMPNEQ':
+        case 'IFCMPLT':
+        case 'IFCMPGT':
+        case 'IFCMPLE':
+        case 'IFCMPGE':
+            if (assertArgs(ex, 2)) {
+                return [
+                    { prim: 'COMPARE' },
+                    { prim: ex.prim.slice(5) },
+                    mkPrim({ prim: 'IF', annots: ex.annots, args: ex.args }),
+                ];
+            }
+            break;
+        // Fail
+        case 'FAIL':
+            if (assertArgs(ex, 0) && assertNoAnnots(ex)) {
+                return [{ prim: 'UNIT' }, { prim: 'FAILWITH' }];
+            }
+            break;
+        // Assertion macros
+        case 'ASSERT':
+            if (assertArgs(ex, 0) && assertNoAnnots(ex)) {
+                return [
+                    {
+                        prim: 'IF',
+                        args: [[], [[{ prim: 'UNIT' }, { prim: 'FAILWITH' }]]],
+                    },
+                ];
+            }
+            break;
+        case 'ASSERT_EQ':
+        case 'ASSERT_NEQ':
+        case 'ASSERT_LT':
+        case 'ASSERT_GT':
+        case 'ASSERT_LE':
+        case 'ASSERT_GE':
+            if (assertArgs(ex, 0) && assertNoAnnots(ex)) {
+                return [
+                    { prim: ex.prim.slice(7) },
+                    {
+                        prim: 'IF',
+                        args: [[], [[{ prim: 'UNIT' }, { prim: 'FAILWITH' }]]],
+                    },
+                ];
+            }
+            break;
+        case 'ASSERT_CMPEQ':
+        case 'ASSERT_CMPNEQ':
+        case 'ASSERT_CMPLT':
+        case 'ASSERT_CMPGT':
+        case 'ASSERT_CMPLE':
+        case 'ASSERT_CMPGE':
+            if (assertArgs(ex, 0) && assertNoAnnots(ex)) {
+                return [
+                    [{ prim: 'COMPARE' }, { prim: ex.prim.slice(10) }],
+                    {
+                        prim: 'IF',
+                        args: [[], [[{ prim: 'UNIT' }, { prim: 'FAILWITH' }]]],
+                    },
+                ];
+            }
+            break;
+        case 'ASSERT_NONE':
+            if (assertArgs(ex, 0) && assertNoAnnots(ex)) {
+                return [
+                    {
+                        prim: 'IF_NONE',
+                        args: [[], [[{ prim: 'UNIT' }, { prim: 'FAILWITH' }]]],
+                    },
+                ];
+            }
+            break;
+        case 'ASSERT_SOME':
+            if (assertArgs(ex, 0)) {
+                return [
+                    {
+                        prim: 'IF_NONE',
+                        args: [[[{ prim: 'UNIT' }, { prim: 'FAILWITH' }]], mayRename(ex.annots)],
+                    },
+                ];
+            }
+            break;
+        case 'ASSERT_LEFT':
+            if (assertArgs(ex, 0)) {
+                return [
+                    {
+                        prim: 'IF_LEFT',
+                        args: [mayRename(ex.annots), [[{ prim: 'UNIT' }, { prim: 'FAILWITH' }]]],
+                    },
+                ];
+            }
+            break;
+        case 'ASSERT_RIGHT':
+            if (assertArgs(ex, 0)) {
+                return [
+                    {
+                        prim: 'IF_LEFT',
+                        args: [[[{ prim: 'UNIT' }, { prim: 'FAILWITH' }]], mayRename(ex.annots)],
+                    },
+                ];
+            }
+            break;
+        // Syntactic conveniences
+        case 'IF_SOME':
+            if (assertArgs(ex, 2)) {
+                return [mkPrim({ prim: 'IF_NONE', annots: ex.annots, args: [ex.args[1], ex.args[0]] })];
+            }
+            break;
+        case 'IF_RIGHT':
+            if (assertArgs(ex, 2)) {
+                return [mkPrim({ prim: 'IF_LEFT', annots: ex.annots, args: [ex.args[1], ex.args[0]] })];
+            }
+            break;
+        // CAR/CDR n
+        case 'CAR':
+        case 'CDR':
+            if (ex.args !== undefined) {
+                if (assertArgs(ex, 1) && assertIntArg(ex, ex.args[0])) {
+                    const n = parseInt(ex.args[0].int, 10);
+                    return mkPrim({
+                        prim: 'GET',
+                        args: [{ int: ex.prim === 'CAR' ? String(n * 2 + 1) : String(n * 2) }],
+                        annots: ex.annots,
+                    });
+                }
+            }
+            else {
+                return ex;
+            }
+    }
+    // More syntactic conveniences
+    // PAPPAIIR macro
+    if (pairRe.test(ex.prim)) {
+        if (assertArgs(ex, 0)) {
+            const { fields, rest } = filterAnnotations(ex.annots);
+            const { r } = parsePairUnpairExpr(ex, ex.prim.slice(1), fields, (l, r, top) => [
+                ...(l || []),
+                ...(r || []),
+                top,
+            ]);
+            return r.map(([v, a], i) => {
+                const ann = [
+                    ...trimLast(a, null).map((v) => (v === null ? '%' : v)),
+                    ...(v === 0 && i === r.length - 1 ? rest : []),
+                ];
+                const leaf = mkPrim({ prim: 'PAIR', annots: ann.length !== 0 ? ann : undefined });
+                return v === 0
+                    ? leaf
+                    : {
+                        prim: 'DIP',
+                        args: v === 1 ? [[leaf]] : [{ int: String(v) }, [leaf]],
+                    };
+            });
+        }
+    }
+    // UNPAPPAIIR macro
+    if (unpairRe.test(ex.prim)) {
+        if ((0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PtEdo2Zk) && assertArgs(ex, 0)) {
+            const { r } = parsePairUnpairExpr(ex, ex.prim.slice(3), ex.annots || [], (l, r, top) => [
+                top,
+                ...(r || []),
+                ...(l || []),
+            ]);
+            return r.map(([v, a]) => {
+                const leaf = [
+                    { prim: 'DUP' },
+                    mkPrim({ prim: 'CAR', annots: a[0] !== null ? [a[0]] : undefined }),
+                    {
+                        prim: 'DIP',
+                        args: [[mkPrim({ prim: 'CDR', annots: a[1] !== null ? [a[1]] : undefined })]],
+                    },
+                ];
+                return v === 0
+                    ? leaf
+                    : {
+                        prim: 'DIP',
+                        args: v === 1 ? [[leaf]] : [{ int: String(v) }, [leaf]],
+                    };
+            });
+        }
+        else {
+            if (ex.prim === 'UNPAIR') {
+                return ex;
+            }
+            if (assertArgs(ex, 0)) {
+                // 008_edo: annotations are deprecated
+                const { r } = parsePairUnpairExpr(ex, ex.prim.slice(3), [], (l, r, top) => [
+                    top,
+                    ...(r || []),
+                    ...(l || []),
+                ]);
+                return r.map(([v]) => {
+                    const leaf = mkPrim({
+                        prim: 'UNPAIR',
+                    });
+                    return v === 0
+                        ? leaf
+                        : {
+                            prim: 'DIP',
+                            args: v === 1 ? [[leaf]] : [{ int: String(v) }, [leaf]],
+                        };
+                });
+            }
+        }
+    }
+    // C[AD]+R macro
+    if (cadrRe.test(ex.prim)) {
+        if (assertArgs(ex, 0)) {
+            const ch = [...ex.prim.slice(1, ex.prim.length - 1)];
+            return ch.map((c, i) => {
+                const ann = i === ch.length - 1 ? ex.annots : undefined;
+                switch (c) {
+                    case 'A':
+                        return mkPrim({ prim: 'CAR', annots: ann });
+                    case 'D':
+                        return mkPrim({ prim: 'CDR', annots: ann });
+                    default:
+                        throw new MacroError(ex, `unexpected character: ${c}`);
+                }
+            });
+        }
+    }
+    // SET_C[AD]+R macro
+    if (setCadrRe.test(ex.prim)) {
+        if (assertArgs(ex, 0)) {
+            const { fields, rest } = filterAnnotations(ex.annots);
+            if (fields.length > 1) {
+                throw new MacroError(ex, `unexpected annotation on macro ${ex.prim}: ${fields}`);
+            }
+            const term = fields.length !== 0
+                ? {
+                    a: [
+                        { prim: 'DUP' },
+                        { prim: 'CAR', annots: fields },
+                        { prim: 'DROP' },
+                        { prim: 'CDR', annots: ['@%%'] },
+                        { prim: 'SWAP' },
+                        { prim: 'PAIR', annots: [fields[0], '%@'] },
+                    ],
+                    d: [
+                        { prim: 'DUP' },
+                        { prim: 'CDR', annots: fields },
+                        { prim: 'DROP' },
+                        { prim: 'CAR', annots: ['@%%'] },
+                        { prim: 'PAIR', annots: ['%@', fields[0]] },
+                    ],
+                }
+                : {
+                    a: [
+                        { prim: 'CDR', annots: ['@%%'] },
+                        { prim: 'SWAP' },
+                        { prim: 'PAIR', annots: ['%', '%@'] },
+                    ],
+                    d: [
+                        { prim: 'CAR', annots: ['@%%'] },
+                        { prim: 'PAIR', annots: ['%@', '%'] },
+                    ],
+                };
+            return parseSetMapCadr(ex, ex.prim.slice(5, ex.prim.length - 1), rest, term);
+        }
+    }
+    // MAP_C[AD]+R macro
+    if (mapCadrRe.test(ex.prim)) {
+        if (assertArgs(ex, 1)) {
+            const { fields } = filterAnnotations(ex.annots);
+            if (fields.length > 1) {
+                throw new MacroError(ex, `unexpected annotation on macro ${ex.prim}: ${fields}`);
+            }
+            const term = {
+                a: [
+                    { prim: 'DUP' },
+                    { prim: 'CDR', annots: ['@%%'] },
+                    {
+                        prim: 'DIP',
+                        args: [
+                            [
+                                mkPrim({
+                                    prim: 'CAR',
+                                    annots: fields.length !== 0 ? ['@' + fields[0].slice(1)] : undefined,
+                                }),
+                                ex.args[0],
+                            ],
+                        ],
+                    },
+                    { prim: 'SWAP' },
+                    { prim: 'PAIR', annots: [fields.length !== 0 ? fields[0] : '%', '%@'] },
+                ],
+                d: [
+                    { prim: 'DUP' },
+                    mkPrim({
+                        prim: 'CDR',
+                        annots: fields.length !== 0 ? ['@' + fields[0].slice(1)] : undefined,
+                    }),
+                    ex.args[0],
+                    { prim: 'SWAP' },
+                    { prim: 'CAR', annots: ['@%%'] },
+                    { prim: 'PAIR', annots: ['%@', fields.length !== 0 ? fields[0] : '%'] },
+                ],
+            };
+            return parseSetMapCadr(ex, ex.prim.slice(5, ex.prim.length - 1), [], term);
+        }
+    }
+    // Expand deprecated DI...IP to [DIP n]
+    if (diipRe.test(ex.prim)) {
+        if (assertArgs(ex, 1)) {
+            let n = 0;
+            while (ex.prim[1 + n] === 'I') {
+                n++;
+            }
+            return mkPrim({ prim: 'DIP', args: [{ int: String(n) }, ex.args[0]] });
+        }
+    }
+    // Expand DU...UP and DUP n
+    if (duupRe.test(ex.prim)) {
+        let n = 0;
+        while (ex.prim[1 + n] === 'U') {
+            n++;
+        }
+        if ((0, michelson_types_1.ProtoInferiorTo)(proto, michelson_types_1.Protocol.PtEdo2Zk)) {
+            if (n === 1) {
+                if (ex.args === undefined) {
+                    return ex; // skip
+                }
+                if (assertArgs(ex, 1) && assertIntArg(ex, ex.args[0])) {
+                    n = parseInt(ex.args[0].int, 10);
+                }
+            }
+            else {
+                assertArgs(ex, 0);
+            }
+            if (n === 1) {
+                return [mkPrim({ prim: 'DUP', annots: ex.annots })];
+            }
+            else if (n === 2) {
+                return [
+                    {
+                        prim: 'DIP',
+                        args: [[mkPrim({ prim: 'DUP', annots: ex.annots })]],
+                    },
+                    { prim: 'SWAP' },
+                ];
+            }
+            else {
+                return [
+                    {
+                        prim: 'DIP',
+                        args: [{ int: String(n - 1) }, [mkPrim({ prim: 'DUP', annots: ex.annots })]],
+                    },
+                    {
+                        prim: 'DIG',
+                        args: [{ int: String(n) }],
+                    },
+                ];
+            }
+        }
+        else {
+            if (n === 1) {
+                return ex;
+            }
+            if (assertArgs(ex, 0)) {
+                return mkPrim({ prim: 'DUP', args: [{ int: String(n) }], annots: ex.annots });
+            }
+        }
+    }
+    return ex;
+}

package/dist/lib/taquito-michel-codec/src/micheline-emitter.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitMicheline = emitMicheline;
+const micheline_1 = require("./micheline");
+class Formatter {
+    constructor(opt, lev = 0) {
+        this.opt = opt;
+        this.lev = lev;
+    }
+    indent(n = 0) {
+        let ret = '';
+        if (this.opt?.indent !== undefined) {
+            for (let i = this.lev + n; i > 0; i--) {
+                ret += this.opt.indent;
+            }
+        }
+        return ret;
+    }
+    get lf() {
+        return this.opt?.newline || '';
+    }
+    get lfsp() {
+        return this.opt?.newline || ' ';
+    }
+    down(n) {
+        return new Formatter(this.opt, this.lev + n);
+    }
+}
+function hasArgs(node) {
+    return ('prim' in node &&
+        ((node.annots !== undefined && node.annots.length !== 0) ||
+            (node.args !== undefined && node.args.length !== 0)));
+}
+function isMultiline(node) {
+    if (node.args !== undefined) {
+        for (const a of node.args) {
+            if (Array.isArray(a) || hasArgs(a)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function emitExpr(node, f, foldMacros) {
+    const macro = node[micheline_1.sourceReference]?.macro;
+    if (foldMacros && macro) {
+        return emitExpr(macro, f, foldMacros);
+    }
+    if (Array.isArray(node)) {
+        return emitSeq(node, f, foldMacros);
+    }
+    else if ('string' in node) {
+        return JSON.stringify(node.string);
+    }
+    else if ('int' in node) {
+        return node.int;
+    }
+    else if ('bytes' in node) {
+        return '0x' + node.bytes;
+    }
+    else {
+        if ((node.annots === undefined || node.annots.length === 0) &&
+            (node.args === undefined || node.args.length === 0)) {
+            return node.prim;
+        }
+        let ret = '(' + node.prim;
+        if (node.annots !== undefined) {
+            for (const a of node.annots) {
+                ret += ' ' + a;
+            }
+        }
+        if (node.args !== undefined) {
+            const multiline = isMultiline(node);
+            for (const a of node.args) {
+                if (multiline) {
+                    ret += f.lfsp + f.indent(1) + emitExpr(a, f.down(1), foldMacros);
+                }
+                else {
+                    ret += ' ' + emitExpr(a, f, foldMacros);
+                }
+            }
+        }
+        return ret + ')';
+    }
+}
+function emitSeq(node, f, foldMacros) {
+    let ret = '{' + f.lf;
+    let i = node.length;
+    for (const el of node) {
+        ret += f.indent(1);
+        if ('prim' in el) {
+            ret += el.prim;
+            if (el.annots !== undefined) {
+                for (const a of el.annots) {
+                    ret += ' ' + a;
+                }
+            }
+            if (el.args !== undefined) {
+                const multiline = isMultiline(el);
+                for (const a of el.args) {
+                    if (multiline) {
+                        ret += f.lfsp + f.indent(2) + emitExpr(a, f.down(2), foldMacros);
+                    }
+                    else {
+                        ret += ' ' + emitExpr(a, f, foldMacros);
+                    }
+                }
+            }
+        }
+        else {
+            ret += emitExpr(el, f.down(1), foldMacros);
+        }
+        ret += i > 1 ? ';' + f.lfsp : f.lf;
+        i--;
+    }
+    return ret + f.indent() + '}';
+}
+/**
+ * Formats Micheline expression
+ * @param expr An AST node
+ * @param opt Options
+ */
+function emitMicheline(expr, opt, foldMacros = false) {
+    if (typeof expr !== 'object') {
+        throw new TypeError(`object type was expected, got ${typeof expr} instead`);
+    }
+    return emitExpr(expr, new Formatter(opt), foldMacros);
+}