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

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

@@ -1,48 +0,0 @@
-import { ContractTokenSchema } from '../schema/types';
-import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a Contract
- */
-export declare class ContractValidationError extends TokenValidationError {
-    value: any;
-    token: ContractToken;
-    name: string;
-    constructor(value: any, token: ContractToken, message: string);
-}
-export declare class ContractToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'contract';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    /**
-     * @throws {@link ContractValidationError}
-     */
-    private validate;
-    /**
-     * @throws {@link ContractValidationError}
-     */
-    Execute(val: {
-        bytes: string;
-        string: string;
-    }): string;
-    /**
-     * @throws {@link ContractValidationError}
-     */
-    Encode(args: any[]): any;
-    /**
-     * @throws {@link ContractValidationError}
-     */
-    EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    generateSchema(): ContractTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,18 +0,0 @@
-import { Token } from './token';
-import { TaquitoError } from '@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.
- */
-export declare class InvalidTokenError extends TaquitoError {
-    message: string;
-    data: any;
-    name: string;
-    constructor(message: string, data: any);
-}
-/**
- *
- * Create a token from a value
- * @throws {@link InvalidTokenError} If the value passed is not supported by the Michelson Encoder
- */
-export declare function createToken(val: any, idx: number, parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined): Token;

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

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

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

