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

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

@@ -1,82 +0,0 @@
-import { MichelsonV1Expression } from '@taquito/rpc';
-import { TaquitoError } from '@taquito/core';
-/**
- *  @category Error
- *  Error that indicates an invalid map type being passed or used
- */
-export declare class InvalidMapTypeError extends TaquitoError {
-    readonly mapType: any;
-    readonly reason: string;
-    constructor(mapType: any, reason: string);
-}
-declare const michelsonMapTypeSymbol: unique symbol;
-export type MichelsonMapKey = Array<any> | object | string | boolean | number | null;
-/**
- *  @category Error
- *  Error that indicates a map type mismatch, where an attempt to set a key or value in a Map doesn't match the defined type of the Map
- */
-export declare class MapTypecheckError extends TaquitoError {
-    readonly value: any;
-    readonly type: any;
-    readonly reason: any;
-    name: string;
-    constructor(value: any, type: any, objectType: 'key' | 'value', reason: any);
-}
-/**
- * Michelson Map is an abstraction over the michelson native map. It supports complex Pair as key
- */
-export declare class MichelsonMap<K extends MichelsonMapKey, T> {
-    private valueMap;
-    private keyMap;
-    [michelsonMapTypeSymbol]: boolean;
-    static isMichelsonMap(obj: any): obj is MichelsonMap<any, any>;
-    private keySchema?;
-    private valueSchema?;
-    /**
-     * @param mapType If specified key and value will be type-checked before being added to the map
-     *
-     * @example new MichelsonMap({ prim: "map", args: [{prim: "string"}, {prim: "int"}]})
-     */
-    constructor(mapType?: MichelsonV1Expression);
-    setType(mapType: MichelsonV1Expression): void;
-    removeType(): void;
-    static fromLiteral(obj: {
-        [key: string]: any;
-    }, mapType?: MichelsonV1Expression): MichelsonMap<MichelsonMapKey, unknown>;
-    private typecheckKey;
-    private typecheckValue;
-    /**
-     * @throws {@link MapTypecheckError} when the argument passed does not match the expected schema for value
-     */
-    private assertTypecheckValue;
-    /**
-     * @throws {@link MapTypecheckError} when the argument passed does not match the expected schema for key
-     */
-    private assertTypecheckKey;
-    private serializeDeterministically;
-    keys(): Generator<K>;
-    values(): Generator<T>;
-    entries(): Generator<[K, T]>;
-    get(key: K): T | undefined;
-    /**
-     *
-     * Set a key and a value in the MichelsonMap. If the key already exists, override the current value.
-     *
-     * @example map.set("myKey", "myValue") // Using a string as key
-     *
-     * @example map.set({0: "test", 1: "test1"}, "myValue") // Using a pair as key
-     *
-     * @remarks The same key can be represented in multiple ways, depending on the type of the key. This duplicate key situation will cause a runtime error (duplicate key) when sending the map data to the Tezos RPC node.
-     *
-     * For example, consider a contract with a map whose key is of type boolean.  If you set the following values in MichelsonMap: map.set(false, "myValue") and map.set(null, "myValue").
-     *
-     * You will get two unique entries in the MichelsonMap. These values will both be evaluated as falsy by the MichelsonEncoder and ultimately rejected by the Tezos RPC.
-     */
-    set(key: K, value: T): void;
-    delete(key: K): void;
-    has(key: K): boolean;
-    clear(): void;
-    get size(): number;
-    forEach(cb: (value: T, key: K, map: MichelsonMap<K, T>) => void): void;
-}
-export {};

package/dist/types/taquito-michelson-encoder/src/schema/errors.d.ts

