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

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingTransactionToken = exports.SaplingTransactionValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction
+ */
+class SaplingTransactionValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'SaplingTransactionValidationError';
+    }
+}
+exports.SaplingTransactionValidationError = SaplingTransactionValidationError;
+class SaplingTransactionToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link SaplingTransactionValidationError}
+     */
+    Execute(_val) {
+        throw new SaplingTransactionValidationError(_val, this, `There is no literal value for the sapling_transaction type. Got: ${JSON.stringify(_val)}.`);
+    }
+    /**
+     * @throws {@link SaplingTransactionValidationError}
+     */
+    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 SaplingTransactionValidationError(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[SaplingTransactionToken.prim]) {
+            return semantic[SaplingTransactionToken.prim](val);
+        }
+        return { bytes: String(val).toString() };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: SaplingTransactionToken.prim,
+            schema: {
+                memoSize: this.val.args[0]['int'],
+            },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (SaplingTransactionToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.SaplingTransactionToken = SaplingTransactionToken;
+SaplingTransactionToken.prim = 'sapling_transaction';

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetToken = exports.SetValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Set
+ */
+class SetValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'SetValidationError';
+    }
+}
+exports.SetValidationError = SetValidationError;
+class SetToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    get KeySchema() {
+        return this.createToken(this.val.args[0], 0);
+    }
+    /**
+     * @throws {@link SetValidationError}
+     */
+    validate(value) {
+        if (!Array.isArray(value)) {
+            throw new SetValidationError(value, this, `Value ${JSON.stringify(value)} is not an array`);
+        }
+    }
+    /**
+     * @throws {@link SetValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return val
+            .sort((a, b) => this.KeySchema.compare(a, b))
+            .reduce((prev, current) => {
+            return [...prev, this.KeySchema.EncodeObject(current)];
+        }, []);
+    }
+    Execute(val, semantics) {
+        return val.reduce((prev, current) => {
+            return [...prev, this.KeySchema.Execute(current, semantics)];
+        }, []);
+    }
+    /**
+     * @throws {@link SetValidationError}
+     */
+    EncodeObject(args, semantic) {
+        this.validate(args);
+        if (semantic && semantic[SetToken.prim]) {
+            return semantic[SetToken.prim](args);
+        }
+        return args
+            .sort((a, b) => this.KeySchema.compare(a, b))
+            .reduce((prev, current) => {
+            return [...prev, this.KeySchema.EncodeObject(current)];
+        }, []);
+    }
+    generateSchema() {
+        return {
+            __michelsonType: SetToken.prim,
+            schema: this.KeySchema.generateSchema(),
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (SetToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        this.KeySchema.findAndReturnTokens(tokenToFind, tokens);
+        return tokens;
+    }
+}
+exports.SetToken = SetToken;
+SetToken.prim = 'set';

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureToken = exports.SignatureValidationError = void 0;
+const token_1 = require("./token");
+const utils_1 = require("@taquito/utils");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Signature
+ */
+class SignatureValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'SignatureValidationError';
+    }
+}
+exports.SignatureValidationError = SignatureValidationError;
+class SignatureToken extends token_1.ComparableToken {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    Execute(val) {
+        if (val.string) {
+            return val.string;
+        }
+        // TODO decode the signature
+        return val.bytes;
+    }
+    /**
+     * @throws {@link SignatureValidationError}
+     */
+    validate(value) {
+        if ((0, utils_1.validateSignature)(value) !== utils_1.ValidationResult.VALID) {
+            throw new SignatureValidationError(value, this, 'Signature is not valid');
+        }
+    }
+    /**
+     * @throws {@link SignatureValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { string: val };
+    }
+    /**
+     * @throws {@link SignatureValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[SignatureToken.prim]) {
+            return semantic[SignatureToken.prim](val);
+        }
+        return { string: val };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: SignatureToken.prim,
+            schema: SignatureToken.prim,
+        };
+    }
+    ToKey(val) {
+        return this.Execute(val);
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { string: val },
+            type: { prim: SignatureToken.prim },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (SignatureToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.SignatureToken = SignatureToken;
+SignatureToken.prim = 'signature';

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketDeprecatedToken = exports.EncodeTicketDeprecatedError = void 0;
+const core_1 = require("@taquito/core");
+const int_1 = require("./comparable/int");
+const contract_1 = require("./contract");
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure when encoding and sending a ticket to the blockchain
+ */
+class EncodeTicketDeprecatedError extends core_1.TaquitoError {
+    constructor() {
+        super();
+        this.name = 'TicketDeprecatedEncodeError';
+        this.message = 'Ticket_deprecated cannot be sent to the blockchain; they are created on-chain';
+    }
+}
+exports.EncodeTicketDeprecatedError = EncodeTicketDeprecatedError;
+const ticketerType = { prim: 'contract' };
+const amountType = { prim: 'int' };
+class TicketDeprecatedToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    get valueToken() {
+        return this.createToken(this.val.args[0], this.idx);
+    }
+    /**
+     * @throws {@link EncodeTicketDeprecatedError}
+     */
+    Encode(_args) {
+        throw new EncodeTicketDeprecatedError();
+    }
+    /**
+     * @throws {@link EncodeTicketDeprecatedError}
+     */
+    EncodeObject(args, semantic) {
+        if (semantic && semantic[TicketDeprecatedToken.prim]) {
+            return semantic[TicketDeprecatedToken.prim](args, this.val);
+        }
+        throw new EncodeTicketDeprecatedError();
+    }
+    Execute(val, semantics) {
+        if (semantics && semantics[TicketDeprecatedToken.prim]) {
+            return semantics[TicketDeprecatedToken.prim](val, this.val);
+        }
+        const ticketer = this.createToken(ticketerType, this.idx);
+        const value = this.valueToken;
+        const amount = this.createToken(amountType, this.idx);
+        if (undefined === val.args[2] && undefined !== val.args[1].args) {
+            return {
+                ticketer: ticketer.Execute(val.args[0], semantics),
+                value: value.Execute(val.args[1].args[0], semantics),
+                amount: amount.Execute(val.args[1].args[1], semantics),
+            };
+        }
+        return {
+            ticketer: ticketer.Execute(val.args[0], semantics),
+            value: value.Execute(val.args[1], semantics),
+            amount: amount.Execute(val.args[2], semantics),
+        };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: TicketDeprecatedToken.prim,
+            schema: {
+                value: this.valueToken.generateSchema(),
+                ticketer: {
+                    __michelsonType: contract_1.ContractToken.prim,
+                    schema: contract_1.ContractToken.prim,
+                },
+                amount: {
+                    __michelsonType: int_1.IntToken.prim,
+                    schema: int_1.IntToken.prim,
+                },
+            },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (TicketDeprecatedToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        this.valueToken.findAndReturnTokens(tokenToFind, tokens);
+        return tokens;
+    }
+}
+exports.TicketDeprecatedToken = TicketDeprecatedToken;
+TicketDeprecatedToken.prim = 'ticket_deprecated';

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketToken = exports.EncodeTicketError = void 0;
+const core_1 = require("@taquito/core");
+const int_1 = require("./comparable/int");
+const contract_1 = require("./contract");
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure when encoding and sending a ticket to the blockchain
+ */
+class EncodeTicketError extends core_1.TaquitoError {
+    constructor() {
+        super();
+        this.name = 'TicketEncodeError';
+        this.message = 'Tickets cannot be sent to the blockchain; they are created on-chain';
+    }
+}
+exports.EncodeTicketError = EncodeTicketError;
+const ticketerType = { prim: 'contract' };
+const amountType = { prim: 'int' };
+class TicketToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    get valueToken() {
+        return this.createToken(this.val.args[0], this.idx);
+    }
+    /**
+     * @throws {@link EncodeTicketError}
+     */
+    Encode(_args) {
+        throw new EncodeTicketError();
+    }
+    /**
+     * @throws {@link EncodeTicketError}
+     */
+    EncodeObject(args, semantic) {
+        if (semantic && semantic[TicketToken.prim]) {
+            return semantic[TicketToken.prim](args, this.val);
+        }
+        throw new EncodeTicketError();
+    }
+    Execute(val, semantics) {
+        if (semantics && semantics[TicketToken.prim]) {
+            return semantics[TicketToken.prim](val, this.val);
+        }
+        const ticketer = this.createToken(ticketerType, this.idx);
+        const value = this.valueToken;
+        const amount = this.createToken(amountType, this.idx);
+        if (undefined === val.args[2] && undefined !== val.args[1].args) {
+            return {
+                ticketer: ticketer.Execute(val.args[0], semantics),
+                value: value.Execute(val.args[1].args[0], semantics),
+                amount: amount.Execute(val.args[1].args[1], semantics),
+            };
+        }
+        return {
+            ticketer: ticketer.Execute(val.args[0], semantics),
+            value: value.Execute(val.args[1], semantics),
+            amount: amount.Execute(val.args[2], semantics),
+        };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: TicketToken.prim,
+            schema: {
+                value: this.valueToken.generateSchema(),
+                ticketer: {
+                    __michelsonType: contract_1.ContractToken.prim,
+                    schema: contract_1.ContractToken.prim,
+                },
+                amount: {
+                    __michelsonType: int_1.IntToken.prim,
+                    schema: int_1.IntToken.prim,
+                },
+            },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (TicketToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        this.valueToken.findAndReturnTokens(tokenToFind, tokens);
+        return tokens;
+    }
+}
+exports.TicketToken = TicketToken;
+TicketToken.prim = 'ticket';

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComparableToken = exports.Token = exports.TokenValidationError = void 0;
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates a failure when encoding invalid or incorrect data (e.g. if an address is expected but a number is received)
+ */
+class TokenValidationError extends core_1.TaquitoError {
+    constructor(value, token, baseMessage) {
+        super();
+        this.value = value;
+        this.token = token;
+        this.name = 'TokenValidationError';
+        const annot = this.token.annot();
+        const annotText = annot ? `[${annot}] ` : '';
+        this.message = `${annotText}${baseMessage}`;
+    }
+}
+exports.TokenValidationError = TokenValidationError;
+class Token {
+    /**
+     * Gets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects, returns a value of type {@link FieldNumberingStrategy} that controls how field numbers are calculated
+     */
+    static get fieldNumberingStrategy() {
+        return Token._fieldNumberingStrategy;
+    }
+    /**
+     * Sets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects, accepts a value of type {@link FieldNumberingStrategy} that controls how field numbers are calculated
+     */
+    static set fieldNumberingStrategy(value) {
+        Token._fieldNumberingStrategy = value;
+    }
+    constructor(val, idx, fac, parentTokenType) {
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+        this.parentTokenType = parentTokenType;
+        this.createToken = this.fac;
+    }
+    typeWithoutAnnotations() {
+        const handleMichelsonExpression = (val) => {
+            if (typeof val === 'object') {
+                if (Array.isArray(val)) {
+                    const array = val;
+                    return array.map((item) => handleMichelsonExpression(item));
+                }
+                const extended = val;
+                if (extended.args) {
+                    return {
+                        prim: extended.prim,
+                        args: extended.args.map((x) => handleMichelsonExpression(x)),
+                    };
+                }
+                else {
+                    return {
+                        prim: extended.prim,
+                    };
+                }
+            }
+            return val;
+        };
+        const handleMichelsonExtended = (val) => {
+            if (val.args) {
+                return {
+                    prim: val.prim,
+                    args: val.args.map((x) => handleMichelsonExpression(x)),
+                };
+            }
+            else {
+                return {
+                    prim: val.prim,
+                };
+            }
+        };
+        return handleMichelsonExtended(this.val);
+    }
+    annot() {
+        return (Array.isArray(this.val.annots) && this.val.annots.length > 0
+            ? this.val.annots[0]
+            : String(this.idx)).replace(/(%|:)(_Liq_entry_)?/, '');
+    }
+    hasAnnotations() {
+        return Array.isArray(this.val.annots) && this.val.annots.length;
+    }
+    get tokenVal() {
+        return this.val;
+    }
+    ExtractSignature() {
+        return [[this.generateSchema()]];
+    }
+}
+exports.Token = Token;
+Token._fieldNumberingStrategy = 'Latest';
+class ComparableToken extends Token {
+    compare(o1, o2) {
+        return o1 < o2 ? -1 : o1 > o2 ? 1 : 0;
+    }
+}
+exports.ComparableToken = ComparableToken;

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokens = void 0;
+const pair_1 = require("./pair");
+const nat_1 = require("./comparable/nat");
+const string_1 = require("./comparable/string");
+const bigmap_1 = require("./bigmap");
+const address_1 = require("./comparable/address");
+const map_1 = require("./map");
+const bool_1 = require("./comparable/bool");
+const or_1 = require("./or");
+const contract_1 = require("./contract");
+const list_1 = require("./list");
+const mutez_1 = require("./comparable/mutez");
+const bytes_1 = require("./comparable/bytes");
+const option_1 = require("./option");
+const timestamp_1 = require("./comparable/timestamp");
+const int_1 = require("./comparable/int");
+const unit_1 = require("./unit");
+const key_1 = require("./key");
+const key_hash_1 = require("./comparable/key_hash");
+const signature_1 = require("./signature");
+const lambda_1 = require("./lambda");
+const operation_1 = require("./operation");
+const set_1 = require("./set");
+const chain_id_1 = require("./chain-id");
+const ticket_1 = require("./ticket");
+const ticket_deprecated_1 = require("./ticket-deprecated");
+const never_1 = require("./never");
+const sapling_state_1 = require("./sapling-state");
+const sapling_transaction_1 = require("./sapling-transaction");
+const sapling_transaction_deprecated_1 = require("./sapling-transaction-deprecated");
+const bls12_381_fr_1 = require("./bls12-381-fr");
+const bls12_381_g1_1 = require("./bls12-381-g1");
+const bls12_381_g2_1 = require("./bls12-381-g2");
+const chest_1 = require("./chest");
+const chest_key_1 = require("./chest-key");
+const constant_1 = require("./constant");
+exports.tokens = [
+    pair_1.PairToken,
+    nat_1.NatToken,
+    string_1.StringToken,
+    bigmap_1.BigMapToken,
+    address_1.AddressToken,
+    map_1.MapToken,
+    bool_1.BoolToken,
+    or_1.OrToken,
+    contract_1.ContractToken,
+    list_1.ListToken,
+    mutez_1.MutezToken,
+    bytes_1.BytesToken,
+    option_1.OptionToken,
+    timestamp_1.TimestampToken,
+    int_1.IntToken,
+    unit_1.UnitToken,
+    key_1.KeyToken,
+    key_hash_1.KeyHashToken,
+    signature_1.SignatureToken,
+    lambda_1.LambdaToken,
+    operation_1.OperationToken,
+    set_1.SetToken,
+    chain_id_1.ChainIDToken,
+    ticket_1.TicketToken,
+    ticket_deprecated_1.TicketDeprecatedToken,
+    never_1.NeverToken,
+    sapling_state_1.SaplingStateToken,
+    sapling_transaction_1.SaplingTransactionToken,
+    sapling_transaction_deprecated_1.SaplingTransactionDeprecatedToken,
+    bls12_381_fr_1.Bls12381frToken,
+    bls12_381_g1_1.Bls12381g1Token,
+    bls12_381_g2_1.Bls12381g2Token,
+    chest_1.ChestToken,
+    chest_key_1.ChestKeyToken,
+    constant_1.GlobalConstantToken,
+];

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitToken = void 0;
+const token_1 = require("./token");
+const constants_1 = require("../constants");
+class UnitToken extends token_1.ComparableToken {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    Encode(args) {
+        args.pop();
+        return { prim: 'Unit' };
+    }
+    EncodeObject(val, semantic) {
+        if (semantic && semantic[UnitToken.prim]) {
+            return semantic[UnitToken.prim](val);
+        }
+        return { prim: 'Unit' };
+    }
+    Execute(_val) {
+        return constants_1.UnitValue;
+    }
+    generateSchema() {
+        return {
+            __michelsonType: UnitToken.prim,
+            schema: UnitToken.prim,
+        };
+    }
+    compare(_val1, _val2) {
+        return 0;
+    }
+    ToKey(_val) {
+        return constants_1.UnitValue;
+    }
+    ToBigMapKey(_val) {
+        return {
+            key: { prim: 'Unit' },
+            type: { prim: UnitToken.prim },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (UnitToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.UnitToken = UnitToken;
+UnitToken.prim = 'unit';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+exports.VERSION = {
+    "commitHash": "fb73f1546d3dff2fbba7741ca6006680212bef16",
+    "version": "24.3.0-beta.2"
+};