@wagmi/core 0.6.12 → 0.7.0

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

@@ -1,37 +0,0 @@
-import { Address } from 'abitype';
-import { providers } from 'ethers';
-import { Signer } from '../../types';
-export declare type PrepareSendTransactionArgs<TSigner extends Signer = Signer> = {
-    /** Chain ID used to validate if the signer is connected to the target chain */
-    chainId?: number;
-    /** Request data to prepare the transaction */
-    request: providers.TransactionRequest & {
-        to: NonNullable<providers.TransactionRequest['to']>;
-    };
-    signer?: TSigner | null;
-};
-export declare type PrepareSendTransactionResult = {
-    chainId?: number;
-    request: providers.TransactionRequest & {
-        to: Address;
-        gasLimit: NonNullable<providers.TransactionRequest['gasLimit']>;
-    };
-    mode: 'prepared';
-};
-/**
- * @description Prepares the parameters required for sending a transaction.
- *
- * Returns config to be passed through to `sendTransaction`.
- *
- * @example
- * import { prepareSendTransaction, sendTransaction } from '@wagmi/core'
- *
- * const config = await prepareSendTransaction({
- *  request: {
- *    to: 'moxey.eth',
- *    value: parseEther('1'),
- *  }
- * })
- * const result = await sendTransaction(config)
- */
-export declare function prepareSendTransaction({ chainId, request, signer: signer_, }: PrepareSendTransactionArgs): Promise<PrepareSendTransactionResult>;

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

@@ -1,48 +0,0 @@
-import { Address } from 'abitype';
-import { providers } from 'ethers';
-import { Hash } from '../../types';
-export declare type SendTransactionPreparedRequest = {
-    /**
-     * `recklesslyUnprepared`: Allow to pass through an unprepared `request`. Note: This has
-     * [UX pitfalls](/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks), it is highly recommended
-     * to not use this and instead prepare the request upfront using the `prepareSendTransaction` function.
-     *
-     * `prepared`: The request has been prepared with parameters required for sending a transaction
-     * via the `prepareSendTransaction` function
-     * */
-    mode: 'prepared';
-    /** The prepared request for sending a transaction. */
-    request: providers.TransactionRequest & {
-        to: Address;
-        gasLimit: NonNullable<providers.TransactionRequest['gasLimit']>;
-    };
-};
-export declare type SendTransactionUnpreparedRequest = {
-    mode: 'recklesslyUnprepared';
-    /** The unprepared request for sending a transaction. */
-    request: providers.TransactionRequest;
-};
-export declare type SendTransactionArgs = {
-    /** Chain ID used to validate if the signer is connected to the target chain */
-    chainId?: number;
-} & (SendTransactionPreparedRequest | SendTransactionUnpreparedRequest);
-export declare type SendTransactionResult = {
-    hash: Hash;
-    wait: providers.TransactionResponse['wait'];
-};
-/**
- * @description Function to send a transaction.
- *
- * It is recommended to pair this with the `prepareSendTransaction` function to avoid
- * [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
- *
- * @example
- * import { prepareSendTransaction, sendTransaction } from '@wagmi/core'
- *
- * const config = await prepareSendTransaction({
- *  to: 'moxey.eth',
- *  value: parseEther('1'),
- * })
- * const result = await sendTransaction(config)
- */
-export declare function sendTransaction({ chainId, mode, request, }: SendTransactionArgs): Promise<SendTransactionResult>;

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

@@ -1,18 +0,0 @@
-import { providers } from 'ethers';
-import { Hash } from '../../types';
-export declare type WaitForTransactionArgs = {
-    /** Chain id to use for provider */
-    chainId?: number;
-    /**
-     * Number of blocks to wait for after transaction is mined
-     * @default 1
-     */
-    confirmations?: number;
-    /** Transaction hash to monitor */
-    hash?: Hash;
-    timeout?: number;
-    /** Function resolving to transaction receipt */
-    wait?: providers.TransactionResponse['wait'];
-};
-export declare type WaitForTransactionResult = providers.TransactionReceipt;
-export declare function waitForTransaction({ chainId, confirmations, hash, timeout, wait: wait_, }: WaitForTransactionArgs): Promise<WaitForTransactionResult>;

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

@@ -1 +0,0 @@
-export { arbitrum, arbitrumGoerli, arbitrumRinkeby, foundry, goerli, hardhat, kovan, sepolia, localhost, mainnet, optimism, optimismKovan, optimismGoerli, polygon, polygonMumbai, rinkeby, ropsten, } from './constants/chains';

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

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

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

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

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

@@ -1,34 +0,0 @@
-import { Chain } from '../../types';
-import { Connector, ConnectorData } 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({ chainId }?: {
-        chainId?: number;
-    }): Promise<Required<ConnectorData<any>>>;
-    disconnect(): Promise<void>;
-    getAccount(): Promise<`0x${string}`>;
-    getChainId(): Promise<number>;
-    getProvider({ chainId }?: {
-        chainId?: number;
-    }): 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

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

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

@@ -1,41 +0,0 @@
-import { providers } from 'ethers';
-import { default as EventEmitter } from 'eventemitter3';
-import { Signer } from '../../types';
-export declare type MockProviderOptions = {
-    chainId?: number;
-    flags?: {
-        isAuthorized?: boolean;
-        failConnect?: boolean;
-        failSwitchChain?: boolean;
-        noSwitchChain?: boolean;
-    };
-    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<`0x${string}`[]>;
-    getSigner(): import("ethers").Signer;
-    switchChain(chainId: number): Promise<void>;
-    watchAsset(_asset: {
-        address: string;
-        decimals?: number;
-        image?: string;
-        symbol: string;
-    }): Promise<boolean>;
-    on(event: Event, listener: providers.Listener): this;
-    once(event: Event, listener: providers.Listener): this;
-    removeListener(event: Event, listener: providers.Listener): this;
-    off(event: Event, listener: providers.Listener): this;
-    toJSON(): string;
-}
-export {};