@wagmi/core 2.0.0-beta.1 → 2.0.0-beta.10

package/src/query/getGasPrice.ts

@@ -0,0 +1,54 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetGasPriceErrorType,
+  type GetGasPriceParameters,
+  type GetGasPriceReturnType,
+  getGasPrice,
+} from '../actions/getGasPrice.js'
+import { type Config } from '../createConfig.js'
+import { type ScopeKeyParameter } from '../types/properties.js'
+import { type Evaluate, type ExactPartial } from '../types/utils.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetGasPriceOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<GetGasPriceParameters<config, chainId>> & ScopeKeyParameter
+>
+
+export function getGasPriceQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(config: config, options: GetGasPriceOptions<config, chainId> = {}) {
+  return {
+    async queryFn({ queryKey }) {
+      const { scopeKey: _, ...parameters } = queryKey[1]
+      const gasPrice = await getGasPrice(config, parameters)
+      return gasPrice ?? null
+    },
+    queryKey: getGasPriceQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetGasPriceQueryFnData,
+    GetGasPriceErrorType,
+    GetGasPriceData,
+    GetGasPriceQueryKey<config, chainId>
+  >
+}
+
+export type GetGasPriceQueryFnData = GetGasPriceReturnType
+
+export type GetGasPriceData = GetGasPriceQueryFnData
+
+export function getGasPriceQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: GetGasPriceOptions<config, chainId> = {}) {
+  return ['gasPrice', filterQueryOptions(options)] as const
+}
+
+export type GetGasPriceQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof getGasPriceQueryKey<config, chainId>>

package/src/query/getToken.ts

@@ -7,8 +7,8 @@ import {
   getToken,
 } from '../actions/getToken.js'
 import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { Evaluate, ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type GetTokenOptions<config extends Config> = Evaluate<

package/src/query/getTransaction.ts

@@ -7,8 +7,8 @@ import {
   getTransaction,
 } from '../actions/getTransaction.js'
 import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { Evaluate, ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type GetTransactionOptions<

package/src/query/getTransactionCount.ts

@@ -0,0 +1,55 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetTransactionCountErrorType,
+  type GetTransactionCountParameters,
+  type GetTransactionCountReturnType,
+  getTransactionCount,
+} from '../actions/getTransactionCount.js'
+import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
+import type { Evaluate, PartialBy } from '../types/utils.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetTransactionCountOptions<config extends Config> = Evaluate<
+  PartialBy<GetTransactionCountParameters<config>, 'address'> &
+    ScopeKeyParameter
+>
+
+export function getTransactionCountQueryOptions<config extends Config>(
+  config: config,
+  options: GetTransactionCountOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      const transactionCount = await getTransactionCount(config, {
+        ...(parameters as GetTransactionCountParameters),
+        address,
+      })
+      return transactionCount ?? null
+    },
+    queryKey: getTransactionCountQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetTransactionCountQueryFnData,
+    GetTransactionCountErrorType,
+    GetTransactionCountData,
+    GetTransactionCountQueryKey<config>
+  >
+}
+
+export type GetTransactionCountQueryFnData =
+  Evaluate<GetTransactionCountReturnType>
+
+export type GetTransactionCountData = GetTransactionCountQueryFnData
+
+export function getTransactionCountQueryKey<config extends Config>(
+  options: GetTransactionCountOptions<config> = {},
+) {
+  return ['transactionCount', filterQueryOptions(options)] as const
+}
+
+export type GetTransactionCountQueryKey<config extends Config> = ReturnType<
+  typeof getTransactionCountQueryKey<config>
+>

package/src/query/getWalletClient.ts

