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

package/dist/types/taquito/src/wallet/interface.d.ts

@@ -1,66 +0,0 @@
-import { DelegateParams, FailingNoopParams, IncreasePaidStorageParams, OriginateParams, TransferParams, StakeParams, UnstakeParams, FinalizeUnstakeParams, TransferTicketParams, RegisterGlobalConstantParams } from '../operations/types';
-export type WalletDefinedFields = 'source';
-export type WalletTransferParams = Omit<TransferParams, WalletDefinedFields>;
-export type WalletStakeParams = Omit<StakeParams, WalletDefinedFields>;
-export type WalletUnstakeParams = Omit<UnstakeParams, WalletDefinedFields>;
-export type WalletFinalizeUnstakeParams = Omit<FinalizeUnstakeParams, WalletDefinedFields>;
-export type WalletOriginateParams<TStorage = any> = Omit<OriginateParams<TStorage>, WalletDefinedFields>;
-export type WalletDelegateParams = Omit<DelegateParams, WalletDefinedFields>;
-export type WalletFailingNoopParams = Omit<FailingNoopParams, WalletDefinedFields>;
-export type WalletIncreasePaidStorageParams = Omit<IncreasePaidStorageParams, WalletDefinedFields>;
-export type WalletTransferTicketParams = Omit<TransferTicketParams, WalletDefinedFields>;
-export type WalletRegisterGlobalConstantParams = Omit<RegisterGlobalConstantParams, WalletDefinedFields>;
-export interface WalletProvider {
-    /**
-     * Request the public key hash from the wallet
-     */
-    getPKH: () => Promise<string>;
-    /**
-     * Request the public key from the wallet
-     */
-    getPK: () => Promise<string>;
-    /**
-     * Transform WalletTransferParams into a format compliant with the underlying wallet
-     */
-    mapTransferParamsToWalletParams: (params: () => Promise<WalletTransferParams>) => Promise<any>;
-    /**
-     * Transform WalletTransferTicketParams into a format compliant with the underlying wallet
-     */
-    mapTransferTicketParamsToWalletParams: (params: () => Promise<WalletTransferTicketParams>) => Promise<any>;
-    /**
-     * Transform WalletRegisterGlobalConstantParams into a format compliant with the underlying wallet
-     */
-    mapRegisterGlobalConstantParamsToWalletParams: (params: () => Promise<WalletRegisterGlobalConstantParams>) => Promise<any>;
-    /**
-     * Transform WalletStakeParams into a format compliant with the underlying wallet
-     */
-    mapStakeParamsToWalletParams: (params: () => Promise<WalletStakeParams>) => Promise<any>;
-    /**
-     * Transform WalletUnstakeParams into a format compliant with the underlying wallet
-     */
-    mapUnstakeParamsToWalletParams: (params: () => Promise<WalletUnstakeParams>) => Promise<any>;
-    /**
-     * Transform WalletFinalizeUnstakeParams into a format compliant with the underlying wallet
-     */
-    mapFinalizeUnstakeParamsToWalletParams: (params: () => Promise<WalletFinalizeUnstakeParams>) => Promise<any>;
-    /**
-     * Transform WalletOriginateParams into a format compliant with the underlying wallet
-     */
-    mapOriginateParamsToWalletParams: (params: () => Promise<WalletOriginateParams>) => Promise<any>;
-    /**
-     * Transform WalletDelegateParams into a format compliant with the underlying wallet
-     */
-    mapDelegateParamsToWalletParams: (params: () => Promise<WalletDelegateParams>) => Promise<any>;
-    /**
-     * Transform WalletIncreasePaidStorageParams into a format compliant with the underlying wallet
-     */
-    mapIncreasePaidStorageWalletParams: (params: () => Promise<WalletIncreasePaidStorageParams>) => Promise<any>;
-    /**
-     * Request the wallet to send an operation batch
-     */
-    sendOperations: (params: any[]) => Promise<string>;
-    /**
-     * Request the wallet to sign a payload
-     */
-    sign(bytes: string, watermark?: Uint8Array): Promise<string>;
-}

package/dist/types/taquito/src/wallet/legacy.d.ts

