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

package/dist/types/taquito/src/read-provider/rpc-read-adapter.d.ts

@@ -0,0 +1,130 @@
+import { BlockResponse, EntrypointsResponse, MichelsonV1Expression, RpcClientInterface, SaplingDiffResponse, ScriptedContracts, AILaunchCycleResponse } from '@taquito/rpc';
+import BigNumber from 'bignumber.js';
+import { BigMapQuery, BlockIdentifier, SaplingStateQuery, TzReadProvider } from './interface';
+/**
+ * Converts calls from TzReadProvider into calls to the wrapped RpcClient in a format it can understand.
+ */
+export declare class RpcReadAdapter implements TzReadProvider {
+    private rpc;
+    constructor(rpc: RpcClientInterface);
+    /**
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
+     * @param address address from which we want to retrieve the spendable balance
+     * @param block from which we want to retrieve the balance
+     * @returns the balance in mutez
+     */
+    getBalance(address: string, block: BlockIdentifier): Promise<BigNumber>;
+    /**
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
+     * @param address address from which we want to retrieve the spendable balance
+     * @param block from which we want to retrieve the balance
+     * @returns the balance in mutez
+     */
+    getSpendable(address: string, block: BlockIdentifier): Promise<BigNumber>;
+    /**
+     * Access the delegate of a contract, if any.
+     * @param address contract address from which we want to retrieve the delegate (baker)
+     * @param block from which we want to retrieve the delegate
+     * @returns the public key hash of the delegate or null if no delegate
+     */
+    getDelegate(address: string, block: BlockIdentifier): Promise<string | null>;
+    /**
+     * Access the next protocol hash
+     * @param block from which we want to retrieve the next protocol hash
+     */
+    getNextProtocol(block: BlockIdentifier): Promise<string>;
+    /**
+     * Access protocol constants used in Taquito
+     * @param block from which we want to retrieve the constants
+     */
+    getProtocolConstants(block: BlockIdentifier): Promise<{
+        time_between_blocks?: BigNumber[];
+        minimal_block_delay?: BigNumber | undefined;
+        hard_gas_limit_per_operation: BigNumber;
+        hard_gas_limit_per_block: BigNumber;
+        hard_storage_limit_per_operation: BigNumber;
+        cost_per_byte: BigNumber;
+        smart_rollup_origination_size: number;
+    }>;
+    /**
+     * Access the script (code and storage) of a smart contract
+     * @param contract contract address from which we want to retrieve the script
+     * @param block from which we want to retrieve the storage value
+     * @returns Note: The code must be in the JSON format and not contain global constant
+     */
+    getScript(contract: string, block: BlockIdentifier): Promise<ScriptedContracts>;
+    /**
+     * Access the storage value of a contract
+     * @param contract contract address from which we want to retrieve the storage
+     * @param block from which we want to retrieve the storage value
+     */
+    getStorage(contract: string, block: BlockIdentifier): Promise<MichelsonV1Expression>;
+    /**
+     * Access the block hash
+     */
+    getBlockHash(block: BlockIdentifier): Promise<string>;
+    /**
+     * Access the block level
+     */
+    getBlockLevel(block: BlockIdentifier): Promise<number>;
+    /**
+     * Access the counter of an address
+     * @param pkh from which we want to retrieve the counter
+     * @param block from which we want to retrieve the counter
+     */
+    getCounter(pkh: string, block: BlockIdentifier): Promise<string>;
+    /**
+     * Access the timestamp of a block
+     * @param block from which we want to retrieve the timestamp
+     * @returns date ISO format zero UTC offset ("2022-01-19T22:37:07Z")
+     */
+    getBlockTimestamp(block: BlockIdentifier): Promise<string>;
+    /**
+     * Access the value associated with a key in a big map.
+     * @param bigMapQuery Big Map ID and Expression hash to query (A b58check encoded Blake2b hash of the expression)
+     * @param block from which we want to retrieve the big map value
+     */
+    getBigMapValue(bigMapQuery: BigMapQuery, block: BlockIdentifier): Promise<MichelsonV1Expression>;
+    /**
+     * Access the value associated with a sapling state ID.
+     * @param saplingStateQuery Sapling state ID query
+     * @param block from which we want to retrieve the sapling state
+     */
+    getSaplingDiffById(saplingStateQuery: SaplingStateQuery, block: BlockIdentifier): Promise<SaplingDiffResponse>;
+    /**
+     * Access the sapling state of a smart contract.
+     * @param contractAddress The address of the smart contract
+     * @param block The block you want to retrieve the sapling state from
+     */
+    getSaplingDiffByContract(contractAddress: string, block: BlockIdentifier): Promise<SaplingDiffResponse>;
+    /**
+     * Return the list of entrypoints of the contract
+     * @param contract address of the contract we want to get the entrypoints of
+     */
+    getEntrypoints(contract: string): Promise<EntrypointsResponse>;
+    /**
+     * Access the chain id
+     */
+    getChainId(): Promise<string>;
+    /**
+     * Indicate if an account is revealed
+     * @param publicKeyHash of the account
+     * @param block from which we want to know if the account is revealed
+     */
+    isAccountRevealed(publicKeyHash: string, block: BlockIdentifier): Promise<boolean>;
+    /**
+     * Return all the information about a block
+     * @param block from which we want to retrieve the information
+     */
+    getBlock(block: BlockIdentifier): Promise<BlockResponse>;
+    /**
+     * Return a list of the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
+     * @param block from which we want to retrieve the information
+     */
+    getLiveBlocks(block: BlockIdentifier): Promise<string[]>;
+    /**
+     * Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
+     * @param block from which we want to retrieve the information
+     */
+    getAdaptiveIssuanceLaunchCycle(block: BlockIdentifier): Promise<AILaunchCycleResponse>;
+}

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

