viem 2.57.8 → 2.57.11

package/clients/createClient.ts

@@ -56,7 +56,7 @@ export type ClientConfig<
   experimental_blockTag?: BlockTag | undefined
   /**
    * Time (in ms) that cached data will remain in memory.
-   * @default chain.blockTime / 3
+   * @default min(pollingInterval, chain.blockTime / 2)
    */
   cacheTime?: number | undefined
   /**
@@ -85,7 +85,7 @@ export type ClientConfig<
   name?: string | undefined
   /**
    * Frequency (in ms) for polling enabled actions & events.
-   * @default chain.blockTime / 3
+   * @default chain.blockTime / 2 (min 500, max 4_000)
    */
   pollingInterval?: number | undefined
   /**
@@ -172,6 +172,40 @@ export type Client<
       Prettify<client> & (extended extends Extended ? extended : unknown),
       tokens
     >
+    /**
+     * Creates a Client with the same configuration, transport, and extensions
+     * that does not share in-flight requests, caches, or batches with other Clients.
+     *
+     * Use a scope for each unit of work that must not wait on another's
+     * requests, such as each request handled by a server or Worker. Calls with
+     * the same `signal` return the same Client.
+     *
+     * @example
+     * ```ts
+     * import { createPublicClient, http } from 'viem'
+     * import { mainnet } from 'viem/chains'
+     *
+     * const client = createPublicClient({ chain: mainnet, transport: http() })
+     *
+     * export default {
+     *   async fetch(request: Request) {
+     *     const scoped = client.scope({ signal: request.signal })
+     *     return Response.json({ blockNumber: String(await scoped.getBlockNumber()) })
+     *   },
+     * }
+     * ```
+     */
+    scope: (
+      options?:
+        | {
+            /**
+             * Signal that aborts the scoped Client's requests and identifies the
+             * scope. Requests made with their own `signal` use it instead.
+             */
+            signal?: AbortSignal | undefined
+          }
+        | undefined,
+    ) => Client<transport, chain, account, rpcSchema, extended, tokens>
   }
 
 type Client_Base<
@@ -199,7 +233,7 @@ type Client_Base<
   key: string
   /** A name for the client. */
   name: string
-  /** Frequency (in ms) for polling enabled actions & events. Defaults to 4_000 milliseconds. */
+  /** Frequency (in ms) for polling enabled actions & events. */
   pollingInterval: number
   /** Request function wrapped with friendly error handling */
   request: EIP1193RequestFn<
@@ -284,7 +318,8 @@ export function createClient(parameters: ClientConfig): Client {
     4_000,
   )
   const pollingInterval = parameters.pollingInterval ?? defaultPollingInterval
-  const cacheTime = parameters.cacheTime ?? pollingInterval
+  const cacheTime =
+    parameters.cacheTime ?? Math.min(pollingInterval, Math.floor(blockTime / 2))
 
   const account = parameters.account
     ? parseAccount(parameters.account)
@@ -314,11 +349,25 @@ export function createClient(parameters: ClientConfig): Client {
     ...(experimental_blockTag ? { experimental_blockTag } : {}),
   }
 