@@ -1,21 +0,0 @@
-import { Context } from '../context';
-import { OpKind } from '../operations/types';
-import { WalletDelegateParams, WalletIncreasePaidStorageParams, WalletOriginateParams, WalletProvider, WalletTransferParams, WalletStakeParams, WalletUnstakeParams, WalletFinalizeUnstakeParams, WalletTransferTicketParams, WalletRegisterGlobalConstantParams } from './interface';
-import { WalletParamsWithKind } from './wallet';
-export declare class LegacyWalletProvider implements WalletProvider {
-    private context;
-    constructor(context: Context);
-    getPKH(): Promise<string>;
-    getPK(): Promise<string>;
-    mapTransferParamsToWalletParams(params: () => Promise<WalletTransferParams>): Promise<import("../operations/types").withKind<WalletTransferParams, OpKind.TRANSACTION>>;
-    mapStakeParamsToWalletParams(params: () => Promise<WalletStakeParams>): Promise<import("../operations/types").withKind<WalletStakeParams, OpKind.TRANSACTION>>;
-    mapUnstakeParamsToWalletParams(params: () => Promise<WalletUnstakeParams>): Promise<import("../operations/types").withKind<WalletUnstakeParams, OpKind.TRANSACTION>>;
-    mapFinalizeUnstakeParamsToWalletParams(params: () => Promise<WalletFinalizeUnstakeParams>): Promise<import("../operations/types").withKind<WalletFinalizeUnstakeParams, OpKind.TRANSACTION>>;
-    mapOriginateParamsToWalletParams(params: () => Promise<WalletOriginateParams>): Promise<import("../operations/types").withKind<WalletOriginateParams, OpKind.ORIGINATION>>;
-    mapDelegateParamsToWalletParams(params: () => Promise<WalletDelegateParams>): Promise<import("../operations/types").withKind<WalletDelegateParams, OpKind.DELEGATION>>;
-    mapIncreasePaidStorageWalletParams(params: () => Promise<WalletIncreasePaidStorageParams>): Promise<import("../operations/types").withKind<WalletIncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE>>;
-    mapTransferTicketParamsToWalletParams(params: () => Promise<WalletTransferTicketParams>): Promise<import("../operations/types").withKind<WalletTransferTicketParams, OpKind.TRANSFER_TICKET>>;
-    mapRegisterGlobalConstantParamsToWalletParams(params: () => Promise<WalletRegisterGlobalConstantParams>): Promise<import("../operations/types").withKind<WalletRegisterGlobalConstantParams, OpKind.REGISTER_GLOBAL_CONSTANT>>;
-    sendOperations(params: WalletParamsWithKind[]): Promise<string>;
-    sign(bytes: string, watermark?: Uint8Array): Promise<string>;
-}

package/dist/types/taquito/src/wallet/operation-factory.d.ts

@@ -1,32 +0,0 @@
-import { BlockResponse } from '@taquito/rpc';
-import { Observable, SchedulerLike } from 'rxjs';
-import { Context } from '../context';
-import { BatchWalletOperation } from './batch-operation';
-import { DelegationWalletOperation } from './delegation-operation';
-import { IncreasePaidStorageWalletOperation } from './increase-paid-storage-operation';
-import { WalletOperation } from './operation';
-import { OriginationWalletOperation } from './origination-operation';
-import { TransactionWalletOperation } from './transaction-operation';
-import { TransferTicketWalletOperation } from './transfer-ticket-operation';
-import { RegisterGlobalConstantWalletOperation } from './register-global-constant-operation';
-export declare function timeoutAfter<T>(timeoutMillisec: number): (source: Observable<T>) => Observable<T>;
-export declare const createNewPollingBasedHeadObservable: (sharedHeadOb: Observable<BlockResponse>, context: Context, _scheduler?: SchedulerLike) => Observable<BlockResponse>;
-export interface OperationFactoryConfig {
-    blockIdentifier?: string;
-}
-export declare class OperationFactory {
-    private context;
-    constructor(context: Context);
-    private sharedHeadObs;
-    private createNewHeadObservable;
-    private createPastBlockWalker;
-    private createHeadObservableFromConfig;
-    createOperation(hash: string, config?: OperationFactoryConfig): Promise<WalletOperation>;
-    createBatchOperation(hash: string, config?: OperationFactoryConfig): Promise<BatchWalletOperation>;
-    createTransactionOperation(hash: string, config?: OperationFactoryConfig): Promise<TransactionWalletOperation>;
-    createTransferTicketOperation(hash: string, config?: OperationFactoryConfig): Promise<TransferTicketWalletOperation>;
-    createDelegationOperation(hash: string, config?: OperationFactoryConfig): Promise<DelegationWalletOperation>;
-    createOriginationOperation(hash: string, config?: OperationFactoryConfig): Promise<OriginationWalletOperation>;
-    createIncreasePaidStorageOperation(hash: string, config?: OperationFactoryConfig): Promise<IncreasePaidStorageWalletOperation>;
-    createRegisterGlobalConstantOperation(hash: string, config?: OperationFactoryConfig): Promise<RegisterGlobalConstantWalletOperation>;
-}

