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

package/dist/types/taquito-michelson-encoder/src/tokens/bls12-381-g2.d.ts

@@ -0,0 +1,47 @@
+import { BaseTokenSchema } from '../schema/types';
+import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a BLS12-381 curve G2
+ */
+export declare class Bls12381g2ValidationError extends TokenValidationError {
+    value: any;
+    token: Bls12381g2Token;
+    name: string;
+    constructor(value: any, token: Bls12381g2Token, message: string);
+}
+export declare class Bls12381g2Token extends Token {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'bls12_381_g2';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    /**
+     * @throws {@link Bls12381g2ValidationError}
+     */
+    private validate;
+    private convertUint8ArrayToHexString;
+    /**
+     * @throws {@link Bls12381g2ValidationError}
+     */
+    Encode(args: any[]): {
+        bytes: any;
+    };
+    /**
+     * @throws {@link Bls12381g2ValidationError}
+     */
+    EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
+        bytes: string | Uint8Array<ArrayBufferLike>;
+    };
+    Execute(val: any): string;
+    generateSchema(): BaseTokenSchema;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/chain-id.d.ts

@@ -0,0 +1,51 @@
+import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEncoding } from './token';
+import { BaseTokenSchema } from '../schema/types';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a ChainID
+ */
+export declare class ChainIDValidationError extends TokenValidationError {
+    value: any;
+    token: ChainIDToken;
+    name: string;
+    constructor(value: any, token: ChainIDToken, message: string);
+}
+export declare class ChainIDToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'chain_id';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    /**
+     * @throws {@link ChainIDValidationError}
+     */
+    private validate;
+    Execute(val: any): string;
+    generateSchema(): BaseTokenSchema;
+    /**
+     * @throws {@link ChainIDValidationError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link ChainIDValidationError}
+     */
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    ToKey({ string }: any): any;
+    ToBigMapKey(val: string): {
+        key: {
+            string: string;
+        };
+        type: {
+            prim: "chain_id";
+        };
+    };
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/chest-key.d.ts

@@ -0,0 +1,47 @@
+import { BaseTokenSchema } from '../schema/types';
+import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Chest Key
+ */
+export declare class ChestKeyValidationError extends TokenValidationError {
+    value: any;
+    token: ChestKeyToken;
+    name: string;
+    constructor(value: any, token: ChestKeyToken, message: string);
+}
+export declare class ChestKeyToken extends Token {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'chest_key';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    private validate;
+    private convertUint8ArrayToHexString;
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    Encode(args: any[]): {
+        bytes: any;
+    };
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
+        bytes: string | Uint8Array<ArrayBufferLike>;
+    };
+    Execute(val: any): string;
+    generateSchema(): BaseTokenSchema;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/chest.d.ts

@@ -0,0 +1,47 @@
+import { BaseTokenSchema } from '../schema/types';
+import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing a Chest
+ */
+export declare class ChestValidationError extends TokenValidationError {
+    value: any;
+    token: ChestToken;
+    name: string;
+    constructor(value: any, token: ChestToken, message: string);
+}
+export declare class ChestToken extends Token {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'chest';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    private validate;
+    private convertUint8ArrayToHexString;
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    Encode(args: any[]): {
+        bytes: any;
+    };
+    /**
+     * @throws {@link ChestKeyValidationError}
+     */
+    EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
+        bytes: string | Uint8Array<ArrayBufferLike>;
+    };
+    Execute(val: any): string;
+    generateSchema(): BaseTokenSchema;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/address.d.ts

@@ -0,0 +1,61 @@
+import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEncoding } from '../token';
+import { BaseTokenSchema } from '../../schema/types';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing an Address
+ */
+export declare class AddressValidationError extends TokenValidationError {
+    value: any;
+    token: AddressToken;
+    name: string;
+    constructor(value: any, token: AddressToken, message: string);
+}
+export declare class AddressToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'address';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    ToBigMapKey(val: any): {
+        key: {
+            bytes: string;
+        };
+        type: {
+            prim: string;
+        };
+    };
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    private validate;
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    Execute(val: {
+        bytes: string;
+        string: string;
+    }): string;
+    generateSchema(): BaseTokenSchema;
+    /**
+     * @throws {@link AddressValidationError}
+     */
+    ToKey({ bytes, string }: any): any;
+    compare(address1: string, address2: string): number;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/bool.d.ts

