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

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyHashToken = exports.KeyHashValidationError = 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 Key Hash
+ */
+class KeyHashValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'KeyHashValidationError';
+    }
+}
+exports.KeyHashValidationError = KeyHashValidationError;
+class KeyHashToken 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;
+        }
+        return (0, utils_1.encodeKeyHash)(val.bytes);
+    }
+    /**
+     * @throws {@link KeyHashValidationError}
+     */
+    validate(value) {
+        if ((0, utils_1.validateKeyHash)(value) !== utils_1.ValidationResult.VALID) {
+            throw new KeyHashValidationError(value, this, `KeyHash is not valid: ${JSON.stringify(value)}`);
+        }
+    }
+    /**
+     * @throws {@link KeyHashValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { string: val };
+    }
+    /**
+     * @throws {@link KeyHashValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[KeyHashToken.prim]) {
+            return semantic[KeyHashToken.prim](val);
+        }
+        return { string: val };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: KeyHashToken.prim,
+            schema: KeyHashToken.prim,
+        };
+    }
+    ToKey({ string, bytes }) {
+        if (string) {
+            return string;
+        }
+        return (0, utils_1.encodeKeyHash)(bytes);
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { string: val },
+            type: { prim: KeyHashToken.prim },
+        };
+    }
+    compare(pkh1, pkh2) {
+        // binary type tag actually reflects the expected prefix order
+        const h1 = (0, utils_1.b58DecodePublicKeyHash)(pkh1, 'array');
+        const h2 = (0, utils_1.b58DecodePublicKeyHash)(pkh2, 'array');
+        return (0, utils_1.compareArrays)(h1, h2);
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (KeyHashToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.KeyHashToken = KeyHashToken;
+KeyHashToken.prim = 'key_hash';

package/dist/lib/taquito-michelson-encoder/src/tokens/comparable/mutez.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.MutezToken = exports.MutezValidationError = 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 Mutez
+ */
+class MutezValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'MutezValidationError';
+    }
+}
+exports.MutezValidationError = MutezValidationError;
+class MutezToken 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: MutezToken.prim,
+            schema: MutezToken.prim,
+        };
+    }
+    /**
+     * @throws {@link MutezValidationError}
+     */
+    validate(val) {
+        const bigNumber = new bignumber_js_1.default(val);
+        if (bigNumber.isNaN()) {
+            throw new MutezValidationError(val, this, `Value is not a number: ${val}`);
+        }
+    }
+    /**
+     * @throws {@link MutezValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { int: String(val).toString() };
+    }
+    /**
+     * @throws {@link MutezValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[MutezToken.prim]) {
+            return semantic[MutezToken.prim](val);
+        }
+        return { int: String(val).toString() };
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { int: String(val) },
+            type: { prim: MutezToken.prim },
+        };
+    }
+    ToKey({ int }) {
+        return int;
+    }
+    compare(mutez1, mutez2) {
+        const o1 = Number(mutez1);
+        const o2 = Number(mutez2);
+        if (o1 === o2) {
+            return 0;
+        }
+        return o1 < o2 ? -1 : 1;
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (MutezToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.MutezToken = MutezToken;
+MutezToken.prim = 'mutez';

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

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatToken = exports.NatValidationError = 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 Nat
+ */
+class NatValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'NatValidationError';
+    }
+}
+exports.NatValidationError = NatValidationError;
+class NatToken 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]]);
+    }
+    /**
+     * @throws {@link NatValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { int: new bignumber_js_1.default(val).toFixed() };
+    }
+    /**
+     * @throws {@link NatValidationError}
+     */
+    validate(val) {
+        const bigNumber = new bignumber_js_1.default(val);
+        if (bigNumber.isNaN()) {
+            throw new NatValidationError(val, this, `Value is not a number: ${JSON.stringify(val)}`);
+        }
+        if (bigNumber.isNegative()) {
+            throw new NatValidationError(val, this, `Value cannot be negative: ${JSON.stringify(val)}`);
+        }
+    }
+    /**
+     * @throws {@link NatValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[NatToken.prim]) {
+            return semantic[NatToken.prim](val);
+        }
+        return { int: new bignumber_js_1.default(val).toFixed() };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: NatToken.prim,
+            schema: NatToken.prim,
+        };
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { int: String(val) },
+            type: { prim: NatToken.prim },
+        };
+    }
+    ToKey({ int }) {
+        return new bignumber_js_1.default(int);
+    }
+    compare(nat1, nat2) {
+        const o1 = Number(nat1);
+        const o2 = Number(nat2);
+        if (o1 === o2) {
+            return 0;
+        }
+        return o1 < o2 ? -1 : 1;
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (NatToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.NatToken = NatToken;
+NatToken.prim = 'nat';

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

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

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampToken = void 0;
+const token_1 = require("../token");
+class TimestampToken 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 && /^\d+$/.test(val.string)) {
+            return new Date(Number(val.string) * 1000).toISOString();
+        }
+        else if (val.string) {
+            return new Date(val.string).toISOString();
+        }
+        else if (val.int) {
+            return new Date(Number(val.int) * 1000).toISOString();
+        }
+    }
+    Encode(args) {
+        const val = args.pop();
+        if (typeof val === 'number') {
+            return { int: String(val) };
+        }
+        else {
+            return { string: val };
+        }
+    }
+    EncodeObject(val, semantic) {
+        if (semantic && semantic[TimestampToken.prim]) {
+            return semantic[TimestampToken.prim](val);
+        }
+        if (typeof val === 'number') {
+            return { int: String(val) };
+        }
+        else {
+            return { string: val };
+        }
+    }
+    generateSchema() {
+        return {
+            __michelsonType: TimestampToken.prim,
+            schema: TimestampToken.prim,
+        };
+    }
+    ToKey({ string }) {
+        return string;
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { string: val },
+            type: { prim: TimestampToken.prim },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (TimestampToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.TimestampToken = TimestampToken;
+TimestampToken.prim = 'timestamp';

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalConstantToken = exports.GlobalConstantDecodingError = exports.GlobalConstantEncodingError = void 0;
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding a Global Constant
+ */
+class GlobalConstantEncodingError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'GlobalConstantEncodingError';
+    }
+}
+exports.GlobalConstantEncodingError = GlobalConstantEncodingError;
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing executing a Global Constant
+ */
+class GlobalConstantDecodingError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'GlobalConstantDecodingError';
+    }
+}
+exports.GlobalConstantDecodingError = GlobalConstantDecodingError;
+class GlobalConstantToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link GlobalConstantDecodingError}
+     */
+    Execute(val, semantic) {
+        if (semantic && semantic[GlobalConstantToken.prim]) {
+            return semantic[GlobalConstantToken.prim](val, this.val);
+        }
+        else {
+            throw new GlobalConstantDecodingError(val, this, `Unable to decode a value represented by a global constants. Please provide an expanded script to the Michelson-Encoder or semantics for the decoding. The following global constant hash was encountered: ${this.val.args[0]['string']}.`);
+        }
+    }
+    /**
+     * @throws {@link GlobalConstantEncodingError}
+     */
+    Encode(args) {
+        throw new GlobalConstantEncodingError(args, this, `Unable to encode a script containing global constants. Please provide an expanded script to the Michelson-Encoder. The following global constant hash was encountered: ${this.val.args[0]['string']}.`);
+    }
+    /**
+     * @throws {@link GlobalConstantEncodingError}
+     */
+    EncodeObject(val, semantic) {
+        if (semantic && semantic[GlobalConstantToken.prim]) {
+            return semantic[GlobalConstantToken.prim](val);
+        }
+        throw new GlobalConstantEncodingError(val, this, `Unable to encode a script containing global constants. Please provide an expanded script to the Michelson-Encoder. The following global constant hash was encountered: ${this.val.args[0]['string']}.`);
+    }
+    generateSchema() {
+        return {
+            __michelsonType: GlobalConstantToken.prim,
+            schema: {
+                hash: this.val.args[0]['string'],
+            },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (GlobalConstantToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.GlobalConstantToken = GlobalConstantToken;
+GlobalConstantToken.prim = 'constant';

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractToken = exports.ContractValidationError = void 0;
+const utils_1 = require("@taquito/utils");
+const token_1 = require("./token");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Contract
+ */
+class ContractValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'ContractValidationError';
+    }
+}
+exports.ContractValidationError = ContractValidationError;
+class ContractToken extends token_1.Token {
+    constructor(val, idx, fac) {
+        super(val, idx, fac);
+        this.val = val;
+        this.idx = idx;
+        this.fac = fac;
+    }
+    /**
+     * @throws {@link ContractValidationError}
+     */
+    validate(value) {
+        if (typeof value !== 'string') {
+            throw new ContractValidationError(value, this, 'Type error');
+        }
+        // tz1,tz2 and tz3 seems to be valid contract values (for Unit contract)
+        if ((0, utils_1.validateAddress)(value) !== utils_1.ValidationResult.VALID) {
+            throw new ContractValidationError(value, this, `Value ${JSON.stringify(value)} is not a valid contract address.`);
+        }
+        return null;
+    }
+    /**
+     * @throws {@link ContractValidationError}
+     */
+    Execute(val) {
+        if (val.string) {
+            return val.string;
+        }
+        if (!val.bytes) {
+            throw new ContractValidationError(val, this, `Value ${JSON.stringify(val)} is not a valid contract address. must contain bytes or string.`);
+        }
+        return (0, utils_1.encodeAddress)(val.bytes);
+    }
+    /**
+     * @throws {@link ContractValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { string: val };
+    }
+    /**
+     * @throws {@link ContractValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[ContractToken.prim]) {
+            return semantic[ContractToken.prim](val);
+        }
+        return { string: val };
+    }
+    generateSchema() {
+        const valueSchema = this.createToken(this.val.args[0], 0);
+        return {
+            __michelsonType: ContractToken.prim,
+            schema: {
+                parameter: this.val.args[0] ? valueSchema.generateSchema() : {},
+            },
+        };
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (ContractToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.ContractToken = ContractToken;
+ContractToken.prim = 'contract';

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTokenError = void 0;
+exports.createToken = createToken;
+const tokens_1 = require("./tokens");
+const pair_1 = require("./pair");
+const core_1 = require("@taquito/core");
+/**
+ *  @category Error
+ *  Error that indicates a script having an invalid type or it being unsupported by the Michelson Encoder. Note some protocol changes might affect this, we encourage users to open an issue so we can look into implementing support for said types.
+ */
+class InvalidTokenError extends core_1.TaquitoError {
+    constructor(message, data) {
+        super(message);
+        this.message = message;
+        this.data = data;
+        this.name = 'Invalid token error';
+    }
+}
+exports.InvalidTokenError = InvalidTokenError;
+/**
+ *
+ * Create a token from a value
+ * @throws {@link InvalidTokenError} If the value passed is not supported by the Michelson Encoder
+ */
+function createToken(val, idx, parentTokenType) {
+    if (Array.isArray(val)) {
+        return new pair_1.PairToken(val, idx, createToken, parentTokenType);
+    }
+    const t = tokens_1.tokens.find((x) => x.prim === val.prim);
+    if (!t) {
+        throw new InvalidTokenError(`Malformed data: ${JSON.stringify(val)}. Expected a value with a valid prim property`, val);
+    }
+    return new t(val, idx, createToken, parentTokenType);
+}

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyToken = exports.KeyValidationError = void 0;
+const token_1 = require("./token");
+const utils_1 = require("@taquito/utils");
+const signer_1 = require("@taquito/signer");
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Key
+ */
+class KeyValidationError extends token_1.TokenValidationError {
+    constructor(value, token, message) {
+        super(value, token, message);
+        this.value = value;
+        this.token = token;
+        this.name = 'KeyValidationError';
+    }
+}
+exports.KeyValidationError = KeyValidationError;
+class KeyToken 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;
+        }
+        return (0, utils_1.encodeKey)(val.bytes);
+    }
+    /**
+     * @throws {@link KeyValidationError}
+     */
+    validate(value) {
+        if ((0, utils_1.validatePublicKey)(value) !== utils_1.ValidationResult.VALID) {
+            throw new KeyValidationError(value, this, 'Key is not valid');
+        }
+    }
+    /**
+     * @throws {@link KeyValidationError}
+     */
+    Encode(args) {
+        const val = args.pop();
+        this.validate(val);
+        return { string: val };
+    }
+    /**
+     * @throws {@link KeyValidationError}
+     */
+    EncodeObject(val, semantic) {
+        this.validate(val);
+        if (semantic && semantic[KeyToken.prim]) {
+            return semantic[KeyToken.prim](val);
+        }
+        return { string: val };
+    }
+    generateSchema() {
+        return {
+            __michelsonType: KeyToken.prim,
+            schema: KeyToken.prim,
+        };
+    }
+    ToKey(val) {
+        return this.Execute(val);
+    }
+    ToBigMapKey(val) {
+        return {
+            key: { string: val },
+            type: { prim: KeyToken.prim },
+        };
+    }
+    compare(key1, key2) {
+        const publicKey1 = (0, signer_1.publicKeyFromString)(key1);
+        const publicKey2 = (0, signer_1.publicKeyFromString)(key2);
+        const bytes1 = publicKey1.toProtocol();
+        const bytes2 = publicKey2.toProtocol();
+        if (bytes1[0] === bytes2[0]) {
+            return publicKey1.compare(publicKey2);
+        }
+        else if (bytes1[0] > bytes2[0]) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    findAndReturnTokens(tokenToFind, tokens) {
+        if (KeyToken.prim === tokenToFind) {
+            tokens.push(this);
+        }
+        return tokens;
+    }
+}
+exports.KeyToken = KeyToken;
+KeyToken.prim = 'key';