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

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/exports/query.ts

@@ -134,6 +134,15 @@ export {
   getWalletClientQueryOptions,
 } from '../query/getWalletClient.js'
 
+export {
+  type InfiniteReadContractsData,
+  type InfiniteReadContractsOptions,
+  type InfiniteReadContractsQueryFnData,
+  type InfiniteReadContractsQueryKey,
+  infiniteReadContractsQueryKey,
+  infiniteReadContractsQueryOptions,
+} from '../query/infiniteReadContracts.js'
+
 export {
   type ReadContractData,
   type ReadContractOptions,

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<

package/src/query/getBalance.ts

@@ -21,20 +21,12 @@ export function getBalanceQueryOptions<config extends Config>(
 ) {
   return {
     async queryFn({ queryKey }) {
-      const {
-        address,
-        blockNumber,
-        blockTag,
-        scopeKey: _,
-        ...parameters
-      } = queryKey[1]
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
       if (!address) throw new Error('address is required')
-      const balance = await getBalance(
-        config,
-        blockNumber
-          ? { ...parameters, address, blockNumber }
-          : { ...parameters, address, blockTag },
-      )
+      const balance = await getBalance(config, {
+        ...(parameters as GetBalanceParameters),
+        address,
+      })
       return balance ?? null
     },
     queryKey: getBalanceQueryKey(options),

package/src/query/getTransaction.ts

@@ -24,23 +24,17 @@ export function getTransactionQueryOptions<
 >(config: config, options: GetTransactionOptions<config, chainId> = {}) {
   return {
     async queryFn({ queryKey }) {
-      const {
-        blockHash,
-        blockNumber,
-        blockTag,
-        hash,
-        index,
-        scopeKey: _,
-      } = queryKey[1]
+      const { blockHash, blockNumber, blockTag, hash, index } = queryKey[1]
       if (!blockHash && !blockNumber && !blockTag && !hash)
         throw new Error('blockHash, blockNumber, blockTag, or hash is required')
       if (!hash && !index)
         throw new Error(
           'index is required for blockHash, blockNumber, or blockTag',
         )
+      const { scopeKey: _, ...rest } = queryKey[1]
       return getTransaction(
         config,
-        queryKey[1] as GetTransactionParameters,
+        rest as GetTransactionParameters,
       ) as unknown as Promise<GetTransactionQueryFnData<config, chainId>>
     },
     queryKey: getTransactionQueryKey(options),

package/src/query/infiniteReadContracts.ts

@@ -0,0 +1,126 @@
+import type { ContractFunctionParameters } from 'viem'
+import {
+  type ReadContractsError,
+  type ReadContractsParameters,
+  type ReadContractsReturnType,
+  readContracts,
+} from '../actions/readContracts.js'
+import type { Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { Omit } from '../types/utils.js'
+import type { InfiniteQueryOptions, ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type InfiniteReadContractsOptions<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+  config extends Config,
+> = {
+  cacheKey: string
+  contracts(
+    pageParam: pageParam,
+  ): ReadContractsParameters<contracts, allowFailure, config>['contracts']
+} & Omit<
+  ReadContractsParameters<contracts, allowFailure, config>,
+  'contracts'
+> &
+  ScopeKeyParameter
+
+export function infiniteReadContractsQueryOptions<
+  config extends Config,
+  const contracts extends readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+  pageParam = unknown,
+>(
+  config: config,
+  options: InfiniteReadContractsOptions<
+    contracts,
+    allowFailure,
+    pageParam,
+    config
+  > &
+    ChainIdParameter<config> &
+    RequiredPageParamsParameters<contracts, allowFailure, pageParam>,
+) {
+  return {
+    ...options.query,
+    async queryFn({ pageParam, queryKey }) {
+      const { contracts } = options
+      const { cacheKey: _, scopeKey: _s, ...parameters } = queryKey[1]
+      return (await readContracts(config, {
+        ...parameters,
+        contracts: contracts(
+          pageParam,
+        ) as readonly ContractFunctionParameters[],
+      })) as ReadContractsReturnType<contracts, allowFailure>
+    },
+    queryKey: infiniteReadContractsQueryKey(options),
+  } as const satisfies InfiniteQueryOptions<
+    InfiniteReadContractsQueryFnData<contracts, allowFailure>,
+    ReadContractsError,
+    InfiniteReadContractsData<contracts, allowFailure>,
+    InfiniteReadContractsData<contracts, allowFailure>,
+    InfiniteReadContractsQueryKey<contracts, allowFailure, pageParam, config>,
+    pageParam
+  >
+}
+
+type RequiredPageParamsParameters<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+> = {
+  query: {
+    initialPageParam: pageParam
+    getNextPageParam(
+      lastPage: InfiniteReadContractsQueryFnData<contracts, allowFailure>,
+      allPages: InfiniteReadContractsQueryFnData<contracts, allowFailure>[],
+      lastPageParam: pageParam,
+      allPageParams: pageParam[],
+    ): pageParam | undefined | null
+  }
+}
+
+export type InfiniteReadContractsQueryFnData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReadContractsReturnType<contracts, allowFailure>
+
+export type InfiniteReadContractsData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = InfiniteReadContractsQueryFnData<contracts, allowFailure>
+
+export function infiniteReadContractsQueryKey<
+  config extends Config,
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+>(
+  options: InfiniteReadContractsOptions<
+    contracts,
+    allowFailure,
+    pageParam,
+    config
+  > &
+    ChainIdParameter<config> &
+    RequiredPageParamsParameters<contracts, allowFailure, pageParam>,
+) {
+  const { contracts: _, query: _q, ...parameters } = options
+  return ['infiniteReadContracts', filterQueryOptions(parameters)] as const
+}
+
+export type InfiniteReadContractsQueryKey<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+  pageParam,
+  config extends Config,
+> = ReturnType<
+  typeof infiniteReadContractsQueryKey<
+    config,
+    contracts,
+    allowFailure,
+    pageParam
+  >
+>

package/src/query/readContract.ts

@@ -30,7 +30,7 @@ export function readContractQueryOptions<
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
 >(
-  config: Config,
+  config: config,
   options: ReadContractOptions<abi, functionName, args, config> = {} as any,
 ) {
   return {
@@ -41,20 +41,20 @@ export function readContractQueryOptions<
       if (!address) throw new Error('address is required')
       if (!functionName) throw new Error('functionName is required')
       const args = parameters.args as readonly unknown[]
-      return (await readContract(config, {
+      return readContract(config, {
         abi,
         address,
         functionName,
         args,
         ...parameters,
-      })) as ReadContractData<abi, functionName, args>
+      }) as Promise<ReadContractData<abi, functionName, args>>
     },
     queryKey: readContractQueryKey(options),
   } as const satisfies QueryOptions<
     ReadContractQueryFnData<abi, functionName, args>,
     ReadContractError,
     ReadContractData<abi, functionName, args>,
-    ReadContractQueryKey<config, abi, functionName, args>
+    ReadContractQueryKey<abi, functionName, args, config>
   >
 }
 
@@ -71,18 +71,18 @@ export type ReadContractData<
 > = ReadContractQueryFnData<abi, functionName, args>
 
 export function readContractQueryKey<
+  config extends Config,
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
-  config extends Config,
 >(options: ReadContractOptions<abi, functionName, args, config> = {} as any) {
   const { abi: _, ...rest } = options
   return ['readContract', filterQueryOptions(rest)] as const
 }
 
 export type ReadContractQueryKey<
-  config extends Config,
   abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
   args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
-> = ReturnType<typeof readContractQueryKey<abi, functionName, args, config>>
+  config extends Config,
+> = ReturnType<typeof readContractQueryKey<config, abi, functionName, args>>

package/src/query/readContracts.ts

@@ -16,9 +16,9 @@ import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type ReadContractsOptions<
-  config extends Config,
   contracts extends readonly unknown[],
   allowFailure extends boolean,
+  config extends Config,
 > = ExactPartial<
   viem_MulticallParameters<
     contracts,
@@ -33,8 +33,8 @@ export function readContractsQueryOptions<
   const contracts extends readonly unknown[],
   allowFailure extends boolean = true,
 >(
-  config: Config,
-  options: ReadContractsOptions<config, contracts, allowFailure> &
+  config: config,
+  options: ReadContractsOptions<contracts, allowFailure, config> &
     ChainIdParameter<config> = {},
 ) {
   return {
@@ -47,17 +47,17 @@ export function readContractsQueryOptions<
         contracts.push({ ...contract, abi })
       }
       const { scopeKey: _, ...parameters } = queryKey[1]
-      return (await readContracts(config, {
+      return readContracts(config, {
         ...parameters,
         contracts,
-      })) as ReadContractsData<contracts, allowFailure>
+      }) as Promise<ReadContractsReturnType<contracts, allowFailure>>
     },
-    queryKey: readContractsQueryKey(options as any),
+    queryKey: readContractsQueryKey(options),
   } as const satisfies QueryOptions<
     ReadContractsQueryFnData<contracts, allowFailure>,
     ReadContractsError,
     ReadContractsData<contracts, allowFailure>,
-    ReadContractsQueryKey<config, contracts, allowFailure>
+    ReadContractsQueryKey<contracts, allowFailure, config>
   >
 }
 
@@ -76,7 +76,7 @@ export function readContractsQueryKey<
   const contracts extends readonly unknown[],
   allowFailure extends boolean,
 >(
-  options: ReadContractsOptions<config, contracts, allowFailure> &
+  options: ReadContractsOptions<contracts, allowFailure, config> &
     ChainIdParameter<config> = {},
 ) {
   const contracts = []
@@ -92,7 +92,7 @@ export function readContractsQueryKey<
 }
 
 export type ReadContractsQueryKey<
-  config extends Config,
   contracts extends readonly unknown[],
   allowFailure extends boolean,
+  config extends Config,
 > = ReturnType<typeof readContractsQueryKey<config, contracts, allowFailure>>

package/src/query/simulateContract.ts

@@ -28,6 +28,7 @@ export type SimulateContractOptions<
   ScopeKeyParameter
 
 export function simulateContractQueryOptions<
+  config extends Config,
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
   args extends ContractFunctionArgs<
@@ -35,7 +36,6 @@ export function simulateContractQueryOptions<
     'nonpayable' | 'payable',
     functionName
   >,
-  config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
 >(
   config: config,
@@ -55,7 +55,11 @@ export function simulateContractQueryOptions<
       const { address, functionName } = parameters
       if (!address) throw new Error('address is required')
       if (!functionName) throw new Error('functionName is required')
-      return simulateContract(config, { abi, connector, ...parameters } as any)
+      return simulateContract(config, {
+        abi,
+        connector,
+        ...(parameters as any),
+      })
     },
     queryKey: simulateContractQueryKey(options),
   } as const satisfies QueryOptions<
@@ -91,6 +95,7 @@ export type SimulateContractData<
 > = SimulateContractQueryFnData<abi, functionName, args, config, chainId>
 
 export function simulateContractQueryKey<
+  config extends Config,
   abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
   args extends ContractFunctionArgs<
@@ -98,7 +103,6 @@ export function simulateContractQueryKey<
     'nonpayable' | 'payable',
     functionName
   >,
-  config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
 >(
   options: SimulateContractOptions<
@@ -124,5 +128,5 @@ export type SimulateContractQueryKey<
   config extends Config,
   chainId extends config['chains'][number]['id'] | undefined,
 > = ReturnType<
-  typeof simulateContractQueryKey<abi, functionName, args, config, chainId>
+  typeof simulateContractQueryKey<config, abi, functionName, args, chainId>
 >