package/dist/types/taquito/src/wallet/operation.d.ts

@@ -1,55 +0,0 @@
-import { BlockResponse, OperationContentsAndResult, OperationResultStatusEnum } from '@taquito/rpc';
-import { Observable, ReplaySubject } from 'rxjs';
-import { Context } from '../context';
-import { Receipt } from './receipt';
-import { BlockIdentifier } from '../read-provider/interface';
-export type OperationStatus = 'pending' | 'unknown' | OperationResultStatusEnum;
-/**
- * WalletOperation allows to monitor operation inclusion on chains and surface information related to the operation
- */
-export declare class WalletOperation {
-    readonly opHash: string;
-    protected readonly context: Context;
-    private _newHead$;
-    protected _operationResult: ReplaySubject<OperationContentsAndResult[]>;
-    protected _includedInBlock: ReplaySubject<BlockResponse>;
-    protected _included: boolean;
-    private lastHead;
-    protected newHead$: Observable<BlockResponse>;
-    private confirmed$;
-    operationResults(): Promise<OperationContentsAndResult[] | undefined>;
-    protected getInclusionBlock(): Promise<BlockResponse>;
-    private getOperationResultsIfIncluded;
-    /**
-     * Receipt expose the total amount of tezos token burn and spent on fees
-     * The promise returned by receipt will resolve only once the transaction is included
-     */
-    receipt(): Promise<Receipt>;
-    /**
-     *
-     * @param opHash Operation hash
-     * @param context Taquito context allowing access to rpc and signer
-     * @throws {InvalidOperationHashError}
-     */
-    constructor(opHash: string, context: Context, _newHead$: Observable<BlockResponse>);
-    getCurrentConfirmation(): Promise<number | undefined>;
-    isInCurrentBranch(tipBlockIdentifier?: BlockIdentifier): Promise<boolean>;
-    confirmationObservable(confirmations?: number): Observable<{
-        block: BlockResponse;
-        expectedConfirmation: number;
-        currentConfirmation: number;
-        completed: boolean;
-        isInCurrentBranch: () => Promise<boolean>;
-    }>;
-    /**
-     *
-     * @param confirmations [0] Number of confirmation to wait for
-     */
-    confirmation(confirmations?: number): Promise<{
-        block: BlockResponse;
-        expectedConfirmation: number;
-        currentConfirmation: number;
-        completed: boolean;
-        isInCurrentBranch: () => Promise<boolean>;
-    } | undefined>;
-}

package/dist/types/taquito/src/wallet/origination-operation.d.ts

@@ -1,14 +0,0 @@
-import { BlockResponse, OperationContentsAndResultOrigination, OperationContentsAndResultReveal } from '@taquito/rpc';
-import { Observable } from 'rxjs';
-import { Context } from '../context';
-import { DefaultWalletType } from '../contract/contract';
-import { WalletOperation, OperationStatus } from './operation';
-export declare class OriginationWalletOperation<TWallet extends DefaultWalletType = DefaultWalletType> extends WalletOperation {
-    readonly opHash: string;
-    protected readonly context: Context;
-    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
-    originationOperation(): Promise<OperationContentsAndResultOrigination | undefined>;
-    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
-    status(): Promise<OperationStatus>;
-    contract(): Promise<TWallet>;
-}

package/dist/types/taquito/src/wallet/receipt.d.ts