@@ -0,0 +1,32 @@
+import { BaseTokenSchema } from '../../schema/types';
+import { Token, TokenFactory, ComparableToken, SemanticEncoding } from '../token';
+export declare class BoolToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'bool';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Execute(val: any): boolean;
+    Encode(args: any[]): any;
+    EncodeObject(val: any, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
+    generateSchema(): BaseTokenSchema;
+    ToBigMapKey(val: string): {
+        key: {
+            [key: string]: string;
+        };
+        type: {
+            prim: string;
+        };
+    };
+    ToKey(val: string): import("@taquito/rpc").MichelsonV1Expression;
+    compare(val1: any, val2: any): 0 | 1 | -1;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/bytes.d.ts

@@ -0,0 +1,52 @@
+import { BaseTokenSchema } from '../../schema/types';
+import { TokenFactory, ComparableToken, TokenValidationError, Token, SemanticEncoding } from '../token';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing Bytes
+ */
+export declare class BytesValidationError extends TokenValidationError {
+    value: any;
+    token: BytesToken;
+    name: string;
+    constructor(value: any, token: BytesToken, message: string);
+}
+export declare class BytesToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'bytes';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    ToBigMapKey(val: string): {
+        key: {
+            bytes: string;
+        };
+        type: {
+            prim: "bytes";
+        };
+    };
+    /**
+     * @throws {@link BytesValidationError}
+     */
+    private validate;
+    private convertUint8ArrayToHexString;
+    /**
+     * @throws {@link BytesValidationError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link BytesValidationError}
+     */
+    EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
+    Execute(val: any): string;
+    generateSchema(): BaseTokenSchema;
+    ToKey({ bytes, string }: any): any;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/int.d.ts

@@ -0,0 +1,56 @@
+import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEncoding } from '../token';
+import { BaseTokenSchema } from '../../schema/types';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing Int
+ */
+export declare class IntValidationError extends TokenValidationError {
+    value: any;
+    token: IntToken;
+    name: string;
+    constructor(value: any, token: IntToken, message: string);
+}
+export declare class IntToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'int';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Execute(val: {
+        [key: string]: string;
+    }): {
+        [key: string]: any;
+    };
+    generateSchema(): BaseTokenSchema;
+    /**
+     * @throws {@link IntValidationError}
+     */
+    private validate;
+    /**
+     * @throws {@link IntValidationError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link IntValidationError}
+     */
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    ToBigMapKey(val: string | number): {
+        key: {
+            int: string;
+        };
+        type: {
+            prim: "int";
+        };
+    };
+    ToKey({ int }: any): any;
+    compare(int1: string | number, int2: string | number): 0 | 1 | -1;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/key_hash.d.ts

@@ -0,0 +1,55 @@
+import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEncoding } from '../token';
+import { BaseTokenSchema } from '../../schema/types';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing Key Hash
+ */
+export declare class KeyHashValidationError extends TokenValidationError {
+    value: any;
+    token: KeyHashToken;
+    name: string;
+    constructor(value: any, token: KeyHashToken, message: string);
+}
+export declare class KeyHashToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'key_hash';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Execute(val: {
+        bytes: string;
+        string: string;
+    }): string;
+    /**
+     * @throws {@link KeyHashValidationError}
+     */
+    private validate;
+    /**
+     * @throws {@link KeyHashValidationError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link KeyHashValidationError}
+     */
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    generateSchema(): BaseTokenSchema;
+    ToKey({ string, bytes }: any): any;
+    ToBigMapKey(val: string): {
+        key: {
+            string: string;
+        };
+        type: {
+            prim: "key_hash";
+        };
+    };
+    compare(pkh1: string, pkh2: string): number;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/mutez.d.ts