-  function extend(base: typeof client) {
-    type ExtendFn = (base: typeof client) => unknown
+  return decorate(client)
+}
+
+/** Built-in `scope` functions, which an extension named `scope` takes precedence over. */
+const scopes_builtin = new WeakSet<object>()
+
+let scopeId = 0
+
+/**
+ * Attaches `extend` and `scope` to a base Client. Base keys other than
+ * `scope` are reserved, so extensions cannot override them.
+ */
+function decorate<client extends Client_Base>(client: client): Client {
+  type ExtendFn = (base: client) => unknown
+
+  function extend(base: client, extensions: readonly ExtendFn[]) {
     return (extendFn: ExtendFn) => {
       const extended = extendFn(base) as Extended
-      for (const key in client) delete extended[key]
+      for (const key in client) if (key !== 'scope') delete extended[key]
       const combined = { ...base, ...extended }
       // For keys that exist on both the base client and the extension and
       // resolve to plain objects (e.g. namespaces like `token`), shallow-merge
@@ -331,11 +380,61 @@ export function createClient(parameters: ClientConfig): Client {
         if (isPlainObject(a) && isPlainObject(b))
           (combined as Record<string, unknown>)[key] = { ...a, ...b }
       }
-      return Object.assign(combined, { extend: extend(combined as any) })
+      const next = [...extensions, extendFn]
+      const { scope: scope_combined } = combined as { scope?: unknown }
+      return Object.assign(combined, {
+        extend: extend(combined as any, next),
+        scope:
+          typeof scope_combined === 'function' &&
+          scopes_builtin.has(scope_combined)
+            ? scope(next)
+            : scope_combined,
+      })
+    }
+  }
+
+  function scope(extensions: readonly ExtendFn[]) {
+    // Memoized by signal, so callers sharing one signal share one scope.
+    const scopes = new WeakMap<AbortSignal, Client>()
+    const fn = (options: { signal?: AbortSignal | undefined } = {}) => {
+      const cached = options.signal && scopes.get(options.signal)
+      if (cached) return cached
+
+      const id = `scope.${scopeId++}`
+      // A scope-owned signal keys transport queues, such as HTTP batches, to the scope.
+      const controller = new AbortController()
+      const { signal } = options
+      if (signal?.aborted) controller.abort(signal.reason)
+      else
+        signal?.addEventListener(
+          'abort',
+          () => controller.abort(signal.reason),
+          {
+            once: true,
+          },
+        )
+      const request: EIP1193RequestFn = (args, options_request) =>
+        client.request(args as never, {
+          ...options_request,
+          signal: options_request?.signal ?? controller.signal,
+          // The request `uid` keys in-flight request deduplication.
+          uid: options_request?.uid ?? id,
+        })
+      const scoped = extensions.reduce<Client>(
+        (base, extendFn) => base.extend(extendFn as never),
+        decorate({ ...client, request, uid: id }),
+      )
+      if (signal) scopes.set(signal, scoped)
+      return scoped
     }
+    scopes_builtin.add(fn)
+    return fn
   }
 
-  return Object.assign(client, { extend: extend(client) as any })
+  return Object.assign(client, {
+    extend: extend(client, []),
+    scope: scope([]),
+  }) as any
 }
 
 /** Whether `value` is a plain object (`{}`), as opposed to a function, array,

package/clients/transports/fallback.ts

@@ -125,7 +125,7 @@ export function fallback<const transports extends readonly Transport[]>(
       {
         key,
         name,
-        async request({ method, params }) {
+        async request({ method, params }, options) {
           let includes: boolean | undefined
 
           const fetch = async (i = 0): Promise<any> => {
@@ -136,10 +136,13 @@ export function fallback<const transports extends readonly Transport[]>(
               timeout,
             })
             try {
-              const response = await transport.request({
-                method,
-                params,
-              } as any)
+              const response = await transport.request(
+                {
+                  method,
+                  params,
+                } as any,
+                options,
+              )
 
               onResponse({
                 method,

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.57.8'
+export const version = '2.57.11'

package/experimental/erc7821/actions/supportsExecutionMode.ts

@@ -64,7 +64,8 @@ export async function supportsExecutionMode<
           args: [mode],
         }),
       {
-        cacheKey: `supportsExecutionMode.${address}.${mode}`,
+        // Distinct from the key `execute` uses, since `execute` wraps this action in its own cache.
+        cacheKey: `supportsExecutionMode.${address}.${mode}.${client.uid}`,
       },
     )
   } catch {

package/op-stack/actions/getPortalVersion.ts

@@ -78,7 +78,10 @@ export async function getPortalVersion<
         address: portalAddress,
         functionName: 'version',
       }),
-    { cacheKey: ['portalVersion', portalAddress].join('.'), cacheTime: 300 },
+    {
+      cacheKey: ['portalVersion', client.uid, portalAddress].join('.'),
+      cacheTime: 300,
+    },
   )
 
   const [major, minor, patch] = version.split('.').map(Number)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.57.8",
+  "version": "2.57.11",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -229,7 +229,7 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "0.14.56",
+    "ox": "0.14.57",
     "ws": "8.21.0"
   },
   "license": "MIT",

package/tempo/Abis.ts

@@ -1,5 +1,5 @@
 // Generated with `pnpm gen:tempo-abis`. Do not modify manually.
-// Source: tempoxyz/tempo@6ef1f812c9ddcbe90a88ada73944012520942d26
+// Source: tempoxyz/tempo@e539a1dac2921670585a08215e516d8b98aa527a
 
 export const accountKeychain = [
   {
@@ -444,7 +444,7 @@ export const addressRegistry = [
   { name: 'VirtualAddressUnregistered', type: 'error', inputs: [] },
 ] as const
 
-export const nativeMultisig = [
+export const configurableAccount = [
   {
     name: 'deriveAccount',
     type: 'function',
@@ -505,7 +505,24 @@ export const nativeMultisig = [
     outputs: [],
   },
   {
-    name: 'MultisigConfigUpdated',
+    name: 'upgradeAccount',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { type: 'uint8', name: 'threshold' },
+      {
+        type: 'tuple[]',
+        name: 'owners',
+        components: [
+          { type: 'address', name: 'owner' },
+          { type: 'uint8', name: 'weight' },
+        ],
+      },
+    ],
+    outputs: [{ type: 'bytes32', name: 'commitment' }],
+  },
+  {
+    name: 'ConfigurableAccountConfigUpdated',
     type: 'event',
     inputs: [
       { type: 'address', name: 'account', indexed: true },
@@ -522,15 +539,37 @@ export const nativeMultisig = [
       },
     ],
   },
+  {
+    name: 'AccountUpgraded',
+    type: 'event',
+    inputs: [
+      { type: 'address', name: 'account', indexed: true },
+      { type: 'bytes32', name: 'commitment', indexed: true },
+      { type: 'bytes32', name: 'salt' },
+      { type: 'uint8', name: 'threshold' },
+      {
+        type: 'tuple[]',
+        name: 'owners',
+        components: [
+          { type: 'address', name: 'owner' },
+          { type: 'uint8', name: 'weight' },
+        ],
+      },
+    ],
+  },
   { name: 'InvalidAccount', type: 'error', inputs: [] },
   { name: 'InvalidConfig', type: 'error', inputs: [] },
   { name: 'InvalidThreshold', type: 'error', inputs: [] },
-  { name: 'InvalidMultisigOwner', type: 'error', inputs: [] },
+  { name: 'InvalidConfigurableAccountOwner', type: 'error', inputs: [] },
   { name: 'InvalidWeight', type: 'error', inputs: [] },
   { name: 'TooManyOwners', type: 'error', inputs: [] },
   { name: 'DuplicateOwner', type: 'error', inputs: [] },
   { name: 'InvalidOwnerOrder', type: 'error', inputs: [] },
-  { name: 'UnauthorizedMultisigCaller', type: 'error', inputs: [] },
+  { name: 'UnauthorizedConfigurableAccountCaller', type: 'error', inputs: [] },
+  { name: 'PrimitiveRootRequired', type: 'error', inputs: [] },
+  { name: 'UpgradeMustBeOnlyCall', type: 'error', inputs: [] },
+  { name: 'AccountAlreadyConfigurable', type: 'error', inputs: [] },
+  { name: 'AccountHasCode', type: 'error', inputs: [] },
 ] as const
 
 export const currentCommittee = [
@@ -705,6 +744,17 @@ export const signatureVerifier = [
     ],
     outputs: [{ type: 'bool' }],
   },
+  {
+    name: 'verifyConfigurableAccount',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { type: 'address', name: 'account' },
+      { type: 'bytes32', name: 'hash' },
+      { type: 'bytes', name: 'signature' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
   { name: 'InvalidFormat', type: 'error', inputs: [] },
   { name: 'InvalidSignature', type: 'error', inputs: [] },
 ] as const
@@ -1710,6 +1760,11 @@ export const tip20ChannelReserve = [
   { name: 'CaptureAmountInvalid', type: 'error', inputs: [] },
   { name: 'CloseNotReady', type: 'error', inputs: [] },
   { name: 'DepositOverflow', type: 'error', inputs: [] },
+  {
+    name: 'RootKeyRetired',
+    type: 'error',
+    inputs: [{ type: 'address', name: 'account' }],
+  },
 ] as const
 
 export const tip20Factory = [
@@ -2314,6 +2369,11 @@ export const tip20 = [
   { name: 'InvalidSignature', type: 'error', inputs: [] },
   { name: 'LogoURITooLong', type: 'error', inputs: [] },
   { name: 'InvalidLogoURI', type: 'error', inputs: [] },
+  {
+    name: 'RootKeyRetired',
+    type: 'error',
+    inputs: [{ type: 'address', name: 'account' }],
+  },
   {
     name: 'hasRole',
     type: 'function',
@@ -9861,10 +9921,10 @@ export const directPropAmm = [
 export const core = [
   ...accountKeychain,
   ...addressRegistry,
+  ...configurableAccount,
   ...currentCommittee,
   ...feeAmm,
   ...feeManager,
-  ...nativeMultisig,
   ...nonce,
   ...receivePolicyGuard,
   ...signatureVerifier,
@@ -9946,6 +10006,19 @@ export const coreErrors = [
   { name: 'InvalidMasterAddress', type: 'error', inputs: [] },
   { name: 'ProofOfWorkFailed', type: 'error', inputs: [] },
   { name: 'VirtualAddressUnregistered', type: 'error', inputs: [] },
+  { name: 'InvalidAccount', type: 'error', inputs: [] },
+  { name: 'InvalidConfig', type: 'error', inputs: [] },
+  { name: 'InvalidThreshold', type: 'error', inputs: [] },
+  { name: 'InvalidConfigurableAccountOwner', type: 'error', inputs: [] },
+  { name: 'InvalidWeight', type: 'error', inputs: [] },
+  { name: 'TooManyOwners', type: 'error', inputs: [] },
+  { name: 'DuplicateOwner', type: 'error', inputs: [] },
+  { name: 'InvalidOwnerOrder', type: 'error', inputs: [] },
+  { name: 'UnauthorizedConfigurableAccountCaller', type: 'error', inputs: [] },
+  { name: 'PrimitiveRootRequired', type: 'error', inputs: [] },
+  { name: 'UpgradeMustBeOnlyCall', type: 'error', inputs: [] },
+  { name: 'AccountAlreadyConfigurable', type: 'error', inputs: [] },
+  { name: 'AccountHasCode', type: 'error', inputs: [] },
   { name: 'Unauthorized', type: 'error', inputs: [] },
   { name: 'IdenticalAddresses', type: 'error', inputs: [] },
   { name: 'InvalidToken', type: 'error', inputs: [] },
@@ -9956,15 +10029,6 @@ export const coreErrors = [
   { name: 'InvalidSwapCalculation', type: 'error', inputs: [] },
   { name: 'InsufficientFeeTokenBalance', type: 'error', inputs: [] },
   { name: 'CannotChangeWithinBlock', type: 'error', inputs: [] },
-  { name: 'InvalidAccount', type: 'error', inputs: [] },
-  { name: 'InvalidConfig', type: 'error', inputs: [] },
-  { name: 'InvalidThreshold', type: 'error', inputs: [] },
-  { name: 'InvalidMultisigOwner', type: 'error', inputs: [] },
-  { name: 'InvalidWeight', type: 'error', inputs: [] },
-  { name: 'TooManyOwners', type: 'error', inputs: [] },
-  { name: 'DuplicateOwner', type: 'error', inputs: [] },
-  { name: 'InvalidOwnerOrder', type: 'error', inputs: [] },
-  { name: 'UnauthorizedMultisigCaller', type: 'error', inputs: [] },
   { name: 'ProtocolNonceNotSupported', type: 'error', inputs: [] },
   { name: 'InvalidNonceKey', type: 'error', inputs: [] },
   { name: 'NonceOverflow', type: 'error', inputs: [] },
@@ -10026,6 +10090,11 @@ export const coreErrors = [
   { name: 'PermitExpired', type: 'error', inputs: [] },
   { name: 'LogoURITooLong', type: 'error', inputs: [] },
   { name: 'InvalidLogoURI', type: 'error', inputs: [] },
+  {
+    name: 'RootKeyRetired',
+    type: 'error',
+    inputs: [{ type: 'address', name: 'account' }],
+  },
   { name: 'ChannelAlreadyExists', type: 'error', inputs: [] },
   { name: 'ChannelNotFound', type: 'error', inputs: [] },
   { name: 'NotPayer', type: 'error', inputs: [] },

package/tempo/Account.ts

@@ -24,7 +24,7 @@ import { keccak256 } from '../utils/hash/keccak256.js'
 import { hashMessage } from '../utils/signature/hashMessage.js'
 import { hashTypedData } from '../utils/signature/hashTypedData.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
-import { nativeMultisigFactory } from './Addresses.js'
+import { configurableAccountRecoveryFactory } from './Addresses.js'
 import { parseApproval } from './accounts/Signature.js'
 import type { KeyAuthorizationManager } from './KeyAuthorizationManager.js'
 import * as Transaction from './Transaction.js'
@@ -281,8 +281,10 @@ export declare namespace fromSecp256k1 {
  *
  * The returned account does not hold a key itself. Omit `address` or set it to
  * `infer` to derive an account address from its initial config. For a current
- * config, set `address` to the stable account address. Pass the address directly
- * for an address-only account.
+ * config, set `address` to the stable account address. For an account
+ * upgraded in place with `Actions.accounts.upgrade`, set `address` to the
+ * upgraded account and pass the installed owners and threshold as `upgrade`.
+ * Pass the address directly for an address-only account.
  *
  * Owners can be accounts or addresses directly, or weighted `{ owner, weight }`
  * entries. Direct owners default to weight `1`, and `threshold` defaults to `1`.
@@ -309,7 +311,7 @@ export declare namespace fromSecp256k1 {
  * const transaction = await client.signTransaction(request)
  * ```
  *
- * @param value Initial config, current config, or account address.
+ * @param value Initial config, current config, upgrade config, or account address.
  * @returns Configurable account.
  */
 export function fromConfig(
@@ -318,6 +320,9 @@ export function fromConfig(
 export function fromConfig(
   value: fromConfig.CurrentConfig,
 ): ConfigurableAccount<AccountConfig.Config>
+export function fromConfig(
+  value: fromConfig.UpgradeConfig,
+): ConfigurableAccount<AccountConfig.Config>
 export function fromConfig(
   address: Address.Address,
 ): ConfigurableAccount<undefined>
@@ -325,7 +330,12 @@ export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount
 export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount {
   const configInput = (() => {
     if (typeof value === 'string') return undefined
-    const { address: _, ...config } = value
+    if ('upgrade' in value) return value.upgrade
+    const {
+      address: _,
+      factory: __,
+      ...config
+    } = value as fromConfig.InitialConfig
     return config
   })()
   const config = (() => {
@@ -335,16 +345,16 @@ export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount {
         ? { owner: value, weight: 1 }
         : value,
     )
-    return AccountConfig.from({
-      ...configInput,
-      owners: ownerEntries.map(({ owner, weight }) => ({
-        owner: typeof owner === 'string' ? owner : owner.address,
-        weight,
-      })),
-      threshold: configInput.threshold ?? 1,
-    })
+    const owners = ownerEntries.map(({ owner, weight }) => ({
+      owner: typeof owner === 'string' ? owner : owner.address,
+      weight,
+    }))
+    const threshold = configInput.threshold ?? 1
+    if (typeof value !== 'string' && 'upgrade' in value)
+      return AccountConfig.fromUpgrade(value.address, { owners, threshold })
+    return AccountConfig.from({ ...configInput, owners, threshold })
   })()
-  if (typeof value !== 'string') {
+  if (typeof value !== 'string' && !('upgrade' in value)) {
     if (
       (value.address === undefined || value.address === 'infer') &&
       config!.version !== 0n
@@ -362,7 +372,7 @@ export function fromConfig(value: fromConfig.Parameters): ConfigurableAccount {
       if (typeof value === 'string') return value
       if (value.address === undefined || value.address === 'infer')
         return AccountConfig.getAddress(config!, {
-          factory: nativeMultisigFactory,
+          factory: value.factory ?? configurableAccountRecoveryFactory,
         })
       return value.address
     })(),
@@ -484,6 +494,11 @@ export declare namespace fromConfig {
   export type InitialConfig = {
     /** Derives the stable account address from this initial config. */
     address?: 'infer' | undefined
+    /**
+     * Recovery factory used to derive the address.
+     * @default `Addresses.configurableAccountRecoveryFactory`
+     */
+    factory?: Address.Address | undefined
     /** Weighted owners. */
     owners: readonly Owner[]
     /** Caller-chosen 32-byte salt. */
@@ -505,7 +520,24 @@ export declare namespace fromConfig {
       })
 
   /** Parameters for {@link fromConfig}. */
-  export type Parameters = Address.Address | CurrentConfig | InitialConfig
+  export type Parameters =
+    | Address.Address
+    | CurrentConfig
+    | InitialConfig
+    | UpgradeConfig
+
+  /** Account upgraded in place and the owners and threshold it installed. */
+  export type UpgradeConfig = {
+    /** Upgraded account address. */
+    address: Address.Address
+    /** Owners and threshold installed by the upgrade. */
+    upgrade: {
+      /** Weighted owners. */
+      owners: readonly Owner[]
+      /** Minimum owner weight required for authorization. */
+      threshold?: number | undefined
+    }
+  }
 }
 
 export type ConfigurableAccount<
@@ -1110,6 +1142,10 @@ declare namespace fromAccessKey {
   export type ReturnValue = AccessKeyAccount
 }
 
+// TODO: support configurable accounts as access keys (TIP-1111): authorize a
+// configurable account with key type `configurable`, sign as it with a keychain
+// envelope wrapping its configurable signature, and accept those envelopes in the
+// relay fee payer.
 /** @internal */
 export function resolveAccessKey(
   accessKey: resolveAccessKey.Parameters,

package/tempo/Addresses.ts

@@ -12,13 +12,13 @@ export const accountImplementation =
 export const accountKeychain = '0xaAAAaaAA00000000000000000000000000000000'
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
+export const configurableAccount = '0xAACC000000000000000000000000000000000000'
+/** Default configurable account recovery factory. Temporary until the production address is finalized. */
+export const configurableAccountRecoveryFactory =
+  '0x7171717171717171717171717171717171717171'
 /** Current consensus committee precompile address, used with `Abis.currentCommittee` to read committee members. */
 export const currentCommittee = '0xC077e00000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
-export const nativeMultisig = '0xAACC000000000000000000000000000000000000'
-/** Temporary recovery factory until the production address is finalized. */
-export const nativeMultisigFactory =
-  '0x7171717171717171717171717171717171717171'
 export const nonceManager = '0x4e4F4E4345000000000000000000000000000000'
 export const ousd = '0x20c0000000000000000000006a37DA5C996874BE'
 export const pathUsd = '0x20c0000000000000000000000000000000000000'