@wagmi/core 2.0.0-alpha.2 → 2.0.0-alpha.3

package/src/actions/connect.ts

@@ -9,9 +9,9 @@ import type { ChainIdParameter } from '../types/properties.js'
 import type { Evaluate } from '../types/utils.js'
 
 export type ConnectParameters<config extends Config = Config> = Evaluate<
-  {
+  ChainIdParameter<config> & {
     connector: Connector | CreateConnectorFn
-  } & ChainIdParameter<config>
+  }
 >
 
 export type ConnectReturnType<config extends Config = Config> = {
@@ -22,7 +22,6 @@ export type ConnectReturnType<config extends Config = Config> = {
 }
 
 export type ConnectError =
-  // connect()
   | ConnectorAlreadyConnectedError
   // connector.connect()
   | UserRejectedRequestError
@@ -39,7 +38,7 @@ export async function connect<config extends Config>(
   // "Register" connector if not already created
   let connector: Connector
   if (typeof parameters.connector === 'function') {
-    connector = config._internal.setup(parameters.connector)
+    connector = config._internal.connectors.setup(parameters.connector)
   } else connector = parameters.connector
 
   // Check if connector is already connected
@@ -69,18 +68,13 @@ export async function connect<config extends Config>(
       status: 'connected',
     }))
 
-    return {
-      accounts,
-      chainId: data.chainId,
-    }
+    return { accounts, chainId: data.chainId }
   } catch (error) {
-    config.setState((x) => {
-      return {
-        ...x,
-        // Keep existing connector connected in case of error
-        status: x.current ? 'connected' : 'disconnected',
-      }
-    })
+    config.setState((x) => ({
+      ...x,
+      // Keep existing connector connected in case of error
+      status: x.current ? 'connected' : 'disconnected',
+    }))
     throw error
   }
 }

package/src/actions/disconnect.ts

@@ -7,10 +7,9 @@ import {
   ConnectorNotConnectedError,
   ConnectorNotFoundError,
 } from '../errors/config.js'
+import type { ConnectorParameter } from '../types/properties.js'
 
-export type DisconnectParameters = {
-  connector?: Connector | undefined
-}
+export type DisconnectParameters = ConnectorParameter
 
 export type DisconnectReturnType = void
 
