@wagmi/core 0.4.8 → 0.5.0

package/connectors/walletConnect/dist/wagmi-core-connectors-walletConnect.cjs.prod.js

@@ -2,15 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var base = require('../../../dist/base-797ad073.cjs.prod.js');
+var getProvider = require('../../../dist/getProvider-5b369460.cjs.prod.js');
 var ethers = require('ethers');
 var utils = require('ethers/lib/utils');
-var client = require('../../../dist/client-a6e61429.cjs.prod.js');
-require('eventemitter3');
-require('../../../dist/chains-f7bb3211.cjs.prod.js');
-require('../../../dist/rpcs-1fd0a12f.cjs.prod.js');
-require('zustand/vanilla');
 require('zustand/middleware');
+require('zustand/vanilla');
+require('eventemitter3');
+require('../../../dist/chains-13baf029.cjs.prod.js');
+require('../../../dist/rpcs-4b3a7778.cjs.prod.js');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -43,31 +42,31 @@ var _provider = /*#__PURE__*/new WeakMap();
 
 var _switchChain = /*#__PURE__*/new WeakSet();
 
-class WalletConnectConnector extends base.Connector {
+class WalletConnectConnector extends getProvider.Connector {
   constructor(config) {
     super(config);
 
-    base._classPrivateMethodInitSpec(this, _switchChain);
+    getProvider._classPrivateMethodInitSpec(this, _switchChain);
 
-    base._defineProperty(this, "id", 'walletConnect');
+    getProvider._defineProperty(this, "id", 'walletConnect');
 
-    base._defineProperty(this, "name", 'WalletConnect');
+    getProvider._defineProperty(this, "name", 'WalletConnect');
 
-    base._defineProperty(this, "ready", true);
+    getProvider._defineProperty(this, "ready", true);
 
-    base._classPrivateFieldInitSpec(this, _provider, {
+    getProvider._classPrivateFieldInitSpec(this, _provider, {
       writable: true,
       value: void 0
     });
 
-    base._defineProperty(this, "onAccountsChanged", accounts => {
+    getProvider._defineProperty(this, "onAccountsChanged", accounts => {
       if (accounts.length === 0) this.emit('disconnect');else this.emit('change', {
         account: utils.getAddress(accounts[0])
       });
     });
 
-    base._defineProperty(this, "onChainChanged", chainId => {
-      const id = base.normalizeChainId(chainId);
+    getProvider._defineProperty(this, "onChainChanged", chainId => {
+      const id = getProvider.normalizeChainId(chainId);
       const unsupported = this.isChainUnsupported(id);
       this.emit('change', {
         chain: {
@@ -77,7 +76,7 @@ class WalletConnectConnector extends base.Connector {
       });
     });
 
-    base._defineProperty(this, "onDisconnect", () => {
+    getProvider._defineProperty(this, "onDisconnect", () => {
       this.emit('disconnect');
     });
   }
@@ -93,7 +92,7 @@ class WalletConnectConnector extends base.Connector {
       let targetChainId = chainId;
 
       if (!targetChainId) {
-        const lastUsedChainId = client.getClient().lastUsedChainId;
+        const lastUsedChainId = getProvider.getClient().lastUsedChainId;
         if (lastUsedChainId && !this.isChainUnsupported(lastUsedChainId)) targetChainId = lastUsedChainId;
       }
 
@@ -115,7 +114,7 @@ class WalletConnectConnector extends base.Connector {
       // 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 : '';
-      if (switchChainAllowedRegex.test(walletName)) this.switchChain = base._classPrivateMethodGet(this, _switchChain, _switchChain2);
+      if (switchChainAllowedRegex.test(walletName)) this.switchChain = getProvider._classPrivateMethodGet(this, _switchChain, _switchChain2);
       return {
         account,
         chain: {
@@ -125,7 +124,7 @@ class WalletConnectConnector extends base.Connector {
         provider: new ethers.providers.Web3Provider(provider)
       };
     } catch (error) {
-      if (/user closed modal/i.test(error.message)) throw new base.UserRejectedRequestError(error);
+      if (/user closed modal/i.test(error.message)) throw new getProvider.UserRejectedRequestError(error);
       throw error;
     }
   }
@@ -148,7 +147,7 @@ class WalletConnectConnector extends base.Connector {
 
   async getChainId() {
     const provider = await this.getProvider();
-    const chainId = base.normalizeChainId(provider.chainId);
+    const chainId = getProvider.normalizeChainId(provider.chainId);
     return chainId;
   }
 
@@ -159,7 +158,7 @@ class WalletConnectConnector extends base.Connector {
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
     // Force create new provider
-    if (!base._classPrivateFieldGet(this, _provider) || chainId || create) {
+    if (!getProvider._classPrivateFieldGet(this, _provider) || chainId || create) {
       var _this$options, _this$options2;
 
       const rpc = !((_this$options = this.options) !== null && _this$options !== void 0 && _this$options.infuraId) ? this.chains.reduce((rpc, chain) => ({ ...rpc,
@@ -167,7 +166,7 @@ class WalletConnectConnector extends base.Connector {
       }), {}) : {};
       const WalletConnectProvider = (await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@walletconnect/ethereum-provider')); })).default;
 
-      base._classPrivateFieldSet(this, _provider, new WalletConnectProvider({ ...this.options,
+      getProvider._classPrivateFieldSet(this, _provider, new WalletConnectProvider({ ...this.options,
         chainId,
         rpc: { ...rpc,
           ...((_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.rpc)
@@ -175,7 +174,7 @@ class WalletConnectConnector extends base.Connector {
       }));
     }
 
-    return base._classPrivateFieldGet(this, _provider);
+    return getProvider._classPrivateFieldGet(this, _provider);
   }
 
   async getSigner() {
@@ -222,8 +221,8 @@ async function _switchChain2(chainId) {
     };
   } catch (error) {
     const message = typeof error === 'string' ? error : error === null || error === void 0 ? void 0 : error.message;
-    if (/user rejected request/i.test(message)) throw new base.UserRejectedRequestError(error);
-    throw new base.SwitchChainError(error);
+    if (/user rejected request/i.test(message)) throw new getProvider.UserRejectedRequestError(error);
+    throw new getProvider.SwitchChainError(error);
   }
 }
 

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

@@ -1,12 +1,11 @@
-import { e as Connector, m as _classPrivateMethodInitSpec, _ as _defineProperty, j as _classPrivateFieldInitSpec, n as normalizeChainId, o as _classPrivateMethodGet, U as UserRejectedRequestError, k as _classPrivateFieldGet, l as _classPrivateFieldSet, i as SwitchChainError } from '../../../dist/base-b565d5d4.esm.js';
+import { j as Connector, _ as _classPrivateMethodInitSpec, r as _defineProperty, s as _classPrivateFieldInitSpec, n as normalizeChainId, g as getClient, v as _classPrivateMethodGet, U as UserRejectedRequestError, t as _classPrivateFieldGet, u as _classPrivateFieldSet, o as SwitchChainError } from '../../../dist/getProvider-dda5b21b.esm.js';
 import { providers } from 'ethers';
 import { getAddress, hexValue } from 'ethers/lib/utils';
-import { g as getClient } from '../../../dist/client-a05fd511.esm.js';
-import 'eventemitter3';
-import '../../../dist/chains-fd2c546c.esm.js';
-import '../../../dist/rpcs-b73a8f60.esm.js';
-import 'zustand/vanilla';
 import 'zustand/middleware';
+import 'zustand/vanilla';
+import 'eventemitter3';
+import '../../../dist/chains-4b1a6cf8.esm.js';
+import '../../../dist/rpcs-5dc0ea1f.esm.js';
 
 /**
  * Wallets that support chain switching through WalletConnect

package/dist/{chains-7e6dc59c.cjs.dev.js → chains-13baf029.cjs.prod.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var rpcs = require('./rpcs-f1d24f0e.cjs.dev.js');
+var rpcs = require('./rpcs-4b3a7778.cjs.prod.js');
 
 const etherscanBlockExplorers = {
   mainnet: {
@@ -401,9 +401,9 @@ const chain = {
   hardhat,
   foundry
 };
-const allChains = Object.values(chain);
-const defaultChains = [chain.mainnet, chain.ropsten, chain.rinkeby, chain.goerli, chain.kovan];
-const defaultL2Chains = [chain.arbitrum, chain.arbitrumRinkeby, chain.optimism, chain.optimismKovan];
+const allChains = [mainnet, ropsten, rinkeby, goerli, kovan, optimism, optimismKovan, polygon, polygonMumbai, arbitrum, arbitrumRinkeby, localhost, hardhat, foundry];
+const defaultChains = [mainnet, ropsten, rinkeby, goerli, kovan];
+const defaultL2Chains = [arbitrum, arbitrumRinkeby, optimism, optimismKovan];
 
 exports.allChains = allChains;
 exports.arbitrum = arbitrum;

package/dist/{chains-fd2c546c.esm.js → chains-4b1a6cf8.esm.js}

@@ -1,4 +1,4 @@
-import { a as alchemyRpcUrls, p as publicRpcUrls, i as infuraRpcUrls } from './rpcs-b73a8f60.esm.js';
+import { a as alchemyRpcUrls, p as publicRpcUrls, i as infuraRpcUrls } from './rpcs-5dc0ea1f.esm.js';
 
 const etherscanBlockExplorers = {
   mainnet: {
@@ -399,8 +399,8 @@ const chain = {
   hardhat,
   foundry
 };
-const allChains = Object.values(chain);
-const defaultChains = [chain.mainnet, chain.ropsten, chain.rinkeby, chain.goerli, chain.kovan];
-const defaultL2Chains = [chain.arbitrum, chain.arbitrumRinkeby, chain.optimism, chain.optimismKovan];
+const allChains = [mainnet, ropsten, rinkeby, goerli, kovan, optimism, optimismKovan, polygon, polygonMumbai, arbitrum, arbitrumRinkeby, localhost, hardhat, foundry];
+const defaultChains = [mainnet, ropsten, rinkeby, goerli, kovan];
+const defaultL2Chains = [arbitrum, arbitrumRinkeby, optimism, optimismKovan];
 
 export { allChains as a, chainId as b, chain as c, defaultChains as d, defaultL2Chains as e, etherscanBlockExplorers as f, arbitrum as g, arbitrumRinkeby as h, foundry as i, goerli as j, hardhat as k, kovan as l, localhost as m, mainnet as n, optimism as o, optimismKovan as p, polygon as q, polygonMumbai as r, rinkeby as s, ropsten as t };

package/dist/{chains-f7bb3211.cjs.prod.js → chains-a1aae67e.cjs.dev.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var rpcs = require('./rpcs-1fd0a12f.cjs.prod.js');
+var rpcs = require('./rpcs-3d4e8104.cjs.dev.js');
 
 const etherscanBlockExplorers = {
   mainnet: {
@@ -401,9 +401,9 @@ const chain = {
   hardhat,
   foundry
 };
-const allChains = Object.values(chain);
-const defaultChains = [chain.mainnet, chain.ropsten, chain.rinkeby, chain.goerli, chain.kovan];
-const defaultL2Chains = [chain.arbitrum, chain.arbitrumRinkeby, chain.optimism, chain.optimismKovan];
+const allChains = [mainnet, ropsten, rinkeby, goerli, kovan, optimism, optimismKovan, polygon, polygonMumbai, arbitrum, arbitrumRinkeby, localhost, hardhat, foundry];
+const defaultChains = [mainnet, ropsten, rinkeby, goerli, kovan];
+const defaultL2Chains = [arbitrum, arbitrumRinkeby, optimism, optimismKovan];
 
 exports.allChains = allChains;
 exports.arbitrum = arbitrum;

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

@@ -14,7 +14,6 @@ export declare type FetchBalanceResult = {
     decimals: number;
     formatted: string;
     symbol: string;
-    unit: Unit | number;
     value: BigNumber;
 };
 export declare function fetchBalance({ addressOrName, chainId, formatUnits: unit, token, }: FetchBalanceArgs): Promise<FetchBalanceResult>;

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

@@ -1,3 +1,3 @@
-import { Signer } from 'ethers/lib/ethers';
-export declare type FetchSignerResult = Signer | null;
-export declare function fetchSigner(): Promise<FetchSignerResult>;
+import { Signer } from '../../types';
+export declare type FetchSignerResult<TSigner extends Signer = Signer> = TSigner | null;
+export declare function fetchSigner<TSigner extends Signer = Signer>(): Promise<FetchSignerResult<TSigner>>;

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

@@ -0,0 +1,16 @@
+import { CallOverrides, Contract, providers } from 'ethers';
+import { GetContractArgs } from './getContract';
+export declare type DeprecatedWriteContractConfig = GetContractArgs & {
+    /**
+     * Chain id to use for write
+     * If signer is not active on this chain, it will attempt to programmatically switch
+     */
+    chainId?: number;
+    /** Method to call on contract */
+    functionName: string;
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    overrides?: CallOverrides;
+};
+export declare type DeprecatedWriteContractResult = providers.TransactionResponse;
+export declare function deprecatedWriteContract<TContract extends Contract = Contract>({ addressOrName, args, chainId, contractInterface, functionName, overrides, signerOrProvider, }: DeprecatedWriteContractConfig): Promise<DeprecatedWriteContractResult>;

package/dist/declarations/src/actions/{tokens → contracts}/fetchToken.d.ts

@@ -11,6 +11,7 @@ export declare type FetchTokenArgs = {
 export declare type FetchTokenResult = {
     address: string;
     decimals: number;
+    name: string;
     symbol: string;
     totalSupply: {
         formatted: string;

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

@@ -1,7 +1,10 @@
+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 { 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 { writeContract, type WriteContractConfig, type WriteContractResult, } from './writeContract';
+export { writeContract, type WriteContractArgs, type WriteContractPreparedArgs, type WriteContractResult, type WriteContractUnpreparedArgs, } from './writeContract';

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

@@ -0,0 +1,37 @@
+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 */
+    chainId?: number;
+    /** Method to call on contract */
+    functionName: string;
+    /** Arguments to pass contract method */
+    args?: any | any[];
+    overrides?: CallOverrides;
+    signer?: TSigner | null;
+};
+export declare type PrepareWriteContractResult<TSigner extends Signer = Signer> = PrepareWriteContractConfig<TSigner> & {
+    chainId?: number;
+    request: PopulatedTransaction & {
+        to: Address;
+        gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
+    };
+    mode: 'prepared';
+};
+/**
+ * @description Prepares the parameters required for a contract write transaction.
+ *
+ * Returns config to be passed through to `writeContract`.
+ *
+ * @example
+ * import { prepareWriteContract, writeContract } from '@wagmi/core'
+ *
+ * const config = await prepareWriteContract({
+ *  addressOrName: '0x...',
+ *  contractInterface: wagmiAbi,
+ *  functionName: 'mint',
+ * })
+ * const result = await writeContract(config)
+ */
+export declare function prepareWriteContract<TContract extends Contract = Contract, TSigner extends Signer = Signer>({ addressOrName, args, chainId, contractInterface, functionName, overrides, signer: signer_, }: PrepareWriteContractConfig): Promise<PrepareWriteContractResult<TSigner>>;

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

@@ -1,16 +1,52 @@
-import { CallOverrides, Contract, providers } from 'ethers';
+import { CallOverrides, PopulatedTransaction } from 'ethers';
+import { Address } from '../../types';
+import { SendTransactionResult } from '../transactions';
 import { GetContractArgs } from './getContract';
-export declare type WriteContractConfig = GetContractArgs & {
+export declare type WriteContractPreparedArgs = {
     /**
-     * Chain id to use for write
-     * If signer is not active on this chain, it will attempt to programmatically switch
-     */
+     * `recklesslyUnprepared`: Allow to pass through unprepared config. Note: This has
+     * [UX pitfalls](https://wagmi.sh/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 {@link prepareWriteContract} function.
+     *
+     * `prepared`: The request has been prepared with parameters required for sending a transaction
+     * via the {@link prepareWriteContract} function
+     * */
+    mode: 'prepared';
+    /** The prepared request. */
+    request: PopulatedTransaction & {
+        to: Address;
+        gasLimit: NonNullable<PopulatedTransaction['gasLimit']>;
+    };
+};
+export declare type WriteContractUnpreparedArgs = {
+    mode: 'recklesslyUnprepared';
+    request?: undefined;
+};
+export declare type WriteContractArgs = Omit<GetContractArgs, 'signerOrProvider'> & {
+    /** Chain ID used to validate if the signer is connected to the target chain */
     chainId?: number;
     /** Method to call on contract */
     functionName: string;
     /** Arguments to pass contract method */
     args?: any | any[];
     overrides?: CallOverrides;
-};
-export declare type WriteContractResult = providers.TransactionResponse;
-export declare function writeContract<TContract extends Contract = Contract>({ addressOrName, args, chainId, contractInterface, functionName, overrides, signerOrProvider, }: WriteContractConfig): Promise<WriteContractResult>;
+} & (WriteContractUnpreparedArgs | WriteContractPreparedArgs);
+export declare type WriteContractResult = SendTransactionResult;
+/**
+ * @description Function to call a contract write method.
+ *
+ * It is recommended to pair this with the {@link prepareWriteContract} function
+ * to avoid [UX pitfalls](https://wagmi.sh/docs/prepare-hooks/intro#ux-pitfalls-without-prepare-hooks).
+ *
+ * @example
+ * import { prepareWriteContract, writeContract } from '@wagmi/core'
+ *
+ * const config = await prepareWriteContract({
+ *   addressOrName: '0x...',
+ *   contractInterface: wagmiAbi,
+ *   functionName: 'mint',
+ * })
+ * const result = await writeContract(config)
+ */
+export declare function writeContract({ addressOrName, args, chainId, contractInterface, functionName, mode, overrides, request: request_, }: WriteContractArgs): Promise<WriteContractResult>;

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

@@ -1,8 +1,9 @@
+import { Address } from '../../types';
 export declare type FetchEnsAddressArgs = {
     /** Chain id to use for provider */
     chainId?: number;
     /** ENS name to resolve */
     name: string;
 };
-export declare type FetchEnsAddressResult = string | null;
+export declare type FetchEnsAddressResult = Address | null;
 export declare function fetchEnsAddress({ chainId, name, }: FetchEnsAddressArgs): Promise<FetchEnsAddressResult>;

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

@@ -1,7 +1,6 @@
 export { connect, disconnect, fetchBalance, fetchSigner, getAccount, getNetwork, signMessage, signTypedData, switchNetwork, watchAccount, watchNetwork, watchSigner, type ConnectArgs, 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 WatchNetworkCallback, type WatchSignerCallback, } from './accounts';
-export { getContract, readContract, readContracts, watchContractEvent, watchReadContract, watchReadContracts, writeContract, type GetContractArgs, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchReadContractConfig, type WatchReadContractResult, type WatchReadContractsConfig, type WatchReadContractsResult, type WriteContractConfig, type WriteContractResult, } from './contracts';
+export { deprecatedWriteContract, fetchToken, getContract, prepareWriteContract, readContract, readContracts, watchContractEvent, watchReadContract, watchReadContracts, writeContract, type DeprecatedWriteContractConfig, type DeprecatedWriteContractResult, type FetchTokenArgs, type FetchTokenResult, type GetContractArgs, type PrepareWriteContractConfig, type PrepareWriteContractResult, type ReadContractConfig, type ReadContractResult, type ReadContractsConfig, type ReadContractsResult, type WatchReadContractConfig, type WatchReadContractResult, type WatchReadContractsConfig, type WatchReadContractsResult, type WriteContractArgs, type WriteContractPreparedArgs, type WriteContractResult, type WriteContractUnpreparedArgs, } from './contracts';
 export { fetchEnsAddress, fetchEnsAvatar, fetchEnsName, fetchEnsResolver, type FetchEnsAddressArgs, type FetchEnsAddressResult, type FetchEnsAvatarArgs, type FetchEnsAvatarResult, type FetchEnsNameArgs, type FetchEnsNameResult, type FetchEnsResolverArgs, type FetchEnsResolverResult, } from './ens';
 export { fetchBlockNumber, fetchFeeData, watchBlockNumber, type FetchBlockNumberArgs, type FetchBlockNumberResult, type FetchFeeDataArgs, type FetchFeeDataResult, type WatchBlockNumberArgs, type WatchBlockNumberCallback, } from './network-status';
 export { getProvider, getWebSocketProvider, watchProvider, watchWebSocketProvider, type GetProviderArgs, type GetProviderResult, type GetWebSocketProviderArgs, type GetWebSocketProviderResult, type WatchProviderCallback, type WatchWebSocketProviderCallback, } from './providers';
-export { fetchToken, type FetchTokenArgs, type FetchTokenResult, } from './tokens';
-export { sendTransaction, waitForTransaction, type SendTransactionArgs, type SendTransactionResult, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';
+export { deprecatedSendTransaction, fetchTransaction, prepareSendTransaction, sendTransaction, waitForTransaction, type DeprecatedSendTransactionArgs, type DeprecatedSendTransactionResult, type FetchTransactionArgs, type FetchTransactionResult, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, type WaitForTransactionArgs, type WaitForTransactionResult, } from './transactions';

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

@@ -0,0 +1,12 @@
+import { providers } from 'ethers';
+export declare type DeprecatedSendTransactionArgs = {
+    /**
+     * Chain id to use for write
+     * If signer is not active on this chain, it will attempt to programmatically switch
+     */
+    chainId?: number;
+    /** Object to use when creating transaction */
+    request: providers.TransactionRequest;
+};
+export declare type DeprecatedSendTransactionResult = providers.TransactionResponse;
+export declare function deprecatedSendTransaction({ chainId, request, }: DeprecatedSendTransactionArgs): Promise<DeprecatedSendTransactionResult>;

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

@@ -0,0 +1,21 @@
+import { providers } from 'ethers';
+import { Hash } from '../../types';
+export declare type FetchTransactionArgs = {
+    /** Chain ID used to validate if the signer is connected to the target chain */
+    chainId?: number;
+    /** Transaction hash */
+    hash: Hash;
+};
+export declare type FetchTransactionResult = providers.TransactionResponse;
+/**
+ * @description Fetches transaction for hash
+ *
+ * @example
+ * import { fetchTransaction } from '@wagmi/core'
+ *
+ * const transaction = await fetchTransaction({
+ *  chainId: 1,
+ *  hash: '0x...',
+ * })
+ */
+export declare function fetchTransaction({ chainId, hash, }: FetchTransactionArgs): Promise<FetchTransactionResult>;

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

@@ -1,2 +1,5 @@
-export { sendTransaction, type SendTransactionArgs, type SendTransactionResult, } from './sendTransaction';
+export { deprecatedSendTransaction, type DeprecatedSendTransactionArgs, type DeprecatedSendTransactionResult, } from './deprecatedSendTransaction';
+export { fetchTransaction, type FetchTransactionArgs, type FetchTransactionResult, } from './fetchTransaction';
+export { prepareSendTransaction, type PrepareSendTransactionArgs, type PrepareSendTransactionResult, } from './prepareSendTransaction';
+export { sendTransaction, type SendTransactionArgs, type SendTransactionPreparedRequest, type SendTransactionResult, type SendTransactionUnpreparedRequest, } from './sendTransaction';
 export { waitForTransaction, type WaitForTransactionArgs, type WaitForTransactionResult, } from './waitForTransaction';

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

@@ -0,0 +1,36 @@
+import { providers } from 'ethers';
+import { Address } from '../../types';
+export declare type PrepareSendTransactionArgs = {
+    /** 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']>;
+    };
+    signerOrProvider?: providers.JsonRpcSigner | providers.Provider;
+};
+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, signerOrProvider, }: PrepareSendTransactionArgs): Promise<PrepareSendTransactionResult>;

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

@@ -1,12 +1,47 @@
 import { providers } from 'ethers';
-export declare type SendTransactionArgs = {
+import { Address } from '../../types';
+export declare type SendTransactionPreparedRequest = {
     /**
-     * Chain id to use for write
-     * If signer is not active on this chain, it will attempt to programmatically switch
-     */
-    chainId?: number;
-    /** Object to use when creating transaction */
+     * `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 SendTransactionResult = providers.TransactionResponse;
-export declare function sendTransaction({ chainId, request, }: SendTransactionArgs): Promise<SendTransactionResult>;
+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: providers.TransactionResponse['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/client.d.ts

@@ -25,7 +25,7 @@ export declare type ClientConfig<TProvider extends Provider = Provider, TWebSock
     }) => TWebSocketProvider | undefined) | TWebSocketProvider;
 };
 export declare type Data<TProvider extends Provider> = ConnectorData<TProvider>;
-export declare type State<TProvider extends Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
+export declare type State<TProvider extends Provider = Provider, TWebSocketProvider extends WebSocketProvider = WebSocketProvider> = {
     chains?: Connector['chains'];
     connector?: Connector;
     connectors: Connector[];
@@ -51,8 +51,8 @@ export declare class Client<TProvider extends Provider = Provider, TWebSocketPro
     ]>;
     constructor({ autoConnect, connectors, provider, storage, webSocketProvider, }: ClientConfig<TProvider, TWebSocketProvider>);
     get chains(): import("./types").Chain[] | undefined;
-    get connectors(): Connector<any, any>[];
-    get connector(): Connector<any, any> | 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;

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

@@ -1,5 +1,4 @@
 import { default as EventEmitter } from 'eventemitter3';
-import { Signer } from 'ethers/lib/ethers';
 import { Chain } from '../types';
 export declare type ConnectorData<Provider = any> = {
     account?: string;
@@ -19,7 +18,7 @@ export interface ConnectorEvents<Provider = any> {
     disconnect(): void;
     error(error: Error): void;
 }
-export declare abstract class Connector<Provider = any, Options = any> extends EventEmitter<ConnectorEvents<Provider>> {
+export declare abstract class Connector<Provider = any, Options = any, Signer = any> extends EventEmitter<ConnectorEvents<Provider>> {
     /** Unique connector id */
     abstract readonly id: string;
     /** Connector name */

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

@@ -1,6 +1,6 @@
-import { providers } from 'ethers';
 import type { CoinbaseWalletProvider } from '@coinbase/wallet-sdk';
 import type { CoinbaseWalletSDKOptions } from '@coinbase/wallet-sdk/dist/CoinbaseWalletSDK';
+import { providers } from 'ethers';
 import { Chain } from '../types';
 import { Connector } from './base';
 declare type Options = CoinbaseWalletSDKOptions & {
@@ -15,7 +15,7 @@ declare type Options = CoinbaseWalletSDKOptions & {
      */
     chainId?: number;
 };
-export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options> {
+export declare class CoinbaseWalletConnector extends Connector<CoinbaseWalletProvider, Options, providers.JsonRpcSigner> {
     #private;
     readonly id = "coinbaseWallet";
     readonly name = "Coinbase Wallet";

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

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

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

@@ -18,12 +18,12 @@ export declare type InjectedConnectorOptions = {
      */
     shimDisconnect?: boolean;
 };
-export declare const shimDisconnectKey = "injected.shimDisconnect";
-export declare class InjectedConnector extends Connector<Window['ethereum'], InjectedConnectorOptions | undefined> {
+export declare class InjectedConnector extends Connector<Window['ethereum'], InjectedConnectorOptions | undefined, providers.JsonRpcSigner> {
     #private;
     readonly id: string;
     readonly name: string;
     readonly ready: boolean;
+    protected shimDisconnectKey: string;
     constructor({ chains, options, }?: {
         chains?: Chain[];
         options?: InjectedConnectorOptions;
@@ -36,12 +36,12 @@ export declare class InjectedConnector extends Connector<Window['ethereum'], Inj
             id: number;
             unsupported: boolean;
         };
-        provider: Ethereum;
+        provider: import("../types").Ethereum;
     }>;
     disconnect(): Promise<void>;
     getAccount(): Promise<string>;
     getChainId(): Promise<number>;
-    getProvider(): Promise<Ethereum | undefined>;
+    getProvider(): Promise<import("../types").Ethereum | undefined>;
     getSigner(): Promise<providers.JsonRpcSigner>;
     isAuthorized(): Promise<boolean>;
     switchChain(chainId: number): Promise<Chain>;