@@ -0,0 +1,53 @@
+import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEncoding } from '../token';
+import BigNumber from 'bignumber.js';
+import { BaseTokenSchema } from '../../schema/types';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing Mutez
+ */
+export declare class MutezValidationError extends TokenValidationError {
+    value: any;
+    token: MutezToken;
+    name: string;
+    constructor(value: any, token: MutezToken, message: string);
+}
+export declare class MutezToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'mutez';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Execute(val: any): BigNumber;
+    generateSchema(): BaseTokenSchema;
+    /**
+     * @throws {@link MutezValidationError}
+     */
+    private validate;
+    /**
+     * @throws {@link MutezValidationError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link MutezValidationError}
+     */
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    ToBigMapKey(val: string | number): {
+        key: {
+            int: string;
+        };
+        type: {
+            prim: "mutez";
+        };
+    };
+    ToKey({ int }: any): any;
+    compare(mutez1: string | number, mutez2: string | number): 0 | 1 | -1;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/nat.d.ts

@@ -0,0 +1,55 @@
+import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEncoding } from '../token';
+import BigNumber from 'bignumber.js';
+import { BaseTokenSchema } from '../../schema/types';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding/executing Nat
+ */
+export declare class NatValidationError extends TokenValidationError {
+    value: any;
+    token: NatToken;
+    name: string;
+    constructor(value: any, token: NatToken, message: string);
+}
+export declare class NatToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'nat';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Execute(val: any): {
+        [key: string]: any;
+    };
+    /**
+     * @throws {@link NatValidationError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link NatValidationError}
+     */
+    private validate;
+    /**
+     * @throws {@link NatValidationError}
+     */
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    generateSchema(): BaseTokenSchema;
+    ToBigMapKey(val: string | number): {
+        key: {
+            int: string;
+        };
+        type: {
+            prim: "nat";
+        };
+    };
+    ToKey({ int }: any): BigNumber;
+    compare(nat1: string | number, nat2: string | number): 0 | 1 | -1;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/string.d.ts

@@ -0,0 +1,31 @@
+import { BaseTokenSchema } from '../../schema/types';
+import { Token, TokenFactory, ComparableToken, SemanticEncoding } from '../token';
+export declare class StringToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'string';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Execute(val: any): string;
+    generateSchema(): BaseTokenSchema;
+    Encode(args: any[]): any;
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    ToKey({ string }: any): any;
+    ToBigMapKey(val: string): {
+        key: {
+            string: string;
+        };
+        type: {
+            prim: "string";
+        };
+    };
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/comparable/timestamp.d.ts

@@ -0,0 +1,34 @@
+import { BaseTokenSchema } from '../../schema/types';
+import { Token, TokenFactory, ComparableToken, SemanticEncoding } from '../token';
+export declare class TimestampToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'timestamp';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Execute(val: {
+        string?: string;
+        int?: string;
+    }): string | undefined;
+    Encode(args: any[]): any;
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    generateSchema(): BaseTokenSchema;
+    ToKey({ string }: any): any;
+    ToBigMapKey(val: string): {
+        key: {
+            string: string;
+        };
+        type: {
+            prim: "timestamp";
+        };
+    };
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/constant.d.ts

@@ -0,0 +1,51 @@
+import { ConstantTokenSchema } from '../schema/types';
+import { Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing encoding a Global Constant
+ */
+export declare class GlobalConstantEncodingError extends TokenValidationError {
+    value: any;
+    token: GlobalConstantToken;
+    name: string;
+    constructor(value: any, token: GlobalConstantToken, message: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates a failure happening when parsing executing a Global Constant
+ */
+export declare class GlobalConstantDecodingError extends TokenValidationError {
+    value: any;
+    token: GlobalConstantToken;
+    name: string;
+    constructor(value: any, token: GlobalConstantToken, message: string);
+}
+export declare class GlobalConstantToken extends Token {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots?: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'constant';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots?: any[];
+    }, idx: number, fac: TokenFactory);
+    /**
+     * @throws {@link GlobalConstantDecodingError}
+     */
+    Execute(val: any, semantic?: Semantic): any;
+    /**
+     * @throws {@link GlobalConstantEncodingError}
+     */
+    Encode(args: any[]): any;
+    /**
+     * @throws {@link GlobalConstantEncodingError}
+     */
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    generateSchema(): ConstantTokenSchema;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}