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

package/dist/types/taquito/src/context.d.ts

@@ -0,0 +1,100 @@
+import { RpcClientInterface } from '@taquito/rpc';
+import { Protocols } from './constants';
+import { Forger } from '@taquito/local-forging';
+import { Injector } from './injector/interface';
+import { Signer } from '@taquito/core';
+import { OperationFactory } from './wallet/operation-factory';
+import { RpcTzProvider } from './tz/rpc-tz-provider';
+import { RPCEstimateProvider } from './estimate/rpc-estimate-provider';
+import { RpcContractProvider } from './contract/rpc-contract-provider';
+import { RPCBatchProvider } from './batch/rpc-batch-provider';
+import { Wallet, WalletProvider } from './wallet';
+import { ParserProvider } from './parser/interface';
+import { Packer } from './packer/interface';
+import { BehaviorSubject } from 'rxjs';
+import { GlobalConstantsProvider } from './global-constants/interface-global-constants-provider';
+import { TzReadProvider } from './read-provider/interface';
+import { SubscribeProvider } from './subscribe/interface';
+import { PrepareProvider } from './prepare/prepare-provider';
+export interface TaquitoProvider<T, K extends Array<any>> {
+    new (context: Context, ...rest: K): T;
+}
+export interface ConfigConfirmation {
+    confirmationPollingTimeoutSecond: number;
+    defaultConfirmationCount: number;
+}
+export declare const defaultConfigConfirmation: ConfigConfirmation;
+/**
+ * Encapsulate common service used throughout different part of the library
+ */
+export declare class Context {
+    private _rpc;
+    private _signer;
+    private _proto?;
+    readonly _config: BehaviorSubject<{
+        confirmationPollingTimeoutSecond: number;
+        defaultConfirmationCount: number;
+    }>;
+    private _rpcClient;
+    private _forger;
+    private _parser;
+    private _injector;
+    private _walletProvider;
+    readonly operationFactory: OperationFactory;
+    private _packer;
+    private providerDecorator;
+    private _globalConstantsProvider;
+    private _readProvider;
+    private _stream;
+    readonly tz: RpcTzProvider;
+    readonly estimate: RPCEstimateProvider;
+    readonly contract: RpcContractProvider;
+    readonly prepare: PrepareProvider;
+    readonly batch: RPCBatchProvider;
+    readonly wallet: Wallet;
+    constructor(_rpc: RpcClientInterface | string, _signer?: Signer, _proto?: Protocols | undefined, _config?: BehaviorSubject<{
+        confirmationPollingTimeoutSecond: number;
+        defaultConfirmationCount: number;
+    }>, forger?: Forger, injector?: Injector, packer?: Packer, wallet?: WalletProvider, parser?: ParserProvider, globalConstantsProvider?: GlobalConstantsProvider, readProvider?: TzReadProvider, stream?: SubscribeProvider);
+    get config(): ConfigConfirmation;
+    set config(value: ConfigConfirmation);
+    setPartialConfig(value: Partial<ConfigConfirmation>): void;
+    get rpc(): RpcClientInterface;
+    set rpc(value: RpcClientInterface);
+    get injector(): Injector;
+    set injector(value: Injector);
+    get forger(): Forger;
+    set forger(value: Forger);
+    get signer(): Signer;
+    set signer(value: Signer);
+    get walletProvider(): WalletProvider;
+    set walletProvider(value: WalletProvider);
+    set proto(value: Protocols | undefined);
+    get proto(): Protocols | undefined;
+    get parser(): ParserProvider;
+    set parser(value: ParserProvider);
+    get packer(): Packer;
+    set packer(value: Packer);
+    get globalConstantsProvider(): GlobalConstantsProvider;
+    set globalConstantsProvider(value: GlobalConstantsProvider);
+    get readProvider(): TzReadProvider;
+    set readProvider(value: TzReadProvider);
+    get stream(): SubscribeProvider;
+    set stream(value: SubscribeProvider);
+    isAnyProtocolActive(protocol?: string[]): Promise<boolean>;
+    isAnySignerConfigured(): boolean;
+    /**
+     * Create a copy of the current context. Useful when you have long running operation and you do not want a context change to affect the operation
+     */
+    clone(): Context;
+    /**
+     * Allows extensions set on the TezosToolkit to inject logic into the context
+     */
+    registerProviderDecorator(fx: (context: Context) => Context): void;
+    /**
+     * Applies the decorators on a cloned instance of the context and returned this cloned instance.
+     * The decorators are functions that inject logic into the context.
+     * They are provided by the extensions set on the TezosToolkit by calling the registerProviderDecorator method.
+     */
+    withExtensions: () => Context;
+}