@@ -0,0 +1,8 @@
+import { TezosToolkitConfigError } from '@taquito/core';
+/**
+ *  @category Error
+ *  Error that indicates no signer has been configured in the TezosToolkit instance
+ */
+export declare class UnconfiguredSignerError extends TezosToolkitConfigError {
+    constructor();
+}

package/dist/types/taquito/src/signer/noop.d.ts

@@ -0,0 +1,11 @@
+import { Signer } from '@taquito/core';
+/**
+ * Default signer implementation which does nothing and produce invalid signature
+ * @throw {@link UnconfiguredSignerError}
+ */
+export declare class NoopSigner implements Signer {
+    publicKey(): Promise<string>;
+    publicKeyHash(): Promise<string>;
+    secretKey(): Promise<string>;
+    sign(_bytes: string, _watermark?: Uint8Array): Promise<any>;
+}

package/dist/types/taquito/src/subscribe/create-observable-from-subscription.d.ts

@@ -0,0 +1,4 @@
+import { BlockResponse } from '@taquito/rpc';
+import { Observable } from 'rxjs';
+import { OperationContent, Subscription } from './interface';
+export declare function createObservableFromSubscription<T extends BlockResponse | string | OperationContent>(sub: Subscription<T>): Observable<T>;

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

@@ -0,0 +1,18 @@
+import { ParameterValidationError } from '@taquito/core';
+import { FilterExpression } from '../taquito';
+/**
+ *  @category Error
+ *  Error that indicates an unsupported event being passed or used
+ */
+export declare class UnsupportedEventError extends ParameterValidationError {
+    readonly type: string;
+    constructor(type: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates an invalid filter expression being passed or used
+ */
+export declare class InvalidFilterExpressionError extends ParameterValidationError {
+    readonly invalidExpression: FilterExpression;
+    constructor(invalidExpression: FilterExpression);
+}

package/dist/types/taquito/src/subscribe/filters.d.ts

@@ -0,0 +1,6 @@
+import { OpFilter, FilterExpression, Filter, OperationContent } from './interface';
+import { InternalOperationResult } from '@taquito/rpc';
+export declare const eventFilter: (result: InternalOperationResult, address?: string, tag?: string, excludeFailedOperations?: boolean) => boolean;
+export declare const evaluateOpFilter: (op: OperationContent, filter: OpFilter) => boolean | undefined;
+export declare const evaluateExpression: (op: OperationContent, exp: FilterExpression) => boolean;
+export declare const evaluateFilter: (op: OperationContent, filter: Filter) => boolean;

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

@@ -0,0 +1,48 @@
+import { BlockResponse, InternalOperationResult, OperationEntry } from '@taquito/rpc';
+export type FilterExpression = {
+    or?: ExpressionOrOpFilter[];
+    and?: ExpressionOrOpFilter[];
+};
+export interface OpHashFilter {
+    opHash: string;
+}
+export interface SourceFilter {
+    source: string;
+}
+export interface KindFilter {
+    kind: string;
+}
+export interface DestinationFilter {
+    destination: string;
+}
+export interface EventFilter {
+    address?: string;
+    tag?: string;
+    excludeFailedOperations?: boolean;
+}
+export interface EventSubscription extends InternalOperationResult {
+    opHash: string;
+    blockHash: string;
+    level: number;
+}
+export type OpFilter = OpHashFilter | SourceFilter | KindFilter | DestinationFilter | EventFilter;
+export type ExpressionOrOpFilter = OpFilter | FilterExpression;
+export type Filter = ExpressionOrOpFilter | ExpressionOrOpFilter[];
+export type OperationContent = OperationEntry['contents'][0] & {
+    hash: string;
+};
+export interface SubscribeProvider {
+    subscribe(filter: 'head'): Subscription<string>;
+    subscribeBlock(filter: 'head'): Subscription<BlockResponse>;
+    subscribeOperation(filter: Filter): Subscription<OperationContent>;
+    subscribeEvent(filter?: EventFilter): Subscription<InternalOperationResult>;
+}
+export interface Subscription<T> {
+    on(type: 'error', cb: (error: Error) => void): void;
+    on(type: 'data', cb: (data: T) => void): void;
+    on(type: 'close', cb: () => void): void;
+    off(type: 'error', cb: (error: Error) => void): void;
+    off(type: 'data', cb: (data: T) => void): void;
+    off(type: 'close', cb: () => void): void;
+    close(): void;
+}

package/dist/types/taquito/src/subscribe/observable-subscription.d.ts

@@ -0,0 +1,21 @@
+import { Observable, OperatorFunction } from 'rxjs';
+import { Subscription } from './interface';
+export { UnsupportedEventError } from './errors';
+export declare class ObservableSubscription<T> implements Subscription<T> {
+    private shouldRetry;
+    private operatorFunction;
+    private errorListeners;
+    private messageListeners;
+    private closeListeners;
+    private completed$;
+    constructor(obs: Observable<T>, shouldRetry?: boolean, operatorFunction?: OperatorFunction<T, T>);
+    private call;
+    private remove;
+    on(type: 'error', cb: (error: Error) => void): void;
+    on(type: 'data', cb: (data: T) => void): void;
+    on(type: 'close', cb: () => void): void;
+    off(type: 'error', cb: (error: Error) => void): void;
+    off(type: 'data', cb: (data: T) => void): void;
+    off(type: 'close', cb: () => void): void;
+    close(): void;
+}

package/dist/types/taquito/src/subscribe/polling-subcribe-provider.d.ts

@@ -0,0 +1,23 @@
+import { BlockResponse, InternalOperationResult } from '@taquito/rpc';
+import { OperatorFunction } from 'rxjs';
+import { Context } from '../context';
+import { Filter, EventFilter, SubscribeProvider, Subscription, OperationContent } from './interface';
+export interface PollingSubscribeProviderConfig {
+    pollingIntervalMilliseconds?: number;
+    shouldObservableSubscriptionRetry: boolean;
+    observableSubscriptionRetryFunction: OperatorFunction<any, any>;
+}
+export declare const defaultConfigStreamer: PollingSubscribeProviderConfig;
+export declare class PollingSubscribeProvider implements SubscribeProvider {
+    private context;
+    private _config$;
+    private timer$;
+    private newBlock$;
+    constructor(context: Context, config?: Partial<PollingSubscribeProviderConfig>);
+    get config(): PollingSubscribeProviderConfig;
+    private getConfirmationPollingInterval;
+    subscribeBlock(_filter: 'head'): Subscription<BlockResponse>;
+    subscribe(_filter: 'head'): Subscription<string>;
+    subscribeOperation(filter: Filter): Subscription<OperationContent>;
+    subscribeEvent(eventFilter?: EventFilter): Subscription<InternalOperationResult>;
+}

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

@@ -0,0 +1,248 @@
+/**
+ * @packageDocumentation
+ * @module @taquito/taquito
+ */
+import { RpcClientInterface } from '@taquito/rpc';
+import { Forger } from '@taquito/local-forging';
+import { Protocols } from './constants';
+import { ConfigConfirmation, TaquitoProvider } from './context';
+import { ContractProvider } from './contract/interface';
+import { Extension } from './extension/extension';
+import { format } from '@taquito/utils';
+import { GlobalConstantsProvider } from './global-constants/interface-global-constants-provider';
+import { Packer } from './packer/interface';
+import { TzReadProvider } from './read-provider/interface';
+import { PreparationProvider } from './prepare/interface';
+import { Signer } from '@taquito/core';
+import { SubscribeProvider } from './subscribe/interface';
+import { TzProvider } from './tz/interface';
+import { Wallet, WalletProvider } from './wallet';
+import { OperationFactory } from './wallet/operation-factory';
+import { EstimationProvider } from './estimate/estimate-provider-interface';
+import { ParserProvider } from './parser/interface';
+import { Injector } from './injector/interface';
+import { FieldNumberingStrategy } from '@taquito/michelson-encoder';
+export { FieldNumberingStrategy, Token, MichelsonMap, UnitValue } from '@taquito/michelson-encoder';
+export { Forger, ForgeParams, ForgeResponse } from '@taquito/local-forging';
+export * from './constants';
+export * from './context';
+export { TaquitoProvider } from './context';
+export * from './contract';
+export * from './contract/big-map';
+export { CompositeForger } from './forger/composite-forger';
+export { RpcForger } from './forger/rpc-forger';
+export * from './operations';
+export { OperationBatch } from './batch/rpc-batch-provider';
+export { Signer } from '@taquito/core';
+export * from './subscribe/interface';
+export { SubscribeProvider } from './subscribe/interface';
+export { PollingSubscribeProvider } from './subscribe/polling-subcribe-provider';
+export { ObservableSubscription } from './subscribe/observable-subscription';
+export * from './tz/interface';
+export * from './wallet';
+export { Extension } from './extension/extension';
+export * from './injector/interface';
+export * from './injector/rpc-injector';
+export * from './parser/interface';
+export * from './parser/michel-codec-parser';
+export * from './parser/noop-parser';
+export * from './packer/interface';
+export * from './packer/michel-codec-packer';
+export * from './packer/rpc-packer';
+export * from './global-constants/default-global-constants-provider';
+export * from './global-constants/errors';
+export * from './global-constants/interface-global-constants-provider';
+export { BigMapQuery, SaplingStateQuery, BlockIdentifier, TzReadProvider, } from './read-provider/interface';
+export { RpcReadAdapter } from './read-provider/rpc-read-adapter';
+export * from './estimate';
+export { TaquitoLocalForger } from './forger/taquito-local-forger';
+export * from './prepare';
+export { importKey } from './import-key';
+export interface SetProviderOptions {
+    forger?: Forger;
+    wallet?: WalletProvider;
+    rpc?: string | RpcClientInterface;
+    readProvider?: TzReadProvider;
+    stream?: string | SubscribeProvider;
+    signer?: Signer;
+    protocol?: Protocols;
+    config?: Partial<ConfigConfirmation>;
+    packer?: Packer;
+    globalConstantsProvider?: GlobalConstantsProvider;
+    parserProvider?: ParserProvider;
+    injectorProvider?: Injector;
+}
+export interface VersionInfo {
+    commitHash: string;
+    version: string;
+}
+/**
+ * Facade class that surfaces all of the libraries capability and allow it's configuration
+ *
+ * @param _rpc The RPC server to use
+ */
+export declare class TezosToolkit {
+    private _rpc;
+    private _options;
+    private _rpcClient;
+    private _wallet;
+    private _context;
+    readonly format: typeof format;
+    constructor(_rpc: RpcClientInterface | string);
+    /**
+     * Sets configuration on the Tezos Taquito instance. Allows user to choose which signer, rpc client, rpc url, forger and so forth
+     *
+     * @param options rpc url or rpcClient to use to interact with the Tezos network
+     *
+     * @example Tezos.setProvider({rpc: 'https://mainnet.tezos.ecadinfra.com/', signer: new InMemorySigner.fromSecretKey(“edsk...”)})
+     * @example Tezos.setProvider({ config: { confirmationPollingTimeoutSecond: 300 }})
+     *
+     */
+    setProvider({ rpc, stream, signer, protocol, config, forger, wallet, packer, globalConstantsProvider, readProvider, parserProvider, injectorProvider, }: SetProviderOptions): void;
+    /**
+     * Sets signer provider on the Tezos Taquito instance.
+     *
+     * @param signer signer to use to interact with the Tezos network
+     *
+     * @example Tezos.setSignerProvider(new InMemorySigner.fromSecretKey('edsk...'))
+     *
+     */
+    setSignerProvider(signer?: SetProviderOptions['signer']): void;
+    /**
+     * Sets rpc provider on the Tezos Taquito instance
+     *
+     * @param rpc rpc url or rpcClient to use to interact with the Tezos network
+     *
+     * @example Tezos.setRpcProvider('https://mainnet.tezos.ecadinfra.com/')
+     *
+     */
+    setRpcProvider(rpc?: SetProviderOptions['rpc']): void;
+    /**
+     * Sets forger provider on the Tezos Taquito instance
+     * The `LocalForger` from `@taquito/local-forging` is set by default.
+     *
+     * @param forger forger to use to interact with the Tezos network
+     *
+     * @example Tezos.setForgerProvider(this.getFactory(RpcForger)())
+     *
+     */
+    setForgerProvider(forger?: SetProviderOptions['forger']): void;
+    /**
+     * Sets stream provider on the Tezos Taquito instance
+     *
+     * @param stream stream to use to interact with the Tezos network
+     *
+     * @example Tezos.setStreamProvider(...)
+     *
+     */
+    setStreamProvider(stream?: SetProviderOptions['stream']): void;
+    /**
+     * Sets wallet provider on the Tezos Taquito instance
+     *
+     * @param wallet wallet to use to interact with the Tezos network
+     *
+     * @example Tezos.setWalletProvider(...)
+     *
+     */
+    setWalletProvider(wallet?: SetProviderOptions['wallet']): void;
+    /**
+     * Sets Packer provider on the Tezos Taquito instance
+     *
+     * @param packer packer to use to interact with the Tezos network
+     *
+     * @example Tezos.setPackerProvider(new MichelCodecPacker())
+     *
+     */
+    setPackerProvider(packer?: SetProviderOptions['packer']): void;
+    /**
+     * Sets global constants provider on the Tezos Taquito instance
+     *
+     * @param globalConstantsProvider globalConstantsProvider to use to interact with the Tezos network
+     *
+     * @example
+     * ```
+     * const globalConst = new DefaultGlobalConstantsProvider();
+     * globalConst.loadGlobalConstant({
+     *  "expruu5BTdW7ajqJ9XPTF3kgcV78pRiaBW3Gq31mgp3WSYjjUBYxre": { prim: "int" },
+     *  // ...
+     * })
+     * Tezos.setGlobalConstantsProvider(globalConst);
+     * ```
+     *
+     */
+    setGlobalConstantsProvider(globalConstantsProvider?: SetProviderOptions['globalConstantsProvider']): void;
+    /**
+     * Sets read provider on the Tezos Taquito instance
+     * By default reads are done from the RPC usign the RpcReadAdapter class, this can be overridden to read from an indexer that implements the TzReadProvider interface
+     *
+     * @param readProvider TzReadProvider to use to interact with the Tezos network
+     *
+     */
+    setReadProvider(readProvider?: SetProviderOptions['readProvider']): void;
+    /**
+     * Sets parser provider on the Tezos Taquito instance
+     *
+     * @param parserProvider parserProvider to use to interact with the Tezos network
+     *
+     */
+    setParserProvider(parserProvider?: SetProviderOptions['parserProvider']): void;
+    /**
+     * Sets injector provider on the Tezos Taquito instance
+     *
+     * @param injectorProvider Injector to use to interact with the Tezos network by default RpcInjector
+     *
+     */
+    setInjectorProvider(injectorProvider?: SetProviderOptions['injectorProvider']): void;
+    /**
+     * Sets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects
+     * @param strategy a value of type FieldNumberingStrategy that controls how field numbers are calculated
+     */
+    setFieldNumberingStrategy(strategy: FieldNumberingStrategy): void;
+    /**
+     * Provide access to tezos account management
+     */
+    get tz(): TzProvider;
+    /**
+     * Provide access to smart contract utilities
+     */
+    get contract(): ContractProvider;
+    /**
+     * Provide access to tezos operation preparation utilities
+     */
+    get prepare(): PreparationProvider;
+    get wallet(): Wallet;
+    get operation(): OperationFactory;
+    /**
+     * Provide access to operation estimation utilities
+     */
+    get estimate(): EstimationProvider;
+    /**
+     * Provide access to streaming utilities backed by an streamer implementation
+     */
+    get stream(): SubscribeProvider;
+    /**
+     * Provide access to the currently used rpc client
+     */
+    get rpc(): RpcClientInterface;
+    /**
+     * Provide access to the currently used signer
+     */
+    get signer(): Signer;
+    /**
+     * Provide access to the currently used globalConstantsProvider
+     */
+    get globalConstants(): GlobalConstantsProvider;
+    /**
+     * Allow to add a module to the TezosToolkit instance. This method adds the appropriate Providers(s) required by the module to the internal context.
+     *
+     * @param module extension to add to the TezosToolkit instance
+     *
+     * @example Tezos.addExtension(new Tzip16Module());
+     */
+    addExtension(module: Extension | Extension[]): void;
+    getFactory<T, K extends Array<any>>(ctor: TaquitoProvider<T, K>): (...args: K) => T;
+    /**
+     * Gets an object containing the version of Taquito library and git sha of the commit this library is compiled from
+     */
+    getVersionInfo(): VersionInfo;
+}

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

@@ -0,0 +1,20 @@
+import BigNumber from 'bignumber.js';
+import { Operation } from '../operations/operations';
+export interface TzProvider {
+    /**
+     *
+     * @param address Tezos address you want to get the spendable balance for (eg tz1...)
+     */
+    getBalance(address: string): Promise<BigNumber>;
+    /**
+     *
+     * @param address Tezos address you want to get the spendable balance for (eg tz1...)
+     */
+    getSpendable(address: string): Promise<BigNumber>;
+    /**
+     *
+     * @param address Tezos address you want to get the delegate for (eg tz1...)
+     */
+    getDelegate(address: string): Promise<string | null>;
+    activate(pkh: string, secret: string): Promise<Operation>;
+}

package/dist/types/taquito/src/tz/rpc-tz-provider.d.ts

@@ -0,0 +1,13 @@
+import BigNumber from 'bignumber.js';
+import { Context } from '../context';
+import { Operation } from '../operations/operations';
+import { TzProvider } from './interface';
+import { Provider } from '../provider';
+export declare class RpcTzProvider extends Provider implements TzProvider {
+    constructor(context: Context);
+    private prepare;
+    getBalance(address: string): Promise<BigNumber>;
+    getSpendable(address: string): Promise<BigNumber>;
+    getDelegate(address: string): Promise<string | null>;
+    activate(pkh: string, secret: string): Promise<Operation>;
+}

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

@@ -0,0 +1,4 @@
+export declare const VERSION: {
+    commitHash: string;
+    version: string;
+};

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

@@ -0,0 +1,13 @@
+import { BlockResponse, OperationContentsAndResultReveal, OpKind } from '@taquito/rpc';
+import { Observable } from 'rxjs';
+import { Context } from '../context';
+import { WalletOperation, OperationStatus } from './operation';
+export declare const WALLET_BATCH_KINDS: OpKind[];
+export declare class BatchWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    getOriginatedContractAddresses: () => Promise<string[]>;
+    status(): Promise<OperationStatus>;
+}

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

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

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

@@ -0,0 +1,24 @@
+import { TezosToolkitConfigError, NetworkError } from '@taquito/core';
+/**
+ *  @category Error
+ *  Error that indicates undefined confirmation has not been specified or configured
+ */
+export declare class ConfirmationUndefinedError extends TezosToolkitConfigError {
+    constructor();
+}
+/**
+ *  @category Error
+ *  Error that indicates a generic failure when trying to fetch an observable
+ */
+export declare class ObservableError extends NetworkError {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ *  @category Error
+ *  Error that indicates a newly originated wallet contract could not be resolved
+ */
+export declare class OriginationWalletOperationError extends ObservableError {
+    readonly message: string;
+    constructor(message: string);
+}

package/dist/types/taquito/src/wallet/increase-paid-storage-operation.d.ts

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

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

@@ -0,0 +1,9 @@
+export * from './wallet';
+export * from './operation';
+export * from './transaction-operation';
+export * from './origination-operation';
+export * from './delegation-operation';
+export * from './transfer-ticket-operation';
+export * from './register-global-constant-operation';
+export * from './interface';
+export * from './legacy';