viem 2.57.7 → 2.57.10

package/tempo/accounts/Config.ts

@@ -4,7 +4,7 @@ import type * as Hex from 'ox/Hex'
 import * as Json from 'ox/Json'
 import { AccountConfig } from 'ox/tempo'
 import { BaseError } from '../../errors/base.js'
-import { nativeMultisigFactory } from '../Addresses.js'
+import { configurableAccountRecoveryFactory } from '../Addresses.js'
 import type * as Store from '../Store.js'
 
 /** A valid 48-owner config is much smaller; 64 KiB bounds hostile store parsing work. */
@@ -78,7 +78,9 @@ function assertKey(options: {
   if (config.version === 0n) {
     if (
       !Address.isEqual(
-        AccountConfig.getAddress(config, { factory: nativeMultisigFactory }),
+        AccountConfig.getAddress(config, {
+          factory: configurableAccountRecoveryFactory,
+        }),
         address,
       )
     )
@@ -106,7 +108,7 @@ function deserialize(value: string): AccountConfig.Config {
 /** Returns the store key for an account and config commitment. */
 function key(options: { address: Address.Address; commitment: Hex.Hex }) {
   const { address, commitment } = options
-  return `multisig:config:${address.toLowerCase()}:${commitment.toLowerCase()}`
+  return `configurableAccount:config:${address.toLowerCase()}:${commitment.toLowerCase()}`
 }
 
 /** Serializes an account config for storage. */

package/tempo/accounts/Operation.ts

@@ -173,12 +173,12 @@ function assertHash(operation: AccountOperation.Operation) {
 
 /** Returns the store key for an operation hash. */
 function operationKey(hash: Hex.Hex) {
-  return `multisig:operation:${hash.toLowerCase()}`
+  return `configurableAccount:operation:${hash.toLowerCase()}`
 }
 
 /** Returns the store key for a submission attempt. */
 function submissionKey(hash: Hex.Hex, submissionId: Hex.Hex) {
-  return `multisig:submission:${hash.toLowerCase()}:${submissionId.toLowerCase()}`
+  return `configurableAccount:submission:${hash.toLowerCase()}:${submissionId.toLowerCase()}`
 }
 
 /** Thrown when a stored account operation is malformed or unsupported. */

package/tempo/actions/accessKey.ts

@@ -55,7 +55,6 @@ import {
   formatAmount,
   formatTime,
   getFeeToken,
-  isTip20,
   type Resolvers,
   withExecutionError,
 } from '../internal/errors.js'
@@ -64,7 +63,7 @@ import type {
   ReadParameters,
   WriteParameters,
 } from '../internal/types.js'
-import { defineCall } from '../internal/utils.js'
+import { defineCall, isTip20 } from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
 import { getConfig } from './accounts.js'
 
@@ -73,6 +72,7 @@ const signatureTypes = {
   0: 'secp256k1',
   1: 'p256',
   2: 'webAuthn',
+  3: 'configurable',
 } as const satisfies Record<number, string>
 
 /** @internal */
@@ -559,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/actions/receivePolicy.ts

@@ -29,7 +29,7 @@ import type {
   ReadParameters,
   WriteParameters,
 } from '../internal/types.js'
-import { defineCall } from '../internal/utils.js'
+import { defineCall, isTip20 } from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
 
 /** TIP-403 policy type. */
@@ -59,9 +59,6 @@ export type BlockedReason = ReceivePolicyReceipt.BlockedReason
 /** @internal */
 const blockedReasons = ['none', 'tokenFilter', 'receivePolicy'] as const
 
-/** @internal 12-byte prefix shared by TIP-20 token addresses. */
-const tip20Prefix = '0x20c000000000000000000000'
-
 /** @internal */
 const systemPrecompiles = [
   Addresses.accountKeychain,
@@ -1300,7 +1297,7 @@ function assertValidRecoveryAuthority(recoveryAuthority: Address) {
   if (isAddressEqual(recoveryAuthority, zeroAddress)) return
   if (VirtualAddress.isVirtual(recoveryAuthority))
     throw new Error('Recovery authority cannot be a TIP-1022 virtual address.')
-  if (recoveryAuthority.toLowerCase().startsWith(tip20Prefix))
+  if (isTip20(recoveryAuthority))
     throw new Error('Recovery authority cannot be a TIP-20 token address.')
   if (
     systemPrecompiles.some((address) =>

package/tempo/actions/token.ts

@@ -49,7 +49,6 @@ import type * as Errors from '../errors.js'
 import { TempoExecutionError } from '../errors.js'
 import {
   formatAmount,
-  isTip20,
   type Resolvers,
   withExecutionError,
 } from '../internal/errors.js'
@@ -64,6 +63,7 @@ import {
   type CallParameters,
   defineCall,
   findDeclaredToken,
+  isTip20,
   pickWriteParameters,
   resolveCallParameters,
   resolveToken,

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,10 +25,14 @@ 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'
+import { transactionReplacement } from './internal/replacement.js'
 import * as Transaction from './Transaction.js'
 
 const maxExpirySecs = 25
@@ -313,13 +320,19 @@ export const chainConfig = {
       } as never)
     },
   },
+  transactionReplacement,
   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
       }
@@ -368,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/errors.ts

@@ -85,11 +85,6 @@ export function getFeeToken(context: Context) {
     : TokenId.toAddress(feeToken)
 }
 
-/** Whether `address` is a TIP-20 token. */
-export function isTip20(address: Address | undefined): address is Address {
-  return !!address?.toLowerCase().startsWith('0x20c0')
-}
-
 /** Formats an amount as `formatted (raw)` when decimals are known. */
 export function formatAmount(
   value: bigint | undefined,