package/dist/types/taquito/src/contract/big-map.d.ts

@@ -0,0 +1,35 @@
+import { Schema, BigMapKeyType } from '@taquito/michelson-encoder';
+import BigNumber from 'bignumber.js';
+import { ContractProvider } from './interface';
+export declare class BigMapAbstraction {
+    private id;
+    private schema;
+    private provider;
+    constructor(id: BigNumber, schema: Schema, provider: ContractProvider);
+    /**
+     *
+     * Fetch one value in a big map
+     *
+     * @param keyToEncode Key to query (will be encoded properly according to the schema)
+     * @param block optional block level to fetch the values from (head will be use by default)
+     * @returns Return a well formatted json object of a big map value or undefined if the key is not found in the big map
+     *
+     */
+    get<T>(keyToEncode: BigMapKeyType, block?: number): Promise<T | undefined>;
+    /**
+     *
+     * Fetch multiple values in a big map
+     * All values will be fetched on the same block level. If a block is specified in the request, the values will be fetched at it.
+     * Otherwise, a first request will be done to the node to fetch the level of the head and all values will be fetched at this level.
+     * If one of the keys does not exist in the big map, its value will be set to undefined.
+     *
+     * @param keysToEncode Array of keys to query (will be encoded properly according to the schema)
+     * @param block optional block level to fetch the values from
+     * @param batchSize optional batch size representing the number of requests to execute in parallel
+     * @returns A MichelsonMap containing the keys queried in the big map and their value in a well-formatted JSON object format
+     *
+     */
+    getMultipleValues<T>(keysToEncode: Array<BigMapKeyType>, block?: number, batchSize?: number): Promise<import("@taquito/michelson-encoder").MichelsonMap<import("@taquito/michelson-encoder").MichelsonMapKey, T | undefined>>;
+    toJSON(): string;
+    toString(): string;
+}

package/dist/types/taquito/src/contract/compose.d.ts

@@ -0,0 +1,5 @@
+import { Wallet } from '../wallet/wallet';
+import { Context } from '../context';
+import { ContractAbstraction } from './contract';
+import { ContractProvider } from './interface';
+export declare function compose<ContractAbsComposer1 extends ContractAbstraction<ContractProvider | Wallet>, ContractAbsComposer2 extends ContractAbstraction<ContractProvider | Wallet>, ContractAbstractionComposed>(functioncomposer1: (abs: ContractAbsComposer1, context: Context) => ContractAbsComposer2, functioncomposer2: (abs: ContractAbsComposer2, context: Context) => ContractAbstractionComposed): (abs: ContractAbsComposer1, context: Context) => ContractAbstractionComposed;

package/dist/types/taquito/src/contract/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_SMART_CONTRACT_METHOD_NAME = "default";

package/dist/types/taquito/src/contract/contract-methods/contract-method-factory.d.ts

@@ -0,0 +1,14 @@
+import type { Wallet } from '../../wallet/wallet';
+import { ContractProvider } from '../interface';
+import { ContractMethodObject } from './contract-method-object-param';
+import { ParameterSchema, ViewSchema } from '@taquito/michelson-encoder';
+import { RpcClientInterface, MichelsonV1Expression } from '@taquito/rpc';
+import { OnChainView } from './contract-on-chain-view';
+import { TzReadProvider } from '../../read-provider/interface';
+export declare class ContractMethodFactory<T extends ContractProvider | Wallet> {
+    private provider;
+    private contractAddress;
+    constructor(provider: T, contractAddress: string);
+    createContractMethodObjectParam(smartContractMethodSchema: ParameterSchema, smartContractMethodName: string, args: any[], isMultipleEntrypoint?: boolean, isAnonymous?: boolean): ContractMethodObject<T>;
+    createContractViewObjectParam(rpc: RpcClientInterface, readProvider: TzReadProvider, smartContractViewSchema: ViewSchema, contractStorageType: MichelsonV1Expression, viewArgs: any): OnChainView;
+}