@@ -1,83 +0,0 @@
-import { InvalidViewParameterError, TaquitoError } from '@taquito/core';
-/**
- *  @category Error
- *  Error that indicates a failure when encoding (transforming JS parameter into JSON Michelson) the parameter of the view
- */
-export declare class ParameterEncodingError extends InvalidViewParameterError {
-    readonly viewName: string;
-    readonly sigs: any;
-    readonly args: any;
-    readonly cause?: any | undefined;
-    constructor(viewName: string, sigs: any, args: any, cause?: any | undefined);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid on-chain view found on the script
- */
-export declare class InvalidScriptError extends TaquitoError {
-    readonly script: any;
-    readonly reason?: string | undefined;
-    name: string;
-    constructor(script: any, reason?: string | undefined);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid RPC response being passed or used
- */
-export declare class InvalidRpcResponseError extends TaquitoError {
-    readonly script: any;
-    readonly reason?: string | undefined;
-    name: string;
-    constructor(script: any, reason?: string | undefined);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid big map schema being passed or used
- */
-export declare class InvalidBigMapSchemaError extends TaquitoError {
-    message: string;
-    name: string;
-    constructor(message: string);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid big map diff being passed or used
- */
-export declare class InvalidBigMapDiffError extends TaquitoError {
-    message: string;
-    readonly value: any;
-    name: string;
-    constructor(message: string, value: any);
-}
-/**
- *  @category Error
- *  Error that indicates a failure when trying to encode big maps
- */
-export declare class BigMapEncodingError extends TaquitoError {
-    readonly details: any;
-    readonly schema: any;
-    readonly value: any;
-    name: string;
-    constructor(obj: 'key' | 'value', details: any, schema: any, value: any);
-}
-/**
- *  @category Error
- *  Error that indicates a failure when trying to encode storage
- */
-export declare class StorageEncodingError extends TaquitoError {
-    details: any;
-    readonly schema: any;
-    readonly value: any;
-    readonly semantics?: any | undefined;
-    name: string;
-    constructor(obj: string, details: any, schema: any, value: any, semantics?: any | undefined);
-}
-/**
- *  @category Error
- *  General error that indicates a function not being passed a necessary argument
- */
-export declare class MissingArgumentError extends TaquitoError {
-    message: string;
-    name: string;
-    constructor(message: string);
-}

package/dist/types/taquito-michelson-encoder/src/schema/event-schema.d.ts

@@ -1,12 +0,0 @@
-import { MichelsonV1Expression, MichelsonV1ExpressionExtended, ScriptResponse } from '@taquito/rpc';
-export declare class EventSchema {
-    readonly tag?: string | undefined;
-    readonly type?: MichelsonV1ExpressionExtended | undefined;
-    constructor(tag?: string | undefined, type?: MichelsonV1ExpressionExtended | undefined);
-    static fromMichelineValue(val: MichelsonV1ExpressionExtended): EventSchema;
-    static fromRPCResponse(val: {
-        script: ScriptResponse;
-    }): EventSchema[];
-    static removeDuplicates(events: EventSchema[]): EventSchema[];
-    static extractEventsRecursively(code: MichelsonV1Expression): EventSchema[];
-}

package/dist/types/taquito-michelson-encoder/src/schema/parameter.d.ts

@@ -1,54 +0,0 @@
-import { Semantic, SemanticEncoding } from '../tokens/token';
-import { ScriptResponse, MichelsonV1Expression } from '@taquito/rpc';
-import { TokenSchema } from './types';
-/**
- * @remarks Our current smart contract abstraction feature is currently in preview. It's API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
- */
-export declare class ParameterSchema {
-    private root;
-    /**
-     *
-     * Create an instance of ParameterSchema from a contract script
-     *
-     * @param val contract script obtained from the RPC
-     * @returns ParameterSchema
-     * @throws {InvalidRpcResponseError} If the RPC response is invalid
-     */
-    static fromRPCResponse(val: {
-        script: ScriptResponse;
-    }): ParameterSchema;
-    /**
-     * Check if the Contract parameter is multiple entry point or not
-     */
-    get isMultipleEntryPoint(): boolean;
-    /**
-     * Check if the Contract parameter has an annotation or not
-     */
-    get hasAnnotation(): boolean;
-    /**
-     * Return the schema of the parameter of a specific entry point
-     * @throws InvalidTokenError
-     */
-    constructor(val: MichelsonV1Expression);
-    /**
-     * Returns the javascript object equivalent of the Micheline value provided
-     */
-    Execute(val: any, semantics?: Semantic): any;
-    /**
-     * Returns a micheline formatted object for the values provided
-     * @throws TokenValidationError
-     * @throws {@link ParameterEncodingError}
-     */
-    Encode(...args: any[]): any;
-    /**
-     * Returns a micheline formatted object for the javascript object provided
-     * @throws TokenValidationError
-     * @throws {@link ParameterEncodingError}
-     */
-    EncodeObject(value?: any, semantics?: SemanticEncoding): any;
-    /**
-     * Produce a schema grouping together all the entry points of a contract.
-     */
-    generateSchema(): TokenSchema;
-    ExtractSignatures(): TokenSchema[][];
-}

package/dist/types/taquito-michelson-encoder/src/schema/storage.d.ts

@@ -1,97 +0,0 @@
-import { MichelsonV1Expression, ScriptResponse } from '@taquito/rpc';
-import { BigMapKeyType, Semantic, SemanticEncoding, Token } from '../tokens/token';
-import { TokenSchema } from './types';
-declare const schemaTypeSymbol: unique symbol;
-export declare function deepEqual(a: MichelsonV1Expression | undefined, b: MichelsonV1Expression | undefined): boolean;
-/**
- * @remarks Our current smart contract abstraction feature is currently in preview. Its API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
- */
-export declare class Schema {
-    readonly val: MichelsonV1Expression;
-    private root;
-    [schemaTypeSymbol]: boolean;
-    static isSchema(obj: Schema): boolean;
-    private bigMap?;
-    /**
-     * @throws {@link InvalidRpcResponseError}
-     */
-    static fromRPCResponse(val: {
-        script: ScriptResponse;
-    }): Schema;
-    private isExpressionExtended;
-    constructor(val: MichelsonV1Expression);
-    private removeTopLevelAnnotation;
-    Execute(val: any, semantics?: Semantic): any;
-    /**
-     * Validates that a value matches the schema type.
-     * Performs type checking with special handling for BigMap, Ticket, and nested Map tokens.
-     *
-     * @param val - The value to validate against the schema
-     * @returns Returns true if validation passes, false if validation fails
-     */
-    Typecheck(val: any): boolean;
-    /**
-     * @throws {@link InvalidBigMapSchemaError}
-     * @throws {@link InvalidBigMapDiffError}
-     */
-    ExecuteOnBigMapDiff(diff: any[], semantics?: Semantic): any;
-    /**
-     * @throws {@link InvalidBigMapSchemaError}
-     */
-    ExecuteOnBigMapValue(key: any, semantics?: Semantic): any;
-    /**
-     * @throws {@link InvalidBigMapSchemaError}
-     * @throws {@link BigMapEncodingError}
-     */
-    EncodeBigMapKey(key: BigMapKeyType): {
-        key: {
-            [key: string]: string | object[];
-        };
-        type: {
-            prim: string;
-            args?: object[];
-        };
-    };
-    /**
-     * @throws TokenValidationError
-     * @throws {@link StorageEncodingError}
-     */
-    Encode(value?: any, semantics?: SemanticEncoding): any;
-    /**
-     * Produce a representation of the storage schema.
-     * Note: Provide guidance on how to write the storage object for the origination operation with Taquito.
-     */
-    generateSchema(): TokenSchema;
-    /**
-     * Look up in top-level pairs of the storage to find a value matching the specified type
-     *
-     * @returns The first value found that match the type or `undefined` if no value is found
-     *
-     * @param storage storage to parse to find the value
-     * @param valueType type of value to look for
-     *
-     */
-    FindFirstInTopLevelPair<T extends MichelsonV1Expression>(storage: any, valueType: any): T | undefined;
-    /**
-     * @throws {@link MissingArgumentError}
-     */
-    private findValue;
-    /**
-     * Look up the schema to find any occurrence of a particular token.
-     *
-     * @returns an array of tokens of the specified kind or an empty array if no token was found
-     *
-     * @param tokenToFind string representing the prim property of the token to find
-     *
-     * @example
-     * ```
-     * Useful to find all global constants in a script, an array of GlobalConstantToken is returned:
-     *
-     * const schema = new Schema(script);
-     * const allGlobalConstantTokens = schema.findToken('constant');
-     * ```
-     *
-     */
-    findToken(tokenToFind: string): Array<Token>;
-}
-export {};

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

@@ -1,105 +0,0 @@
-export type Falsy<T> = T | undefined | false;
-export type BaseTokenSchema = {
-    __michelsonType: 'address' | 'bool' | 'bytes' | 'int' | 'key' | 'key_hash' | 'mutez' | 'nat' | 'string' | 'timestamp' | 'bls12_381_fr' | 'bls12_381_g1' | 'bls12_381_g2' | 'chain_id' | 'never' | 'operation' | 'chest' | 'chest_key' | 'signature' | 'unit';
-    schema: string;
-};
-export type OrTokenSchema = {
-    __michelsonType: 'or';
-    schema: Record<string, TokenSchema>;
-};
-export type PairTokenSchema = {
-    __michelsonType: 'pair';
-    schema: Record<string, TokenSchema>;
-};
-export type ListTokenSchema = {
-    __michelsonType: 'list';
-    schema: TokenSchema;
-};
-export type SetTokenSchema = {
-    __michelsonType: 'set';
-    schema: TokenSchema;
-};
-export type OptionTokenSchema = {
-    __michelsonType: 'option';
-    schema: TokenSchema;
-};
-export type MapTokenSchema = {
-    __michelsonType: 'map';
-    schema: {
-        key: TokenSchema;
-        value: TokenSchema;
-    };
-};
-export type BigMapTokenSchema = {
-    __michelsonType: 'big_map';
-    schema: {
-        key: TokenSchema;
-        value: TokenSchema;
-    };
-};
-export type ConstantTokenSchema = {
-    __michelsonType: 'constant';
-    schema: {
-        hash: string;
-    };
-};
-export type ContractTokenSchema = {
-    __michelsonType: 'contract';
-    schema: {
-        parameter: TokenSchema;
-    };
-};
-export type LambdaTokenSchema = {
-    __michelsonType: 'lambda';
-    schema: {
-        parameters: TokenSchema;
-        returns: TokenSchema;
-    };
-};
-export type SaplingStateTokenSchema = {
-    __michelsonType: 'sapling_state';
-    schema: {
-        memoSize: string;
-    };
-};
-export type SaplingTransactionTokenSchema = {
-    __michelsonType: 'sapling_transaction';
-    schema: {
-        memoSize: string;
-    };
-};
-export type SaplingTransactionDeprecatedTokenSchema = {
-    __michelsonType: 'sapling_transaction_deprecated';
-    schema: {
-        memoSize: string;
-    };
-};
-export type TicketTokenSchema = {
-    __michelsonType: 'ticket';
-    schema: {
-        value: TokenSchema;
-        ticketer: {
-            __michelsonType: 'contract';
-            schema: 'contract';
-        };
-        amount: {
-            __michelsonType: 'int';
-            schema: 'int';
-        };
-    };
-};
-export type TicketDeprecatedTokenSchema = {
-    __michelsonType: 'ticket_deprecated';
-    schema: {
-        value: TokenSchema;
-        ticketer: {
-            __michelsonType: 'contract';
-            schema: 'contract';
-        };
-        amount: {
-            __michelsonType: 'int';
-            schema: 'int';
-        };
-    };
-};
-export type TokenSchema = BaseTokenSchema | OrTokenSchema | PairTokenSchema | ListTokenSchema | SetTokenSchema | OptionTokenSchema | MapTokenSchema | BigMapTokenSchema | ConstantTokenSchema | ContractTokenSchema | LambdaTokenSchema | SaplingStateTokenSchema | SaplingTransactionTokenSchema | SaplingTransactionDeprecatedTokenSchema | TicketTokenSchema | TicketDeprecatedTokenSchema;

package/dist/types/taquito-michelson-encoder/src/schema/view-schema.d.ts

@@ -1,53 +0,0 @@
-import { MichelsonV1Expression, MichelsonV1ExpressionExtended, ScriptResponse } from '@taquito/rpc';
-import { Semantic } from '../tokens/token';
-export declare class ViewSchema {
-    readonly viewName: string;
-    readonly viewArgsType: MichelsonV1ExpressionExtended;
-    readonly viewReturnType: MichelsonV1ExpressionExtended;
-    readonly instructions: MichelsonV1ExpressionExtended[];
-    private rootArgsType;
-    private rootReturnType;
-    /**
-     *
-     * Create an instance of ViewSchema for each view in a script
-     *
-     * @param val contract script obtained from the RPC
-     * @returns array of ViewSchema or empty array if there is no view in the contract
-     * @throws {@link InvalidScriptError}
-     */
-    static fromRPCResponse(val: {
-        script: ScriptResponse;
-    }): ViewSchema[];
-    /**
-     * @throws {@link InvalidScriptError}
-     */
-    constructor(viewArgs: MichelsonV1Expression[] | undefined);
-    /**
-     *
-     * Transform the view parameter into Michelson
-     *
-     * @param args parameter of the view in js format
-     * @returns parameter of the view in Michelson
-     * @throws {@link ParameterEncodingError}
-     */
-    encodeViewArgs(args: any): any;
-    /**
-     *
-     * Transform the view result from Michelson to readable data
-     *
-     * @param val result of the view in JSON Michelson
-     * @param semantics optional semantics to override the default decoding behavior
-     * @returns result of the view in a readable format
-     */
-    decodeViewResult(val: any, semantics?: Semantic): any;
-    /**
-     *
-     * Return the signature of the view parameter
-     */
-    extractArgsSchema(): import("./types").TokenSchema;
-    /**
-     *
-     * Return the format of the view result
-     */
-    extractResultSchema(): import("./types").TokenSchema;
-}

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

@@ -1,16 +0,0 @@
-/**
- * @packageDocumentation
- * @module @taquito/michelson-encoder
- */
-export * from './schema/storage';
-export * from './schema/parameter';
-export * from './schema/view-schema';
-export * from './schema/event-schema';
-export * from './schema/errors';
-export * from './schema/types';
-export { Semantic, SemanticEncoding, BigMapKeyType } from './tokens/token';
-export * from './errors';
-export { UnitValue, SaplingStateValue } from './constants';
-export * from './michelson-map';
-export { VERSION } from './version';
-export { FieldNumberingStrategy, Token } from './tokens/token';

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

@@ -1,51 +0,0 @@
-import { BigMapTokenSchema } from '../schema/types';
-import { ComparableToken, Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
-/**
- *  @category Error
- *  Error that indicates a failure happening when parsing encoding/executing Big Map types
- */
-export declare class BigMapValidationError extends TokenValidationError {
-    value: any;
-    token: BigMapToken;
-    name: string;
-    constructor(value: any, token: BigMapToken, message: string);
-}
-export declare class BigMapToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots?: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'big_map';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots?: any[];
-    }, idx: number, fac: TokenFactory);
-    get ValueSchema(): Token;
-    get KeySchema(): ComparableToken;
-    generateSchema(): BigMapTokenSchema;
-    /**
-     * @throws {@link BigMapValidationError}
-     */
-    private validate;
-    private objLitToMichelsonMap;
-    /**
-     * @throws {@link BigMapValidationError}
-     */
-    Encode(args: any[]): any;
-    /**
-     * @throws {@link BigMapValidationError}
-     */
-    EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    /**
-     * @throws {@link InvalidMapTypeError} when the argument passed to val is an array but not a valid map type
-     * @throws {@link BigMapValidationError} when the value is invalid
-     */
-    Execute(val: any[] | {
-        int: string;
-    }, semantic?: Semantic): any;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,51 +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 BLS12-381 scalar field Fr
- */
-export declare class Bls12381frValidationError extends TokenValidationError {
-    value: any;
-    token: Bls12381frToken;
-    name: string;
-    constructor(value: any, token: Bls12381frToken, message: string);
-}
-export declare class Bls12381frToken extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'bls12_381_fr';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    /**
-     * @throws {@link Bls12381frValidationError}
-     */
-    private validate;
-    private convertUint8ArrayToHexString;
-    /**
-     * @throws {@link Bls12381frValidationError}
-     */
-    Encode(args: any[]): {
-        int: string;
-        bytes?: undefined;
-    } | {
-        bytes: any;
-        int?: undefined;
-    };
-    /**
-     * @throws {@link Bls12381frValidationError}
-     */
-    EncodeObject(val: string | Uint8Array | number, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
-        bytes: string | number | Uint8Array<ArrayBufferLike>;
-    };
-    Execute(val: any): string;
-    generateSchema(): BaseTokenSchema;
-    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
-}

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

@@ -1,47 +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 BLS12-381 curve G1
- */
-export declare class Bls12381g1ValidationError extends TokenValidationError {
-    value: any;
-    token: Bls12381g1Token;
-    name: string;
-    constructor(value: any, token: Bls12381g1Token, message: string);
-}
-export declare class Bls12381g1Token extends Token {
-    protected val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    };
-    protected idx: number;
-    protected fac: TokenFactory;
-    static prim: 'bls12_381_g1';
-    constructor(val: {
-        prim: string;
-        args: any[];
-        annots: any[];
-    }, idx: number, fac: TokenFactory);
-    /**
-     * @throws {@link Bls12381g1ValidationError}
-     */
-    private validate;
-    private convertUint8ArrayToHexString;
-    /**
-     * @throws {@link Bls12381g1ValidationError}
-     */
-    Encode(args: any[]): {
-        bytes: any;
-    };
-    /**
-     * @throws {@link Bls12381g1ValidationError}
-     */
-    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[];
-}