@wagmi/core 0.5.7 → 0.6.0

package/connectors/walletConnect/dist/wagmi-core-connectors-walletConnect.esm.js

@@ -1,11 +1,11 @@
-import { l as Connector, _ as _classPrivateMethodInitSpec, t as _defineProperty, u as _classPrivateFieldInitSpec, n as normalizeChainId, g as getClient, x as _classPrivateMethodGet, U as UserRejectedRequestError, v as _classPrivateFieldGet, w as _classPrivateFieldSet, q as SwitchChainError } from '../../../dist/getProvider-f1dfc7e3.esm.js';
+import { l as Connector, _ as _classPrivateMethodInitSpec, t as _defineProperty, v as _classPrivateFieldInitSpec, n as normalizeChainId, g as getClient, u as _classPrivateMethodGet, U as UserRejectedRequestError, x as _classPrivateFieldGet, w as _classPrivateFieldSet, q as SwitchChainError } from '../../../dist/getProvider-24ec6544.esm.js';
 import { providers } from 'ethers';
 import { getAddress, hexValue } from 'ethers/lib/utils';
 import 'zustand/middleware';
 import 'zustand/vanilla';
 import 'eventemitter3';
-import '../../../dist/chains-8c76af1b.esm.js';
-import '../../../dist/rpcs-8d636858.esm.js';
+import '../../../dist/chains-2970e5fa.esm.js';
+import '../../../dist/rpcs-b4aa70b9.esm.js';
 
 /**
  * Wallets that support chain switching through WalletConnect
@@ -65,7 +65,7 @@ class WalletConnectConnector extends Connector {
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
     try {
-      var _provider$connector$p, _provider$connector, _provider$connector$p2;
+      var _provider$connector, _provider$connector$p;
 
       let targetChainId = chainId;
 
@@ -91,7 +91,7 @@ class WalletConnectConnector extends Connector {
       const unsupported = this.isChainUnsupported(id); // Not all WalletConnect options support programmatic chain switching
       // Only enable for wallet options that do
 
-      const walletName = (_provider$connector$p = (_provider$connector = provider.connector) === null || _provider$connector === void 0 ? void 0 : (_provider$connector$p2 = _provider$connector.peerMeta) === null || _provider$connector$p2 === void 0 ? void 0 : _provider$connector$p2.name) !== null && _provider$connector$p !== void 0 ? _provider$connector$p : '';
+      const walletName = ((_provider$connector = provider.connector) === null || _provider$connector === void 0 ? void 0 : (_provider$connector$p = _provider$connector.peerMeta) === null || _provider$connector$p === void 0 ? void 0 : _provider$connector$p.name) ?? '';
       if (switchChainAllowedRegex.test(walletName)) this.switchChain = _classPrivateMethodGet(this, _switchChain, _switchChain2);
       return {
         account,
@@ -162,7 +162,7 @@ class WalletConnectConnector extends Connector {
     const [provider, account] = await Promise.all([this.getProvider({
       chainId
     }), this.getAccount()]);
-    return new providers.Web3Provider(provider).getSigner(account);
+    return new providers.Web3Provider(provider, chainId).getSigner(account);
   }
 
   async isAuthorized() {
@@ -181,18 +181,16 @@ async function _switchChain2(chainId) {
   const id = hexValue(chainId);
 
   try {
-    var _this$chains$find;
-
     await provider.request({
       method: 'wallet_switchEthereumChain',
       params: [{
         chainId: id
       }]
     });
-    return (_this$chains$find = this.chains.find(x => x.id === chainId)) !== null && _this$chains$find !== void 0 ? _this$chains$find : {
+    return this.chains.find(x => x.id === chainId) ?? {
       id: chainId,
-      name: "Chain ".concat(id),
-      network: "".concat(id),
+      name: `Chain ${id}`,
+      network: `${id}`,
       rpcUrls: {
         default: ''
       }

package/dist/{chains-8c76af1b.esm.js → chains-2970e5fa.esm.js}

@@ -1,4 +1,4 @@
-import { a as alchemyRpcUrls, p as publicRpcUrls, i as infuraRpcUrls } from './rpcs-8d636858.esm.js';
+import { a as alchemyRpcUrls, p as publicRpcUrls, i as infuraRpcUrls } from './rpcs-b4aa70b9.esm.js';
 
 const etherscanBlockExplorers = {
   mainnet: {
@@ -48,6 +48,10 @@ const etherscanBlockExplorers = {
   arbitrumRinkeby: {
     name: 'Arbiscan',
     url: 'https://testnet.arbiscan.io'
+  },
+  arbitrumGoerli: {
+    name: 'Arbiscan',
+    url: 'https://goerli.arbiscan.io'
   }
 };
 
@@ -57,18 +61,18 @@ const chainId = {
   rinkeby: 4,
   goerli: 5,
   kovan: 42,
-  sepolia: 11155111,
+  sepolia: 11_155_111,
   optimism: 10,
   optimismKovan: 69,
   optimismGoerli: 420,
   polygon: 137,
-  polygonMumbai: 80001,
-  arbitrum: 42161,
-  arbitrumRinkeby: 421611,
-  arbitrumGoerli: 421613,
-  localhost: 1337,
-  hardhat: 31337,
-  foundry: 31337
+  polygonMumbai: 80_001,
+  arbitrum: 42_161,
+  arbitrumRinkeby: 421_611,
+  arbitrumGoerli: 421_613,
+  localhost: 1_337,
+  hardhat: 31_337,
+  foundry: 31_337
 };
 const mainnet = {
   id: chainId.mainnet,
@@ -428,10 +432,12 @@ const arbitrumGoerli = {
     public: publicRpcUrls.arbitrumGoerli
   },
   blockExplorers: {
-    default: {
+    arbitrum: {
       name: 'Arbitrum Explorer',
       url: 'https://goerli-rollup-explorer.arbitrum.io'
-    }
+    },
+    etherscan: etherscanBlockExplorers.arbitrumGoerli,
+    default: etherscanBlockExplorers.arbitrumGoerli
   },
   multicall: {
     address: '0xca11bde05977b3631167028862be2a173976ca11',

package/dist/{chains-ec1de502.cjs.dev.js → chains-45d5aa86.cjs.prod.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var rpcs = require('./rpcs-d2cd65f1.cjs.dev.js');
+var rpcs = require('./rpcs-c62bf9b0.cjs.prod.js');
 
 const etherscanBlockExplorers = {
   mainnet: {
@@ -50,6 +50,10 @@ const etherscanBlockExplorers = {
   arbitrumRinkeby: {
     name: 'Arbiscan',
     url: 'https://testnet.arbiscan.io'
+  },
+  arbitrumGoerli: {
+    name: 'Arbiscan',
+    url: 'https://goerli.arbiscan.io'
   }
 };
 
@@ -59,18 +63,18 @@ const chainId = {
   rinkeby: 4,
   goerli: 5,
   kovan: 42,
-  sepolia: 11155111,
+  sepolia: 11_155_111,
   optimism: 10,
   optimismKovan: 69,
   optimismGoerli: 420,
   polygon: 137,
-  polygonMumbai: 80001,
-  arbitrum: 42161,
-  arbitrumRinkeby: 421611,
-  arbitrumGoerli: 421613,
-  localhost: 1337,
-  hardhat: 31337,
-  foundry: 31337
+  polygonMumbai: 80_001,
+  arbitrum: 42_161,
+  arbitrumRinkeby: 421_611,
+  arbitrumGoerli: 421_613,
+  localhost: 1_337,
+  hardhat: 31_337,
+  foundry: 31_337
 };
 const mainnet = {
   id: chainId.mainnet,
@@ -430,10 +434,12 @@ const arbitrumGoerli = {
     public: rpcs.publicRpcUrls.arbitrumGoerli
   },
   blockExplorers: {
-    default: {
+    arbitrum: {
       name: 'Arbitrum Explorer',
       url: 'https://goerli-rollup-explorer.arbitrum.io'
-    }
+    },
+    etherscan: etherscanBlockExplorers.arbitrumGoerli,
+    default: etherscanBlockExplorers.arbitrumGoerli
   },
   multicall: {
     address: '0xca11bde05977b3631167028862be2a173976ca11',

package/dist/{chains-789e0c2e.cjs.prod.js → chains-524f4950.cjs.dev.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var rpcs = require('./rpcs-edec227e.cjs.prod.js');
+var rpcs = require('./rpcs-0d21dfe8.cjs.dev.js');
 
 const etherscanBlockExplorers = {
   mainnet: {
@@ -50,6 +50,10 @@ const etherscanBlockExplorers = {
   arbitrumRinkeby: {
     name: 'Arbiscan',
     url: 'https://testnet.arbiscan.io'
+  },
+  arbitrumGoerli: {
+    name: 'Arbiscan',
+    url: 'https://goerli.arbiscan.io'
   }
 };
 
@@ -59,18 +63,18 @@ const chainId = {
   rinkeby: 4,
   goerli: 5,
   kovan: 42,
-  sepolia: 11155111,
+  sepolia: 11_155_111,
   optimism: 10,
   optimismKovan: 69,
   optimismGoerli: 420,
   polygon: 137,
-  polygonMumbai: 80001,
-  arbitrum: 42161,
-  arbitrumRinkeby: 421611,
-  arbitrumGoerli: 421613,
-  localhost: 1337,
-  hardhat: 31337,
-  foundry: 31337
+  polygonMumbai: 80_001,
+  arbitrum: 42_161,
+  arbitrumRinkeby: 421_611,
+  arbitrumGoerli: 421_613,
+  localhost: 1_337,
+  hardhat: 31_337,
+  foundry: 31_337
 };
 const mainnet = {
   id: chainId.mainnet,
@@ -430,10 +434,12 @@ const arbitrumGoerli = {
     public: rpcs.publicRpcUrls.arbitrumGoerli
   },
   blockExplorers: {
-    default: {
+    arbitrum: {
       name: 'Arbitrum Explorer',
       url: 'https://goerli-rollup-explorer.arbitrum.io'
-    }
+    },
+    etherscan: etherscanBlockExplorers.arbitrumGoerli,
+    default: etherscanBlockExplorers.arbitrumGoerli
   },
   multicall: {
     address: '0xca11bde05977b3631167028862be2a173976ca11',

package/dist/declarations/src/actions/accounts/fetchBalance.d.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from 'ethers/lib/ethers';
+import { Address, ResolvedConfig } from 'abitype';
 import { Unit } from '../../types';
 export declare type FetchBalanceArgs = {
     /** Address or ENS name */
