@wagmi/core 2.0.0-alpha.4 → 2.0.0-alpha.6

package/src/actions/getWalletClient.ts

@@ -3,7 +3,7 @@ import { type Account, type WalletClient, walletActions } from 'viem'
 import type { Config } from '../createConfig.js'
 import type { Evaluate } from '../types/utils.js'
 import {
-  type GetConnectorClientError,
+  type GetConnectorClientErrorType,
   type GetConnectorClientParameters,
   getConnectorClient,
 } from './getConnectorClient.js'
@@ -24,7 +24,7 @@ export type GetWalletClientReturnType<
   >
 >
 
-export type GetWalletClientError = GetConnectorClientError
+export type GetWalletClientErrorType = GetConnectorClientErrorType
 
 export async function getWalletClient<
   config extends Config,

package/src/actions/multicall.ts

@@ -1,5 +1,6 @@
 import type {
   ContractFunctionParameters,
+  MulticallErrorType as viem_MulticallErrorType,
   MulticallParameters as viem_MulticallParameters,
   MulticallReturnType as viem_MulticallReturnType,
 } from 'viem'
@@ -19,6 +20,8 @@ export type MulticallReturnType<
   allowFailure extends boolean = true,
 > = viem_MulticallReturnType<contracts, allowFailure>
 
+export type MulticallErrorType = viem_MulticallErrorType
+
 export async function multicall<
   config extends Config,
   const contracts extends readonly ContractFunctionParameters[],

package/src/actions/readContract.ts