@@ -7,8 +7,8 @@ import {
   getWalletClient,
 } from '../actions/getWalletClient.js'
 import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { Evaluate, ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type GetWalletClientOptions<

package/src/query/infiniteReadContracts.ts

@@ -6,9 +6,12 @@ import {
   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 {
+  type ChainIdParameter,
+  type ScopeKeyParameter,
+} from '../types/properties.js'
+import { type Omit } from '../types/utils.js'
+import { type InfiniteQueryOptions } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type InfiniteReadContractsOptions<

package/src/query/readContract.ts

@@ -12,8 +12,8 @@ import {
   readContract,
 } from '../actions/readContract.js'
 import { type Config } from '../createConfig.js'
-import type { UnionPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
+import { type ScopeKeyParameter } from '../types/properties.js'
+import { type UnionPartial } from '../types/utils.js'
 import { filterQueryOptions } from './utils.js'
 
 export type ReadContractOptions<
@@ -34,6 +34,8 @@ export function readContractQueryOptions<
   options: ReadContractOptions<abi, functionName, args, config> = {} as any,
 ) {
   return {
+    // TODO: Support `signal` once Viem actions allow passthrough
+    // https://tkdodo.eu/blog/why-you-want-react-query#bonus-cancellation
     async queryFn({ queryKey }) {
       const abi = options.abi as Abi
       if (!abi) throw new Error('abi is required')

package/src/query/readContracts.ts

@@ -11,8 +11,8 @@ import {
 } from '../actions/readContracts.js'
 import { type Config } from '../createConfig.js'
 import { type ChainIdParameter } from '../types/properties.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { ExactPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type ReadContractsOptions<

package/src/query/simulateContract.ts

@@ -8,8 +8,8 @@ import {
   simulateContract,
 } from '../actions/simulateContract.js'
 import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
 import type { UnionPartial } from '../types/utils.js'
-import type { ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type SimulateContractOptions<

package/src/query/types.ts

@@ -79,5 +79,3 @@ type MutateFn<
         | Evaluate<MutateOptions<data, error, variables, context>>
         | undefined,
     ) => Promise<data>
-
-export type ScopeKeyParameter = { scopeKey?: string | undefined }

package/src/query/verifyMessage.ts

@@ -0,0 +1,54 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type VerifyMessageErrorType,
+  type VerifyMessageParameters,
+  type VerifyMessageReturnType,
+  verifyMessage,
+} from '../actions/verifyMessage.js'
+import { type Config } from '../createConfig.js'
+import type { ScopeKeyParameter } from '../types/properties.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import { filterQueryOptions } from './utils.js'
+
+export type VerifyMessageOptions<config extends Config> = Evaluate<
+  ExactPartial<VerifyMessageParameters<config>> & ScopeKeyParameter
+>
+
+export function verifyMessageQueryOptions<config extends Config>(
+  config: config,
+  options: VerifyMessageOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, message, signature } = queryKey[1]
+      if (!address || !message || !signature)
+        throw new Error('address, message, and signature are required')
+
+      const { scopeKey: _, ...parameters } = queryKey[1]
+
+      const verified = await verifyMessage(
+        config,
+        parameters as VerifyMessageParameters,
+      )
+      return verified ?? null
+    },
+    queryKey: verifyMessageQueryKey(options),
+  } as const satisfies QueryOptions<
+    VerifyMessageQueryFnData,
+    VerifyMessageErrorType,
+    VerifyMessageData,
+    VerifyMessageQueryKey
+  >
+}
+export type VerifyMessageQueryFnData = VerifyMessageReturnType
+
+export type VerifyMessageData = VerifyMessageQueryFnData
+
+export function verifyMessageQueryKey<config extends Config>(
+  options: VerifyMessageOptions<config>,
+) {
+  return ['verifyMessage', filterQueryOptions(options)] as const
+}
+
+export type VerifyMessageQueryKey = ReturnType<typeof verifyMessageQueryKey>

package/src/query/verifyTypedData.ts

@@ -0,0 +1,81 @@
+import { type QueryOptions } from '@tanstack/query-core'
+import { type TypedData } from 'viem'
+
+import {
+  type VerifyTypedDataErrorType,
+  type VerifyTypedDataParameters,
+  type VerifyTypedDataReturnType,
+  verifyTypedData,
+} from '../actions/verifyTypedData.js'
+import { type Config } from '../createConfig.js'
+import { type ScopeKeyParameter } from '../types/properties.js'
+import { type ExactPartial } from '../types/utils.js'
+import { filterQueryOptions } from './utils.js'
+
+export type VerifyTypedDataOptions<
+  typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+  config extends Config,
+> = ExactPartial<VerifyTypedDataParameters<typedData, primaryType, config>> &
+  ScopeKeyParameter
+
+export function verifyTypedDataQueryOptions<
+  config extends Config,
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  config: config,
+  options: VerifyTypedDataOptions<typedData, primaryType, config> = {} as any,
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const {
+        address,
+        message,
+        primaryType,
+        signature,
+        types,
+        scopeKey: _,
+        ...parameters
+      } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      if (!message) throw new Error('message is required')
+      if (!primaryType) throw new Error('primaryType is required')
+      if (!signature) throw new Error('signature is required')
+      if (!types) throw new Error('types is required')
+
+      const verified = await verifyTypedData(config, {
+        address,
+        message,
+        primaryType,
+        signature,
+        types,
+        ...parameters,
+      })
+      return verified ?? null
+    },
+    queryKey: verifyTypedDataQueryKey(options),
+  } as const satisfies QueryOptions<
+    VerifyTypedDataQueryFnData,
+    VerifyTypedDataErrorType,
+    VerifyTypedDataData,
+    VerifyTypedDataQueryKey<typedData, primaryType, config>
+  >
+}
+export type VerifyTypedDataQueryFnData = VerifyTypedDataReturnType
+
+export type VerifyTypedDataData = VerifyTypedDataQueryFnData
+
+export function verifyTypedDataQueryKey<
+  config extends Config,
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(options: VerifyTypedDataOptions<typedData, primaryType, config>) {
+  return ['verifyTypedData', filterQueryOptions(options)] as const
+}
+
+export type VerifyTypedDataQueryKey<
+  typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+  config extends Config,
+> = ReturnType<typeof verifyTypedDataQueryKey<config, typedData, primaryType>>

