@wagmi/core 2.0.0 → 2.0.2

package/src/connectors/mock.ts

@@ -0,0 +1,176 @@
+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
+}
+
+mock.type = 'mock' as const
+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',
+    type: mock.type,
+    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

@@ -1,18 +1,24 @@
+import {
+  type EIP6963ProviderDetail,
+  type Store as MipdStore,
+  createStore as createMipd,
+} from 'mipd'
 import {
   type Address,
   type Chain,
   type Client,
   type ClientConfig as viem_ClientConfig,
-  type Transport,
+  type Transport as viem_Transport,
   createClient,
 } from 'viem'
 import { persist, subscribeWithSelector } from 'zustand/middleware'
-import { createStore } from 'zustand/vanilla'
+import { type Mutate, type StoreApi, createStore } from 'zustand/vanilla'
 
 import {
   type ConnectorEventMap,
   type CreateConnectorFn,
-} from './createConnector.js'
+} from './connectors/createConnector.js'
+import { injected } from './connectors/injected.js'
 import { Emitter, type EventData, createEmitter } from './createEmitter.js'
 import { type Storage, createStorage, noopStorage } from './createStorage.js'
 import { ChainNotConfiguredError } from './errors/config.js'
@@ -29,8 +35,9 @@ export type CreateConfigParameters<
   {
     chains: chains
     connectors?: CreateConnectorFn[] | undefined
-    reconnectOnMount?: boolean | undefined
+    multiInjectedProviderDiscovery?: boolean | undefined
     storage?: Storage | null | undefined
+    ssr?: boolean | undefined
     syncConnectedChain?: boolean | undefined
   } & OneOf<
     | ({ transports: transports } & {
@@ -45,57 +52,9 @@ export type CreateConfigParameters<
           chains[number]
         >
       }
-  > &
-    OneOf<
-      | {
-          /** @deprecated Use `reconnectOnMount` instead */
-          autoConnect?: boolean | undefined
-        }
-      | { reconnectOnMount?: boolean | undefined }
-    >
+  >
 >
 
-export type Config<
-  chains extends readonly [Chain, ...Chain[]] = readonly [Chain, ...Chain[]],
-  transports extends Record<chains[number]['id'], Transport> = Record<
-    chains[number]['id'],
-    Transport
-  >,
-> = {
-  readonly chains: chains
-  readonly connectors: readonly Connector[]
-  readonly state: State<chains>
-  readonly storage: Storage | null
-
-  getClient<chainId extends chains[number]['id']>(parameters?: {
-    chainId?: chainId | chains[number]['id'] | undefined
-  }): Client<transports[chainId], Extract<chains[number], { id: chainId }>>
-  setState<tchains extends readonly [Chain, ...Chain[]] = chains>(
-    value: State<tchains> | ((state: State<tchains>) => State<tchains>),
-  ): void
-  subscribe<state>(
-    selector: (state: State<chains>) => state,
-    listener: (selectedState: state, previousSelectedState: state) => void,
-    options?:
-      | {
-          equalityFn?: ((a: state, b: state) => boolean) | undefined
-          fireImmediately?: boolean | undefined
-        }
-      | undefined,
-  ): () => void
-
-  _internal: {
-    readonly reconnectOnMount: boolean
-    readonly syncConnectedChain: boolean
-    readonly transports: transports
-
-    change(data: EventData<ConnectorEventMap, 'change'>): void
-    connect(data: EventData<ConnectorEventMap, 'connect'>): void
-    disconnect(data: EventData<ConnectorEventMap, 'disconnect'>): void
-    setup(connectorFn: CreateConnectorFn): Connector
-  }
-}
-
 export function createConfig<
   const chains extends readonly [Chain, ...Chain[]],
   transports extends Record<chains[number]['id'], Transport>,
@@ -103,9 +62,8 @@ export function createConfig<
   parameters: CreateConfigParameters<chains, transports>,
 ): Config<chains, transports> {
   const {
-    autoConnect,
     chains,
-    reconnectOnMount = autoConnect ?? true,
+    multiInjectedProviderDiscovery = true,
     storage = createStorage({
       storage:
         typeof window !== 'undefined' && window.localStorage
@@ -113,6 +71,7 @@ export function createConfig<
           : noopStorage,
     }),
     syncConnectedChain = true,
+    ssr,
     ...rest
   } = parameters
 
@@ -120,8 +79,20 @@ export function createConfig<
   // Set up connectors, clients, etc.
   /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  const connectors = (rest.connectors ?? []).map(setup)
-  function setup(connectorFn: CreateConnectorFn) {
+  const mipd =
+    typeof window !== 'undefined' && multiInjectedProviderDiscovery
+      ? createMipd()
+      : undefined
+
+  const connectors = createStore(() =>
+    [
+      ...(rest.connectors ?? []),
+      ...(!ssr
+        ? mipd?.getProviders().map(providerDetailToConnector) ?? []
+        : []),
+    ].map(setup),
+  )
+  function setup(connectorFn: CreateConnectorFn): Connector {
     // Set up emitter with uid and add to connector so they are "linked" together.
     const emitter = createEmitter<ConnectorEventMap>(uid())
     const connector = {
@@ -130,13 +101,19 @@ export function createConfig<
       uid: emitter.uid,
     }
 
-    // Start listening for `connect` events if `reconnectOnMount` is switched on.
+    // Start listening for `connect` events on connector setup
     // This allows connectors to "connect" themselves without user interaction (e.g. MetaMask's "Manually connect to current site")
-    if (reconnectOnMount) emitter.on('connect', connect)
+    emitter.on('connect', connect)
     connector.setup?.()
 
     return connector
   }
+  function providerDetailToConnector(providerDetail: EIP6963ProviderDetail) {
+    const { info, provider } = providerDetail
+    return injected({
+      target: { ...info, id: info.rdns, provider: provider as any },
+    })
+  }
 
   const clients = new Map<number, Client<Transport, chains[number]>>()
   function getClient<chainId extends chains[number]['id']>(
@@ -146,7 +123,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)
@@ -179,7 +155,11 @@ export function createConfig<
         ...properties,
         chain,
         batch: properties.batch ?? { multicall: true },
-        transport: rest.transports[chainId],
+        transport: (parameters) =>
+          rest.transports[chainId]({
+            ...parameters,
+            connectors,
+          }),
       })
     }
 