@@ -1,16 +0,0 @@
-import { OperationContentsAndResult } from '@taquito/rpc';
-import BigNumber from 'bignumber.js';
-export interface Receipt {
-    totalFee: BigNumber;
-    totalGas: BigNumber;
-    totalMilliGas: BigNumber;
-    totalStorage: BigNumber;
-    totalAllocationBurn: BigNumber;
-    totalOriginationBurn: BigNumber;
-    totalPaidStorageDiff: BigNumber;
-    totalStorageBurn: BigNumber;
-}
-export declare const receiptFromOperation: (op: OperationContentsAndResult[], { ALLOCATION_BURN, ORIGINATION_BURN }?: {
-    ALLOCATION_BURN: number;
-    ORIGINATION_BURN: number;
-}) => Receipt;

package/dist/types/taquito/src/wallet/register-global-constant-operation.d.ts

@@ -1,13 +0,0 @@
-import { BlockResponse, OperationContentsAndResultRegisterGlobalConstant, OperationContentsAndResultReveal } from '@taquito/rpc';
-import { Observable } from 'rxjs';
-import { Context } from '../context';
-import { WalletOperation, OperationStatus } from './operation';
-export declare class RegisterGlobalConstantWalletOperation extends WalletOperation {
-    readonly opHash: string;
-    protected readonly context: Context;
-    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
-    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
-    registerGlobalConstantOperation(): Promise<OperationContentsAndResultRegisterGlobalConstant | undefined>;
-    status(): Promise<OperationStatus>;
-    globalConstantHash(): Promise<string | undefined>;
-}

package/dist/types/taquito/src/wallet/transaction-operation.d.ts

@@ -1,12 +0,0 @@
-import { WalletOperation, OperationStatus } from './operation';
-import { Context } from '../context';
-import { Observable } from 'rxjs';
-import { BlockResponse, OperationContentsAndResultReveal, OperationContentsAndResultTransaction } from '@taquito/rpc';
-export declare class TransactionWalletOperation extends WalletOperation {
-    readonly opHash: string;
-    protected readonly context: Context;
-    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
-    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
-    transactionOperation(): Promise<OperationContentsAndResultTransaction | undefined>;
-    status(): Promise<OperationStatus>;
-}

package/dist/types/taquito/src/wallet/transfer-ticket-operation.d.ts

@@ -1,12 +0,0 @@
-import { WalletOperation, OperationStatus } from './operation';
-import { Context } from '../context';
-import { Observable } from 'rxjs';
-import { BlockResponse, OperationContentsAndResultReveal, OperationContentsAndResultTransferTicket } from '@taquito/rpc';
-export declare class TransferTicketWalletOperation extends WalletOperation {
-    readonly opHash: string;
-    protected readonly context: Context;
-    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
-    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
-    transferTicketOperation(): Promise<OperationContentsAndResultTransferTicket | undefined>;
-    status(): Promise<OperationStatus>;
-}

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