@@ -1,24 +0,0 @@
-import { LambdaTokenSchema } from '../schema/types';
-import { SemanticEncoding, Token, TokenFactory } from './token';
-export declare class LambdaToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'lambda';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    get paramSchema(): Token;
-    get returnSchema(): Token;
-    Execute(val: any): any;
-    Encode(args: any[]): any;
-    EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    generateSchema(): LambdaTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,46 +0,0 @@
-import { ListTokenSchema } from '../schema/types';
-import { Token, TokenFactory, Semantic, TokenValidationError, SemanticEncoding } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a List
- */
-export declare class ListValidationError extends TokenValidationError {
-    value: any;
-    token: ListToken;
-    name: string;
-    constructor(value: any, token: ListToken, message: string);
-}
-export declare class ListToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'list';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    get valueSchema(): Token;
-    /**
-     * @throws {@link ListValidationError}
-     */
-    private validate;
-    /**
-     * @throws {@link ListValidationError}
-     */
-    Encode(args: any[]): any;
-    /**
-     * @throws {@link ListValidationError}
-     */
-    Execute(val: any, semantics?: Semantic): any;
-    /**
-     * @throws {@link ListValidationError}
-     */
-    EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    generateSchema(): ListTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,47 +0,0 @@
-import { MapTokenSchema } from '../schema/types';
-import { ComparableToken, Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a Map
- */
-export declare class MapValidationError extends TokenValidationError {
-    value: any;
-    token: MapToken;
-    name: string;
-    constructor(value: any, token: MapToken, message: string);
-}
-export declare class MapToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'map';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    get ValueSchema(): Token;
-    get KeySchema(): ComparableToken;
-    /**
-     * @throws {@link MapValidationError}
-     */
-    validate(value: any): void;
-    Execute(val: any[], semantics?: Semantic): {
-        [key: string]: any;
-    };
-    private objLitToMichelsonMap;
-    /**
-     * @throws {@link MapValidationError}
-     */
-    Encode(args: any[]): any;
-    /**
-     * @throws {@link MapValidationError}
-     */
-    EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    generateSchema(): MapTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,41 +0,0 @@
-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 Never Token
- */
-export declare class NeverTokenError extends TokenValidationError {
-    value: any;
-    token: NeverToken;
-    name: string;
-    constructor(value: any, token: NeverToken, message: string);
-}
-export declare class NeverToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'never';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    /**
-     * @throws {@link NeverTokenError}
-     */
-    Encode(args: any[]): any;
-    /**
-     * @throws {@link NeverTokenError}
-     */
-    EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @throws {@link NeverTokenError}
-     */
-    Execute(val: any): void;
-    generateSchema(): BaseTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

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

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

@@ -1,37 +0,0 @@
-import { OptionTokenSchema } from '../schema/types';
-import { Token, TokenFactory, Semantic, ComparableToken, SemanticEncoding } from './token';
-export declare class OptionToken extends ComparableToken {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'option';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    subToken(): Token;
-    schema(): Token;
-    annot(): string;
-    Encode(args: any): any;
-    EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    Execute(val: any, semantics?: Semantic): {
-        Some: any;
-    } | null;
-    generateSchema(): OptionTokenSchema;
-    ExtractSignature(): import("../schema/types").TokenSchema[][];
-    get KeySchema(): ComparableToken;
-    compare(val1: any, val2: any): number;
-    ToKey(val: any): {
-        Some: any;
-    } | null;
-    ToBigMapKey(val: any): {
-        key: any;
-        type: Omit<import("@taquito/rpc").MichelsonV1ExpressionExtended, "annots">;
-    };
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,53 +0,0 @@
-import { OrTokenSchema } from '../schema/types';
-import { Token, TokenFactory, Semantic, ComparableToken, SemanticEncoding, TokenValidationError } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing an OrToken
- */
-export declare class OrValidationError extends TokenValidationError {
-    value: any;
-    token: OrToken;
-    name: string;
-    constructor(value: any, token: OrToken, message: string);
-}
-export declare class OrToken extends ComparableToken {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    protected parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined;
-    static prim: 'or';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory, parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined);
-    Encode(args: any[]): any;
-    ExtractSignature(): any;
-    /**
-     * @throws {@link OrValidationError}
-     */
-    EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    /**
-     * @throws {@link OrValidationError}
-     */
-    private validateJavascriptObject;
-    /**
-     * @throws {@link OrValidationError}
-     */
-    Execute(val: any, semantics?: Semantic): any;
-    private traversal;
-    generateSchema(): OrTokenSchema;
-    private findToken;
-    compare(val1: any, val2: any): any;
-    ToKey(val: any): any;
-    ToBigMapKey(val: any): {
-        key: any;
-        type: Omit<import("@taquito/rpc").MichelsonV1ExpressionExtended, "annots">;
-    };
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-    protected getIdxForChildren(): number;
-}

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

@@ -1,50 +0,0 @@
-import { Token, TokenFactory, Semantic, ComparableToken, SemanticEncoding } from './token';
-import { PairTokenSchema } from '../schema/types';
-import { MichelsonV1Expression, MichelsonV1ExpressionExtended } from '@taquito/rpc';
-import { TaquitoError } from '@taquito/core';
-/**
- *  @category Error
- *  Error that indicates in invalid token argument being passed
- */
-export declare class TokenArgumentValidationError extends TaquitoError {
-    message: string;
-    name: string;
-    constructor(message: string);
-}
-/**
- *  @category Error
- *  Error that indicates a failure occurring when doing a comparison of tokens
- */
-export declare class TokenComparisonError extends TaquitoError {
-    val1: string;
-    val2: string;
-    name: string;
-    constructor(val1: string, val2: string);
-}
-export declare class PairToken extends ComparableToken {
-    static prim: 'pair';
-    constructor(val: MichelsonV1Expression, idx: number, fac: TokenFactory, parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined);
-    private args;
-    private tokens;
-    Encode(args: any[]): any;
-    ExtractSignature(): any;
-    ToBigMapKey(val: any): {
-        key: any;
-        type: Omit<MichelsonV1ExpressionExtended, "annots">;
-    };
-    ToKey(val: any): {
-        [key: string]: any;
-    };
-    EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    private traversal;
-    Execute(val: any, semantics?: Semantic): {
-        [key: string]: any;
-    };
-    generateSchema(): PairTokenSchema;
-    /**
-     * @throws {@link TokenComparisonError}
-     */
-    compare(val1: any, val2: any): number;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-    protected getIdxForChildren(): number;
-}

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

@@ -1,44 +0,0 @@
-import { SaplingStateTokenSchema } from '../schema/types';
-import { Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a Sapling State
- */
-export declare class SaplingStateValidationError extends TokenValidationError {
-    value: any;
-    token: SaplingStateToken;
-    name: string;
-    constructor(value: any, token: SaplingStateToken, message: string);
-}
-export declare class SaplingStateToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'sapling_state';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    private isValid;
-    /**
-     * @throws {@link SaplingStateValidationError}
-     */
-    Execute(val: {
-        int: string;
-    }, semantic?: Semantic): any;
-    /**
-     * @throws {@link SaplingStateValidationError}
-     */
-    Encode(args: any[]): any;
-    /**
-     * @throws {@link SaplingStateValidationError}
-     */
-    EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    generateSchema(): SaplingStateTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

package/dist/types/taquito-michelson-encoder/src/tokens/sapling-transaction-deprecated.d.ts

@@ -1,40 +0,0 @@
-import { SaplingTransactionDeprecatedTokenSchema } from '../schema/types';
-import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction Deprecated
- */
-export declare class SaplingTransactionDeprecatedValidationError extends TokenValidationError {
-    value: any;
-    token: SaplingTransactionDeprecatedToken;
-    name: string;
-    constructor(value: any, token: SaplingTransactionDeprecatedToken, message: string);
-}
-export declare class SaplingTransactionDeprecatedToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'sapling_transaction_deprecated';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    /**
-     * @throws {@link SaplingTransactionDeprecatedValidationError}
-     */
-    Execute(_val: any): void;
-    /**
-     * @throws {@link SaplingTransactionDeprecatedValidationError}
-     */
-    private validateBytes;
-    private convertUint8ArrayToHexString;
-    Encode(args: any[]): any;
-    EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
-    generateSchema(): SaplingTransactionDeprecatedTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,40 +0,0 @@
-import { SaplingTransactionTokenSchema } from '../schema/types';
-import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction
- */
-export declare class SaplingTransactionValidationError extends TokenValidationError {
-    value: any;
-    token: SaplingTransactionToken;
-    name: string;
-    constructor(value: any, token: SaplingTransactionToken, message: string);
-}
-export declare class SaplingTransactionToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'sapling_transaction';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    /**
-     * @throws {@link SaplingTransactionValidationError}
-     */
-    Execute(_val: any): void;
-    /**
-     * @throws {@link SaplingTransactionValidationError}
-     */
-    private validateBytes;
-    private convertUint8ArrayToHexString;
-    Encode(args: any[]): any;
-    EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
-    generateSchema(): SaplingTransactionTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,43 +0,0 @@
-import { SetTokenSchema } from '../schema/types';
-import { Token, TokenFactory, Semantic, TokenValidationError, ComparableToken, SemanticEncoding } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing a Set
- */
-export declare class SetValidationError extends TokenValidationError {
-    value: any;
-    token: SetToken;
-    name: string;
-    constructor(value: any, token: SetToken, message: string);
-}
-export declare class SetToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'set';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    get KeySchema(): ComparableToken;
-    /**
-     * @throws {@link SetValidationError}
-     */
-    private validate;
-    /**
-     * @throws {@link SetValidationError}
-     */
-    Encode(args: any[]): any;
-    Execute(val: any, semantics?: Semantic): any;
-    /**
-     * @throws {@link SetValidationError}
-     */
-    EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    generateSchema(): SetTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

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