@@ -206,13 +186,12 @@ export function createConfig<
             name: 'store',
             partialize(state) {
               return {
-                chainId: state.chainId,
                 connections: state.connections,
+                chainId: state.chainId,
                 current: state.current,
-                status: state.status,
               } satisfies PartializedState
             },
-            skipHydration: !reconnectOnMount,
+            skipHydration: ssr,
             storage: storage as Storage<Record<string, unknown>>,
             version: 1,
           })
@@ -241,6 +220,23 @@ export function createConfig<
       },
     )
 
+  // EIP-6963 subscribe for new wallet providers
+  mipd?.subscribe((providerDetails) => {
+    const currentConnectorIds = new Map()
+    for (const connector of connectors.getState()) {
+      currentConnectorIds.set(connector.id, true)
+    }
+
+    const newConnectors: Connector[] = []
+    for (const providerDetail of providerDetails) {
+      const connector = setup(providerDetailToConnector(providerDetail))
+      if (currentConnectorIds.has(connector.id)) continue
+      newConnectors.push(connector)
+    }
+
+    connectors.setState((x) => [...x, ...newConnectors], true)
+  })
+
   /////////////////////////////////////////////////////////////////////////////////////////////////
   // Emitter listeners
   /////////////////////////////////////////////////////////////////////////////////////////////////