package/src/query/waitForTransactionReceipt.ts

@@ -7,8 +7,8 @@ import {
   waitForTransactionReceipt,
 } from '../actions/waitForTransactionReceipt.js'
 import { type Config } from '../createConfig.js'
+import { type ScopeKeyParameter } from '../types/properties.js'
 import { type Evaluate, type ExactPartial } from '../types/utils.js'
-import { type ScopeKeyParameter } from './types.js'
 import { filterQueryOptions } from './utils.js'
 
 export type WaitForTransactionReceiptOptions<

package/src/transports/connector.ts

@@ -0,0 +1,87 @@
+import {
+  ChainDisconnectedError,
+  type EIP1193Parameters,
+  type EIP1193Provider,
+  type EIP1193RequestFn,
+  ProviderDisconnectedError,
+  type TransportConfig,
+  type WalletRpcSchema,
+  createTransport,
+  hexToNumber,
+  withRetry,
+  withTimeout,
+} from 'viem'
+
+import type { Connector, Transport } from '../createConfig.js'
+
+export type ConnectorTransportConfig = {
+  /** The key of the transport. */
+  key?: TransportConfig['key'] | undefined
+  /** The name of the transport. */
+  name?: TransportConfig['name'] | undefined
+  /** The max number of times to retry. */
+  retryCount?: TransportConfig['retryCount'] | undefined
+  /** The base delay (in ms) between retries. */
+  retryDelay?: TransportConfig['retryDelay'] | undefined
+}
+
+export type ConnectorTransport = Transport
+
+export function unstable_connector(
+  connector: Pick<Connector, 'type'>,
+  config: ConnectorTransportConfig = {},
+): Transport {
+  const { type } = connector
+  const { key = 'connector', name = 'Connector', retryDelay } = config
+
+  return (parameters) => {
+    const { chain, connectors } = parameters
+    const retryCount = config.retryCount ?? parameters.retryCount
+
+    const request: EIP1193RequestFn = async ({ method, params }) => {
+      const connector = connectors?.getState().find((c) => c.type === type)
+      if (!connector)
+        throw new ProviderDisconnectedError(
+          new Error(
+            `Could not find connector of type "${type}" in \`connectors\` passed to \`createConfig\`.`,
+          ),
+        )
+
+      const provider = (await connector.getProvider({
+        chainId: chain?.id,
+      })) as EIP1193Provider | undefined
+      if (!provider)
+        throw new ProviderDisconnectedError(
+          new Error('Provider is disconnected.'),
+        )
+
+      // We are applying a retry & timeout strategy here as some injected wallets (ie. MetaMask) fail to
+      // immediately resolve a JSON-RPC request on page load.
+      const chainId = hexToNumber(
+        await withRetry(() =>
+          withTimeout(() => provider.request({ method: 'eth_chainId' }), {
+            timeout: 100,
+          }),
+        ),
+      )
+      if (chain && chainId !== chain.id)
+        throw new ChainDisconnectedError(
+          new Error(
+            `The current chain of the connector (id: ${chainId}) does not match the target chain for the request (id: ${chain.id} – ${chain.name}).`,
+          ),
+        )
+
+      const body = { method, params } as EIP1193Parameters<WalletRpcSchema>
+      return provider.request(body)
+    }
+
+    return createTransport({
+      key,
+      name,
+      request,
+      retryCount,
+      retryDelay,
+      type: 'connector',
+    })
+  }
+}

package/src/transports/fallback.ts

@@ -0,0 +1,10 @@
+import { fallback as viem_fallback } from 'viem'
+
+import { type Transport } from '../createConfig.js'
+
+export function fallback(
+  transports: Transport[],
+  config?: Parameters<typeof viem_fallback>[1],
+) {
+  return viem_fallback(transports, config)
+}

package/src/types/properties.ts

@@ -16,6 +16,8 @@ export type ConnectorParameter = {
   connector?: Connector | undefined
 }
 
+export type ScopeKeyParameter = { scopeKey?: string | undefined }
+
 export type SyncConnectedChainParameter = {
   syncConnectedChain?: boolean | undefined
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '2.0.0-beta.1'
+export const version = '2.0.0-beta.10'