@@ -41,6 +40,7 @@ export async function disconnect(
   connections.delete(connector.uid)
 
   config.setState((x) => {
+    // if no connections exist, move to disconnected state
     if (connections.size === 0)
       return {
         ...x,
@@ -49,6 +49,7 @@ export async function disconnect(
         status: 'disconnected',
       }
 
+    // switch over to another connection
     const nextConnection = connections.values().next().value as Connection
     return {
       ...x,

package/src/actions/getBalance.ts

@@ -54,6 +54,7 @@ export async function getBalance<config extends Config>(
     try {
       return getTokenBalance(config, {
         balanceAddress: address,
+        chainId,
         symbolType: 'string',
         tokenAddress,
       })
@@ -64,6 +65,7 @@ export async function getBalance<config extends Config>(
       if (error instanceof ContractFunctionExecutionError) {
         const balance = await getTokenBalance(config, {
           balanceAddress: address,
+          chainId,
           symbolType: 'bytes32',
           tokenAddress,
         })
@@ -92,6 +94,7 @@ export async function getBalance<config extends Config>(
 
 type GetTokenBalanceParameters = {
   balanceAddress: Address
+  chainId?: number | undefined
   symbolType: 'bytes32' | 'string'
   tokenAddress: Address
   unit?: Unit | undefined
@@ -101,7 +104,7 @@ async function getTokenBalance(
   config: Config,
   parameters: GetTokenBalanceParameters,
 ) {
-  const { balanceAddress, symbolType, tokenAddress, unit } = parameters
+  const { balanceAddress, chainId, symbolType, tokenAddress, unit } = parameters
   const contract = {
     abi: [
       {
@@ -131,9 +134,14 @@ async function getTokenBalance(
   const [value, decimals, symbol] = await readContracts(config, {
     allowFailure: false,
     contracts: [
-      { ...contract, functionName: 'balanceOf', args: [balanceAddress] },
-      { ...contract, functionName: 'decimals' },
-      { ...contract, functionName: 'symbol' },
+      {
+        ...contract,
+        functionName: 'balanceOf',
+        args: [balanceAddress],
+        chainId,
+      },
+      { ...contract, functionName: 'decimals', chainId },
+      { ...contract, functionName: 'symbol', chainId },
     ] as const,
   })
   const formatted = formatUnits(value ?? '0', getUnit(unit ?? decimals))

package/src/actions/getBlock.ts

@@ -57,7 +57,7 @@ export function getBlock<
 ): Promise<GetBlockReturnType<includeTransactions, blockTag, config, chainId>> {
   const { chainId } = parameters
   const client = config.getClient({ chainId })
-  return viem_getBlock(client, parameters) as {} as Promise<
+  return viem_getBlock(client, parameters) as Promise<
     GetBlockReturnType<includeTransactions, blockTag, config, chainId>
   >
 }

package/src/actions/getConnectorClient.ts

@@ -92,5 +92,5 @@ export async function getConnectorClient<
     chain,
     name: 'Connector Client',
     transport: (opts) => custom(provider)({ ...opts, retryCount: 0 }),
-  }) as unknown as Return
+  }) as Return
 }

package/src/actions/getConnectors.ts

@@ -0,0 +1,14 @@
+import type { Config, Connector } from '../createConfig.js'
+import { deepEqual } from '../utils/deepEqual.js'
+
+export type GetConnectorsReturnType = readonly Connector[]
+
+let previousConnectors: readonly Connector[] = []
+
+/** https://alpha.wagmi.sh/core/api/actions/getConnectors */
+export function getConnectors(config: Config): GetConnectorsReturnType {
+  const connectors = config.connectors
+  if (deepEqual(previousConnectors, connectors)) return previousConnectors
+  previousConnectors = connectors
+  return connectors
+}

package/src/actions/getToken.ts

@@ -14,10 +14,10 @@ import { getUnit } from '../utils/getUnit.js'
 import { readContracts } from './readContracts.js'
 
 export type GetTokenParameters<config extends Config = Config> = Evaluate<
-  {
+  ChainIdParameter<config> & {
     address: Address
-    formatUnits?: Unit
-  } & ChainIdParameter<config>
+    formatUnits?: Unit | undefined
+  }
 >
 
 export type GetTokenReturnType = {

package/src/actions/multicall.ts

@@ -21,7 +21,7 @@ export type MulticallReturnType<
 
 export async function multicall<
   config extends Config,
-  const contracts extends readonly unknown[],
+  const contracts extends readonly ContractFunctionParameters[],
   allowFailure extends boolean = true,
 >(
   config: config,

package/src/actions/reconnect.ts

@@ -35,7 +35,7 @@ export async function reconnect(
       let connector: Connector
       // "Register" connector if not already created
       if (typeof connector_ === 'function')
-        connector = config._internal.setup(connector_)
+        connector = config._internal.connectors.setup(connector_)
       else connector = connector_
       connectors.push(connector)
     }

package/src/actions/signTypedData.ts

@@ -7,6 +7,7 @@ import {
 
 import { type Config } from '../createConfig.js'
 import type { ConnectorParameter } from '../types/properties.js'
+import type { UnionEvaluate } from '../types/utils.js'
 import { getConnectorClient } from './getConnectorClient.js'
 
 export type SignTypedDataParameters<
@@ -14,13 +15,10 @@ export type SignTypedDataParameters<
   primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
   ///
   primaryTypes = typedData extends TypedData ? keyof typedData : string,
-> = viem_SignTypedDataParameters<
-  typedData,
-  primaryType,
-  Account,
-  primaryTypes
-> &
-  ConnectorParameter
+> = UnionEvaluate<
+  viem_SignTypedDataParameters<typedData, primaryType, Account, primaryTypes> &
+    ConnectorParameter
+>
 
 export type SignTypedDataReturnType = viem_SignTypedDataReturnType
 

package/src/actions/switchAccount.ts

@@ -22,6 +22,7 @@ export async function switchAccount<config extends Config>(
   parameters: SwitchAccountParameters,
 ): Promise<SwitchAccountReturnType<config>> {
   const { connector } = parameters
+
   const connection = config.state.connections.get(connector.uid)
   if (!connection) throw new ConnectorNotConnectedError()
 

package/src/actions/switchChain.ts

@@ -15,9 +15,9 @@ export type SwitchChainParameters<
   config extends Config = Config,
   chainId extends config['chains'][number]['id'] = config['chains'][number]['id'],
 > = Evaluate<
-  {
+  ConnectorParameter & {
     chainId: chainId | config['chains'][number]['id']
-  } & ConnectorParameter
+  }
 >
 
 export type SwitchChainReturnType<

package/src/actions/waitForTransactionReceipt.ts

@@ -44,12 +44,13 @@ export async function waitForTransactionReceipt<
   parameters: WaitForTransactionReceiptParameters<config, chainId>,
 ): Promise<WaitForTransactionReceiptReturnType<config, chainId>> {
   const { chainId, timeout = 0, ...rest } = parameters
-  const client = config.getClient({ chainId })
 
+  const client = config.getClient({ chainId })
   const receipt = await viem_waitForTransactionReceipt(client, {
     ...rest,
     timeout,
   })
+
   if (receipt.status === 'reverted') {
     const txn = await getTransaction(client, { hash: receipt.transactionHash })
     const code = (await call(client, {
@@ -62,6 +63,7 @@ export async function waitForTransactionReceipt<
     const reason = hexToString(`0x${code.substring(138)}`)
     throw new Error(reason)
   }
+
   return receipt as unknown as WaitForTransactionReceiptReturnType<
     config,
     chainId

package/src/actions/watchAccount.ts

@@ -17,6 +17,7 @@ export function watchAccount(
   parameters: WatchAccountParameters,
 ): WatchAccountReturnType {
   const { onChange } = parameters
+
   return config.subscribe(() => getAccount(config), onChange, {
     equalityFn(a, b) {
       const { connector: aConnector, ...aRest } = a

package/src/actions/watchBlockNumber.ts

@@ -44,7 +44,7 @@ export function watchBlockNumber<
   parameters: WatchBlockNumberParameters<config, chainId>,
 ): WatchBlockNumberReturnType {
   const { syncConnectedChain = config._internal.syncConnectedChain, ...rest } =
-    parameters
+    parameters as WatchBlockNumberParameters
 
   let unwatch: WatchBlockNumberReturnType | undefined
   const listener = (chainId: number | undefined) => {
@@ -53,7 +53,7 @@ export function watchBlockNumber<
     const client = config.getClient({ chainId })
     unwatch = viem_watchBlockNumber(
       client,
-      rest as unknown as viem_WatchBlockNumberParameters,
+      rest as viem_WatchBlockNumberParameters,
     )
     return unwatch
   }

package/src/actions/watchBlocks.ts

@@ -56,17 +56,14 @@ export function watchBlocks<
   >,
 ): WatchBlocksReturnType {
   const { syncConnectedChain = config._internal.syncConnectedChain, ...rest } =
-    parameters
+    parameters as WatchBlocksParameters
 
   let unwatch: WatchBlocksReturnType | undefined
   const listener = (chainId: number | undefined) => {
     if (unwatch) unwatch()
 
     const client = config.getClient({ chainId })
-    unwatch = viem_watchBlocks(
-      client,
-      rest as unknown as viem_WatchBlocksParameters,
-    )
+    unwatch = viem_watchBlocks(client, rest as viem_WatchBlocksParameters)
     return unwatch
   }
 

package/src/actions/watchConnectors.ts

@@ -0,0 +1,22 @@
+import type { Config } from '../createConfig.js'
+import { type GetConnectorsReturnType } from './getConnectors.js'
+
+export type WatchConnectorsParameters = {
+  onChange(
+    connections: GetConnectorsReturnType,
+    prevConnectors: GetConnectorsReturnType,
+  ): void
+}
+
+export type WatchConnectorsReturnType = () => void
+
+/** https://alpha.wagmi.sh/core/api/actions/watchConnectors */
+export function watchConnectors(
+  config: Config,
+  parameters: WatchConnectorsParameters,
+): WatchConnectorsReturnType {
+  const { onChange } = parameters
+  return config._internal.connectors.subscribe((connectors, prevConnectors) => {
+    onChange(Object.values(connectors), prevConnectors)
+  })
+}

package/src/createConfig.ts

@@ -55,47 +55,6 @@ export type CreateConfigParameters<
     >
 >
 
-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>,
@@ -120,7 +79,7 @@ export function createConfig<
   // Set up connectors, clients, etc.
   /////////////////////////////////////////////////////////////////////////////////////////////////
 
-  const connectors = (rest.connectors ?? []).map(setup)
+  const connectors = createStore(() => (rest.connectors ?? []).map(setup))
   function setup(connectorFn: CreateConnectorFn) {
     // Set up emitter with uid and add to connector so they are "linked" together.
     const emitter = createEmitter<ConnectorEventMap>(uid())
@@ -205,12 +164,7 @@ export function createConfig<
         ? persist(() => initialState, {
             name: 'store',
             partialize(state) {
-              return {
-                chainId: state.chainId,
-                connections: state.connections,
-                current: state.current,
-                status: state.status,
-              } satisfies PartializedState
+              return state satisfies PartializedState
             },
             skipHydration: !reconnectOnMount,
             storage: storage as Storage<Record<string, unknown>>,
@@ -265,7 +219,7 @@ export function createConfig<
     if (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 +263,14 @@ 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)
@@ -336,6 +291,8 @@ export function createConfig<
       )
     },
 
+    getClient,
+
     _internal: {
       reconnectOnMount,
       syncConnectedChain,
@@ -343,7 +300,19 @@ export function createConfig<
       change,
       connect,
       disconnect,
-      setup,
+      connectors: {
+        setup,
+        setState(value) {
+          let newState: Connector[]
+          if (typeof value === 'function')
+            newState = value(connectors.getState())
+          else newState = value
+          connectors.setState(newState, true)
+        },
+        subscribe(listener) {
+          return connectors.subscribe(listener)
+        },
+      },
     },
   }
 }
@@ -352,6 +321,58 @@ 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?:
+      | {
+          equalityFn?: ((a: state, b: state) => boolean) | undefined
+          fireImmediately?: 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 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
+
+    connectors: {
+      setup(connectorFn: CreateConnectorFn): Connector
+      setState(value: Connector[] | ((state: Connector[]) => Connector[])): void
+      subscribe(
+        listener: (
+          state: readonly Connector[],
+          prevState: readonly Connector[],
+        ) => void,
+      ): () => void
+    }
+  }
+}
+
 export type State<
   chains extends readonly [Chain, ...Chain[]] = readonly [Chain, ...Chain[]],
 > = {

package/src/createConnector.ts

@@ -45,18 +45,10 @@ export type CreateConnectorFn<
     getAccounts(): Promise<readonly Address[]>
     getChainId(): Promise<number>
     getProvider(
-      parameters?:
-        | {
-            chainId?: number | undefined
-          }
-        | undefined,
+      parameters?: { chainId?: number | undefined } | undefined,
     ): Promise<provider>
     getClient?(
-      parameters?:
-        | {
-            chainId?: number | undefined
-          }
-        | undefined,
+      parameters?: { chainId?: number | undefined } | undefined,
     ): Promise<Client>
     isAuthorized(): Promise<boolean>
     switchChain?(parameters: { chainId: number }): Promise<Chain>

package/src/createStorage.ts

@@ -43,7 +43,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,12 +54,11 @@ 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
   }
 

package/src/errors/base.ts

@@ -2,11 +2,11 @@ import type { Evaluate, OneOf } from '../types/utils.js'
 import { getVersion } from '../utils/getVersion.js'
 
 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 class BaseError extends Error {

package/src/exports/actions.ts

@@ -64,6 +64,11 @@ export {
   getConnections,
 } from '../actions/getConnections.js'
 
+export {
+  type GetConnectorsReturnType,
+  getConnectors,
+} from '../actions/getConnectors.js'
+
 export {
   type GetConnectorClientError,
   type GetConnectorClientParameters,
@@ -225,6 +230,12 @@ export {
   watchConnections,
 } from '../actions/watchConnections.js'
 
+export {
+  type WatchConnectorsParameters,
+  type WatchConnectorsReturnType,
+  watchConnectors,
+} from '../actions/watchConnectors.js'
+
 export {
   type WatchContractEventParameters,
   type WatchContractEventReturnType,

package/src/exports/index.ts

@@ -82,6 +82,11 @@ export {
   getConnections,
 } from '../actions/getConnections.js'
 
+export {
+  type GetConnectorsReturnType,
+  getConnectors,
+} from '../actions/getConnectors.js'
+
 export {
   type GetConnectorClientError,
   type GetConnectorClientParameters,
@@ -249,6 +254,12 @@ export {
   watchConnections,
 } from '../actions/watchConnections.js'
 
+export {
+  type WatchConnectorsParameters,
+  type WatchConnectorsReturnType,
+  watchConnectors,
+} from '../actions/watchConnectors.js'
+
 export {
   type WatchContractEventParameters,
   type WatchContractEventReturnType,

package/src/query/estimateGas.ts

@@ -26,7 +26,7 @@ export function estimateGasQueryOptions<
       const { account, scopeKey: _, ...parameters } = queryKey[1]
       if (!account && !connector)
         throw new Error('account or connector is required')
-      return estimateGas(config, { account, connector, ...parameters } as any)
+      return estimateGas(config, { account, connector, ...(parameters as any) })
     },
     queryKey: estimateGasQueryKey(options),
   } as const satisfies QueryOptions<