@wagmi/core 0.2.0-next.0

package/dist/declarations/src/actions/contracts/writeContract.d.ts

@@ -0,0 +1,11 @@
+import type { TransactionResponse } from '@ethersproject/providers';
+import { CallOverrides, Contract as EthersContract } from 'ethers/lib/ethers';
+import { GetContractArgs } from './getContract';
+export declare type WriteContractArgs = GetContractArgs;
+export declare type WriteContractConfig = {
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    overrides?: CallOverrides;
+};
+export declare type WriteContractResult = TransactionResponse;
+export declare function writeContract<Contract extends EthersContract = EthersContract>(contractConfig: WriteContractArgs, functionName: string, { args, overrides }?: WriteContractConfig): Promise<WriteContractResult>;

package/dist/declarations/src/actions/ens/fetchEnsAddress.d.ts

@@ -0,0 +1,6 @@
+export declare type FetchEnsAddressArgs = {
+    /** ENS name to resolve */
+    name: string;
+};
+export declare type FetchEnsAddressResult = string | null;
+export declare function fetchEnsAddress({ name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;

package/dist/declarations/src/actions/ens/fetchEnsAvatar.d.ts

@@ -0,0 +1,6 @@
+export declare type FetchEnsAvatarArgs = {
+    /** Address or ENS name */
+    addressOrName: string;
+};
+export declare type FetchEnsAvatarResult = string | null;
+export declare function fetchEnsAvatar({ addressOrName, }: FetchEnsAvatarArgs): Promise<FetchEnsAvatarResult>;

package/dist/declarations/src/actions/ens/fetchEnsName.d.ts

@@ -0,0 +1,6 @@
+export declare type FetchEnsNameArgs = {
+    /** Address to lookup */
+    address: string;
+};
+export declare type FetchEnsNameResult = string | null;
+export declare function fetchEnsName({ address, }: FetchEnsNameArgs): Promise<FetchEnsNameResult>;

package/dist/declarations/src/actions/ens/fetchEnsResolver.d.ts

@@ -0,0 +1,7 @@
+import type { Resolver } from '@ethersproject/providers';
+export declare type FetchEnsResolverArgs = {
+    /** ENS name to resolve */
+    name: string;
+};
+export declare type FetchEnsResolverResult = Resolver | null;
+export declare function fetchEnsResolver({ name, }: FetchEnsResolverArgs): Promise<FetchEnsResolverResult>;

package/dist/declarations/src/actions/ens/index.d.ts

@@ -0,0 +1,8 @@
+export { fetchEnsAddress, type FetchEnsAddressArgs, type FetchEnsAddressResult, } from './fetchEnsAddress';
+export { fetchEnsAvatar, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, } from './fetchEnsAvatar';
+export { fetchEnsName, type FetchEnsNameArgs, type FetchEnsNameResult, } from './fetchEnsName';
+export { fetchEnsResolver, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './fetchEnsResolver';
+export { watchEnsAddress, type WatchEnsAddressCallback, } from './watchEnsAddress';
+export { type WatchEnsAvatarCallback, watchEnsAvatar } from './watchEnsAvatar';
+export { type WatchEnsNameCallback, watchEnsName } from './watchEnsName';
+export { watchEnsResolver, type WatchEnsResolverCallback, } from './watchEnsResolver';

package/dist/declarations/src/actions/ens/watchEnsAddress.d.ts

@@ -0,0 +1,3 @@
+import { FetchEnsAddressArgs, FetchEnsAddressResult } from './fetchEnsAddress';
+export declare type WatchEnsAddressCallback = (address: FetchEnsAddressResult) => void;
+export declare function watchEnsAddress(args: FetchEnsAddressArgs, callback: WatchEnsAddressCallback): () => void;

package/dist/declarations/src/actions/ens/watchEnsAvatar.d.ts

@@ -0,0 +1,3 @@
+import { FetchEnsAvatarArgs, FetchEnsAvatarResult } from './fetchEnsAvatar';
+export declare type WatchEnsAvatarCallback = (addressOrName: FetchEnsAvatarResult) => void;
+export declare function watchEnsAvatar(args: FetchEnsAvatarArgs, callback: WatchEnsAvatarCallback): () => void;

package/dist/declarations/src/actions/ens/watchEnsName.d.ts

@@ -0,0 +1,3 @@
+import { FetchEnsNameArgs, FetchEnsNameResult } from './fetchEnsName';
+export declare type WatchEnsNameCallback = (name: FetchEnsNameResult) => void;
+export declare function watchEnsName(args: FetchEnsNameArgs, callback: WatchEnsNameCallback): () => void;

package/dist/declarations/src/actions/ens/watchEnsResolver.d.ts

@@ -0,0 +1,3 @@
+import { FetchEnsResolverArgs, FetchEnsResolverResult } from './fetchEnsResolver';
+export declare type WatchEnsResolverCallback = (resolver: FetchEnsResolverResult) => void;
+export declare function watchEnsResolver(args: FetchEnsResolverArgs, callback: WatchEnsResolverCallback): () => void;

package/dist/declarations/src/actions/index.d.ts

@@ -0,0 +1,7 @@
+export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchBalance, watchNetwork, watchSigner, type ConnectResult, type FetchBalanceArgs, type FetchBalanceResult, type FetchSignerResult, type GetAccountResult, type GetNetworkResult, type SignMessageArgs, type SignMessageResult, type SignTypedDataArgs, type SignTypedDataResult, type SwitchNetworkArgs, type SwitchNetworkResult, type WatchAccountCallback, type WatchBalanceCallback, type WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
+export { getContract, readContract, watchContractEvent, watchReadContract, writeContract, type GetContractArgs, type ReadContractArgs, type ReadContractConfig, type ReadContractResult, type WatchReadContractArgs, type WatchReadContractConfig, type WatchReadContractResult, type WriteContractArgs, type WriteContractConfig, type WriteContractResult, } from './contracts';
+export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, watchEnsAddress, watchEnsAvatar, watchEnsName, watchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, type WatchEnsAddressCallback, type WatchEnsAvatarCallback, type WatchEnsNameCallback, type WatchEnsResolverCallback, } from './ens';
+export { fetchBlockNumber, fetchFeeData, watchBlockNumber, watchFeeData, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, type WatchFeeDataArgs, type WatchFeeDataCallback, } from './network-status';
+export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderResult, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';
+export { fetchToken, watchToken, type FetchTokenArgs, type FetchTokenResult, type WatchTokenCallback, } from './tokens';
+export { sendTransaction, waitForTransaction, type SendTransactionArgs, type SendTransactionResult, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';

package/dist/declarations/src/actions/network-status/fetchBlockNumber.d.ts

@@ -0,0 +1,2 @@
+export declare type FetchBlockNumberResult = number;
+export declare function fetchBlockNumber(): Promise<number>;

package/dist/declarations/src/actions/network-status/fetchFeeData.d.ts

@@ -0,0 +1,14 @@
+import type { FeeData } from '@ethersproject/providers';
+import { Unit } from '../../types';
+export declare type FetchFeeDataArgs = {
+    /** Units for formatting output */
+    formatUnits?: Unit | number;
+};
+export declare type FetchFeeDataResult = FeeData & {
+    formatted: {
+        gasPrice: string;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string;
+    };
+};
+export declare function fetchFeeData({ formatUnits: units, }?: FetchFeeDataArgs): Promise<FetchFeeDataResult>;

package/dist/declarations/src/actions/network-status/index.d.ts

@@ -0,0 +1,4 @@
+export { fetchBlockNumber, type FetchBlockNumberResult, } from './fetchBlockNumber';
+export { fetchFeeData, type FetchFeeDataResult, type FetchFeeDataArgs, } from './fetchFeeData';
+export { watchFeeData, type WatchFeeDataArgs, type WatchFeeDataCallback, } from './watchFeeData';
+export { watchBlockNumber, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './watchBlockNumber';

package/dist/declarations/src/actions/network-status/watchBlockNumber.d.ts

@@ -0,0 +1,6 @@
+import { FetchBlockNumberResult } from './fetchBlockNumber';
+export declare type WatchBlockNumberArgs = {
+    listen: boolean;
+};
+export declare type WatchBlockNumberCallback = (blockNumber: FetchBlockNumberResult) => void;
+export declare function watchBlockNumber(args: WatchBlockNumberArgs, callback: WatchBlockNumberCallback): () => void;

package/dist/declarations/src/actions/network-status/watchFeeData.d.ts

@@ -0,0 +1,7 @@
+import { FetchFeeDataArgs, FetchFeeDataResult } from './fetchFeeData';
+export declare type WatchFeeDataArgs = FetchFeeDataArgs & {
+    /** Watch for changes to block number */
+    listenToBlock?: boolean;
+};
+export declare type WatchFeeDataCallback = (feeData: FetchFeeDataResult) => void;
+export declare function watchFeeData(args: WatchFeeDataArgs, callback: WatchFeeDataCallback): () => void;

package/dist/declarations/src/actions/providers/getProvider.d.ts

@@ -0,0 +1,3 @@
+import type { BaseProvider } from '@ethersproject/providers';
+export declare type GetProviderResult = BaseProvider;
+export declare function getProvider(): GetProviderResult;

package/dist/declarations/src/actions/providers/getWebSocketProvider.d.ts

@@ -0,0 +1,3 @@
+import type { WebSocketProvider } from '@ethersproject/providers';
+export declare type GetWebSocketProviderResult = WebSocketProvider | undefined;
+export declare function getWebSocketProvider(): GetWebSocketProviderResult;

package/dist/declarations/src/actions/providers/index.d.ts

@@ -0,0 +1,4 @@
+export { getProvider, type GetProviderResult } from './getProvider';
+export { getWebSocketProvider, type GetWebSocketProviderResult, } from './getWebSocketProvider';
+export { watchProvider, type WatchProviderCallback } from './watchProvider';
+export { watchWebSocketProvider, type WatchWebSocketProviderCallback, } from './watchWebSocketProvider';

package/dist/declarations/src/actions/providers/watchProvider.d.ts

@@ -0,0 +1,3 @@
+import { GetProviderResult } from './getProvider';
+export declare type WatchProviderCallback = (provider: GetProviderResult) => void;
+export declare function watchProvider(callback: WatchProviderCallback): () => void;

package/dist/declarations/src/actions/providers/watchWebSocketProvider.d.ts

@@ -0,0 +1,3 @@
+import { GetWebSocketProviderResult } from './getWebSocketProvider';
+export declare type WatchWebSocketProviderCallback = (webSocketProvider: GetWebSocketProviderResult) => void;
+export declare function watchWebSocketProvider(callback: WatchWebSocketProviderCallback): () => void;

package/dist/declarations/src/actions/tokens/fetchToken.d.ts

@@ -0,0 +1,24 @@
+import { BigNumber } from 'ethers/lib/ethers';
+import { Unit } from '../../types';
+export declare type FetchTokenArgs = {
+    address?: string;
+    formatUnits?: Unit | number;
+};
+export declare type FetchTokenResult = {
+    address: string;
+    decimals: number;
+    symbol: string;
+    totalSupply: {
+        formatted: string;
+        value: BigNumber;
+    };
+};
+export declare function fetchToken({ address, formatUnits: units, }: FetchTokenArgs): Promise<{
+    address: string;
+    decimals: any;
+    symbol: any;
+    totalSupply: {
+        formatted: string;
+        value: any;
+    };
+}>;

package/dist/declarations/src/actions/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './fetchToken';
+export { watchToken, type WatchTokenCallback } from './watchToken';

package/dist/declarations/src/actions/tokens/watchToken.d.ts

@@ -0,0 +1,3 @@
+import { FetchTokenArgs, FetchTokenResult } from './fetchToken';
+export declare type WatchTokenCallback = (address: FetchTokenResult) => void;
+export declare function watchToken(args: FetchTokenArgs, callback: WatchTokenCallback): () => void;

package/dist/declarations/src/actions/transactions/index.d.ts

@@ -0,0 +1,2 @@
+export { sendTransaction, type SendTransactionArgs, type SendTransactionResult, } from './sendTransaction';
+export { waitForTransaction, type WaitForTransactionArgs, type WaitForTransactionResult, } from './waitForTransaction';

package/dist/declarations/src/actions/transactions/sendTransaction.d.ts

@@ -0,0 +1,7 @@
+import type { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
+export declare type SendTransactionArgs = {
+    /** Object to use when creating transaction */
+    request: TransactionRequest;
+};
+export declare type SendTransactionResult = TransactionResponse;
+export declare function sendTransaction(args: SendTransactionArgs): Promise<SendTransactionResult>;

package/dist/declarations/src/actions/transactions/waitForTransaction.d.ts

@@ -0,0 +1,15 @@
+import type { TransactionReceipt, TransactionResponse } from '@ethersproject/providers';
+export declare type WaitForTransactionArgs = {
+    /**
+     * Number of blocks to wait for after transaction is mined
+     * @default 1
+     */
+    confirmations?: number;
+    /** Transaction hash to monitor */
+    hash?: string;
+    timeout?: number;
+    /** Function resolving to transaction receipt */
+    wait?: TransactionResponse['wait'];
+};
+export declare type WaitForTransactionResult = TransactionReceipt;
+export declare function waitForTransaction(args: WaitForTransactionArgs): Promise<WaitForTransactionResult>;

package/dist/declarations/src/client.d.ts

@@ -0,0 +1,78 @@
+import type { BaseProvider, WebSocketProvider } from '@ethersproject/providers';
+import { Mutate, StoreApi } from 'zustand/vanilla';
+import { Connector, ConnectorData } from './connectors';
+import { WagmiStorage } from './storage';
+export declare type ClientConfig = {
+    /** Enables reconnecting to last used connector on init */
+    autoConnect?: boolean;
+    /**
+     * Connectors used for linking accounts
+     * @default [new InjectedConnector()]
+     */
+    connectors?: ((config: {
+        chainId?: number;
+    }) => Connector[]) | Connector[];
+    /**
+     * Interface for connecting to network
+     * @default (config) => getDefaultProvider(config.chainId)
+     */
+    provider?: ((config: {
+        chainId?: number;
+    }) => BaseProvider) | BaseProvider;
+    /**
+     * Custom storage for data persistance
+     * @default window.localStorage
+     */
+    storage?: WagmiStorage;
+    /** WebSocket interface for connecting to network */
+    webSocketProvider?: ((config: {
+        chainId?: number;
+    }) => WebSocketProvider | undefined) | WebSocketProvider;
+};
+export declare type Data = ConnectorData<BaseProvider>;
+export declare type State = {
+    connector?: Connector;
+    connectors: Connector[];
+    data?: Data;
+    error?: Error;
+    provider: BaseProvider;
+    status: 'connected' | 'connecting' | 'reconnecting' | 'disconnected';
+    webSocketProvider?: WebSocketProvider;
+};
+export declare class Client {
+    #private;
+    config: Partial<ClientConfig>;
+    storage: WagmiStorage;
+    store: Mutate<StoreApi<State>, [
+        [
+            'zustand/subscribeWithSelector',
+            never
+        ],
+        [
+            'zustand/persist',
+            Partial<State>
+        ]
+    ]>;
+    constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }?: ClientConfig);
+    get connectors(): Connector<any, any>[];
+    get connector(): Connector<any, any> | undefined;
+    get data(): Data | undefined;
+    get error(): Error | undefined;
+    get provider(): BaseProvider;
+    get status(): "connected" | "connecting" | "reconnecting" | "disconnected";
+    get subscribe(): {
+        (listener: (selectedState: State, previousSelectedState: State) => void): () => void;
+        <U>(selector: (state: State) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean | undefined;
+        } | undefined): () => void;
+    };
+    get webSocketProvider(): WebSocketProvider | undefined;
+    setState(updater: State | ((state: State) => State)): void;
+    clearState(): void;
+    destroy(): Promise<void>;
+    autoConnect(): Promise<Data | undefined>;
+    setLastUsedConnector(lastUsedConnector?: string | null): void;
+}
+export declare let client: Client;
+export declare function createClient(config?: ClientConfig): Client;

package/dist/declarations/src/connectors/base.d.ts

@@ -0,0 +1,50 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { Signer } from 'ethers/lib/ethers';
+import { Chain } from '../types';
+export declare type ConnectorData<Provider = any> = {
+    account?: string;
+    chain?: {
+        id: number;
+        unsupported: boolean;
+    };
+    provider?: Provider;
+};
+export interface ConnectorEvents<Provider = any> {
+    change(data: ConnectorData<Provider>): void;
+    connect(data: ConnectorData<Provider>): void;
+    disconnect(): void;
+    error(error: Error): void;
+}
+export declare abstract class Connector<Provider = any, Options = any> extends EventEmitter<ConnectorEvents<Provider>> {
+    /** Unique connector id */
+    abstract readonly id: string;
+    /** Connector name */
+    abstract readonly name: string;
+    /** Chains connector supports */
+    readonly chains: Chain[];
+    /** Options to use with connector */
+    readonly options: Options;
+    /** Whether connector is usable */
+    abstract readonly ready: boolean;
+    constructor({ chains, options, }: {
+        chains?: Chain[];
+        options: Options;
+    });
+    abstract connect(): Promise<ConnectorData>;
+    abstract disconnect(): Promise<void>;
+    abstract getAccount(): Promise<string>;
+    abstract getChainId(): Promise<number>;
+    abstract getProvider(create?: boolean): Promise<Provider>;
+    abstract getSigner(): Promise<Signer>;
+    abstract isAuthorized(): Promise<boolean>;
+    switchChain?(chainId: number): Promise<Chain>;
+    watchAsset?(asset: {
+        address: string;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected abstract onAccountsChanged(accounts: string[]): void;
+    protected abstract onChainChanged(chain: number | string): void;
+    protected abstract onDisconnect(error: Error): void;
+    protected isChainUnsupported(chainId: number): boolean;
+}

package/dist/declarations/src/connectors/coinbaseWallet.d.ts

@@ -0,0 +1,43 @@
+import { providers } from 'ethers';
+import type { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
+import type { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
+import { Chain } from '../types';
+import { Connector } from './base';
+declare type Options = CoinbaseWalletSDKOptions & {
+    jsonRpcUrl?: string;
+};
+export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options> {
+    #private;
+    readonly id = "coinbaseWallet";
+    readonly name = "Coinbase Wallet";
+    readonly ready: boolean;
+    constructor(config: {
+        chains?: Chain[];
+        options: Options;
+    });
+    connect(): Promise<{
+        account: string;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: providers.Web3Provider;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<string>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<CoinbaseWalletProvider>;
+    getSigner(): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
+    watchAsset({ address, decimals, image, symbol, }: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}
+export {};

package/dist/declarations/src/connectors/index.d.ts

@@ -0,0 +1,2 @@
+export { InjectedConnector } from './injected';
+export { Connector, type ConnectorData, type ConnectorEvents } from './base';

package/dist/declarations/src/connectors/injected.d.ts

@@ -0,0 +1,55 @@
+import { providers } from 'ethers';
+import { Chain } from '../types';
+import { Connector } from './base';
+declare type InjectedConnectorOptions = {
+    /**
+     * MetaMask and other injected providers do not support programmatic disconnect.
+     * This flag simulates the disconnect behavior by keeping track of connection status in storage.
+     * @see https://github.com/MetaMask/metamask-extension/issues/10353
+     * @default true
+     */
+    shimDisconnect?: boolean;
+};
+export declare class InjectedConnector extends Connector<Window['ethereum'], InjectedConnectorOptions | undefined> {
+    #private;
+    readonly id = "injected";
+    readonly name: string;
+    readonly ready: boolean;
+    constructor(config?: {
+        chains?: Chain[];
+        options?: InjectedConnectorOptions;
+    });
+    connect(): Promise<{
+        account: string;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: InjectedProviders & {
+            on?: ((...args: any[]) => void) | undefined;
+            removeListener?: ((...args: any[]) => void) | undefined;
+            request<T = any>(args: RequestArguments): Promise<T>;
+        };
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<string>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<(InjectedProviders & {
+        on?: ((...args: any[]) => void) | undefined;
+        removeListener?: ((...args: any[]) => void) | undefined;
+        request<T = any>(args: RequestArguments): Promise<T>;
+    }) | undefined>;
+    getSigner(): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    switchChain(chainId: number): Promise<Chain>;
+    watchAsset({ address, decimals, image, symbol, }: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<any>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}
+export {};

package/dist/declarations/src/connectors/mock/connector.d.ts

@@ -0,0 +1,37 @@
+import { Chain } from '../../types';
+import { Connector } from '../base';
+import { MockProvider, MockProviderOptions } from './provider';
+export declare class MockConnector extends Connector<MockProvider, MockProviderOptions> {
+    #private;
+    readonly id = "mock";
+    readonly name = "Mock";
+    readonly ready = true;
+    constructor(config: {
+        chains: Chain[];
+        options: MockProviderOptions;
+    });
+    connect(): Promise<{
+        account: string;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: MockProvider;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<string>;
+    getChainId(): Promise<number>;
+    getProvider(): Promise<MockProvider>;
+    getSigner(): Promise<import("ethers").Signer>;
+    isAuthorized(): Promise<boolean>;
+    watchAsset(asset: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+    toJSON(): string;
+}

package/dist/declarations/src/connectors/mock/index.d.ts

@@ -0,0 +1,2 @@
+export { MockConnector } from './connector';
+export { type MockProviderOptions, MockProvider } from './provider';

package/dist/declarations/src/connectors/mock/provider.d.ts

@@ -0,0 +1,40 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { Signer } from 'ethers/lib/ethers';
+import type { Listener } from '@ethersproject/providers';
+import { providers } from 'ethers';
+export declare type MockProviderOptions = {
+    flags?: {
+        failConnect?: boolean;
+        failSwitchChain?: boolean;
+    };
+    network?: number | string;
+    signer: Signer;
+};
+declare type Events = {
+    accountsChanged(accounts: string[]): void;
+    chainChanged(chainId: number | string): void;
+    disconnect(): void;
+};
+declare type Event = keyof Events;
+export declare class MockProvider extends providers.BaseProvider {
+    #private;
+    events: EventEmitter<Events, any>;
+    constructor(options: MockProviderOptions);
+    enable(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    getAccounts(): Promise<string[]>;
+    getSigner(): Signer;
+    switchChain(chainId: number): Promise<void>;
+    watchAsset(_asset: {
+        address: string;
+        decimals?: number;
+        image?: string;
+        symbol: string;
+    }): Promise<boolean>;
+    on(event: Event, listener: Listener): this;
+    once(event: Event, listener: Listener): this;
+    removeListener(event: Event, listener: Listener): this;
+    off(event: Event, listener: Listener): this;
+    toJSON(): string;
+}
+export {};

package/dist/declarations/src/connectors/walletConnect.d.ts

@@ -0,0 +1,32 @@
+import { providers } from 'ethers';
+import type WalletConnectProvider from '@walletconnect/ethereum-provider';
+import type { IWCEthRpcConnectionOptions } from '@walletconnect/types';
+import { Chain } from '../types';
+import { Connector } from './base';
+export declare class WalletConnectConnector extends Connector<WalletConnectProvider, IWCEthRpcConnectionOptions> {
+    #private;
+    readonly id = "walletConnect";
+    readonly name = "WalletConnect";
+    readonly ready = true;
+    constructor(config: {
+        chains?: Chain[];
+        options: IWCEthRpcConnectionOptions;
+    });
+    connect(): Promise<{
+        account: string;
+        chain: {
+            id: number;
+            unsupported: boolean;
+        };
+        provider: providers.Web3Provider;
+    }>;
+    disconnect(): Promise<void>;
+    getAccount(): Promise<string>;
+    getChainId(): Promise<number>;
+    getProvider(create?: boolean): Promise<WalletConnectProvider>;
+    getSigner(): Promise<providers.JsonRpcSigner>;
+    isAuthorized(): Promise<boolean>;
+    protected onAccountsChanged: (accounts: string[]) => void;
+    protected onChainChanged: (chainId: number | string) => void;
+    protected onDisconnect: () => void;
+}

package/dist/declarations/src/constants/abis/erc1155.d.ts

@@ -0,0 +1,17 @@
+export declare const erc1155ABI: {
+    constant: boolean;
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+}[];

package/dist/declarations/src/constants/abis/erc20.d.ts

@@ -0,0 +1,38 @@
+export declare const erc20ABI: ({
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    constant?: undefined;
+    inputs?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+})[];

package/dist/declarations/src/constants/abis/erc721.d.ts

@@ -0,0 +1,15 @@
+export declare const erc721ABI: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];