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

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

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrToken = exports.OrValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing an OrToken
+ */
+class OrValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'OrValidationError';
+    }
+}
+exports.OrValidationError = OrValidationError;
+class OrToken extends token_1.ComparableToken {
+    constructor(val, idx, fac, parentTokenType) {
+        super(val, idx, fac, parentTokenType);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+        this.parentTokenType = parentTokenType;
+    }
+    Encode(args) {
+        const label = args[args.length - 1];
+        const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
+        let keyCount = 1;
+        if (leftToken instanceof OrToken) {
+            keyCount = Object.keys(leftToken.generateSchema().schema).length;
+        }
+        const rightToken = this.createToken(this.val.args[1], this.getIdxForChildren() + keyCount, 'Or');
+        if (String(leftToken.annot()) === String(label) && !(leftToken instanceof OrToken)) {
+            args.pop();
+            return { prim: 'Left', args: [leftToken.Encode(args)] };
+        }
+        else if (String(rightToken.annot()) === String(label) && !(rightToken instanceof OrToken)) {
+            args.pop();
+            return { prim: 'Right', args: [rightToken.Encode(args)] };
+        }
+        else {
+            if (leftToken instanceof OrToken) {
+                const val = leftToken.Encode(args);
+                if (val) {
+                    return { prim: 'Left', args: [val] };
+                }
+            }
+            if (rightToken instanceof OrToken) {
+                const val = rightToken.Encode(args);
+                if (val) {
+                    return { prim: 'Right', args: [val] };
+                }
+            }
+            return null;
+        }
+    }
+    ExtractSignature() {
+        const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
+        let keyCount = 1;
+        if (leftToken instanceof OrToken) {
+            keyCount = Object.keys(leftToken.generateSchema().schema).length;
+        }
+        const rightToken = this.createToken(this.val.args[1], this.getIdxForChildren() + keyCount, 'Or');
+        const newSig = [];
+        if (leftToken instanceof OrToken) {
+            newSig.push(...leftToken.ExtractSignature());
+        }
+        else {
+            for (const sig of leftToken.ExtractSignature()) {
+                newSig.push([leftToken.annot(), ...sig]);
+            }
+        }
+        if (rightToken instanceof OrToken) {
+            newSig.push(...rightToken.ExtractSignature());
+        }
+        else {
+            for (const sig of rightToken.ExtractSignature()) {
+                newSig.push([rightToken.annot(), ...sig]);
+            }
+        }
+        return newSig;
+    }
+    /**
+     * @throws {@link OrValidationError}
+     */
+    EncodeObject(args, semantic) {
+        this.validateJavascriptObject(args);
+        const label = Object.keys(args)[0];
+        const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
+        let keyCount = 1;
+        if (leftToken instanceof OrToken) {
+            keyCount = Object.keys(leftToken.generateSchema().schema).length;
+        }
+        const rightToken = this.createToken(this.val.args[1], this.getIdxForChildren() + keyCount, 'Or');
+        if (String(leftToken.annot()) === String(label) && !(leftToken instanceof OrToken)) {
+            return { prim: 'Left', args: [leftToken.EncodeObject(args[label], semantic)] };
+        }
+        else if (String(rightToken.annot()) === String(label) && !(rightToken instanceof OrToken)) {
+            return { prim: 'Right', args: [rightToken.EncodeObject(args[label], semantic)] };
+        }
+        else {
+            if (leftToken instanceof OrToken) {
+                const val = leftToken.EncodeObject(args, semantic);
+                if (val) {
+                    return { prim: 'Left', args: [val] };
+                }
+            }
+            if (rightToken instanceof OrToken) {
+                const val = rightToken.EncodeObject(args, semantic);
+                if (val) {
+                    return { prim: 'Right', args: [val] };
+                }
+            }
+            return null;
+        }
+    }
+    /**
+     * @throws {@link OrValidationError}
+     */
+    validateJavascriptObject(args) {
+        if (typeof args !== 'object' ||
+            Array.isArray(args) ||
+            args === null ||
+            Object.keys(args).length !== 1) {
+            throw new OrValidationError(args, this, `EncodeObject expects an object with a single key but got: ${JSON.stringify(args)}`);
+        }
+    }
+    /**
+     * @throws {@link OrValidationError}
+     */
+    Execute(val, semantics) {
+        const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
+        let keyCount = 1;
+        if (leftToken instanceof OrToken) {
+            keyCount = Object.keys(leftToken.generateSchema().schema).length;
+        }
+        const rightToken = this.createToken(this.val.args[1], this.getIdxForChildren() + keyCount, 'Or');
+        if (val.prim === 'Right') {
+            if (rightToken instanceof OrToken) {
+                return rightToken.Execute(val.args[0], semantics);
+            }
+            else {
+                return {
+                    [rightToken.annot()]: rightToken.Execute(val.args[0], semantics),
+                };
+            }
+        }
+        else if (val.prim === 'Left') {
+            if (leftToken instanceof OrToken) {
+                return leftToken.Execute(val.args[0], semantics);
+            }
+            return {
+                [leftToken.annot()]: leftToken.Execute(val.args[0], semantics),
+            };
+        }
+        else {
+            throw new OrValidationError(val, this, `Was expecting Left or Right prim but got: ${JSON.stringify(val.prim)}`);
+        }
+    }
+    traversal(getLeftValue, getRightValue, concat) {
+        const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
+        let keyCount = 1;
+        let leftValue;
+        if (leftToken instanceof OrToken) {
+            leftValue = getLeftValue(leftToken);
+            keyCount = Object.keys(leftToken.generateSchema().schema).length;
+        }
+        else {
+            leftValue = { [leftToken.annot()]: getLeftValue(leftToken) };
+        }
+        const rightToken = this.createToken(this.val.args[1], this.getIdxForChildren() + keyCount, 'Or');
+        let rightValue;
+        if (rightToken instanceof OrToken) {
+            rightValue = getRightValue(rightToken);
+        }
+        else {
+            rightValue = { [rightToken.annot()]: getRightValue(rightToken) };
+        }
+        const res = concat(leftValue, rightValue);
+        return res;
+    }
+    generateSchema() {
+        return {
+            __michelsonType: OrToken.prim,
+            schema: this.traversal((leftToken) => {
+                if (leftToken instanceof OrToken) {
+                    return leftToken.generateSchema().schema;
+                }
+                else {
+                    return leftToken.generateSchema();
+                }
+            }, (rightToken) => {
+                if (rightToken instanceof OrToken) {
+                    return rightToken.generateSchema().schema;
+                }
+                else {
+                    return rightToken.generateSchema();
+                }
+            }, (leftValue, rightValue) => ({
+                ...leftValue,
+                ...rightValue,
+            })),
+        };
+    }
+    findToken(label) {
+        const leftToken = this.createToken(this.val.args[0], this.getIdxForChildren(), 'Or');
+        let keyCount = 1;
+        if (leftToken instanceof OrToken) {
+            const schema = leftToken.generateSchema();
+            keyCount = Object.keys(schema.schema).length;
+        }
+        const rightToken = this.createToken(this.val.args[1], this.getIdxForChildren() + keyCount, 'Or');
+        if (String(leftToken.annot()) === String(label) &&
+            !(leftToken instanceof OrToken) &&
+            leftToken instanceof token_1.ComparableToken) {
+            return leftToken;
+        }
+        else if (String(rightToken.annot()) === String(label) &&
+            !(rightToken instanceof OrToken) &&
+            rightToken instanceof token_1.ComparableToken) {
+            return rightToken;
+        }
+        else {
+            if (leftToken instanceof OrToken) {
+                const tok = leftToken.findToken(label);
+                if (tok) {
+                    return tok;
+                }
+            }
+            if (rightToken instanceof OrToken) {
+                const tok = rightToken.findToken(label);
+                if (tok) {
+                    return tok;
+                }
+            }
+            return null;
+        }
+    }
+    compare(val1, val2) {
+        const labelVal1 = Object.keys(val1)[0];
+        const labelVal2 = Object.keys(val2)[0];
+        if (labelVal1 === labelVal2) {
+            const token = this.findToken(labelVal1);
+            if (token instanceof token_1.ComparableToken) {
+                return token.compare(val1[labelVal1], val2[labelVal1]);
+            }
+        }
+        else {
+            const encoded1 = JSON.stringify(this.EncodeObject(val1));
+            const encoded2 = JSON.stringify(this.EncodeObject(val2));
+            return encoded1 < encoded2 ? -1 : 1;
+        }
+    }
+    ToKey(val) {
+        return this.Execute(val);
+    }
+    ToBigMapKey(val) {
+        return {
+            key: this.EncodeObject(val),
+            type: this.typeWithoutAnnotations(),
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (OrToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        this.traversal((leftToken) => leftToken.findAndReturnTokens(tokenToFind, tokens), (rightToken) => rightToken.findAndReturnTokens(tokenToFind, tokens), (leftValue, rightValue) => ({
+            ...leftValue,
+            ...rightValue,
+        }));
+        return tokens;
+    }
+    getIdxForChildren() {
+        if (token_1.Token.fieldNumberingStrategy === 'Legacy') {
+            return this.idx;
+        }
+        return this.parentTokenType === 'Or' ? this.idx : 0;
+    }
+}
+exports.OrToken = OrToken;
+OrToken.prim = 'or';

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

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairToken = exports.TokenComparisonError = exports.TokenArgumentValidationError = void 0;
+const token_1 = require("./token");
+const or_1 = require("./or");
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates in invalid token argument being passed
+ */
+class TokenArgumentValidationError extends core_1.TaquitoError {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'TokenArgumentValidationError';
+    }
+}
+exports.TokenArgumentValidationError = TokenArgumentValidationError;
+/**
+ *  @category Error
+ *  Error that indicates a failure occurring when doing a comparison of tokens
+ */
+class TokenComparisonError extends core_1.TaquitoError {
+    constructor(val1, val2) {
+        super();
+        this.val1 = val1;
+        this.val2 = val2;
+        this.name = 'TokenComparisonError';
+        this.message = `Tokens ${JSON.stringify(val1)} and ${JSON.stringify(val2)} are not comparable`;
+    }
+}
+exports.TokenComparisonError = TokenComparisonError;
+// collapse comb pair
+/**
+ * @throws {@link TokenArgumentValidationError}
+ */
+function collapse(val, prim = PairToken.prim) {
+    if (Array.isArray(val)) {
+        return collapse({
+            prim: prim,
+            args: val,
+        }, prim);
+    }
+    if (val.args === undefined) {
+        throw new TokenArgumentValidationError(`The value ${JSON.stringify(val)} is an invalid PairToken with no arguments, a pair must have two or more arguments.`);
+    }
+    if (val.args.length > 2) {
+        return [
+            val.args[0],
+            {
+                prim: prim,
+                args: val.args.slice(1),
+            },
+        ];
+    }
+    return [val.args[0], val.args[1]];
+}
+class PairToken extends token_1.ComparableToken {
+    constructor(val, idx, fac, parentTokenType) {
+        super(Array.isArray(val)
+            ? {
+                prim: PairToken.prim,
+                args: val,
+            }
+            : val.prim
+                ? val
+                : {
+                    prim: PairToken.prim,
+                    args: val,
+                }, idx, fac, parentTokenType);
+    }
+    args() {
+        // collapse comb pair
+        return collapse(this.val);
+    }
+    tokens() {
+        let cnt = 0;
+        return this.args().map((a) => {
+            const tok = this.createToken(a, this.getIdxForChildren() + cnt, 'Pair');
+            if (tok instanceof PairToken) {
+                cnt += Object.keys(tok.generateSchema()).length;
+            }
+            else {
+                cnt++;
+            }
+            return tok;
+        });
+    }
+    Encode(args) {
+        return {
+            prim: 'Pair',
+            args: this.tokens().map((t) => t.Encode(args)),
+        };
+    }
+    ExtractSignature() {
+        const args = this.args();
+        const leftToken = this.createToken(args[0], this.getIdxForChildren(), 'Pair');
+        let keyCount = 1;
+        if (leftToken instanceof or_1.OrToken) {
+            keyCount = Object.keys(leftToken.generateSchema()).length;
+        }
+        const rightToken = this.createToken(args[1], this.getIdxForChildren() + keyCount, 'Pair');
+        const newSig = [];
+        for (const leftSig of leftToken.ExtractSignature()) {
+            for (const rightSig of rightToken.ExtractSignature()) {
+                newSig.push([...leftSig, ...rightSig]);
+            }
+        }
+        return newSig;
+    }
+    ToBigMapKey(val) {
+        return {
+            key: this.EncodeObject(val),
+            type: this.typeWithoutAnnotations(),
+        };
+    }
+    ToKey(val) {
+        return this.Execute(val);
+    }
+    EncodeObject(args, semantic) {
+        const [leftToken, rightToken] = this.tokens();
+        let leftValue;
+        if (leftToken instanceof PairToken && !leftToken.hasAnnotations()) {
+            leftValue = args;
+        }
+        else {
+            leftValue = args[leftToken.annot()];
+        }
+        let rightValue;
+        if (rightToken instanceof PairToken && !rightToken.hasAnnotations()) {
+            rightValue = args;
+        }
+        else {
+            rightValue = args[rightToken.annot()];
+        }
+        return {
+            prim: 'Pair',
+            args: [
+                leftToken.EncodeObject(leftValue, semantic),
+                rightToken.EncodeObject(rightValue, semantic),
+            ],
+        };
+    }
+    traversal(getLeftValue, getRightValue) {
+        const args = this.args();
+        const leftToken = this.createToken(args[0], this.getIdxForChildren(), 'Pair');
+        let keyCount = 1;
+        let leftValue;
+        if (leftToken instanceof PairToken && !leftToken.hasAnnotations()) {
+            leftValue = getLeftValue(leftToken);
+            if (leftToken instanceof PairToken) {
+                keyCount = Object.keys(leftToken.generateSchema()).length;
+            }
+        }
+        else {
+            leftValue = { [leftToken.annot()]: getLeftValue(leftToken) };
+        }
+        const rightToken = this.createToken(args[1], this.getIdxForChildren() + keyCount, 'Pair');
+        let rightValue;
+        if (rightToken instanceof PairToken && !rightToken.hasAnnotations()) {
+            rightValue = getRightValue(rightToken);
+        }
+        else {
+            rightValue = { [rightToken.annot()]: getRightValue(rightToken) };
+        }
+        const res = {
+            ...leftValue,
+            ...rightValue,
+        };
+        return res;
+    }
+    Execute(val, semantics) {
+        const args = collapse(val, 'Pair');
+        return this.traversal((leftToken) => leftToken.Execute(args[0], semantics), (rightToken) => rightToken.Execute(args[1], semantics));
+    }
+    generateSchema() {
+        return {
+            __michelsonType: PairToken.prim,
+            schema: this.traversal((leftToken) => {
+                if (leftToken instanceof PairToken && !leftToken.hasAnnotations()) {
+                    return leftToken.generateSchema().schema;
+                }
+                else {
+                    return leftToken.generateSchema();
+                }
+            }, (rightToken) => {
+                if (rightToken instanceof PairToken && !rightToken.hasAnnotations()) {
+                    return rightToken.generateSchema().schema;
+                }
+                else {
+                    return rightToken.generateSchema();
+                }
+            }),
+        };
+    }
+    /**
+     * @throws {@link TokenComparisonError}
+     */
+    compare(val1, val2) {
+        const [leftToken, rightToken] = this.tokens();
+        const getValue = (token, args) => {
+            if (token instanceof PairToken && !token.hasAnnotations()) {
+                return args;
+            }
+            else {
+                return args[token.annot()];
+            }
+        };
+        if (leftToken instanceof token_1.ComparableToken && rightToken instanceof token_1.ComparableToken) {
+            const result = leftToken.compare(getValue(leftToken, val1), getValue(leftToken, val2));
+            if (result === 0) {
+                return rightToken.compare(getValue(rightToken, val1), getValue(rightToken, val2));
+            }
+            return result;
+        }
+        throw new TokenComparisonError(val1, val2);
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (PairToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        this.tokens().map((t) => t.findAndReturnTokens(tokenToFind, tokens));
+        return tokens;
+    }
+    getIdxForChildren() {
+        if (token_1.Token.fieldNumberingStrategy === 'Legacy') {
+            return this.idx;
+        }
+        return this.parentTokenType === 'Pair' ? this.idx : 0;
+    }
+}
+exports.PairToken = PairToken;
+PairToken.prim = 'pair';

package/dist/lib/taquito-michelson-encoder/src/tokens/sapling-state.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingStateToken = exports.SaplingStateValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Sapling State
+ */
+class SaplingStateValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'SaplingStateValidationError';
+    }
+}
+exports.SaplingStateValidationError = SaplingStateValidationError;
+class SaplingStateToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    isValid(val) {
+        return typeof val === 'object' && Object.keys(val).length === 0;
+    }
+    /**
+     * @throws {@link SaplingStateValidationError}
+     */
+    Execute(val, semantic) {
+        if (semantic && semantic[SaplingStateToken.prim]) {
+            return semantic[SaplingStateToken.prim](val, this.val);
+        }
+        if ('int' in val) {
+            return val.int;
+        }
+        else {
+            throw new SaplingStateValidationError(val, this, `Sapling state is expecting an object with an int property. Got ${JSON.stringify(val)}`);
+        }
+    }
+    /**
+     * @throws {@link SaplingStateValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        if (this.isValid(val)) {
+            return [];
+        }
+        else {
+            throw new SaplingStateValidationError(val, this, `Invalid sapling_state. Received: ${JSON.stringify(val)} while expecting: {}`);
+        }
+    }
+    /**
+     * @throws {@link SaplingStateValidationError}
+     */
+    EncodeObject(val, semantic) {
+        if (semantic && semantic[SaplingStateToken.prim]) {
+            return semantic[SaplingStateToken.prim](val);
+        }
+        if (this.isValid(val)) {
+            return [];
+        }
+        else {
+            throw new SaplingStateValidationError(val, this, `Invalid sapling_state. Received: ${JSON.stringify(val)} while expecting: {}`);
+        }
+    }
+    generateSchema() {
+        return {
+            __michelsonType: SaplingStateToken.prim,
+            schema: {
+                memoSize: this.val.args[0]['int'],
+            },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (SaplingStateToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.SaplingStateToken = SaplingStateToken;
+SaplingStateToken.prim = 'sapling_state';

package/dist/lib/taquito-michelson-encoder/src/tokens/sapling-transaction-deprecated.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingTransactionDeprecatedToken = exports.SaplingTransactionDeprecatedValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction Deprecated
+ */
+class SaplingTransactionDeprecatedValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'SaplingTransactionDeprecatedValidationError';
+    }
+}
+exports.SaplingTransactionDeprecatedValidationError = SaplingTransactionDeprecatedValidationError;
+class SaplingTransactionDeprecatedToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link SaplingTransactionDeprecatedValidationError}
+     */
+    Execute(_val) {
+        throw new SaplingTransactionDeprecatedValidationError(_val, this, `There is no literal value for the sapling_transaction_deprecated type. Got: ${JSON.stringify(_val)}.`);
+    }
+    /**
+     * @throws {@link SaplingTransactionDeprecatedValidationError}
+     */
+    validateBytes(val) {
+        const bytes = /^(0x|0X)?([0-9a-fA-F]*$)/.exec(val);
+        if (bytes && bytes[2].length % 2 === 0) {
+            return bytes[2];
+        }
+        else {
+            throw new SaplingTransactionDeprecatedValidationError(val, this, `Invalid bytes: ${JSON.stringify(val)}`);
+        }
+    }
+    convertUint8ArrayToHexString(val) {
+        return val.constructor === Uint8Array ? Buffer.from(val).toString('hex') : val;
+    }
+    Encode(args) {
+        let val = args.pop();
+        val = this.validateBytes(this.convertUint8ArrayToHexString(val));
+        return { bytes: String(val).toString() };
+    }
+    EncodeObject(val, semantic) {
+        val = this.validateBytes(this.convertUint8ArrayToHexString(val));
+        if (semantic && semantic[SaplingTransactionDeprecatedToken.prim]) {
+            return semantic[SaplingTransactionDeprecatedToken.prim](val);
+        }
+        return { bytes: String(val).toString() };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: SaplingTransactionDeprecatedToken.prim,
+            schema: {
+                memoSize: this.val.args[0]['int'],
+            },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (SaplingTransactionDeprecatedToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.SaplingTransactionDeprecatedToken = SaplingTransactionDeprecatedToken;
+SaplingTransactionDeprecatedToken.prim = 'sapling_transaction_deprecated';