@@ -1,196 +0,0 @@
-import { Context } from '../context';
-import { ContractAbstraction } from '../contract/contract';
-import type { ContractStorageType, DefaultWalletType } from '../contract/contract';
-import { SendParams } from '../contract/contract-methods/contract-method-interface';
-import type { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
-import { OpKind, withKind } from '../operations/types';
-import { OriginationWalletOperation } from './origination-operation';
-import { WalletDelegateParams, WalletFailingNoopParams, WalletIncreasePaidStorageParams, WalletOriginateParams, WalletProvider, WalletTransferParams, WalletStakeParams, WalletUnstakeParams, WalletFinalizeUnstakeParams, WalletTransferTicketParams, WalletRegisterGlobalConstantParams } from './interface';
-import { BlockIdentifier } from '../read-provider/interface';
-export interface PKHOption {
-    forceRefetch?: boolean;
-}
-export type WalletParamsWithKind = withKind<WalletTransferParams, OpKind.TRANSACTION> | withKind<WalletOriginateParams, OpKind.ORIGINATION> | withKind<WalletDelegateParams, OpKind.DELEGATION> | withKind<WalletIncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE> | withKind<WalletTransferTicketParams, OpKind.TRANSFER_TICKET> | withKind<WalletRegisterGlobalConstantParams, OpKind.REGISTER_GLOBAL_CONSTANT>;
-export declare class WalletOperationBatch {
-    private walletProvider;
-    private context;
-    private operations;
-    constructor(walletProvider: WalletProvider, context: Context);
-    /**
-     * Add a transaction operation to the batch
-     * @param params Transfer operation parameter
-     */
-    withTransfer(params: WalletTransferParams): this;
-    /**
-     * Add a contract call to the batch
-     * @param params Call a contract method
-     * @param options Generic operation parameters
-     */
-    withContractCall(params: ContractMethodObject<Wallet>, options?: Partial<SendParams>): this;
-    /**
-     * Add a delegation operation to the batch
-     * @param params Delegation operation parameter
-     */
-    withDelegation(params: WalletDelegateParams): this;
-    /**
-     * Add an origination operation to the batch
-     * @param params Origination operation parameter
-     */
-    withOrigination<TWallet extends DefaultWalletType = DefaultWalletType>(params: WalletOriginateParams<ContractStorageType<TWallet>>): this;
-    /**
-     * Add an IncreasePaidStorage operation to the batch
-     * @param params IncreasePaidStorage operation parameter
-     */
-    withIncreasePaidStorage(params: WalletIncreasePaidStorageParams): this;
-    /**
-     * Add an TransferTicket operation to the batch
-     * @param params TransferTicket operation parameter
-     */
-    withTransferTicket(params: WalletTransferTicketParams): this;
-    /**
-     * Add a RegisterGlobalConstant operation to the batch
-     * @param params RegisterGlobalConstant operation parameter
-     */
-    withRegisterGlobalConstant(params: WalletRegisterGlobalConstantParams): this;
-    private mapOperation;
-    /**
-     * Add a group operation to the batch. Operation will be applied in the order they are in the params array
-     * @param params Operations parameter
-     * @throws InvalidOperationKindError
-     */
-    with(params: WalletParamsWithKind[]): this;
-    /**
-     * Submit batch operation to wallet
-     */
-    send(): Promise<import("./batch-operation").BatchWalletOperation>;
-}
-export declare class Wallet {
-    private context;
-    constructor(context: Context);
-    private get walletProvider();
-    private _pkh?;
-    private _pk?;
-    /**
-     * Retrieve the PKH of the account that is currently in use by the wallet
-     * @param option Option to use while fetching the PKH.
-     * If forceRefetch is specified the wallet provider implementation will refetch the PKH from the wallet
-     */
-    pkh({ forceRefetch }?: PKHOption): Promise<string>;
-    /**
-     * Retrieve the PK of the account that is currently in use by the wallet
-     * @param option Option to use while fetching the PK.
-     * If forceRefetch is specified the wallet provider implementation will refetch the PK from the wallet
-     */
-    pk({ forceRefetch }?: PKHOption): Promise<string>;
-    private walletCommand;
-    /**
-     * Originate a new contract according to the script in parameters.
-     * @returns a OriginationWalletOperation promise object when followed by .send()
-     * @param params Originate operation parameter
-     */
-    originate<TWallet extends DefaultWalletType = DefaultWalletType>(params: WalletOriginateParams<ContractStorageType<TWallet>>): {
-        send: () => Promise<OriginationWalletOperation<TWallet>>;
-    };
-    /**
-     * Set the delegate for a contract.
-     * @returns a WalletDelegateParams promise object when followed by .send()
-     * @param params operation parameter
-     */
-    setDelegate(params: WalletDelegateParams): {
-        send: () => Promise<import("./delegation-operation").DelegationWalletOperation>;
-    };
-    /**
-     * failing_noop operation that is guaranteed to fail. DISCLAIMER: Not all wallets support signing failing_noop operations.
-     * @returns Signature for a failing_noop
-     * @param params operation parameter
-     */
-    signFailingNoop(params: WalletFailingNoopParams): Promise<{
-        signature: string;
-        bytes: string;
-        signedContent: {
-            branch: string;
-            contents: {
-                kind: OpKind;
-                arbitrary: string;
-            }[];
-        };
-    }>;
-    /**
-     * Register the current address as delegate.
-     * @returns a DelegationWalletOperation promise object when followed by .send()
-     */
-    registerDelegate(): {
-        send: () => Promise<import("./delegation-operation").DelegationWalletOperation>;
-    };
-    /**
-     * Transfer tezos tokens from current address to a specific address or call a smart contract.
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params operation parameter
-     */
-    transfer(params: WalletTransferParams): {
-        send: () => Promise<import("./transaction-operation").TransactionWalletOperation>;
-    };
-    /**
-     * Transfer tezos tickets from current address to a specific address or a smart contract
-     * @returns a TransferTicketWalletOperation promise object when followed by .send()
-     * @param params operation parameter
-     */
-    transferTicket(params: WalletTransferTicketParams): {
-        send: () => Promise<import("./transfer-ticket-operation").TransferTicketWalletOperation>;
-    };
-    /**
-     * Stake a given amount for the source address
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params Stake pseudo-operation parameter
-     */
-    stake(params: WalletStakeParams): {
-        send: () => Promise<import("./transaction-operation").TransactionWalletOperation>;
-    };
-    /**
-     * Unstake the given amount. If "everything" is given as amount, unstakes everything from the staking balance.
-     * Unstaked tez remains frozen for a set amount of cycles (the slashing period) after the operation. Once this period is over,
-     * the operation "finalize unstake" must be called for the funds to appear in the liquid balance.
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params Unstake pseudo-operation parameter
-     */
-    unstake(params: WalletUnstakeParams): {
-        send: () => Promise<import("./transaction-operation").TransactionWalletOperation>;
-    };
-    /**
-     * Transfer all the finalizable unstaked funds of the source to their liquid balance
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params Finalize_unstake pseudo-operation parameter
-     */
-    finalizeUnstake(params: WalletFinalizeUnstakeParams): {
-        send: () => Promise<import("./transaction-operation").TransactionWalletOperation>;
-    };
-    /**
-     * Increase the paid storage of a smart contract.
-     * @returns a IncreasePaidStorageWalletOperation promise object when followed by .send()
-     * @param params operation parameter
-     */
-    increasePaidStorage(params: WalletIncreasePaidStorageParams): {
-        send: () => Promise<import("./increase-paid-storage-operation").IncreasePaidStorageWalletOperation>;
-    };
-    /**
-     * Register a Micheline expression in a global table of constants.
-     * @returns a RegisterGlobalConstantWalletOperation promise object when followed by .send()
-     * @param params operation parameter
-     */
-    registerGlobalConstant(params: WalletRegisterGlobalConstantParams): {
-        send: () => Promise<import("./register-global-constant-operation").RegisterGlobalConstantWalletOperation>;
-    };
-    /**
-     * Create a batch of operation
-     * @returns A batch object from which we can add more operation or send a command to the wallet to execute the batch
-     * @param params List of operation to initialize the batch with
-     */
-    batch(params?: Parameters<WalletOperationBatch['with']>[0]): WalletOperationBatch;
-    /**
-     * Create an smart contract abstraction for the address specified. Calling entrypoints with the returned
-     * smart contract abstraction will leverage the wallet provider to make smart contract calls
-     * @param address Smart contract address
-     * @throws InvalidContractAddressError If the contract address is not valid
-     */
-    at<T extends ContractAbstraction<Wallet>>(address: string, contractAbstractionComposer?: (abs: ContractAbstraction<Wallet>, context: Context) => T, block?: BlockIdentifier): Promise<T>;
-}

package/dist/types/taquito-core/src/errors.d.ts

@@ -1,213 +0,0 @@
-export declare enum ValidationResult {
-    NO_PREFIX_MATCHED = 0,
-    INVALID_CHECKSUM = 1,
-    INVALID_LENGTH = 2,
-    VALID = 3,
-    PREFIX_NOT_ALLOWED = 4,
-    INVALID_ENCODING = 5,
-    OTHER = 6
-}
-/**
- *  @category Error
- *  Parent error class all taquito errors to extend from
- */
-export declare class TaquitoError extends Error {
-}
-/**
- *  @category Error
- *  Error that indicates invalid user inputs
- */
-export declare class ParameterValidationError extends TaquitoError {
-    readonly errorDetail?: string;
-    readonly result?: ValidationResult;
-    constructor(validationResult?: ValidationResult);
-    constructor(message?: string, errorDetail?: string | ValidationResult);
-    constructor(message?: string, validationResult?: ValidationResult, errorDetail?: string);
-}
-/**
- *  @category Error
- *  Error returned by RPC node
- */
-export declare class RpcError extends TaquitoError {
-}
-/**
- *  @category Error
- *  Error that indicates TezosToolKit has not been configured appropriately
- */
-export declare class TezosToolkitConfigError extends TaquitoError {
-}
-/**
- *  @category Error
- *  Error that indicates a requested action is not supported by Taquito
- */
-export declare class UnsupportedActionError extends TaquitoError {
-}
-/**
- *  @category Error
- *  Error during a network operation
- */
-export declare class NetworkError extends TaquitoError {
-}
-/**
- *  @category Error
- *  Error that indicates user attempts an action without necessary permissions
- */
-export declare class PermissionDeniedError extends TaquitoError {
-}
-/**
- *  @category Error
- *  Error that indicates an invalid originated or implicit address being passed or used
- */
-export declare class InvalidAddressError extends ParameterValidationError {
-    readonly address: string;
-    constructor(address: string, errorDetail?: string | ValidationResult);
-}
-export declare class InvalidProofError extends ParameterValidationError {
-    readonly proof: string;
-    constructor(proof: string, errorDetail?: string | ValidationResult);
-}
-export declare class InvalidStakingAddressError extends ParameterValidationError {
-    readonly address: string;
-    constructor(address: string, errorDetail?: string | ValidationResult);
-}
-export declare class InvalidFinalizeUnstakeAmountError extends ParameterValidationError {
-    readonly address: string;
-    constructor(address: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid block hash being passed or used
- */
-export declare class InvalidBlockHashError extends ParameterValidationError {
-    readonly blockHash: string;
-    constructor(blockHash: string, errorDetail?: string | ValidationResult);
-}
-/**
- * @category Error
- * Error that indicates an invalid amount of tez being passed as a parameter
- */
-export declare class InvalidAmountError extends ParameterValidationError {
-    readonly amount: string;
-    constructor(amount: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid derivation path being passed or used
- */
-export declare class InvalidDerivationPathError extends ParameterValidationError {
-    readonly derivationPath: string;
-    constructor(derivationPath: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid hex string have been passed or used
- */
-export declare class InvalidHexStringError extends ParameterValidationError {
-    readonly hexString: string;
-    constructor(hexString: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid message being passed or used
- */
-export declare class InvalidMessageError extends ParameterValidationError {
-    readonly msg: string;
-    constructor(msg: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates invalid view parameter of a smart contract
- */
-export declare class InvalidViewParameterError extends ParameterValidationError {
-    readonly viewName: string;
-    readonly sigs: any;
-    readonly args: any;
-    readonly cause?: any | undefined;
-    constructor(viewName: string, sigs: any, args: any, cause?: any | undefined, errorDetail?: string);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid private key being passed or used
- */
-export declare class InvalidKeyError extends ParameterValidationError {
-    constructor(errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an Invalid Public Key being passed or used
- */
-export declare class InvalidPublicKeyError extends ParameterValidationError {
-    readonly publicKey?: string | undefined;
-    constructor(publicKey?: string | undefined, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid signature being passed or used
- */
-export declare class InvalidSignatureError extends ParameterValidationError {
-    readonly signature: string;
-    constructor(signature: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid contract address being passed or used
- */
-export declare class InvalidContractAddressError extends ParameterValidationError {
-    readonly contractAddress: string;
-    constructor(contractAddress: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid chain id being passed or used
- */
-export declare class InvalidChainIdError extends ParameterValidationError {
-    readonly chainId: string;
-    constructor(chainId: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid public key hash being passed or used
- */
-export declare class InvalidKeyHashError extends ParameterValidationError {
-    readonly keyHash: string;
-    constructor(keyHash: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid operation hash being passed or used
- */
-export declare class InvalidOperationHashError extends ParameterValidationError {
-    readonly operationHash: string;
-    constructor(operationHash: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  Error that indicates an invalid operation kind being passed or used
- */
-export declare class InvalidOperationKindError extends ParameterValidationError {
-    readonly operationKind: string;
-    constructor(operationKind: string, errorDetail?: string | ValidationResult);
-}
-/**
- *  @category Error
- *  General error that indicates something is no longer supported and/or deprecated
- */
-export declare class DeprecationError extends UnsupportedActionError {
-    constructor(message: string);
-}
-/**
- *  @category Error
- *  General error that indicates an action is prohibited or not allowed
- */
-export declare class ProhibitedActionError extends UnsupportedActionError {
-    constructor(message: string);
-}
-/**
- *  @category Error
- *  Error that indicates a failure in grabbing the public key
- */
-export declare class PublicKeyNotFoundError extends TaquitoError {
-    readonly pkh: string;
-    readonly cause?: any | undefined;
-    constructor(pkh: string, cause?: any | undefined);
-}