viem 2.56.9 → 2.57.0

package/clients/createClientResolver.ts

@@ -0,0 +1,191 @@
+import type { Address } from 'abitype'
+
+import type { JsonRpcAccount } from '../accounts/types.js'
+import { BaseError } from '../errors/base.js'
+import type { Tokens } from '../tokens/defineToken.js'
+import type { Account } from '../types/account.js'
+import type { Chain } from '../types/chain.js'
+import type { RpcSchema } from '../types/eip1193.js'
+import type { Prettify } from '../types/utils.js'
+import {
+  type Client,
+  type ClientConfig,
+  type CreateClientErrorType,
+  createClient,
+} from './createClient.js'
+import type { Transport } from './transports/createTransport.js'
+
+/**
+ * Creates a resolver that lazily constructs and caches a Client for each configured chain.
+ *
+ * @example
+ * ```ts
+ * import { createClientResolver, http } from 'viem'
+ * import { mainnet, optimism } from 'viem/chains'
+ *
+ * const resolver = createClientResolver({
+ *   chains: [mainnet, optimism],
+ *   transport: {
+ *     [mainnet.id]: http(),
+ *     [optimism.id]: http(),
+ *   },
+ * })
+ *
+ * const client = resolver.getClient({ chainId: optimism.id })
+ * ```
+ *
+ * @param options - Resolver options, including shared Client configuration.
+ * @returns A resolver for the configured chains.
+ */
+export function createClientResolver<
+  const chains extends Chains,
+  accountOrAddress extends Account | Address | undefined = undefined,
+  const transport extends TransportConfig<NoInfer<chains>> = TransportConfig<
+    NoInfer<chains>
+  >,
+  const tokens extends Tokens | undefined = undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+>(
+  options: createClientResolver.Options<
+    chains,
+    accountOrAddress,
+    transport,
+    tokens,
+    rpcSchema
+  >,
+): createClientResolver.ReturnType<
+  chains,
+  accountOrAddress,
+  transport,
+  tokens,
+  rpcSchema
+> {
+  const { chains, transport, ...rest } = options
+  const clients = new Map<number, unknown>()
+
+  // The chain and transport are selected from the same chain ID.
+  return {
+    getClient({ chainId }) {
+      const cached = clients.get(chainId)
+      if (cached) return cached
+
+      const chain = chains.find((chain) => chain.id === chainId)
+      if (!chain) throw new ChainNotConfiguredError({ chainId })
+      const transport_ =
+        typeof transport === 'function'
+          ? transport({ chainId })
+          : (transport as TransportMap<chains>)[chainId]
+      if (!transport_) throw new TransportNotConfiguredError({ chainId })
+      const client = createClient({ ...rest, chain, transport: transport_ })
+      clients.set(chainId, client)
+      return client
+    },
+  } as createClientResolver.ReturnType<
+    chains,
+    accountOrAddress,
+    transport,
+    tokens,
+    rpcSchema
+  >
+}
+
+export declare namespace createClientResolver {
+  /** Errors thrown while resolving a Client. */
+  type ErrorType =
+    | ChainNotConfiguredError
+    | CreateClientErrorType
+    | TransportNotConfiguredError
+
+  /** Options for {@link createClientResolver}. */
+  type Options<
+    chains extends Chains = Chains,
+    accountOrAddress extends Account | Address | undefined =
+      | Account
+      | Address
+      | undefined,
+    transport extends TransportConfig<chains> = TransportConfig<chains>,
+    tokens extends Tokens | undefined = Tokens | undefined,
+    rpcSchema extends RpcSchema | undefined = undefined,
+  > = Prettify<
+    Omit<
+      ClientConfig<Transport, undefined, accountOrAddress, rpcSchema, tokens>,
+      'chain' | 'transport'
+    > & {
+      /** Chains available to the resolver. Must contain at least one chain. */
+      chains: chains
+      /** Transports indexed or resolved by chain ID. */
+      transport: transport
+    }
+  >
+
+  /** Return type of {@link createClientResolver}. */
+  type ReturnType<
+    chains extends Chains = Chains,
+    accountOrAddress extends Account | Address | undefined =
+      | Account
+      | Address
+      | undefined,
+    transport extends TransportConfig<chains> = TransportConfig<chains>,
+    tokens extends Tokens | undefined = Tokens | undefined,
+    rpcSchema extends RpcSchema | undefined = undefined,
+  > = {
+    /** Returns the cached Client configured for `chainId`, creating it on first use. */
+    getClient<const chainId extends chains[number]['id']>(options: {
+      /** ID of a configured chain. */
+      chainId: chainId
+    }): Client<
+      ResolvedTransport<chains, transport, chainId>,
+      number extends chains[number]['id']
+        ? chains[number]
+        : Extract<chains[number], { id: chainId }>,
+      accountOrAddress extends Address
+        ? Prettify<JsonRpcAccount<accountOrAddress>>
+        : accountOrAddress,
+      rpcSchema,
+      undefined,
+      tokens
+    >
+  }
+}
+
+type Chains = readonly [Chain, ...Chain[]]
+
+type TransportConfig<chains extends Chains> =
+  | TransportMap<chains>
+  | ((options: { chainId: chains[number]['id'] }) => Transport)
+
+type TransportMap<chains extends Chains> = {
+  readonly [chainId in chains[number]['id']]: Transport
+}
+
+type ResolvedTransport<
+  chains extends Chains,
+  transport extends TransportConfig<chains>,
+  chainId extends chains[number]['id'],
+> = transport extends (...args: never[]) => infer resolved
+  ? resolved extends Transport
+    ? resolved
+    : never
+  : transport extends Record<chainId, infer resolved>
+    ? resolved extends Transport
+      ? resolved
+      : never
+    : never
+
+/** Thrown when a Client is requested for an unconfigured chain. */
+export class ChainNotConfiguredError extends BaseError {
+  constructor({ chainId }: { chainId: number }) {
+    super(`Chain with id ${chainId} is not configured.`, {
+      name: 'createClientResolver.ChainNotConfiguredError',
+    })
+  }
+}
+
+/** Thrown when a configured chain has no transport. */
+export class TransportNotConfiguredError extends BaseError {
+  constructor({ chainId }: { chainId: number }) {
+    super(`Transport for chain with id ${chainId} is not configured.`, {
+      name: 'createClientResolver.TransportNotConfiguredError',
+    })
+  }
+}

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.56.9'
+export const version = '2.57.0'

