viem 2.57.8 → 2.57.10

package/tempo/actions/accessKey.ts

@@ -72,6 +72,7 @@ const signatureTypes = {
   0: 'secp256k1',
   1: 'p256',
   2: 'webAuthn',
+  3: 'configurable',
 } as const satisfies Record<number, string>
 
 /** @internal */
@@ -558,8 +559,8 @@ export namespace getMetadata {
   export type ReturnValue = {
     /** The access key address. */
     address: Address
-    /** The key type. */
-    keyType: 'secp256k1' | 'p256' | 'webAuthn'
+    /** The key type. `configurable` for a configurable account access key. */
+    keyType: 'secp256k1' | 'p256' | 'webAuthn' | 'configurable'
     /** The expiry timestamp. */
     expiry: bigint
     /** The spending policy. */

package/tempo/actions/accounts.ts

@@ -13,7 +13,7 @@ import type { Transport } from '../../clients/transports/createTransport.js'
 import type { BaseErrorType } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
 import type { Log } from '../../types/log.js'
-import type { Compute } from '../../types/utils.js'
+import type { Compute, OneOf, UnionOmit } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
 import * as Abis from '../Abis.js'
 import { type ConfigurableAccount, fromConfig } from '../Account.js'
@@ -24,6 +24,88 @@ import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type * as Transaction from '../Transaction.js'
 
+/**
+ * Derives a configurable account address from an initial config with the
+ * configurable account precompile.
+ *
+ * The precompile validates the config and derives the address with the chain's
+ * recovery factory. To derive the address locally, use
+ * `AccountConfig.getAddress` or `Account.fromConfig({ address: 'infer' })`.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const address = await Actions.accounts.deriveAccount(client, {
+ *   owners: [{ owner: '0x...', weight: 1 }],
+ *   threshold: 1,
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The configurable account address.
+ */
+export async function deriveAccount<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: deriveAccount.Parameters,
+): Promise<deriveAccount.ReturnValue> {
+  const { owners, salt, threshold, ...rest } = parameters
+  return withExecutionError(readContract)(client, {
+    ...rest,
+    ...deriveAccount.call({ owners, salt, threshold }),
+  })
+}
+
+export namespace deriveAccount {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Weighted owners. Normalized into canonical address order. */
+    owners: AccountConfig.Config['owners']
+    /** Caller-chosen 32-byte salt. Defaults to the zero salt. */
+    salt?: Hex.Hex | undefined
+    /** Minimum total owner weight required for authorization. */
+    threshold: number
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.configurableAccount,
+    'deriveAccount',
+    never
+  >
+
+  /**
+   * Defines a call to the `deriveAccount` function.
+   *
+   * Can be passed to [`multicall`](https://viem.sh/docs/contract/multicall).
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { owners, salt, threshold } = AccountConfig.from(args)
+    return defineCall({
+      address: Addresses.configurableAccount,
+      abi: Abis.configurableAccount,
+      args: [salt, threshold, owners],
+      functionName: 'deriveAccount',
+    })
+  }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
+}
+
 /**
  * Gets the current cached config for a configurable account.
  *
@@ -118,7 +200,7 @@ export namespace getConfigCommitment {
   }
 
   export type ReturnValue = ReadContractReturnType<
-    typeof Abis.nativeMultisig,
+    typeof Abis.configurableAccount,
     'getConfigCommitment',
     never
   >
@@ -133,8 +215,8 @@ export namespace getConfigCommitment {
    */
   export function call(args: Args) {
     return defineCall({
-      address: Addresses.nativeMultisig,
-      abi: Abis.nativeMultisig,
+      address: Addresses.configurableAccount,
+      abi: Abis.configurableAccount,
       args: [args.account],
       functionName: 'getConfigCommitment',
     })
@@ -348,27 +430,28 @@ export namespace updateConfig {
     const currentConfig = AccountConfig.from(args.currentConfig)
     const nextConfig = AccountConfig.update(currentConfig, args.nextConfig)
     return defineCall({
-      address: Addresses.nativeMultisig,
-      abi: Abis.nativeMultisig,
+      address: Addresses.configurableAccount,
+      abi: Abis.configurableAccount,
       args: [currentConfig, nextConfig.threshold, nextConfig.owners],
       functionName: 'updateConfig',
     })
   }
 
   /**
-   * Extracts the `MultisigConfigUpdated` event from logs.
+   * Extracts the `ConfigurableAccountConfigUpdated` event from logs.
    *
    * @param logs - Transaction logs.
    * @returns The configuration update event.
    */
   export function extractEvent(logs: Log[]) {
     const [log] = parseEventLogs({
-      abi: Abis.nativeMultisig,
+      abi: Abis.configurableAccount,
       logs,
-      eventName: 'MultisigConfigUpdated',
+      eventName: 'ConfigurableAccountConfigUpdated',
       strict: true,
     })
-    if (!log) throw new Error('`MultisigConfigUpdated` event not found.')
+    if (!log)
+      throw new Error('`ConfigurableAccountConfigUpdated` event not found.')
     return log
   }
 }
@@ -447,3 +530,304 @@ export namespace updateConfigSync {
 
   export type ErrorType = updateConfig.ErrorType
 }
+
+/**
+ * Upgrades an existing account to a configurable account in place
+ * ([TIP-1113](https://tips.sh/1113)).
+ *
+ * The account keeps its address and installs `owners` and `threshold`. The
+ * root key must sign the upgrade, which is sent as the transaction's only
+ * call. After the upgrade, the root key can no longer sign for the account.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempoLocalnet } from 'viem/chains'
+ * import { Account, Actions } from 'viem/tempo'
+ *
+ * const root = Account.fromSecp256k1('0x...')
+ * const client = createClient({
+ *   chain: tempoLocalnet,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.accounts.upgrade(client, {
+ *   account: root,
+ *   owners: [{ owner: '0x...', weight: 1 }],
+ *   threshold: 1,
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function upgrade<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: upgrade.Parameters<chain, account>,
+): Promise<upgrade.ReturnValue> {
+  return upgrade.inner(writeContract, client, parameters)
+}
+
+export namespace upgrade {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = UnionOmit<WriteParameters<chain, account>, 'keyAuthorization' | 'owner'> &
+    Args
+
+  export type Args = Pick<AccountConfig.Config, 'owners' | 'threshold'>
+
+  export type ReturnValue = WriteContractReturnType
+
+  // TODO: exhaustive error type
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
+
+  /** @internal */
+  export async function inner<
+    action extends typeof writeContract | typeof writeContractSync,
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    action: action,
+    client: Client<Transport, chain, account>,
+    parameters: Parameters<chain, account>,
+  ): Promise<ReturnType<action>> {
+    const { owners, threshold, ...rest } = parameters
+    for (const key of [
+      'authorizationList',
+      'calls',
+      'data',
+      'keyAuthorization',
+      'to',
+    ])
+      if ((rest as Record<string, unknown>)[key] !== undefined)
+        throw new Error(
+          `\`${key}\` is not supported: the upgrade must be the only call, without authorizations.`,
+        )
+    const account = rest.account ?? client.account
+    if (typeof account === 'object') {
+      if (account.source === 'configurable')
+        throw new Error('The account is already a configurable account.')
+      if (account.source === 'accessKey')
+        throw new Error(
+          'The root key must sign the upgrade, not an access key.',
+        )
+    }
+    // Always send a Tempo envelope, so relays recognize and cache the upgrade.
+    return (await withExecutionError(action)(client, {
+      ...rest,
+      ...upgrade.call({ owners, threshold }),
+      type: 'tempo',
+    } as never)) as never
+  }
+
+  /**
+   * Defines a call to the `upgradeAccount` function.
+   *
+   * The call must be the only call in a transaction signed by the account's
+   * root key.
+   *
+   * @example
+   * ```ts
+   * import { Actions } from 'viem/tempo'
+   *
+   * const call = Actions.accounts.upgrade.call({
+   *   owners: [{ owner: '0x...', weight: 1 }],
+   *   threshold: 1,
+   * })
+   * ```
+   *
+   * @param args - Owners and threshold to install.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { owners, threshold } = AccountConfig.from(args)
+    return defineCall({
+      address: Addresses.configurableAccount,
+      abi: Abis.configurableAccount,
+      args: [threshold, owners],
+      functionName: 'upgradeAccount',
+    })
+  }
+
+  /**
+   * Extracts the `AccountUpgraded` event from logs.
+   *
+   * @param logs - Transaction logs.
+   * @returns The account upgrade event.
+   */
+  export function extractEvent(logs: Log[]) {
+    const [log] = parseEventLogs({
+      abi: Abis.configurableAccount,
+      logs,
+      eventName: 'AccountUpgraded',
+      strict: true,
+    })
+    if (!log) throw new Error('`AccountUpgraded` event not found.')
+    return log
+  }
+}
+
+/**
+ * Upgrades an existing account to a configurable account in place
+ * ([TIP-1113](https://tips.sh/1113)) and waits for confirmation.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempoLocalnet } from 'viem/chains'
+ * import { Account, Actions } from 'viem/tempo'
+ *
+ * const root = Account.fromSecp256k1('0x...')
+ * const client = createClient({
+ *   chain: tempoLocalnet,
+ *   transport: http(),
+ * })
+ *
+ * const { config } = await Actions.accounts.upgradeSync(client, {
+ *   account: root,
+ *   owners: [{ owner: '0x...', weight: 1 }],
+ *   threshold: 1,
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The installed configuration, its commitment, and the transaction receipt.
+ */
+export async function upgradeSync<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: upgradeSync.Parameters<chain, account>,
+): Promise<upgradeSync.ReturnValue> {
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await upgrade.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
+  // Pending and (with `throwOnReceiptRevert: false`) reverted receipts carry no upgrade event.
+  if ((receipt as Transaction.TransactionReceipt).status !== 'success')
+    return { receipt } as never
+  const { args } = upgrade.extractEvent(receipt.logs)
+  return {
+    account: args.account,
+    commitment: args.commitment,
+    config: AccountConfig.from({
+      owners: args.owners,
+      salt: args.salt,
+      threshold: args.threshold,
+      version: 1n,
+    }),
+    receipt,
+  } as never
+}
+
+export namespace upgradeSync {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = upgrade.Parameters<chain, account>
+
+  export type Args = upgrade.Args
+
+  /** Pending and reverted receipts carry no installed configuration. */
+  export type ReturnValue = OneOf<
+    | {
+        account: Address
+        commitment: Hex.Hex
+        config: AccountConfig.Config
+        receipt: Transaction.TransactionReceipt
+      }
+    | { receipt: Transaction.TransactionReceipt }
+  >
+
+  export type ErrorType = upgrade.ErrorType
+}
+
+/**
+ * Verifies a configurable account signature against the account's current
+ * configuration with the signature verifier precompile.
+ *
+ * Returns `false` when the signature is for another account or a config that
+ * is not the account's current config. Throws when the signature is malformed
+ * or its approvals do not reach quorum.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const valid = await Actions.accounts.verifyHash(client, {
+ *   account: '0x...',
+ *   hash: '0x...',
+ *   signature: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Whether the signature is valid for the account.
+ */
+export async function verifyHash<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: verifyHash.Parameters,
+): Promise<verifyHash.ReturnValue> {
+  const { account, hash, signature, ...rest } = parameters
+  return withExecutionError(readContract)(client, {
+    ...rest,
+    ...verifyHash.call({ account, hash, signature }),
+  })
+}
+
+export namespace verifyHash {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Configurable account address the signature is expected to belong to. */
+    account: Address
+    /** Original message hash that was signed. */
+    hash: Hex.Hex
+    /** Configurable account signature envelope. */
+    signature: Hex.Hex
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.signatureVerifier,
+    'verifyConfigurableAccount',
+    never
+  >
+
+  /**
+   * Defines a call to the `verifyConfigurableAccount` function on the
+   * signature verifier precompile.
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const { account, hash, signature } = args
+    return defineCall({
+      address: Addresses.signatureVerifier,
+      abi: Abis.signatureVerifier,
+      args: [account, hash, signature],
+      functionName: 'verifyConfigurableAccount',
+    })
+  }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
+}

package/tempo/chainConfig.ts

@@ -9,8 +9,11 @@ import {
 } from 'ox/tempo'
 import { getCode } from '../actions/public/getCode.js'
 import { getTransaction } from '../actions/public/getTransaction.js'
+import { readContract } from '../actions/public/readContract.js'
 import { verifyHash } from '../actions/public/verifyHash.js'
 import { maxUint256 } from '../constants/number.js'
+import { BaseError } from '../errors/base.js'
+import { ContractFunctionRevertedError } from '../errors/contract.js'
 import type { Chain, ChainConfig as viem_ChainConfig } from '../types/chain.js'
 import { isAddressEqual } from '../utils/address/isAddressEqual.js'
 import { extendSchema } from '../utils/chain/defineChain.js'
@@ -22,7 +25,10 @@ import { keccak256 } from '../utils/hash/keccak256.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
 import type { Account, ConfigurableAccount } from './Account.js'
 import { getMetadata } from './actions/accessKey.js'
-import { getConfig } from './actions/accounts.js'
+import {
+  getConfig,
+  verifyHash as verifyConfigurableAccount,
+} from './actions/accounts.js'
 import * as Formatters from './Formatters.js'
 import type { Hardfork } from './Hardfork.js'
 import * as Concurrent from './internal/concurrent.js'
@@ -318,10 +324,15 @@ export const chainConfig = {
   async verifyHash(client, parameters) {
     const { address, hash, signature, mode } = parameters
 
+    const serialized = (() => {
+      if (typeof signature === 'string') return signature
+      if (signature instanceof Uint8Array) return Hex.fromBytes(signature)
+      return undefined
+    })()
     const envelope = (() => {
-      if (typeof signature !== 'string') return
+      if (!serialized) return
       try {
-        return SignatureEnvelope.deserialize(signature)
+        return SignatureEnvelope.deserialize(serialized)
       } catch {
         return undefined
       }
@@ -370,6 +381,33 @@ export const chainConfig = {
         })
       }
 
+      // Configurable account signatures are verified against the account's
+      // current config commitment, which only the chain knows.
+      // Reverts (malformed signatures or approvals below quorum) are invalid signatures.
+      if (envelope.type === 'configurable')
+        return await (
+          readContract(client, {
+            blockHash: parameters.blockHash,
+            blockNumber: parameters.blockNumber,
+            blockTag: parameters.blockTag,
+            requireCanonical: parameters.requireCanonical,
+            ...verifyConfigurableAccount.call({
+              account: address,
+              hash,
+              signature: serialized as Hex.Hex,
+            }),
+          } as never) as Promise<boolean>
+        ).catch((error) => {
+          if (
+            error instanceof BaseError &&
+            error.walk(
+              (cause) => cause instanceof ContractFunctionRevertedError,
+            )
+          )
+            return false
+          throw error
+        })
+
       // Stateless, non-keychain signature envelopes (P256, WebAuthn) can be
       // verified directly without a network request.
       if (envelope.type === 'p256' || envelope.type === 'webAuthn') {

package/tempo/internal/relay/accounts.ts

@@ -225,8 +225,16 @@ async function submit(options: submit.Options) {
     if (
       options.method === 'eth_sendRawTransaction' ||
       options.method === 'eth_sendRawTransactionSync'
-    )
-      return await options.next(options.request, options.requestOptions)
+    ) {
+      const result = await options.next(options.request, options.requestOptions)
+      // Cache after the node accepts the transaction, so only validly signed upgrades are cached.
+      // Caching is best-effort: a store failure must not mask an accepted upgrade.
+      if (transaction)
+        await cacheUpgradeConfig({ store: options.store, transaction }).catch(
+          () => {},
+        )
+      return result
+    }
     throw new RpcResponse.InvalidParamsError({
       message: 'Expected a configurable account transaction signature.',
     })
@@ -758,7 +766,7 @@ function assertConfig(options: {
   if (
     config.version === 0n &&
     AccountConfig.getAddress(config, {
-      factory: Addresses.nativeMultisigFactory,
+      factory: Addresses.configurableAccountRecoveryFactory,
     }).toLowerCase() !== account.toLowerCase()
   )
     throw new RpcResponse.InvalidParamsError({
@@ -798,13 +806,16 @@ async function cacheNextConfigs(options: cacheNextConfigs.Options) {
   for (const call of options.transaction.calls) {
     if (
       !call.to ||
-      !isAddressEqual(call.to, Addresses.nativeMultisig) ||
+      !isAddressEqual(call.to, Addresses.configurableAccount) ||
       !call.data
     )
       continue
     const decoded = (() => {
       try {
-        return decodeFunctionData({ abi: Abis.nativeMultisig, data: call.data })
+        return decodeFunctionData({
+          abi: Abis.configurableAccount,
+          data: call.data,
+        })
       } catch {
         return undefined
       }
@@ -855,6 +866,52 @@ declare namespace cacheNextConfigs {
   }
 }
 
+/** Caches the config installed by a root-signed account upgrade. */
+// biome-ignore lint/correctness/noUnusedVariables: declaration merge
+async function cacheUpgradeConfig(options: cacheUpgradeConfig.Options) {
+  const { calls, from, signature } = options.transaction
+  const [call] = calls
+  if (
+    !from ||
+    !signature ||
+    signature.type === 'keychain' ||
+    calls.length !== 1 ||
+    !call?.to ||
+    !isAddressEqual(call.to, Addresses.configurableAccount) ||
+    !call.data
+  )
+    return
+  const config = (() => {
+    try {
+      const decoded = decodeFunctionData({
+        abi: Abis.configurableAccount,
+        data: call.data,
+      })
+      if (decoded.functionName !== 'upgradeAccount') return undefined
+      const [threshold, owners] = decoded.args
+      return AccountConfig.fromUpgrade(from, { owners, threshold })
+    } catch {
+      return undefined
+    }
+  })()
+  if (!config) return
+  await ConfigStore.write(options.store, {
+    address: from,
+    commitment: AccountConfig.getCommitment(config),
+    config,
+  })
+}
+
+declare namespace cacheUpgradeConfig {
+  /** Parameters for {@link cacheUpgradeConfig}. */
+  export type Options = {
+    /** Shared account store. */
+    store: Store.Store
+    /** Submitted transaction containing a potential account upgrade. */
+    transaction: Transaction.TransactionSerializableTempo
+  }
+}
+
 /** Validates primitive approvals and translates invalid input into an RPC error. @internal */
 export async function selectApprovals(
   options: AccountOperation.selectApprovals.Options,

package/tempo/internal/relay/feePayer.ts

@@ -174,8 +174,8 @@ export function create(options: Relay.feePayer.Options): Relay.Plugin {
         Object.assign(filled, { feeToken: token })
 
       const defer =
-        typeof normalized.multisigSimulation === 'object' &&
-        normalized.multisigSimulation !== null
+        typeof normalized.configurableAccountSimulation === 'object' &&
+        normalized.configurableAccountSimulation !== null
 
       // Bound before validation so the validated envelope is the one signed, and returned signatures expire.
       const signs = !!options.account && !external && !defer
@@ -237,8 +237,8 @@ export function create(options: Relay.feePayer.Options): Relay.Plugin {
         typeof parameters.feePayer === 'string' ||
         parameters.feePayer === false ||
         !result.capabilities?.sponsored ||
-        (typeof parameters.multisigSimulation === 'object' &&
-          parameters.multisigSimulation !== null)
+        (typeof parameters.configurableAccountSimulation === 'object' &&
+          parameters.configurableAccountSimulation !== null)
       )
         return undefined
       const transaction = Utils.normalizeTempoTransaction(result.tx)

package/utils/promise/withRetry.ts

@@ -39,6 +39,10 @@ export function withRetry<data>(
   }: WithRetryParameters = {},
 ) {
   return new Promise<data>((resolve, reject) => {
+    // Settles on abort even when `fn` ignores the signal.
+    const onAbort = () => reject(getAbortError(signal))
+    signal?.addEventListener('abort', onAbort, { once: true })
+
     const attemptRetry = async ({ count = 0 } = {}): Promise<void> => {
       if (signal?.aborted) {
         reject(getAbortError(signal))
@@ -79,6 +83,8 @@ export function withRetry<data>(
         reject(err)
       }
     }
-    void attemptRetry().catch(reject)
+    void attemptRetry()
+      .catch(reject)
+      .finally(() => signal?.removeEventListener('abort', onAbort))
   })
 }