package/dist/types/taquito/src/contract/contract-methods/contract-method-interface.d.ts

@@ -0,0 +1,28 @@
+import { TransactionOperation } from '../../operations/transaction-operation';
+import { TransferParams } from '../../operations/types';
+import { TransactionWalletOperation } from '../../wallet';
+export interface SendParams {
+    fee?: number;
+    storageLimit?: number;
+    gasLimit?: number;
+    amount: number;
+    source?: string;
+    mutez?: boolean;
+}
+export type ExplicitTransferParams = Required<Omit<TransferParams, keyof SendParams>> & SendParams;
+export interface ContractMethodInterface {
+    /**
+     *
+     * Send the smart contract operation
+     *
+     * @param params generic operation parameter
+     */
+    send(params: Partial<SendParams>): Promise<TransactionWalletOperation | TransactionOperation>;
+    /**
+     *
+     * Create transfer params to be used with TezosToolkit.contract.transfer methods
+     *
+     * @param params generic transfer operation parameters
+     */
+    toTransferParams(params: Partial<SendParams>): TransferParams;
+}

package/dist/types/taquito/src/contract/contract-methods/contract-method-object-param.d.ts

@@ -0,0 +1,39 @@
+import { TransactionOperation } from '../../operations/transaction-operation';
+import { TransferParams } from '../../operations/types';
+import { ContractProvider } from '../interface';
+import type { Wallet } from '../../wallet/wallet';
+import { TransactionWalletOperation } from '../../wallet/transaction-operation';
+import { ParameterSchema } from '@taquito/michelson-encoder';
+import { ContractMethodInterface, SendParams } from './contract-method-interface';
+/**
+ * Utility class to send smart contract operation
+ * The format for the arguments is the object representation
+ */
+export declare class ContractMethodObject<T extends ContractProvider | Wallet> implements ContractMethodInterface {
+    private provider;
+    private address;
+    private parameterSchema;
+    private name;
+    private args;
+    private isMultipleEntrypoint;
+    private isAnonymous;
+    constructor(provider: T, address: string, parameterSchema: ParameterSchema, name: string, args?: any, isMultipleEntrypoint?: boolean, isAnonymous?: boolean);
+    /**
+     * Get the signature of the smart contract method
+     */
+    getSignature(): unknown;
+    /**
+     *
+     * Send the smart contract operation
+     *
+     * @param params generic operation parameter
+     */
+    send(params?: Partial<SendParams>): Promise<T extends Wallet ? TransactionWalletOperation : TransactionOperation>;
+    /**
+     *
+     * Create transfer params to be used with TezosToolkit.contract.transfer methods
+     *
+     * @param params generic transfer operation parameters
+     */
+    toTransferParams({ fee, gasLimit, storageLimit, source, amount, mutez, }?: Partial<SendParams>): TransferParams;
+}

package/dist/types/taquito/src/contract/contract-methods/contract-on-chain-view.d.ts

@@ -0,0 +1,43 @@
+import { ViewSchema } from '@taquito/michelson-encoder';
+import { MichelsonV1Expression, RpcClientInterface } from '@taquito/rpc';
+import { TzReadProvider } from '../../read-provider/interface';
+export interface ExecutionContextParams {
+    source?: string;
+    viewCaller: string;
+}
+export declare class OnChainView {
+    private _rpc;
+    private _readProvider;
+    private _contractAddress;
+    private _smartContractViewSchema;
+    private _contractStorageType;
+    private _args;
+    constructor(_rpc: RpcClientInterface, _readProvider: TzReadProvider, _contractAddress: string, _smartContractViewSchema: ViewSchema, _contractStorageType: MichelsonV1Expression, _args?: any);
+    /**
+     * Get the signature of the smart contract view
+     */
+    getSignature(): {
+        parameter: import("@taquito/michelson-encoder").TokenSchema;
+        result: import("@taquito/michelson-encoder").TokenSchema;
+    };
+    /**
+     * Get the result of the view simulation
+     * @param executionContext.source the public key hash of the account who initialized this view execution.
+     * @param executionContext.viewCaller the contract address which is the caller of view.
+     */
+    executeView(executionContext: ExecutionContextParams): Promise<any>;
+    private verifyContextExecution;
+    private transformArgsToMichelson;
+    /**
+     * Loops through the view's instructions and replace BALANCE, SENDER, SELF_ADDRESS and AMOUNT with Michelson expressions that match the current context, if applicable.
+     *
+     * Certain specific instructions have different semantics in view:
+     * BALANCE represents the current amount of mutez held by the contract where view is;
+     * SENDER represents the contract which is the caller of view;
+     * SELF_ADDRESS represents the contract where view is;
+     * AMOUNT is always 0 mutez.
+     *
+     */
+    private adaptViewCodeToContext;
+    private executeViewAndDecodeResult;
+}