package/index.ts

@@ -609,6 +609,12 @@ export {
   type MulticallBatchOptions,
   rpcSchema,
 } from './clients/createClient.js'
+/** Lazily resolves and caches typed Clients across configured chains. */
+export {
+  ChainNotConfiguredError,
+  createClientResolver,
+  TransportNotConfiguredError,
+} from './clients/createClientResolver.js'
 export {
   type CreatePublicClientErrorType,
   createPublicClient,

package/op-stack/actions/getGame.ts

@@ -93,7 +93,9 @@ export async function getGame<
 
   const latestGames = await getGames(client, parameters)
 
-  const games = latestGames.filter((game) => game.l2BlockNumber > l2BlockNumber)
+  const games = latestGames.filter(
+    (game) => game.l2BlockNumber >= l2BlockNumber,
+  )
 
   const game = (() => {
     if (strategy === 'random')

package/op-stack/actions/getGames.ts

@@ -145,7 +145,7 @@ export async function getGames<
   const games = rawGames
     .map((game, i) => {
       const blockNumber = l2SequenceNumbers[i] as bigint
-      return !l2BlockNumber || blockNumber > l2BlockNumber
+      return !l2BlockNumber || blockNumber >= l2BlockNumber
         ? { ...game, l2BlockNumber: blockNumber, usesSuperRoots }
         : null
     })

package/op-stack/actions/getTimeToNextGame.ts

@@ -133,9 +133,9 @@ export async function getTimeToNextGame<
     // then we assume that the dispute game has already been submitted.
     if (now < latestGameTimestamp) return 0
 
-    // If the latest dispute game block is newer than the provided dispute game block number,
+    // If the latest dispute game covers the provided block number,
     // then we assume that the dispute game has already been submitted.
-    if (latestGame.l2BlockNumber > l2BlockNumber) return 0
+    if (latestGame.l2BlockNumber >= l2BlockNumber) return 0
 
     // If there is only a single game, no interval data
     if (intervalWithBuffer === 0) return 0

package/op-stack/actions/getTimeToNextL2Output.ts

@@ -141,9 +141,9 @@ export async function getTimeToNextL2Output<
     // then we assume that the L2 output has already been submitted.
     if (now < latestOutputTimestamp) return 0
 
-    // If the latest L2 output block is newer than the provided L2 block number,
+    // If the latest L2 output covers the provided L2 block number,
     // then we assume that the L2 output has already been submitted.
-    if (latestOutput.l2BlockNumber > l2BlockNumber) return 0
+    if (latestOutput.l2BlockNumber >= l2BlockNumber) return 0
 
     const elapsedBlocks = Number(l2BlockNumber - latestOutput.l2BlockNumber)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.56.9",
+  "version": "2.57.0",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/tempo/Capabilities.ts

@@ -1,8 +1,8 @@
 import type { Address } from 'abitype'
 import type { DefaultCapabilitiesSchema } from '../types/capabilities.js'
 import type { Hex } from '../types/misc.js'
-import type { ExactPartial, OneOf } from '../types/utils.js'
-import type { DecodeErrorResultReturnType } from '../utils/index.js'
+import type { ExactPartial } from '../types/utils.js'
+import type * as ExecutionError from './ExecutionError.js'
 import type { TransactionRequestTempo } from './Transaction.js'
 
 export type Schema = Omit<DefaultCapabilitiesSchema, 'sendCalls'> & {
@@ -18,27 +18,13 @@ export type Schema = Omit<DefaultCapabilitiesSchema, 'sendCalls'> & {
 export type FillTransactionRequestCapabilities = {
   /** Whether to include `balanceDiffs` in the response. */
   balanceDiffs?: boolean | undefined
+  /** Whether execution reverts return error capabilities instead of throwing. */
+  errors?: boolean | undefined
 }
 
 export type FillTransactionCapabilities = {
-  autoSwap?:
-    | {
-        calls: readonly { to: Address; data: Hex; value: Hex }[]
-        maxIn: SwapAmount
-        minOut: SwapAmount
-        slippage: number
-      }
-    | undefined
   balanceDiffs?: Readonly<Record<Address, readonly BalanceDiff[]>> | undefined
-  error?:
-    | OneOf<
-        | (DecodeErrorResultReturnType & {
-            data: Hex
-            message: string
-          })
-        | { errorName: 'unknown'; message: string }
-      >
-    | undefined
+  error?: ExecutionError.Rpc | undefined
   fee?:
     | {
         amount: Hex
@@ -47,7 +33,7 @@ export type FillTransactionCapabilities = {
         symbol: string
       }
     | undefined
-  requireFunds?:
+  insufficientFunds?:
     | {
         amount: Hex
         decimals: number
@@ -68,6 +54,7 @@ export type FillTransactionCapabilities = {
   virtualAddresses?: Readonly<Record<Address, Address | null>> | undefined
 }
 
+/** A token balance preview. Incoming funds and outgoing approval exposure can produce separate entries for the same token. */
 export type BalanceDiff = {
   address: Address
   decimals: number
@@ -78,12 +65,3 @@ export type BalanceDiff = {
   symbol: string
   value: Hex
 }
-
-export type SwapAmount = {
-  decimals: number
-  formatted: string
-  name: string
-  symbol: string
-  token: Address
-  value: Hex
-}

package/tempo/Client.ts

@@ -25,8 +25,6 @@ import type { RpcSchema } from '../types/eip1193.js'
 import type { Prettify } from '../types/utils.js'
 import { tempo, tempoTestnet } from './Chain.js'
 import { type Decorator, decorator as tempoActions } from './Decorator.js'
-import * as Store from './Store.js'
-import { withMultisig } from './Transport.js'
 
 /**
  * Configuration for a Tempo {@link Client}.
@@ -54,19 +52,6 @@ export type ClientConfig<
      * @default tempo (or `tempoTestnet` when `testnet` is truthy)
      */
     chain?: chain | Chain | undefined
-    /**
-     * Enables native multisig approval coordination. Pass `true` to use an
-     * in-memory store or provide a shared store.
-     *
-     * @default undefined
-     */
-    experimental_multisig?:
-      | true
-      | {
-          /** Store shared by multisig coordinators. */
-          store: Store.Atomic
-        }
-      | undefined
     /**
      * Default fee token for the Client. Extended onto the chain so it applies
      * to every transaction sent with the Client.
@@ -121,8 +106,8 @@ export type CreateClientErrorType = ErrorType
  * Defaults to the `tempo` mainnet chain and `http` transport, so a minimal
  * client can be created with `createClient()`. Pass `testnet` to use the
  * Tempo testnet, or `chain` to override the chain entirely. Pass `feeToken`
- * to set a default fee token for every transaction. Pass
- * `experimental_multisig` to coordinate multisig owner approvals.
+ * to set a default fee token for every transaction. Use `withRelay` with a
+ * `Relay.multisig` plugin to coordinate multisig owner approvals.
  *
  * @example
  * ```ts
@@ -156,11 +141,13 @@ export type CreateClientErrorType = ErrorType
  *
  * @example
  * ```ts
- * import { createClient } from 'viem/tempo'
+ * import { createClient, http, Relay, Store, withRelay } from 'viem/tempo'
  *
  * // Multisig coordination with a client-local in-memory store.
  * const client = createClient({
- *   experimental_multisig: true,
+ *   transport: withRelay(http(), {
+ *     plugins: [Relay.multisig({ store: Store.memory() })],
+ *   }),
  * })
  * ```
  *
@@ -182,15 +169,7 @@ export function createClient<
     : accountOrAddress,
   rpcSchema
 > {
-  const {
-    chain,
-    experimental_multisig,
-    feeToken,
-    testnet,
-    tokens,
-    transport,
-    ...rest
-  } = parameters
+  const { chain, feeToken, testnet, tokens, transport, ...rest } = parameters
   const baseChain = chain ?? (testnet ? tempoTestnet : tempo)
   const resolvedChain =
     feeToken && typeof (baseChain as { extend?: unknown }).extend === 'function'
@@ -198,20 +177,11 @@ export function createClient<
           feeToken,
         })
       : baseChain
-  const transport_ = transport ?? http()
-  const resolvedTransport = experimental_multisig
-    ? withMultisig(
-        transport_,
-        experimental_multisig === true
-          ? { store: Store.memory() }
-          : experimental_multisig,
-      )
-    : transport_
   return createClient_({
     ...rest,
     chain: resolvedChain,
     tokens: tokens ?? tokenSets.tempo,
-    transport: resolvedTransport,
+    transport: transport ?? http(),
   } as ClientConfig_)
     .extend(publicActions)
     .extend(walletActions)