@@ -1,6 +1,7 @@
 import { type Abi } from 'viem'
 import type { ContractFunctionArgs, ContractFunctionName } from 'viem'
 import {
+  type ReadContractErrorType as viem_ReadContractErrorType,
   type ReadContractParameters as viem_ReadContractParameters,
   type ReadContractReturnType as viem_ReadContractReturnType,
   readContract as viem_readContract,
@@ -37,7 +38,7 @@ export type ReadContractReturnType<
   > = ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
 > = viem_ReadContractReturnType<abi, functionName, args>
 
-export type ReadContractError = Error
+export type ReadContractErrorType = viem_ReadContractErrorType
 
 /** https://alpha.wagmi.sh/core/api/actions/readContract */
 export function readContract<

package/src/actions/readContracts.ts

@@ -7,8 +7,8 @@ import { ContractFunctionExecutionError } from 'viem'
 
 import { type Config } from '../createConfig.js'
 import { type ChainIdParameter } from '../types/properties.js'
-import { multicall } from './multicall.js'
-import { readContract } from './readContract.js'
+import { type MulticallErrorType, multicall } from './multicall.js'
+import { type ReadContractErrorType, readContract } from './readContract.js'
 
 export type ReadContractsParameters<
   contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
@@ -25,7 +25,7 @@ export type ReadContractsReturnType<
   allowFailure extends boolean = true,
 > = viem_MulticallReturnType<contracts, allowFailure>
 
-export type ReadContractsError = Error
+export type ReadContractsErrorType = MulticallErrorType | ReadContractErrorType
 
 export async function readContracts<
   config extends Config,

package/src/actions/reconnect.ts

@@ -11,7 +11,7 @@ export type ReconnectParameters = {
 
 export type ReconnectReturnType = Evaluate<Connection>[]
 
-export type ReconnectError = Error
+export type ReconnectErrorType = Error
 
 let isReconnecting = false
 

package/src/actions/sendTransaction.ts

@@ -2,6 +2,7 @@ import type {
   Account,
   Address,
   Chain,
+  SendTransactionErrorType as viem_SendTransactionErrorType,
   SendTransactionParameters as viem_SendTransactionParameters,
   SendTransactionReturnType as viem_SendTransactionReturnType,
 } from 'viem'
@@ -37,7 +38,7 @@ export type SendTransactionParameters<
 
 export type SendTransactionReturnType = viem_SendTransactionReturnType
 
-export type SendTransactionError = Error
+export type SendTransactionErrorType = viem_SendTransactionErrorType
 
 /** https://alpha.wagmi.sh/core/api/actions/sendTransaction */
 export async function sendTransaction<

package/src/actions/signMessage.ts

@@ -1,5 +1,6 @@
 import type { Account } from 'viem'
 import {
+  type SignMessageErrorType as viem_SignMessageErrorType,
   type SignMessageParameters as viem_SignMessageParameters,
   type SignMessageReturnType as viem_SignMessageReturnType,
   signMessage as viem_signMessage,
@@ -16,7 +17,7 @@ export type SignMessageParameters = Evaluate<
 
 export type SignMessageReturnType = viem_SignMessageReturnType
 
-export type SignMessageError = Error
+export type SignMessageErrorType = viem_SignMessageErrorType
 
 /** https://alpha.wagmi.sh/core/api/actions/signMessage */
 export async function signMessage(

package/src/actions/signTypedData.ts

@@ -1,5 +1,6 @@
 import type { Account, TypedData } from 'viem'
 import {
+  type SignMessageErrorType as viem_SignMessageErrorType,
   type SignTypedDataParameters as viem_SignTypedDataParameters,
   type SignTypedDataReturnType as viem_SignTypedDataReturnType,
   signTypedData as viem_signTypedData,
@@ -22,7 +23,7 @@ export type SignTypedDataParameters<
 
 export type SignTypedDataReturnType = viem_SignTypedDataReturnType
 
-export type SignTypedDataError = Error
+export type SignTypedDataErrorType = viem_SignMessageErrorType
 
 /** https://alpha.wagmi.sh/core/api/actions/signTypedData */
 export async function signTypedData<

package/src/actions/simulateContract.ts

@@ -7,6 +7,7 @@ import type {
   ContractFunctionName,
 } from 'viem'
 import {
+  type SimulateContractErrorType as viem_SimulateContractErrorType,
   type SimulateContractParameters as viem_SimulateContractParameters,
   type SimulateContractReturnType as viem_SimulateContractReturnType,
   simulateContract as viem_simulateContract,
@@ -100,7 +101,7 @@ export type SimulateContractReturnType<
     : never
 }[number]
 
-export type SimulateContractError = Error
+export type SimulateContractErrorType = viem_SimulateContractErrorType
 
 /** https://alpha.wagmi.sh/core/api/actions/simulateContract */
 export async function simulateContract<

package/src/actions/switchAccount.ts

@@ -14,7 +14,7 @@ export type SwitchAccountReturnType<config extends Config = Config> = {
     | (number extends config['chains'][number]['id'] ? number : number & {})
 }
 
-export type SwitchAccountError = ConnectorNotConnectedError | Error
+export type SwitchAccountErrorType = ConnectorNotConnectedError | Error
 
 /** https://alpha.wagmi.sh/core/api/actions/switchAccount */
 export async function switchAccount<config extends Config>(

package/src/actions/switchChain.ts

@@ -28,7 +28,7 @@ export type SwitchChainReturnType<
   { id: Config extends config ? number : chainId }
 >
 
-export type SwitchChainError =
+export type SwitchChainErrorType =
   | ProviderNotFoundError
   | SwitchChainError_
   | UserRejectedRequestError

package/src/actions/waitForTransactionReceipt.ts

@@ -1,11 +1,9 @@
-import type {
-  CallParameters,
-  Chain,
-  WaitForTransactionReceiptParameters as viem_WaitForTransactionReceiptParameters,
-  WaitForTransactionReceiptReturnType as viem_WaitForTransactionReceiptReturnType,
-} from 'viem'
+import type { CallParameters, Chain } from 'viem'
 import { hexToString } from 'viem'
 import {
+  type WaitForTransactionReceiptErrorType as viem_WaitForTransactionReceiptErrorType,
+  type WaitForTransactionReceiptParameters as viem_WaitForTransactionReceiptParameters,
+  type WaitForTransactionReceiptReturnType as viem_WaitForTransactionReceiptReturnType,
   call,
   getTransaction,
   waitForTransactionReceipt as viem_waitForTransactionReceipt,
@@ -34,7 +32,8 @@ export type WaitForTransactionReceiptReturnType<
   }[number]
 >
 
-export type WaitForTransactionReceiptError = Error
+export type WaitForTransactionReceiptErrorType =
+  viem_WaitForTransactionReceiptErrorType
 
 export async function waitForTransactionReceipt<
   config extends Config,

package/src/actions/watchBlockNumber.ts

@@ -66,9 +66,7 @@ export function watchBlockNumber<
   if (syncConnectedChain && !parameters.chainId)
     unsubscribe = config.subscribe(
       ({ chainId }) => chainId,
-      async (chainId) => {
-        return listener(chainId)
-      },
+      async (chainId) => listener(chainId),
     )
 
   return () => {

package/src/actions/watchBlocks.ts

@@ -75,9 +75,7 @@ export function watchBlocks<
   if (syncConnectedChain && !parameters.chainId)
     unsubscribe = config.subscribe(
       ({ chainId }) => chainId,
-      async (chainId) => {
-        return listener(chainId)
-      },
+      async (chainId) => listener(chainId),
     )
 
   return () => {

package/src/actions/watchContractEvent.ts

@@ -86,9 +86,7 @@ export function watchContractEvent<
   if (syncConnectedChain && !parameters.chainId)
     unsubscribe = config.subscribe(
       ({ chainId }) => chainId,
-      async (chainId) => {
-        return listener(chainId)
-      },
+      async (chainId) => listener(chainId),
     )
 
   return () => {

package/src/actions/watchPendingTransactions.ts

@@ -67,9 +67,7 @@ export function watchPendingTransactions<
   if (syncConnectedChain && !parameters.chainId)
     unsubscribe = config.subscribe(
       ({ chainId }) => chainId,
-      async (chainId) => {
-        return listener(chainId)
-      },
+      async (chainId) => listener(chainId),
     )
 
   return () => {

package/src/actions/writeContract.ts

@@ -4,10 +4,13 @@ import type {
   Chain,
   ContractFunctionArgs,
   ContractFunctionName,
-  WriteContractParameters as viem_WriteContractParameters,
-  WriteContractReturnType as viem_WriteContractReturnType,
 } from 'viem'
-import { writeContract as viem_writeContract } from 'viem/actions'
+import {
+  type WriteContractErrorType as viem_WriteContractErrorType,
+  type WriteContractParameters as viem_WriteContractParameters,
+  type WriteContractReturnType as viem_WriteContractReturnType,
+  writeContract as viem_writeContract,
+} from 'viem/actions'
 
 import type { Config } from '../createConfig.js'
 import type { SelectChains } from '../types/chain.js'
@@ -15,7 +18,7 @@ import type {
   ChainIdParameter,
   ConnectorParameter,
 } from '../types/properties.js'
-import type { Evaluate, UnionOmit } from '../types/utils.js'
+import type { Evaluate, UnionEvaluate, UnionOmit } from '../types/utils.js'
 import { assertActiveChain } from '../utils/assertActiveChain.js'
 import { getConnectorClient } from './getConnectorClient.js'
 import {
@@ -39,26 +42,28 @@ export type WriteContractParameters<
   ///
   allFunctionNames = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
   chains extends readonly Chain[] = SelectChains<config, chainId>,
-> = {
-  [key in keyof chains]: UnionOmit<
-    viem_WriteContractParameters<
-      abi,
-      functionName,
-      args,
-      chains[key],
-      Account,
-      chains[key],
-      allFunctionNames
-    >,
-    'chain'
-  >
-}[number] &
-  Evaluate<ChainIdParameter<config, chainId>> &
-  ConnectorParameter & { __mode?: 'prepared' }
+> = UnionEvaluate<
+  {
+    [key in keyof chains]: UnionOmit<
+      viem_WriteContractParameters<
+        abi,
+        functionName,
+        args,
+        chains[key],
+        Account,
+        chains[key],
+        allFunctionNames
+      >,
+      'chain'
+    >
+  }[number] &
+    Evaluate<ChainIdParameter<config, chainId>> &
+    ConnectorParameter & { __mode?: 'prepared' }
+>
 
 export type WriteContractReturnType = viem_WriteContractReturnType
 
-export type WriteContractError = Error
+export type WriteContractErrorType = viem_WriteContractErrorType
 
 /** https://alpha.wagmi.sh/core/api/actions/writeContract */
 export async function writeContract<
@@ -91,13 +96,7 @@ export async function writeContract<
   } else {
     const { request: simulateRequest } = await simulateContract(
       config,
-      rest as unknown as SimulateContractParameters<
-        abi,
-        functionName,
-        args,
-        config,
-        chainId
-      >,
+      rest as SimulateContractParameters,
     )
     request = simulateRequest
   }

package/src/connectors/injected.ts

@@ -28,11 +28,7 @@ export type InjectedParameters = {
   /**
    * [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193) Ethereum Provider to target
    */
-  target?:
-    | TargetId
-    | TargetMap[TargetId]
-    | (() => TargetMap[TargetId] | undefined)
-    | undefined
+  target?: TargetId | Target | (() => Target | undefined) | undefined
 }
 
 const targetMap = {
@@ -91,7 +87,7 @@ const targetMap = {
 export function injected(parameters: InjectedParameters = {}) {
   const { shimDisconnect = true, unstable_shimAsyncInject } = parameters
 
-  function getTarget(): Evaluate<TargetMap[TargetId] & { id: string }> {
+  function getTarget(): Evaluate<Target & { id: string }> {
     const target = parameters.target
     if (typeof target === 'function') {
       const result = target()
@@ -122,7 +118,9 @@ export function injected(parameters: InjectedParameters = {}) {
   type Properties = {
     onConnect(connectInfo: ProviderConnectInfo): void
   }
-  type StorageItem = { [_ in `${string}.disconnected`]: true }
+  type StorageItem = {
+    [_ in 'injected.connected' | `${string}.disconnected`]: true
+  }
 
   return createConnector<Provider, Properties, StorageItem>((config) => ({
     get icon() {
@@ -137,9 +135,8 @@ export function injected(parameters: InjectedParameters = {}) {
     async setup() {
       const provider = await this.getProvider()
       // Only start listening for events if `target` is set, otherwise `injected()` will also receive events
-      if (provider && parameters.target) {
+      if (provider && parameters.target)
         provider.on('connect', this.onConnect.bind(this))
-      }
     },
     async connect({ chainId, isReconnecting } = {}) {
       const provider = await this.getProvider()
@@ -190,9 +187,13 @@ export function injected(parameters: InjectedParameters = {}) {
           currentChainId = chain?.id ?? currentChainId
         }
 
-        // Remove disconnected shim if it exists
-        if (shimDisconnect)
+        if (shimDisconnect) {
+          // Remove disconnected shim if it exists
           await config.storage?.removeItem(`${this.id}.disconnected`)
+          // Add connected shim if no target exists
+          if (!parameters.target)
+            await config.storage?.setItem('injected.connected', true)
+        }
 
         return { accounts, chainId: currentChainId }
       } catch (err) {
@@ -217,8 +218,11 @@ export function injected(parameters: InjectedParameters = {}) {
       provider.on('connect', this.onConnect.bind(this))
 
       // Add shim signalling connector is disconnected
-      if (shimDisconnect)
+      if (shimDisconnect) {
         await config.storage?.setItem(`${this.id}.disconnected`, true)
+        if (!parameters.target)
+          await config.storage?.removeItem('injected.connected')
+      }
     },
     async getAccounts() {
       const provider = await this.getProvider()
@@ -249,6 +253,15 @@ export function injected(parameters: InjectedParameters = {}) {
           (await config.storage?.getItem(`${this.id}.disconnected`))
         if (isDisconnected) return false
 
+        // Don't allow injected connector to connect if no target is set and it hasn't already connected
+        // (e.g. flag in storage is not set). This prevents a targetless injected connector from connecting
+        // automatically whenever there is a targeted connector configured.
+        if (!parameters.target) {
+          const connected = await config.storage?.getItem('injected.connected')
+          console.log({ connected })
+          if (!connected) return false
+        }
+
         const provider = await this.getProvider()
         if (!provider) {
           if (
@@ -442,6 +455,7 @@ type Target = {
     | ((window?: Window | undefined) => WalletProvider | undefined)
 }
 
+/** @deprecated */
 export type TargetId = Evaluate<WalletProviderFlags> extends `is${infer name}`
   ? name extends `${infer char}${infer rest}`
     ? `${Lowercase<char>}${rest}`
@@ -450,6 +464,7 @@ export type TargetId = Evaluate<WalletProviderFlags> extends `is${infer name}`
 
 type TargetMap = { [_ in TargetId]?: Target | undefined }
 
+/** @deprecated */
 type WalletProviderFlags =
   | 'isApexWallet'
   | 'isAvalanche'

package/src/connectors/mock.ts

@@ -0,0 +1,174 @@
+import {
+  type Address,
+  type EIP1193RequestFn,
+  type Hex,
+  RpcRequestError,
+  SwitchChainError,
+  type Transport,
+  UserRejectedRequestError,
+  type WalletRpcSchema,
+  custom,
+  fromHex,
+  getAddress,
+  numberToHex,
+} from 'viem'
+import { rpc } from 'viem/utils'
+
+import {
+  ChainNotConfiguredError,
+  ConnectorNotConnectedError,
+} from '../errors/config.js'
+import { normalizeChainId } from '../utils/normalizeChainId.js'
+import { createConnector } from './createConnector.js'
+
+export type MockParameters = {
+  accounts: readonly [Address, ...Address[]]
+  features?:
+    | {
+        connectError?: boolean | Error | undefined
+        switchChainError?: boolean | Error | undefined
+        signMessageError?: boolean | Error | undefined
+        signTypedDataError?: boolean | Error | undefined
+        reconnect?: boolean | undefined
+      }
+    | undefined
+}
+
+export function mock(parameters: MockParameters) {
+  const features = parameters.features ?? {}
+
+  type Provider = ReturnType<
+    Transport<'custom', {}, EIP1193RequestFn<WalletRpcSchema>>
+  >
+  let connected = false
+  let connectedChainId: number
+
+  return createConnector<Provider>((config) => ({
+    id: 'mock',
+    name: 'Mock Connector',
+    async setup() {
+      connectedChainId = config.chains[0].id
+    },
+    async connect({ chainId } = {}) {
+      if (features.connectError) {
+        if (typeof features.connectError === 'boolean')
+          throw new UserRejectedRequestError(new Error('Failed to connect.'))
+        throw features.connectError
+      }
+
+      const provider = await this.getProvider()
+      const accounts = await provider.request({
+        method: 'eth_requestAccounts',
+      })
+
+      let currentChainId = await this.getChainId()
+      if (chainId && currentChainId !== chainId) {
+        const chain = await this.switchChain!({ chainId })
+        currentChainId = chain.id
+      }
+
+      connected = true
+
+      return { accounts, chainId: currentChainId }
+    },
+    async disconnect() {
+      connected = false
+    },
+    async getAccounts() {
+      if (!connected) throw new ConnectorNotConnectedError()
+      const provider = await this.getProvider()
+      const accounts = await provider.request({ method: 'eth_accounts' })
+      return accounts.map(getAddress)
+    },
+    async getChainId() {
+      const provider = await this.getProvider()
+      const hexChainId = await provider.request({ method: 'eth_chainId' })
+      return fromHex(hexChainId, 'number')
+    },
+    async isAuthorized() {
+      if (!features.reconnect) return false
+      if (!connected) return false
+      const accounts = await this.getAccounts()
+      return !!accounts.length
+    },
+    async switchChain({ chainId }) {
+      const provider = await this.getProvider()
+      const chain = config.chains.find((x) => x.id === chainId)
+      if (!chain) throw new SwitchChainError(new ChainNotConfiguredError())
+
+      await provider.request({
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: numberToHex(chainId) }],
+      })
+      return chain
+    },
+    onAccountsChanged(accounts) {
+      if (accounts.length === 0) this.onDisconnect()
+      else config.emitter.emit('change', { accounts: accounts.map(getAddress) })
+    },
+    onChainChanged(chain) {
+      const chainId = normalizeChainId(chain)
+      config.emitter.emit('change', { chainId })
+    },
+    async onDisconnect(_error) {
+      config.emitter.emit('disconnect')
+      connected = false
+    },
+    async getProvider({ chainId } = {}) {
+      const chain =
+        config.chains.find((x) => x.id === chainId) ?? config.chains[0]
+      const url = chain.rpcUrls.default.http[0]!
+
+      const request: EIP1193RequestFn = async ({ method, params }) => {
+        // eth methods
+        if (method === 'eth_chainId') return numberToHex(connectedChainId)
+        if (method === 'eth_requestAccounts') return parameters.accounts
+        if (method === 'eth_signTypedData_v4')
+          if (features.signTypedDataError) {
+            if (typeof features.signTypedDataError === 'boolean')
+              throw new UserRejectedRequestError(
+                new Error('Failed to sign typed data.'),
+              )
+            throw features.signTypedDataError
+          }
+
+        // wallet methods
+        if (method === 'wallet_switchEthereumChain') {
+          if (features.switchChainError) {
+            if (typeof features.switchChainError === 'boolean')
+              throw new UserRejectedRequestError(
+                new Error('Failed to switch chain.'),
+              )
+            throw features.switchChainError
+          }
+          type Params = [{ chainId: Hex }]
+          connectedChainId = fromHex((params as Params)[0].chainId, 'number')
+          this.onChainChanged(connectedChainId.toString())
+          return
+        }
+
+        // other methods
+        if (method === 'personal_sign') {
+          if (features.signMessageError) {
+            if (typeof features.signMessageError === 'boolean')
+              throw new UserRejectedRequestError(
+                new Error('Failed to sign message.'),
+              )
+            throw features.signMessageError
+          }
+          // Change `personal_sign` to `eth_sign` and swap params
+          method = 'eth_sign'
+          type Params = [data: Hex, address: Address]
+          params = [(params as Params)[1], (params as Params)[0]]
+        }
+
+        const body = { method, params }
+        const { error, result } = await rpc.http(url, { body })
+        if (error) throw new RpcRequestError({ body, error, url })
+
+        return result
+      }
+      return custom({ request })({ retryCount: 0 })
+    },
+  }))
+}

package/src/createConfig.ts

@@ -115,7 +115,6 @@ export function createConfig<
     const chain = chains.find((x) => x.id === chainId)
 
     // If the target chain is not configured, use the client of the current chain.
-    // TODO: should we error instead? idk. figure out later.
     type Return = Client<Transport, Extract<chains[number], { id: chainId }>>
     {
       const client = clients.get(store.getState().chainId)
@@ -313,7 +312,7 @@ export function createConfig<
         selector as unknown as (state: State) => any,
         listener,
         options
-          ? { ...options, fireImmediately: options.emitOnBegin }
+          ? { ...options, fireImmediately: options.emitImmediately }
           : undefined,
       )
     },
@@ -359,7 +358,7 @@ export type Config<
     listener: (state: state, previousState: state) => void,
     options?:
       | {
-          emitOnBegin?: boolean | undefined
+          emitImmediately?: boolean | undefined
           equalityFn?: ((a: state, b: state) => boolean) | undefined
         }
       | undefined,