package/dist/types/taquito/src/contract/contract.d.ts

@@ -0,0 +1,75 @@
+import { ParameterSchema, Schema, ViewSchema, EventSchema } from '@taquito/michelson-encoder';
+import { EntrypointsResponse, RpcClientInterface, ScriptResponse } from '@taquito/rpc';
+import { ChainIds } from '../constants';
+import { TzReadProvider } from '../read-provider/interface';
+import type { Wallet } from '../wallet/wallet';
+import { ContractMethodObject } from './contract-methods/contract-method-object-param';
+import { OnChainView } from './contract-methods/contract-on-chain-view';
+import { ContractProvider, StorageProvider } from './interface';
+import { DEFAULT_SMART_CONTRACT_METHOD_NAME } from './constants';
+export { DEFAULT_SMART_CONTRACT_METHOD_NAME };
+/**
+ * Utility class to retrieve data from a smart contract's storage without incurring fees via a contract's view method
+ */
+export declare class ContractView {
+    private currentContract;
+    private name;
+    private callbackParametersSchema;
+    private parameterSchema;
+    private args;
+    private rpc;
+    private readProvider;
+    constructor(currentContract: ContractAbstraction<ContractProvider | Wallet>, name: string, callbackParametersSchema: ParameterSchema, parameterSchema: ParameterSchema, args: any[], rpc: RpcClientInterface, readProvider: TzReadProvider);
+    read(chainId?: ChainIds): Promise<any>;
+}
+export type Contract = ContractAbstraction<ContractProvider>;
+export type WalletContract = ContractAbstraction<Wallet>;
+type DefaultMethodsObject<T extends ContractProvider | Wallet> = Record<string, (args?: any) => ContractMethodObject<T>>;
+type DefaultViews = Record<string, (...args: any[]) => ContractView>;
+type DefaultContractViews = Record<string, (args?: any) => OnChainView>;
+type DefaultStorage = unknown;
+type PromiseReturnType<T extends (...args: any) => any> = T extends (...args: any) => Promise<infer R> ? R : any;
+export type ContractStorageType<T extends ContractAbstraction<ContractProvider | Wallet>> = PromiseReturnType<T['storage']>;
+export type DefaultContractType = ContractAbstraction<ContractProvider>;
+export type DefaultWalletType = ContractAbstraction<Wallet>;
+/**
+ * Smart contract abstraction
+ */
+export declare class ContractAbstraction<T extends ContractProvider | Wallet, TMethodsObject extends DefaultMethodsObject<T> = DefaultMethodsObject<T>, TViews extends DefaultViews = DefaultViews, TContractViews extends DefaultContractViews = DefaultContractViews, TStorage extends DefaultStorage = DefaultStorage> {
+    readonly address: string;
+    readonly script: ScriptResponse;
+    private storageProvider;
+    readonly entrypoints: EntrypointsResponse;
+    private rpc;
+    private readProvider;
+    private contractMethodFactory;
+    /**
+     * Contains methods that are implemented by the target Tezos Smart Contract, and offers the user to call the Smart Contract methods as if they were native TS/JS methods.
+     * `methodsObject` serves the exact same purpose as the `methods` member. The difference is that it allows passing the parameter in an object format when calling the smart contract method (instead of the flattened representation)
+     * NB: if the contract contains annotation it will include named properties; if not it will be indexed by a number.
+     *
+     */
+    methodsObject: TMethodsObject;
+    /**
+     * Contains lamda views (tzip4) that are implemented by the target Tezos Smart Contract, and offers the user to call the lambda views as if they were native TS/JS methods.
+     * NB: These are the view defined in the tzip4 standard, not the views introduced by the Hangzhou protocol.
+     */
+    views: TViews;
+    /**
+     * Contains on-chain views that are defined by the target Tezos Smart Contract, and offers the user to simulate the views execution as if they were native TS/JS methods.
+     * NB: the expected format for the parameter when calling a smart contract view is the object format (same format as for the storage) and not the flattened representation.
+     *
+     */
+    contractViews: TContractViews;
+    readonly schema: Schema;
+    readonly parameterSchema: ParameterSchema;
+    readonly viewSchema: ViewSchema[];
+    readonly eventSchema: EventSchema[];
+    constructor(address: string, script: ScriptResponse, provider: T, storageProvider: StorageProvider, entrypoints: EntrypointsResponse, rpc: RpcClientInterface, readProvider: TzReadProvider);
+    private _initializeMethods;
+    private _initializeOnChainViews;
+    /**
+     * Return a friendly representation of the smart contract storage
+     */
+    storage<T extends TStorage = TStorage>(): Promise<T>;
+}