@@ -261,11 +257,15 @@ export function createConfig<
     })
   }
   function connect(data: EventData<ConnectorEventMap, 'connect'>) {
-    // Disable handling if reconnecting
-    if (store.getState().status === 'reconnecting') return
+    // Disable handling if reconnecting/connecting
+    if (
+      store.getState().status === 'connecting' ||
+      store.getState().status === 'reconnecting'
+    )
+      return
 
     store.setState((x) => {
-      const connector = connectors.find((x) => x.uid === data.uid)
+      const connector = connectors.getState().find((x) => x.uid === data.uid)
       if (!connector) return x
       return {
         ...x,
@@ -309,13 +309,15 @@ export function createConfig<
 
   return {
     chains: chains as chains,
-    connectors,
-    get state() {
-      return store.getState() as unknown as State<chains>
+    get connectors() {
+      return connectors.getState()
     },
     storage,
 
     getClient,
+    get state() {
+      return store.getState() as unknown as State<chains>
+    },
     setState(value) {
       let newState: State
       if (typeof value === 'function') newState = value(store.getState() as any)
@@ -332,18 +334,29 @@ export function createConfig<
       return store.subscribe(
         selector as unknown as (state: State) => any,
         listener,
-        options,
+        options
+          ? { ...options, fireImmediately: options.emitImmediately }
+          : undefined,
       )
     },
 
     _internal: {
-      reconnectOnMount,
+      mipd,
+      store,
+      ssr: Boolean(ssr),
       syncConnectedChain,
       transports: rest.transports as transports,
-      change,
-      connect,
-      disconnect,
-      setup,
+      connectors: {
+        providerDetailToConnector,
+        setup,
+        setState: (value) =>
+          connectors.setState(
+            typeof value === 'function' ? value(connectors.getState()) : value,
+            true,
+          ),
+        subscribe: (listener) => connectors.subscribe(listener),
+      },
+      events: { change, connect, disconnect },
     },
   }
 }
@@ -352,6 +365,64 @@ export function createConfig<
 // Types
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
+export type Config<
+  chains extends readonly [Chain, ...Chain[]] = readonly [Chain, ...Chain[]],
+  transports extends Record<chains[number]['id'], Transport> = Record<
+    chains[number]['id'],
+    Transport
+  >,
+> = {
+  readonly chains: chains
+  readonly connectors: readonly Connector[]
+  readonly storage: Storage | null
+
+  readonly state: State<chains>
+  setState<tchains extends readonly [Chain, ...Chain[]] = chains>(
+    value: State<tchains> | ((state: State<tchains>) => State<tchains>),
+  ): void
+  subscribe<state>(
+    selector: (state: State<chains>) => state,
+    listener: (state: state, previousState: state) => void,
+    options?:
+      | {
+          emitImmediately?: boolean | undefined
+          equalityFn?: ((a: state, b: state) => boolean) | undefined
+        }
+      | undefined,
+  ): () => void
+
+  getClient<chainId extends chains[number]['id']>(parameters?: {
+    chainId?: chainId | chains[number]['id'] | undefined
+  }): Client<transports[chainId], Extract<chains[number], { id: chainId }>>
+
+  _internal: {
+    readonly mipd: MipdStore | undefined
+    readonly store: Mutate<StoreApi<any>, [['zustand/persist', any]]>
+    readonly ssr: boolean
+    readonly syncConnectedChain: boolean
+    readonly transports: transports
+
+    connectors: {
+      providerDetailToConnector(
+        providerDetail: EIP6963ProviderDetail,
+      ): CreateConnectorFn
+      setup(connectorFn: CreateConnectorFn): Connector
+      setState(value: Connector[] | ((state: Connector[]) => Connector[])): void
+      subscribe(
+        listener: (
+          state: readonly Connector[],
+          prevState: readonly Connector[],
+        ) => void,
+      ): () => void
+    }
+    events: {
+      change(data: EventData<ConnectorEventMap, 'change'>): void
+      connect(data: EventData<ConnectorEventMap, 'connect'>): void
+      disconnect(data: EventData<ConnectorEventMap, 'disconnect'>): void
+    }
+  }
+}
+
 export type State<
   chains extends readonly [Chain, ...Chain[]] = readonly [Chain, ...Chain[]],
 > = {
@@ -376,6 +447,12 @@ export type Connector = ReturnType<CreateConnectorFn> & {
   uid: string
 }
 
+export type Transport = (
+  params: Parameters<viem_Transport>[0] & {
+    connectors?: StoreApi<Connector[]>
+  },
+) => ReturnType<viem_Transport>
+
 type ClientConfig = LooseOmit<
   viem_ClientConfig,
   'account' | 'chain' | 'key' | 'name' | 'transport' | 'type'

package/src/createStorage.ts

@@ -1,5 +1,5 @@
 import { type PartializedState } from './createConfig.js'
-import type { Evaluate } from './types/utils.js'
+import { type Evaluate } from './types/utils.js'
 import { deserialize as deserialize_ } from './utils/deserialize.js'
 import { serialize as serialize_ } from './utils/serialize.js'
 
@@ -14,6 +14,7 @@ export type Storage<
   ///
   storageItemMap extends StorageItemMap = StorageItemMap & itemMap,
 > = {
+  key: string
   getItem<
     key extends keyof storageItemMap,
     value extends storageItemMap[key],
@@ -31,7 +32,7 @@ export type Storage<
   removeItem(key: keyof storageItemMap): void | Promise<void>
 }
 
-type BaseStorage = {
+export type BaseStorage = {
   getItem(
     key: string,
   ): string | null | undefined | Promise<string | null | undefined>
@@ -43,7 +44,7 @@ export type CreateStorageParameters = {
   deserialize?: (<T>(value: string) => T) | undefined
   key?: string | undefined
   serialize?: (<T>(value: T) => string) | undefined
-  storage: Evaluate<BaseStorage>
+  storage?: Evaluate<BaseStorage> | undefined
 }
 
 export function createStorage<
@@ -54,17 +55,17 @@ export function createStorage<
     deserialize = deserialize_,
     key: prefix = 'wagmi',
     serialize = serialize_,
-    storage,
+    storage = noopStorage,
   } = parameters
 
   function unwrap<type>(value: type): type | Promise<type> {
-    if (value instanceof Promise)
-      return value.then((x) => x).catch(() => undefined)
+    if (value instanceof Promise) return value.then((x) => x).catch(() => null)
     return value
   }
 
   return {
     ...storage,
+    key: prefix,
     async getItem(key, defaultValue) {
       const value = storage.getItem(`${prefix}.${key as string}`)
       const unwrapped = await unwrap(value)

package/src/errors/base.ts

@@ -1,14 +1,17 @@
 import type { Evaluate, OneOf } from '../types/utils.js'
 import { getVersion } from '../utils/getVersion.js'
 
+export type ErrorType<name extends string = 'Error'> = Error & { name: name }
+
 type BaseErrorOptions = Evaluate<
-  {
-    docsPath?: string
-    docsSlug?: string
-    metaMessages?: string[]
-  } & OneOf<{ details?: string } | { cause: BaseError | Error }>
+  OneOf<{ details?: string | undefined } | { cause: BaseError | Error }> & {
+    docsPath?: string | undefined
+    docsSlug?: string | undefined
+    metaMessages?: string[] | undefined
+  }
 >
 
+export type BaseErrorType = BaseError & { name: 'WagmiCoreError' }
 export class BaseError extends Error {
   details: string
   docsPath?: string | undefined
@@ -17,7 +20,7 @@ export class BaseError extends Error {
 
   override name = 'WagmiCoreError'
   get docsBaseUrl() {
-    return 'https://alpha.wagmi.sh/core'
+    return 'https://wagmi.sh/core'
   }
   get version() {
     return getVersion()