@@ -8,12 +8,12 @@ export declare type FetchBalanceArgs = {
     /** Units for formatting output */
     formatUnits?: Unit | number;
     /** ERC-20 address */
-    token?: string;
+    token?: Address;
 };
 export declare type FetchBalanceResult = {
-    decimals: number;
+    decimals: ResolvedConfig['IntType'];
     formatted: string;
     symbol: string;
-    value: BigNumber;
+    value: ResolvedConfig['BigIntType'];
 };
 export declare function fetchBalance({ addressOrName, chainId, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;

package/dist/declarations/src/actions/accounts/fetchSigner.d.ts

@@ -1,3 +1,7 @@
 import { Signer } from '../../types';
+export declare type FetchSignerArgs = {
+    /** Chain ID to use for signer */
+    chainId?: number;
+};
 export declare type FetchSignerResult<TSigner extends Signer = Signer> = TSigner | null;
-export declare function fetchSigner<TSigner extends Signer = Signer>(): Promise<FetchSignerResult<TSigner>>;
+export declare function fetchSigner<TSigner extends Signer = Signer>({ chainId, }?: FetchSignerArgs): Promise<FetchSignerResult<TSigner>>;

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

@@ -1,7 +1,7 @@
 export { connect, type ConnectArgs, type ConnectResult } from './connect';
 export { disconnect } from './disconnect';
 export { fetchBalance, type FetchBalanceArgs, type FetchBalanceResult, } from './fetchBalance';
-export { fetchSigner, type FetchSignerResult } from './fetchSigner';
+export { fetchSigner, type FetchSignerArgs, type FetchSignerResult, } from './fetchSigner';
 export { getAccount, type GetAccountResult } from './getAccount';
 export { getNetwork, type GetNetworkResult } from './getNetwork';
 export { signMessage, type SignMessageArgs, type SignMessageResult, } from './signMessage';

package/dist/declarations/src/actions/accounts/signMessage.d.ts

@@ -1,9 +1,7 @@
-import { Bytes } from 'ethers/lib/utils';
+import { ResolvedConfig } from 'abitype';
 export declare type SignMessageArgs = {
     /** Message to sign with wallet */
-    message: Bytes | string;
+    message: string | Uint8Array;
 };
-declare type Signature = string;
-export declare type SignMessageResult = Signature;
+export declare type SignMessageResult = ResolvedConfig['BytesType'];
 export declare function signMessage(args: SignMessageArgs): Promise<SignMessageResult>;
-export {};

package/dist/declarations/src/actions/accounts/signTypedData.d.ts

@@ -1,24 +1,23 @@
-import { BytesLike } from 'ethers';
-export declare type SignTypedDataArgs = {
+import { Narrow, TypedData, TypedDataDomain, TypedDataToPrimitiveTypes } from 'abitype';
+export declare type SignTypedDataArgs<TTypedData = unknown> = {
     /** Domain or domain signature for origin or contract */
-    domain: {
-        name?: string;
-        version?: string;
-        /**
-         * Chain permitted for signing
-         * If signer is not active on this chain, it will attempt to programmatically switch
-         */
-        chainId?: string | number | bigint;
-        verifyingContract?: string;
-        salt?: BytesLike;
-    };
+    domain: TypedDataDomain;
     /** Named list of all type definitions */
-    types: Record<string, Array<{
-        name: string;
-        type: string;
-    }>>;
+    types: Narrow<TTypedData>;
+} & (TTypedData extends TypedData ? TypedDataToPrimitiveTypes<TTypedData> extends infer TSchema ? TSchema[keyof TSchema] extends infer TValue ? {
+    [key: string]: any;
+} extends TValue ? {
+    /**
+     * Data to sign
+     *
+     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link types} for type inference.
+     */
+    value: {
+        [key: string]: unknown;
+    };
+} : {
     /** Data to sign */
-    value: Record<string, any>;
-};
+    value: TValue;
+} : never : never : never);
 export declare type SignTypedDataResult = string;
-export declare function signTypedData({ domain, types, value, }: SignTypedDataArgs): Promise<SignTypedDataResult>;
+export declare function signTypedData<TTypedData extends TypedData>({ domain, types, value, }: SignTypedDataArgs<TTypedData>): Promise<SignTypedDataResult>;

package/dist/declarations/src/actions/accounts/watchSigner.d.ts

@@ -1,3 +1,5 @@
-import { FetchSignerResult } from './fetchSigner';
-export declare type WatchSignerCallback = (data: FetchSignerResult) => void;
-export declare function watchSigner(callback: WatchSignerCallback): () => void;
+import { Signer } from '../../types';
+import { FetchSignerArgs, FetchSignerResult } from './fetchSigner';
+export declare type WatchSignerArgs = FetchSignerArgs;
+export declare type WatchSignerCallback<TSigner extends Signer = Signer> = (data: FetchSignerResult<TSigner>) => void;
+export declare function watchSigner<TSigner extends Signer = Signer>({ chainId }: WatchSignerArgs, callback: WatchSignerCallback<TSigner>): () => void;

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

@@ -1,21 +1,21 @@
-import { BigNumber } from 'ethers/lib/ethers';
+import { Address, ResolvedConfig } from 'abitype';
 import { Unit } from '../../types';
 export declare type FetchTokenArgs = {
     /** Address of ERC-20 token */
-    address: string;
+    address: Address;
     /** Chain id to use for provider */
     chainId?: number;
     /** Units for formatting output */
     formatUnits?: Unit | number;
 };
 export declare type FetchTokenResult = {
-    address: string;
-    decimals: number;
+    address: Address;
+    decimals: ResolvedConfig['IntType'];
     name: string;
     symbol: string;
     totalSupply: {
         formatted: string;
-        value: BigNumber;
+        value: ResolvedConfig['BigIntType'];
     };
 };
 export declare function fetchToken({ address, chainId, formatUnits: units, }: FetchTokenArgs): Promise<FetchTokenResult>;

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

@@ -1,10 +1,113 @@
-import { Contract, ContractInterface, Signer, providers } from 'ethers';
-export declare type GetContractArgs = {
-    /** Contract address or ENS name */
-    addressOrName: string;
-    /** Contract interface or ABI */
-    contractInterface: ContractInterface;
+import { Abi, AbiEvent, AbiFunction, AbiParameter, AbiParameterToPrimitiveType, AbiParametersToPrimitiveTypes, Address, ExtractAbiEvent, ExtractAbiEventNames, Narrow, ResolvedConfig } from 'abitype';
+import { Contract as EthersContract, Signer, ethers, providers } from 'ethers';
+import { AbiEventParametersToPrimitiveTypes, AbiItemName, Event, GetOverridesForAbiStateMutability } from '../../types/contracts';
+import { CountOccurrences, IsUnknown, UnionToIntersection } from '../../types/utils';
+export declare type GetContractArgs<TAbi extends Abi | readonly unknown[] = Abi> = {
+    /** Contract address */
+    address: string;
+    /** Contract ABI */
+    abi: Narrow<TAbi>;
     /** Signer or provider to attach to contract */
-    signerOrProvider?: Signer | providers.Provider | null;
+    signerOrProvider?: Signer | providers.Provider;
 };
-export declare function getContract<T = Contract>({ addressOrName, contractInterface, signerOrProvider, }: GetContractArgs): T;
+export declare type GetContractResult<TAbi = unknown> = TAbi extends Abi ? Contract<TAbi> & EthersContract : EthersContract;
+export declare function getContract<TAbi extends Abi | readonly unknown[]>({ address, abi, signerOrProvider, }: GetContractArgs<TAbi>): GetContractResult<TAbi>;
+declare type PropertyKeys = 'address' | 'attach' | 'connect' | 'deployed' | 'interface' | 'resolvedAddress';
+declare type FunctionKeys = 'callStatic' | 'estimateGas' | 'functions' | 'populateTransaction';
+declare type EventKeys = 'emit' | 'filters' | 'listenerCount' | 'listeners' | 'off' | 'on' | 'once' | 'queryFilter' | 'removeAllListeners' | 'removeListener';
+declare type BaseContract<TContract extends Record<keyof Pick<EthersContract, PropertyKeys | FunctionKeys | EventKeys>, unknown>> = Omit<EthersContract, PropertyKeys | FunctionKeys | EventKeys> & TContract;
+declare type InterfaceKeys = 'events' | 'functions';
+declare type BaseInterface<Interface extends Record<keyof Pick<ethers.utils.Interface, InterfaceKeys>, unknown>> = Omit<ethers.utils.Interface, InterfaceKeys> & Interface;
+export declare type Contract<TAbi extends Abi, _Functions = Functions<TAbi>> = _Functions & BaseContract<{
+    address: Address;
+    resolvedAddress: Promise<Address>;
+    attach(addressOrName: Address | string): Contract<TAbi>;
+    connect(signerOrProvider: ethers.Signer | ethers.providers.Provider | string): Contract<TAbi>;
+    deployed(): Promise<Contract<TAbi>>;
+    interface: BaseInterface<{
+        events: InterfaceEvents<TAbi>;
+        functions: InterfaceFunctions<TAbi>;
+    }>;
+    callStatic: _Functions;
+    estimateGas: Functions<TAbi, {
+        ReturnType: ResolvedConfig['BigIntType'];
+    }>;
+    functions: Functions<TAbi, {
+        ReturnTypeAsArray: true;
+    }>;
+    populateTransaction: Functions<TAbi, {
+        ReturnType: ethers.PopulatedTransaction;
+    }>;
+    emit<TEventName extends ExtractAbiEventNames<TAbi> | ethers.EventFilter>(eventName: TEventName, ...args: AbiEventParametersToPrimitiveTypes<ExtractAbiEvent<TAbi, TEventName extends string ? TEventName : ExtractAbiEventNames<TAbi>>['inputs']> extends infer TArgs extends readonly unknown[] ? TArgs : never): boolean;
+    filters: Filters<TAbi>;
+    listenerCount(): number;
+    listenerCount<TEventName extends ExtractAbiEventNames<TAbi>>(eventName: TEventName): number;
+    listenerCount(eventFilter: ethers.EventFilter): number;
+    listeners(): Array<(...args: any[]) => void>;
+    listeners<TEventName extends ExtractAbiEventNames<TAbi>>(eventName: TEventName): Array<Listener<TAbi, TEventName>>;
+    listeners(eventFilter: ethers.EventFilter): Array<Listener<TAbi, ExtractAbiEventNames<TAbi>>>;
+    off: EventListener<TAbi>;
+    on: EventListener<TAbi>;
+    once: EventListener<TAbi>;
+    queryFilter<TEventName extends ExtractAbiEventNames<TAbi>>(event: TEventName, fromBlockOrBlockhash?: string | number, toBlock?: string | number): Promise<Array<ethers.Event>>;
+    queryFilter(eventFilter: ethers.EventFilter, fromBlockOrBlockhash?: string | number, toBlock?: string | number): Promise<Array<ethers.Event>>;
+    removeAllListeners(eventName?: ExtractAbiEventNames<TAbi>): Contract<TAbi>;
+    removeAllListeners(eventFilter: ethers.EventFilter): Contract<TAbi>;
+    removeListener: EventListener<TAbi>;
+}>;
+declare type Functions<TAbi extends Abi, Options extends {
+    ReturnType?: any;
+    ReturnTypeAsArray?: boolean;
+} = {
+    ReturnTypeAsArray: false;
+}> = UnionToIntersection<{
+    [K in keyof TAbi]: TAbi[K] extends infer TAbiFunction extends AbiFunction & {
+        type: 'function';
+    } ? {
+        [K in CountOccurrences<TAbi, {
+            name: TAbiFunction['name'];
+        }> extends 1 ? AbiItemName<TAbiFunction> : AbiItemName<TAbiFunction, true>]: (...args: [
+            ...args: TAbiFunction['inputs'] extends infer TInputs extends readonly AbiParameter[] ? AbiParametersToPrimitiveTypes<TInputs> : never,
+            overrides?: GetOverridesForAbiStateMutability<TAbiFunction['stateMutability']>
+        ]) => Promise<IsUnknown<Options['ReturnType']> extends true ? AbiFunctionReturnType<TAbiFunction> extends infer TAbiFunctionReturnType ? Options['ReturnTypeAsArray'] extends true ? [TAbiFunctionReturnType] : TAbiFunctionReturnType : never : Options['ReturnType']>;
+    } : never;
+}[number]>;
+declare type AbiFunctionReturnType<TAbiFunction extends AbiFunction & {
+    type: 'function';
+}> = ({
+    payable: ethers.ContractTransaction;
+    nonpayable: ethers.ContractTransaction;
+} & {
+    [_ in 'pure' | 'view']: TAbiFunction['outputs']['length'] extends infer TLength ? TLength extends 0 ? void : TLength extends 1 ? AbiParameterToPrimitiveType<TAbiFunction['outputs'][0]> : {
+        [Output in TAbiFunction['outputs'][number] as Output['name'] extends '' ? never : Output['name']]: AbiParameterToPrimitiveType<Output>;
+    } & AbiParametersToPrimitiveTypes<TAbiFunction['outputs']> : never;
+})[TAbiFunction['stateMutability']];
+declare type InterfaceFunctions<TAbi extends Abi> = UnionToIntersection<{
+    [K in keyof TAbi]: TAbi[K] extends infer TAbiFunction extends AbiFunction & {
+        type: 'function';
+    } ? {
+        [K in AbiItemName<TAbiFunction, true>]: ethers.utils.FunctionFragment;
+    } : never;
+}[number]>;
+declare type InterfaceEvents<TAbi extends Abi> = UnionToIntersection<{
+    [K in keyof TAbi]: TAbi[K] extends infer TAbiEvent extends AbiEvent ? {
+        [K in AbiItemName<TAbiEvent, true>]: ethers.utils.EventFragment;
+    } : never;
+}[number]>;
+interface EventListener<TAbi extends Abi> {
+    <TEventName extends ExtractAbiEventNames<TAbi>>(eventName: TEventName, listener: Listener<TAbi, TEventName>): Contract<TAbi>;
+    (eventFilter: ethers.EventFilter, listener: Listener<TAbi, ExtractAbiEventNames<TAbi>>): Contract<TAbi>;
+}
+declare type Listener<TAbi extends Abi, TEventName extends string, TAbiEvent extends AbiEvent = ExtractAbiEvent<TAbi, TEventName>> = AbiEventParametersToPrimitiveTypes<TAbiEvent['inputs']> extends infer TArgs extends readonly unknown[] ? (...args: [...args: TArgs, event: Event<TAbiEvent>]) => void : never;
+declare type Filters<TAbi extends Abi> = UnionToIntersection<{
+    [K in keyof TAbi]: TAbi[K] extends infer TAbiEvent extends AbiEvent ? {
+        [K in CountOccurrences<TAbi, {
+            name: TAbiEvent['name'];
+        }> extends 1 ? AbiItemName<TAbiEvent> : AbiItemName<TAbiEvent, true>]: (...args: TAbiEvent['inputs'] extends infer TAbiParameters extends readonly (AbiParameter & {
+            indexed?: boolean;
+        })[] ? AbiEventParametersToPrimitiveTypes<TAbiParameters, {
+            AllowNull: true;
+        }> : never) => ethers.EventFilter;
+    } : never;
+}[number]>;
+export {};

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

@@ -1,10 +1,11 @@
-export { deprecatedWriteContract, type DeprecatedWriteContractConfig, type DeprecatedWriteContractResult, } from './deprecatedWriteContract';
 export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './fetchToken';
 export { prepareWriteContract, type PrepareWriteContractConfig, type PrepareWriteContractResult, } from './prepareWriteContract';
-export { getContract, type GetContractArgs } from './getContract';
+export { getContract, type GetContractArgs, type GetContractResult, } from './getContract';
+export { multicall, type MulticallConfig, type MulticallResult, } from './multicall';
 export { readContract, type ReadContractConfig, type ReadContractResult, } from './readContract';
 export { readContracts, type ReadContractsConfig, type ReadContractsResult, } from './readContracts';
 export { watchContractEvent } from './watchContractEvent';
-export { watchReadContract, type WatchReadContractConfig, type WatchReadContractResult, } from './watchReadContract';
-export { watchReadContracts, type WatchReadContractsConfig, type WatchReadContractsResult, } from './watchReadContracts';
+export { watchMulticall, type WatchMulticallConfig, type WatchMulticallCallback, } from './watchMulticall';
+export { watchReadContract, type WatchReadContractConfig, type WatchReadContractCallback, } from './watchReadContract';
+export { watchReadContracts, type WatchReadContractsConfig, type WatchReadContractsCallback, } from './watchReadContracts';
 export { writeContract, type WriteContractArgs, type WriteContractPreparedArgs, type WriteContractResult, type WriteContractUnpreparedArgs, } from './writeContract';

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

@@ -1,21 +1,17 @@
-import { CallOverrides } from 'ethers/lib/ethers';
-import { Result } from 'ethers/lib/utils';
-import { ReadContractConfig } from './readContract';
-declare type MulticallContract = {
-    addressOrName: ReadContractConfig['addressOrName'];
-    args?: ReadContractConfig['args'];
-    contractInterface: ReadContractConfig['contractInterface'];
-    functionName: ReadContractConfig['functionName'];
-};
-export declare type MulticallConfig = {
+import { Abi } from 'abitype';
+import { ContractsConfig, ContractsResult, GetOverridesForAbiStateMutability } from '../../types/contracts';
+export declare type MulticallConfig<TContracts extends unknown[]> = {
     /** Failures in the multicall will fail silently */
     allowFailure?: boolean;
     /** Chain id to use for provider */
     chainId?: number;
-    contracts: MulticallContract[];
+    /** Contracts to query */
+    contracts: readonly [...ContractsConfig<TContracts>];
     /** Call overrides */
-    overrides?: CallOverrides;
+    overrides?: GetOverridesForAbiStateMutability<'pure'> | GetOverridesForAbiStateMutability<'view'>;
 };
-export declare type MulticallResult<Data extends any[] = Result[]> = Data;
-export declare function multicall<Data extends any[] = Result[]>({ allowFailure, chainId, contracts, overrides, }: MulticallConfig): Promise<MulticallResult<Data>>;
-export {};
+export declare type MulticallResult<TContracts extends unknown[]> = ContractsResult<TContracts>;
+export declare function multicall<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TContracts extends {
+    abi: TAbi;
+    functionName: TFunctionName;
+}[]>({ allowFailure, chainId, contracts, overrides, }: MulticallConfig<TContracts>): Promise<MulticallResult<TContracts>>;

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

@@ -1,23 +1,33 @@
-import { CallOverrides, Contract, PopulatedTransaction } from 'ethers/lib/ethers';
-import { Address, Signer } from '../../types';
-import { GetContractArgs } from './getContract';
-export declare type PrepareWriteContractConfig<TSigner extends Signer = Signer> = Omit<GetContractArgs, 'signerOrProvider'> & {
-    /** Chain ID used to validate if the signer is connected to the target chain */
+import { Abi, Address, ExtractAbiFunction } from 'abitype';
+import { PopulatedTransaction } from 'ethers/lib/ethers';
+import { Signer } from '../../types';
+import { DefaultOptions, GetConfig, GetOverridesForAbiStateMutability, Options } from '../../types/contracts';
+export declare type PrepareWriteContractConfig<TAbi = Abi, TFunctionName = string, TSigner extends Signer = Signer, TOptions extends Options = DefaultOptions> = GetConfig<{
+    abi: TAbi;
+    functionName: TFunctionName;
+    /** Chain id to use for provider */
     chainId?: number;
-    /** Method to call on contract */
-    functionName: string;
-    /** Arguments to pass contract method */
-    args?: any | any[];
-    overrides?: CallOverrides;
+    /** Overrides */
+    overrides?: GetOverridesForAbiStateMutability<[
+        TAbi,
+        TFunctionName
+    ] extends [
+        infer TAbi_ extends Abi,
+        infer TFunctionName_ extends string
+    ] ? ExtractAbiFunction<TAbi_, TFunctionName_>['stateMutability'] : 'nonpayable' | 'payable'>;
+    /** Custom signer */
     signer?: TSigner | null;
-};
-export declare type PrepareWriteContractResult<TSigner extends Signer = Signer> = PrepareWriteContractConfig<TSigner> & {
+}, 'nonpayable' | 'payable', TOptions>;
+export declare type PrepareWriteContractResult<TAbi = Abi, TFunctionName extends string = string> = {
+    abi: TAbi extends Abi ? [ExtractAbiFunction<TAbi, TFunctionName>] : readonly unknown[];
+    address: string;
     chainId?: number;
+    functionName: TFunctionName;
+    mode: 'prepared';
     request: PopulatedTransaction & {
         to: Address;
         gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
     };
-    mode: 'prepared';
 };
 /**
  * @description Prepares the parameters required for a contract write transaction.
@@ -28,10 +38,10 @@ export declare type PrepareWriteContractResult<TSigner extends Signer = Signer>
  * import { prepareWriteContract, writeContract } from '@wagmi/core'
  *
  * const config = await prepareWriteContract({
- *  addressOrName: '0x...',
- *  contractInterface: wagmiAbi,
+ *  address: '0x...',
+ *  abi: wagmiAbi,
  *  functionName: 'mint',
  * })
  * const result = await writeContract(config)
  */
-export declare function prepareWriteContract<TContract extends Contract = Contract, TSigner extends Signer = Signer>({ addressOrName, args, chainId, contractInterface: contractInterface_, functionName, overrides, signer: signer_, }: PrepareWriteContractConfig): Promise<PrepareWriteContractResult<TSigner>>;
+export declare function prepareWriteContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TSigner extends Signer = Signer>({ abi, address, args, chainId, functionName, overrides, signer: signer_, }: PrepareWriteContractConfig<TAbi, TFunctionName, TSigner>): Promise<PrepareWriteContractResult<TAbi, TFunctionName>>;