package/dist/types/taquito/src/contract/errors.d.ts

@@ -0,0 +1,83 @@
+import { ParameterValidationError, RpcError } from '@taquito/core';
+import { HttpResponseError } from '@taquito/http-utils';
+import { MichelsonV1Expression } from '@taquito/rpc';
+/**
+ *  @category Error
+ *  Error that indicates invalid smart contract parameters being passed or used
+ */
+export declare class InvalidParameterError extends ParameterValidationError {
+    readonly smartContractMethodName: string;
+    readonly sigs: any[];
+    readonly invalidParams: any[];
+    constructor(smartContractMethodName: string, sigs: any[], invalidParams: any[]);
+}
+/**
+ *  @category Error
+ *  Error that indicates an invalid delegation source contract address being passed or used
+ */
+export declare class InvalidDelegationSource extends ParameterValidationError {
+    readonly source: string;
+    constructor(source: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates an invalid smart contract code parameter being passed or used
+ */
+export declare class InvalidCodeParameter extends ParameterValidationError {
+    readonly message: string;
+    readonly data: any;
+    constructor(message: string, data: any);
+}
+/**
+ *  @category Error
+ *  Error that indicates invalid smart contract init parameter being passed or used
+ */
+export declare class InvalidInitParameter extends ParameterValidationError {
+    readonly message: string;
+    readonly data: any;
+    constructor(message: string, data: any);
+}
+/**
+ *  @category Error
+ *  Error that indicates a failure when conducting a view simulation
+ */
+export declare class ViewSimulationError extends RpcError {
+    readonly message: string;
+    readonly viewName: string;
+    readonly failWith?: MichelsonV1Expression | undefined;
+    readonly cause?: any | undefined;
+    constructor(message: string, viewName: string, failWith?: MichelsonV1Expression | undefined, cause?: any | undefined);
+}
+export declare const validateAndExtractFailwith: (error: HttpResponseError) => MichelsonV1Expression | undefined;
+/**
+ *  @category Error
+ *  Error that indicates invalid or unconfigured context when executing a view
+ */
+export declare class InvalidViewSimulationContext extends ParameterValidationError {
+    readonly info: string;
+    constructor(info: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates a mistake happening during the reveal operation
+ */
+export declare class RevealOperationError extends RpcError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates a mistake in the parameters in the preparation of an Origination operation
+ */
+export declare class OriginationParameterError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates an invalid balance being passed or used
+ */
+export declare class InvalidBalanceError extends ParameterValidationError {
+    readonly message: string;
+    constructor(message: string);
+}

package/dist/types/taquito/src/contract/index.d.ts

@@ -0,0 +1,11 @@
+export * from './contract';
+export * from './errors';
+export * from './interface';
+export * from './manager-lambda';
+export * from './prepare';
+export * from './view_lambda';
+export { compose } from './compose';
+export * from './contract-methods/contract-method-interface';
+export * from './contract-methods/contract-method-object-param';
+export * from './sapling-state-abstraction';
+export { smartContractAbstractionSemantic } from './semantic';