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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bls12381g2Token = exports.Bls12381g2ValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a BLS12-381 curve G2
+ */
+class Bls12381g2ValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'Bls12381g2ValidationError';
+    }
+}
+exports.Bls12381g2ValidationError = Bls12381g2ValidationError;
+class Bls12381g2Token extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link Bls12381g2ValidationError}
+     */
+    validate(val) {
+        if (/^[0-9a-fA-F]*$/.test(val) && val.length % 2 === 0) {
+            return;
+        }
+        throw new Bls12381g2ValidationError(val, this, `Invalid bytes: ${JSON.stringify(val)}`);
+    }
+    convertUint8ArrayToHexString(val) {
+        return val.constructor === Uint8Array ? Buffer.from(val).toString('hex') : val;
+    }
+    /**
+     * @throws {@link Bls12381g2ValidationError}
+     */
+    Encode(args) {
+        let val = args.pop();
+        val = this.convertUint8ArrayToHexString(val);
+        this.validate(val);
+        return { bytes: val };
+    }
+    /**
+     * @throws {@link Bls12381g2ValidationError}
+     */
+    EncodeObject(val, semantic) {
+        val = this.convertUint8ArrayToHexString(val);
+        this.validate(val);
+        if (semantic && semantic[Bls12381g2Token.prim]) {
+            return semantic[Bls12381g2Token.prim](val);
+        }
+        return { bytes: val };
+    }
+    Execute(val) {
+        return val.bytes;
+    }
+    generateSchema() {
+        return {
+            __michelsonType: Bls12381g2Token.prim,
+            schema: Bls12381g2Token.prim,
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (Bls12381g2Token.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.Bls12381g2Token = Bls12381g2Token;
+// A point on the BLS12-381 curve G2
+// See https://tezos.gitlab.io/michelson-reference/#type-bls12_381_g2
+Bls12381g2Token.prim = 'bls12_381_g2';

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainIDToken = exports.ChainIDValidationError = 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 ChainID
+ */
+class ChainIDValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'ChainIDValidationError';
+    }
+}
+exports.ChainIDValidationError = ChainIDValidationError;
+class ChainIDToken extends token_1.ComparableToken {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link ChainIDValidationError}
+     */
+    validate(value) {
+        if ((0, utils_1.validateChain)(value) !== utils_1.ValidationResult.VALID) {
+            throw new ChainIDValidationError(value, this, `Value ${JSON.stringify(value)} is not a valid ChainID`);
+        }
+    }
+    Execute(val) {
+        return val[Object.keys(val)[0]];
+    }
+    generateSchema() {
+        return {
+            __michelsonType: ChainIDToken.prim,
+            schema: ChainIDToken.prim,
+        };
+    }
+    /**
+     * @throws {@link ChainIDValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { string: val };
+    }
+    /**
+     * @throws {@link ChainIDValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[ChainIDToken.prim]) {
+            return semantic[ChainIDToken.prim](val);
+        }
+        return { string: val };
+    }
+    ToKey({ string }) {
+        return string;
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { string: val },
+            type: { prim: ChainIDToken.prim },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (ChainIDToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.ChainIDToken = ChainIDToken;
+ChainIDToken.prim = 'chain_id';

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChestKeyToken = exports.ChestKeyValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Chest Key
+ */
+class ChestKeyValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'ChestKeyValidationError';
+    }
+}
+exports.ChestKeyValidationError = ChestKeyValidationError;
+class ChestKeyToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    validate(val) {
+        if (/^[0-9a-fA-F]*$/.test(val) && val.length % 2 === 0) {
+            return;
+        }
+        throw new ChestKeyValidationError(val, this, `Invalid bytes: ${JSON.stringify(val)}`);
+    }
+    convertUint8ArrayToHexString(val) {
+        return val.constructor === Uint8Array ? Buffer.from(val).toString('hex') : val;
+    }
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    Encode(args) {
+        let val = args.pop();
+        val = this.convertUint8ArrayToHexString(val);
+        this.validate(val);
+        return { bytes: val };
+    }
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    EncodeObject(val, semantic) {
+        val = this.convertUint8ArrayToHexString(val);
+        this.validate(val);
+        if (semantic && semantic[ChestKeyToken.prim]) {
+            return semantic[ChestKeyToken.prim](val);
+        }
+        return { bytes: val };
+    }
+    Execute(val) {
+        return val.bytes;
+    }
+    generateSchema() {
+        return {
+            __michelsonType: ChestKeyToken.prim,
+            schema: ChestKeyToken.prim,
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (ChestKeyToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.ChestKeyToken = ChestKeyToken;
+ChestKeyToken.prim = 'chest_key';

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChestToken = exports.ChestValidationError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Chest
+ */
+class ChestValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'ChestValidationError';
+    }
+}
+exports.ChestValidationError = ChestValidationError;
+class ChestToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    validate(val) {
+        if (/^[0-9a-fA-F]*$/.test(val) && val.length % 2 == 0) {
+            return;
+        }
+        throw new ChestValidationError(val, this, `Invalid bytes: ${JSON.stringify(val)}`);
+    }
+    convertUint8ArrayToHexString(val) {
+        return val.constructor === Uint8Array ? Buffer.from(val).toString('hex') : val;
+    }
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    Encode(args) {
+        let val = args.pop();
+        val = this.convertUint8ArrayToHexString(val);
+        this.validate(val);
+        return { bytes: val };
+    }
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    EncodeObject(val, semantic) {
+        val = this.convertUint8ArrayToHexString(val);
+        this.validate(val);
+        if (semantic && semantic[ChestToken.prim]) {
+            return semantic[ChestToken.prim](val);
+        }
+        return { bytes: val };
+    }
+    Execute(val) {
+        return val.bytes;
+    }
+    generateSchema() {
+        return {
+            __michelsonType: ChestToken.prim,
+            schema: ChestToken.prim,
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (ChestToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.ChestToken = ChestToken;
+ChestToken.prim = 'chest';

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressToken = exports.AddressValidationError = 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 an Address
+ */
+class AddressValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'AddressValidationError';
+    }
+}
+exports.AddressValidationError = AddressValidationError;
+class AddressToken extends token_1.ComparableToken {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    ToBigMapKey(val) {
+        const decoded = (0, utils_1.b58DecodeAddress)(val);
+        return {
+            key: { bytes: decoded },
+            type: { prim: 'bytes' },
+        };
+    }
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    validate(value) {
+        if (typeof value !== 'string') {
+            throw new AddressValidationError(value, this, 'Type error');
+        }
+        if ((0, utils_1.validateAddress)(value) !== utils_1.ValidationResult.VALID) {
+            throw new AddressValidationError(value, this, `Address is not valid: ${JSON.stringify(value)}`);
+        }
+    }
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { string: val };
+    }
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[AddressToken.prim]) {
+            return semantic[AddressToken.prim](val);
+        }
+        return { string: val };
+    }
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    Execute(val) {
+        if (val.string) {
+            return val.string;
+        }
+        if (!val.bytes) {
+            throw new AddressValidationError(val, this, `cannot be missing both string and bytes: ${JSON.stringify(val)}`);
+        }
+        return (0, utils_1.encodeAddress)(val.bytes);
+    }
+    generateSchema() {
+        return {
+            __michelsonType: AddressToken.prim,
+            schema: AddressToken.prim,
+        };
+    }
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    ToKey({ bytes, string }) {
+        if (string) {
+            return string;
+        }
+        if (!bytes) {
+            throw new AddressValidationError({ bytes, string }, this, `cannot be missing both string and bytes ${JSON.stringify({ string, bytes })}`);
+        }
+        return (0, utils_1.encodeAddress)(bytes);
+    }
+    compare(address1, address2) {
+        const [addr1, endpoint1] = (0, utils_1.splitAddress)(address1);
+        const [addr2, endpoint2] = (0, utils_1.splitAddress)(address2);
+        const ep1 = endpoint1 || '';
+        const ep2 = endpoint2 || '';
+        // binary type tag actually reflects the expected prefix order
+        const bytes1 = (0, utils_1.b58DecodeAddress)(addr1, 'array');
+        const bytes2 = (0, utils_1.b58DecodeAddress)(addr2, 'array');
+        const res = (0, utils_1.compareArrays)(bytes1, bytes2);
+        if (res === 0) {
+            return ep1 < ep2 ? -1 : ep1 > ep2 ? 1 : 0;
+        }
+        else {
+            return res;
+        }
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (AddressToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.AddressToken = AddressToken;
+AddressToken.prim = 'address';

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoolToken = void 0;
+const token_1 = require("../token");
+class BoolToken extends token_1.ComparableToken {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    Execute(val) {
+        return String(val.prim).toLowerCase() === 'true' ? true : false;
+    }
+    Encode(args) {
+        const val = args.pop();
+        return { prim: val ? 'True' : 'False' };
+    }
+    EncodeObject(val, semantic) {
+        if (semantic && semantic[BoolToken.prim]) {
+            return semantic[BoolToken.prim](val);
+        }
+        return { prim: val ? 'True' : 'False' };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: BoolToken.prim,
+            schema: BoolToken.prim,
+        };
+    }
+    ToBigMapKey(val) {
+        return {
+            key: this.EncodeObject(val),
+            type: { prim: BoolToken.prim },
+        };
+    }
+    ToKey(val) {
+        return this.EncodeObject(val);
+    }
+    compare(val1, val2) {
+        if ((val1 && val2) || (!val1 && !val2)) {
+            return 0;
+        }
+        else if (val1) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (BoolToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.BoolToken = BoolToken;
+BoolToken.prim = 'bool';

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytesToken = exports.BytesValidationError = 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 Bytes
+ */
+class BytesValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'BytesValidationError';
+    }
+}
+exports.BytesValidationError = BytesValidationError;
+class BytesToken extends token_1.ComparableToken {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { bytes: val },
+            type: { prim: BytesToken.prim },
+        };
+    }
+    /**
+     * @throws {@link BytesValidationError}
+     */
+    validate(val) {
+        if (typeof val === 'string' && /^[0-9a-fA-F]*$/.test(val) && val.length % 2 === 0) {
+            return;
+        }
+        throw new BytesValidationError(val, this, `Invalid bytes: ${val}`);
+    }
+    convertUint8ArrayToHexString(val) {
+        return val.constructor === Uint8Array ? Buffer.from(val).toString('hex') : val;
+    }
+    /**
+     * @throws {@link BytesValidationError}
+     */
+    Encode(args) {
+        let val = args.pop();
+        val = (0, utils_1.stripHexPrefix)(this.convertUint8ArrayToHexString(val));
+        this.validate(val);
+        return { bytes: String(val).toString() };
+    }
+    /**
+     * @throws {@link BytesValidationError}
+     */
+    EncodeObject(val, semantic) {
+        val = this.convertUint8ArrayToHexString(val);
+        if (typeof val === 'string') {
+            val = (0, utils_1.stripHexPrefix)(val);
+        }
+        this.validate(val);
+        if (semantic && semantic[BytesToken.prim]) {
+            return semantic[BytesToken.prim](val);
+        }
+        return { bytes: String(val).toString() };
+    }
+    Execute(val) {
+        return val.bytes;
+    }
+    generateSchema() {
+        return {
+            __michelsonType: BytesToken.prim,
+            schema: BytesToken.prim,
+        };
+    }
+    ToKey({ bytes, string }) {
+        if (string) {
+            return string;
+        }
+        return bytes;
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (BytesToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.BytesToken = BytesToken;
+BytesToken.prim = 'bytes';

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

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntToken = exports.IntValidationError = void 0;
+const token_1 = require("../token");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing Int
+ */
+class IntValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'IntValidationError';
+    }
+}
+exports.IntValidationError = IntValidationError;
+class IntToken extends token_1.ComparableToken {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    Execute(val) {
+        return new bignumber_js_1.default(val[Object.keys(val)[0]]);
+    }
+    generateSchema() {
+        return {
+            __michelsonType: IntToken.prim,
+            schema: IntToken.prim,
+        };
+    }
+    /**
+     * @throws {@link IntValidationError}
+     */
+    validate(val) {
+        const bigNumber = new bignumber_js_1.default(val);
+        if (bigNumber.isNaN()) {
+            throw new IntValidationError(val, this, `Value is not a number: ${JSON.stringify(val)}`);
+        }
+    }
+    /**
+     * @throws {@link IntValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { int: new bignumber_js_1.default(val).toFixed() };
+    }
+    /**
+     * @throws {@link IntValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[IntToken.prim]) {
+            return semantic[IntToken.prim](val);
+        }
+        return { int: new bignumber_js_1.default(val).toFixed() };
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { int: String(val) },
+            type: { prim: IntToken.prim },
+        };
+    }
+    ToKey({ int }) {
+        return int;
+    }
+    compare(int1, int2) {
+        const o1 = Number(int1);
+        const o2 = Number(int2);
+        if (o1 === o2) {
+            return 0;
+        }
+        return o1 < o2 ? -1 : 1;
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (IntToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.IntToken = IntToken;
+IntToken.prim = 'int';