viem 2.57.4 → 2.57.6

package/tempo/Decorator.ts

@@ -4,13 +4,13 @@ import { bindActionDecorators, type Client } from '../clients/createClient.js'
 import type { Transport } from '../clients/transports/createTransport.js'
 import type { Chain } from '../types/chain.js'
 import * as accessKeyActions from './actions/accessKey.js'
+import * as accountsActions from './actions/accounts.js'
 import * as ammActions from './actions/amm.js'
 import * as channelActions from './actions/channel.js'
 import * as dexActions from './actions/dex.js'
 import * as earnActions from './actions/earn.js'
 import * as faucetActions from './actions/faucet.js'
 import * as feeActions from './actions/fee.js'
-import * as multisigActions from './actions/multisig.js'
 import * as nonceActions from './actions/nonce.js'
 import * as policyActions from './actions/policy.js'
 import * as propAmmActions from './actions/propAmm.js'
@@ -308,13 +308,41 @@ type DecoratorBase<
       parameters: accessKeyActions.revokeSync.Parameters<chain, account>,
     ) => Promise<accessKeyActions.revokeSync.ReturnValue>
     /**
-     * Signs a key authorization or adds one coordinated multisig approval.
+     * Saves a signed key authorization to a relay with key authorization storage.
+     *
+     * The relay attaches the authorization to the access key's next transaction
+     * until the key is active onchain. Requires a relay running the
+     * `Relay.keyAuthorization` plugin.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions, withRelay } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   chain: tempo,
+     *   transport: withRelay(http(), http('https://relay.example.com'), {
+     *     keyAuthorization: true,
+     *   }),
+     * }).extend(tempoActions())
+     *
+     * await client.accessKey.saveAuthorization({ keyAuthorization })
+     * ```
+     *
+     * @param parameters - Parameters.
+     */
+    saveAuthorization: (
+      parameters: accessKeyActions.saveAuthorization.Parameters,
+    ) => Promise<accessKeyActions.saveAuthorization.ReturnValue>
+    /**
+     * Signs a key authorization or adds one coordinated owner approval.
      *
      * @example
      * ```ts
      * const pending = await client.accessKey.signAuthorization({
      *   accessKey,
-     *   account: multisig,
+     *   account: configurable,
      *   owner: owner_1,
      * })
      * const success = await client.accessKey.signAuthorization({
@@ -324,7 +352,7 @@ type DecoratorBase<
      * ```
      *
      * @param parameters - Authorization fields, or a stored operation hash.
-     * @returns A signed key authorization with multisig operation metadata when coordinated.
+     * @returns A signed key authorization with account operation metadata when coordinated.
      */
     signAuthorization: {
       (
@@ -474,6 +502,48 @@ type DecoratorBase<
       parameters: accessKeyActions.watchWitnessBurned.Parameters,
     ) => ReturnType<typeof accessKeyActions.watchWitnessBurned>
   }
+  accounts: {
+    /**
+     * Gets the current cached config for a configurable account.
+     *
+     * @param parameters - Parameters.
+     * @returns The config, or `null` when it is unknown.
+     */
+    getConfig: (
+      parameters: accountsActions.getConfig.Parameters,
+    ) => Promise<accountsActions.getConfig.ReturnValue>
+    /** Gets the current configuration commitment for a configurable account. */
+    getConfigCommitment: (
+      parameters: accountsActions.getConfigCommitment.Parameters,
+    ) => Promise<accountsActions.getConfigCommitment.ReturnValue>
+    /**
+     * Gets a coordinated account operation by its hash.
+     *
+     * @param parameters - Parameters.
+     * @returns The operation, or `null` when it is unknown.
+     */
+    getOperation: (
+      parameters: accountsActions.getOperation.Parameters,
+    ) => Promise<accountsActions.getOperation.ReturnValue>
+    /**
+     * Replaces the current configuration for a configurable account.
+     *
+     * @param parameters - New configuration and transaction parameters.
+     * @returns The transaction hash.
+     */
+    updateConfig: (
+      parameters: accountsActions.updateConfig.Parameters<chain, account>,
+    ) => Promise<accountsActions.updateConfig.ReturnValue>
+    /**
+     * Replaces a configurable account configuration and waits for confirmation.
+     *
+     * @param parameters - New configuration and transaction parameters.
+     * @returns The update event and transaction receipt.
+     */
+    updateConfigSync: (
+      parameters: accountsActions.updateConfigSync.Parameters<chain, account>,
+    ) => Promise<accountsActions.updateConfigSync.ReturnValue>
+  }
   amm: {
     /**
      * Gets the reserves for a liquidity pool.
@@ -2392,48 +2462,6 @@ type DecoratorBase<
       parameters: faucetActions.fundSync.Parameters,
     ) => Promise<faucetActions.fundSync.ReturnValue>
   }
-  multisig: {
-    /**
-     * Gets the current cached config for a multisig account.
-     *
-     * @param parameters - Parameters.
-     * @returns The config, or `null` when it is unknown.
-     */
-    getConfig: (
-      parameters: multisigActions.getConfig.Parameters,
-    ) => Promise<multisigActions.getConfig.ReturnValue>
-    /** Gets the current configuration commitment for a multisig account. */
-    getConfigCommitment: (
-      parameters: multisigActions.getConfigCommitment.Parameters,
-    ) => Promise<multisigActions.getConfigCommitment.ReturnValue>
-    /**
-     * Gets a coordinated multisig operation by its hash.
-     *
-     * @param parameters - Parameters.
-     * @returns The operation, or `null` when it is unknown.
-     */
-    getOperation: (
-      parameters: multisigActions.getOperation.Parameters,
-    ) => Promise<multisigActions.getOperation.ReturnValue>
-    /**
-     * Replaces the current configuration for a native multisig account.
-     *
-     * @param parameters - New configuration and transaction parameters.
-     * @returns The transaction hash.
-     */
-    updateConfig: (
-      parameters: multisigActions.updateConfig.Parameters<chain, account>,
-    ) => Promise<multisigActions.updateConfig.ReturnValue>
-    /**
-     * Replaces a native multisig configuration and waits for confirmation.
-     *
-     * @param parameters - New configuration and transaction parameters.
-     * @returns The update event and transaction receipt.
-     */
-    updateConfigSync: (
-      parameters: multisigActions.updateConfigSync.Parameters<chain, account>,
-    ) => Promise<multisigActions.updateConfigSync.ReturnValue>
-  }
   nonce: {
     /**
      * Gets the nonce for an account and nonce key.
@@ -6049,9 +6077,11 @@ type DecorateNamespace<namespace, actions> = {
     ? namespace[key] & BoundActionHelpers<actions[key]>
     : namespace[key]
 } & {
-  [key in Exclude<keyof actions, keyof namespace> as actions[key] extends (
-    ...parameters: any
-  ) => any
+  // Error classes and resolvers are not actions; skipping them by name avoids evaluating their types.
+  [key in Exclude<
+    keyof actions,
+    keyof namespace | `${string}Error` | 'errorResolvers'
+  > as actions[key] extends (...parameters: any) => any
     ? key
     : never]: BoundAction<actions[key]>
 }
@@ -6064,6 +6094,10 @@ export type Decorator<
     DecoratorBase<chain, account>['accessKey'],
     typeof accessKeyActions
   >
+  accounts: DecorateNamespace<
+    DecoratorBase<chain, account>['accounts'],
+    typeof accountsActions
+  >
   amm: DecorateNamespace<
     DecoratorBase<chain, account>['amm'],
     typeof ammActions
@@ -6084,10 +6118,6 @@ export type Decorator<
     DecoratorBase<chain, account>['faucet'],
     typeof faucetActions
   >
-  multisig: DecorateNamespace<
-    DecoratorBase<chain, account>['multisig'],
-    typeof multisigActions
-  >
   nonce: DecorateNamespace<
     DecoratorBase<chain, account>['nonce'],
     typeof nonceActions
@@ -6166,6 +6196,7 @@ export function decorator() {
         'prepareAuthorization',
         'revoke',
         'revokeSync',
+        'saveAuthorization',
         'signAuthorization',
         'updateLimit',
         'updateLimitSync',
@@ -6174,6 +6205,13 @@ export function decorator() {
         'watchWitness',
         'watchWitnessBurned',
       ]),
+      accounts: bindActions(client, accountsActions, [
+        'getConfig',
+        'getConfigCommitment',
+        'getOperation',
+        'updateConfig',
+        'updateConfigSync',
+      ]),
       amm: bindActions(client, ammActions, [
         'getPool',
         'getLiquidityBalance',
@@ -6262,13 +6300,6 @@ export function decorator() {
         'withdrawExactSync',
       ]),
       faucet: bindActions(client, faucetActions, ['fund', 'fundSync']),
-      multisig: bindActions(client, multisigActions, [
-        'getConfig',
-        'getConfigCommitment',
-        'getOperation',
-        'updateConfig',
-        'updateConfigSync',
-      ]),
       nonce: bindActions(client, nonceActions, [
         'getNonce',
         'watchNonceIncremented',

package/tempo/ExecutionError.ts

@@ -8,7 +8,7 @@ import { formatAbiItem } from '../utils/abi/formatAbiItem.js'
 import { toFunctionSelector } from '../utils/hash/toFunctionSelector.js'
 import * as Abis from './Abis.js'
 
-type AllAbis = typeof Abis.core
+type AllAbis = typeof Abis.coreErrors
 type AbiErrorName = Extract<AllAbis[number], { type: 'error' }>['name']
 
 type DecodedError<error = DecodeErrorResultReturnType<AllAbis>> =
@@ -114,7 +114,7 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'InvalidMasterAddress()': 'Invalid master address.',
   'InvalidMigrationIndex()': 'Invalid migration index.',
   'InvalidMode()': 'Invalid mode.',
-  'InvalidMultisigOwner()': 'Invalid multisig owner.',
+  'InvalidMultisigOwner()': 'Invalid owner.',
   'InvalidNonceKey()': 'Invalid nonce key.',
   'InvalidOwner()': 'Invalid owner.',
   'InvalidOwnerOrder()': 'Invalid owner order.',
@@ -230,6 +230,88 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'ZeroPublicKey()': 'Public key cannot be zero.',
 }
 
+/** Steps to resolve an error, keyed by error signature in `Abis.core`. */
+export const hints: Partial<Record<keyof typeof messages, readonly string[]>> =
+  {
+    'CallNotAllowed()': [
+      "The access key's scopes do not allow this target, selector, or recipient.",
+      'Authorize an access key whose scopes include this call.',
+    ],
+    'ContractPaused()': [
+      'The token is paused. An account with the unpause role can unpause it.',
+    ],
+    'ExpiringNonceReplay()': ['Resend the transaction with a new nonce.'],
+    'ExpiryInPast()': ['Set the expiry to a future time.'],
+    'InsufficientAllowance()': [
+      'Approve the spender for at least this amount.',
+    ],
+    'InsufficientBalance(uint256,uint256,address)': [
+      'Fund the account or lower the amount.',
+    ],
+    'InsufficientFeeTokenBalance()': [
+      'Fund the account with the fee token, or pay fees with another token.',
+    ],
+    'KeyAlreadyExists()': ['Use a new access key, or revoke the existing one.'],
+    'KeyAlreadyRevoked()': [
+      'Revoked access keys cannot be used or re-authorized. Authorize a new access key.',
+    ],
+    'KeyExpired()': ['Authorize a new access key.'],
+    'KeyNotFound()': [
+      'Authorize the access key first, or authorize it in the same transaction with a key authorization.',
+    ],
+    'PolicyForbids()': [
+      'The token transfer policy forbids this sender or recipient.',
+    ],
+    'SpendingLimitExceeded()': [
+      'Raise the spending limit, or wait for a periodic limit to reset.',
+    ],
+    'UnauthorizedCaller()': ['Sign with the root key or an admin access key.'],
+    'AmountExceedsDeposit()': [
+      'Top up the channel, or use a voucher for a smaller amount.',
+    ],
+    'AmountNotIncreasing()': [
+      'Use a voucher with a higher cumulative amount than the amount already settled.',
+    ],
+    'BelowMinimumOrderSize(uint128)': ['Place a larger order.'],
+    'ChannelNotFound()': [
+      'Check the channel details, or open the channel first.',
+    ],
+    'CloseNotReady()': [
+      'Request a close, then wait for the grace period to end before withdrawing.',
+    ],
+    'InsufficientBalance()': [
+      'Deposit more of the token, or lower the amount.',
+    ],
+    'InsufficientLiquidity()': ['Use a smaller amount.'],
+    'InsufficientOutput()': [
+      'Lower the minimum output amount, or sell a smaller amount.',
+    ],
+    'InsufficientReserves()': ['Use a smaller amount.'],
+    'InvalidExpiringNonceExpiry()': [
+      'Set the transaction expiry to a time in the near future.',
+    ],
+    'InvalidFlipTick()': [
+      'Choose a flip tick on the correct side of the order tick.',
+    ],
+    'MaxInputExceeded()': [
+      'Raise the maximum input amount, or buy a smaller amount.',
+    ],
+    'OrderDoesNotExist()': [
+      'Check the order ID. Filled and cancelled orders no longer exist.',
+    ],
+    'OrderNotStale()': [
+      'Only orders whose maker lost authorization can be cancelled as stale.',
+    ],
+    'PairDoesNotExist()': ['Create the trading pair first.'],
+    'PolicyNotFound()': ['Check the policy ID, or create the policy first.'],
+    'SignatureTypeMismatch(uint8,uint8)': [
+      'Sign with the same key type the access key was authorized with.',
+    ],
+    'SupplyCapExceeded()': ['Mint a smaller amount, or raise the supply cap.'],
+    'TickOutOfBounds(int16)': ['Use a tick within the allowed range.'],
+    'Unauthorized()': ['The account lacks the permission this call requires.'],
+  }
+
 /** Interpolate `{0}`, `{1}`, … placeholders with args. */
 function interpolate(template: string, args?: readonly unknown[]): string {
   if (!args) return template
@@ -370,7 +452,7 @@ function parse(error: Exclude<from.Parameters, Hex>): ExecutionError {
   const data = extractRevertData(error)
   if (data) {
     try {
-      const decoded = decodeErrorResult({ abi: Abis.core, data })
+      const decoded = decodeErrorResult({ abi: Abis.coreErrors, data })
       const template =
         messages[formatAbiItem(decoded.abiItem) as keyof typeof messages]
       return {
@@ -382,7 +464,7 @@ function parse(error: Exclude<from.Parameters, Hex>): ExecutionError {
       } as never
     } catch {
       if (data.length === 10) {
-        const abiItem = Abis.core.find(
+        const abiItem = Abis.coreErrors.find(
           (item) =>
             item.type === 'error' &&
             toFunctionSelector(formatAbiItem(item)) === data.toLowerCase(),
@@ -399,6 +481,22 @@ function parse(error: Exclude<from.Parameters, Hex>): ExecutionError {
     }
   }
 
+  // Nodes print zero-argument errors as `Name(Name)`, whose revert data is the selector alone.
+  const debugMatch = /\b(\w+)\(\1\)/.exec(raw)
+  const abiItem = debugMatch
+    ? Abis.coreErrors.find(
+        (item) => item.name === debugMatch[1] && item.inputs.length === 0,
+      )
+    : undefined
+  if (abiItem)
+    return {
+      abiItem,
+      args: undefined,
+      data: toFunctionSelector(formatAbiItem(abiItem)),
+      errorName: abiItem.name,
+      message: messages[formatAbiItem(abiItem) as keyof typeof messages]!,
+    } as DecodedError
+
   // Human-readable names cannot distinguish overloads with different templates.
   const nameMatch = /:\s*(\w+)\(([^)]*)\)/.exec(raw)
   if (nameMatch) {

package/tempo/Formatters.ts

@@ -3,7 +3,7 @@
 import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
 import {
-  MultisigOperation,
+  AccountOperation,
   Transaction as ox_Transaction,
   TransactionRequest as ox_TransactionRequest,
 } from 'ox/tempo'
@@ -12,7 +12,7 @@ import { parseAccount } from '../accounts/utils/parseAccount.js'
 import { formatTransaction as viem_formatTransaction } from '../utils/formatters/transaction.js'
 import { formatTransactionReceipt as viem_formatTransactionReceipt } from '../utils/formatters/transactionReceipt.js'
 import { formatTransactionRequest as viem_formatTransactionRequest } from '../utils/formatters/transactionRequest.js'
-import type { Account, MultisigAccount } from './Account.js'
+import type { Account, ConfigurableAccount } from './Account.js'
 import {
   isTempo,
   type Transaction,
@@ -33,7 +33,7 @@ export function formatTransaction(
     transaction.blockTimestamp == null
       ? undefined
       : BigInt(transaction.blockTimestamp)
-  const multisig = transaction.multisig
+  const operation = transaction.operation
   const {
     feePayerSignature,
     gasPrice: _,
@@ -53,8 +53,8 @@ export function formatTransaction(
           yParity: feePayerSignature.yParity,
         }
       : undefined,
-    multisig: formatMultisig(multisig),
     nonce: Number(nonce),
+    operation: formatOperation(operation),
     typeHex:
       ox_Transaction.toRpcType[
         tx.type as keyof typeof ox_Transaction.toRpcType
@@ -69,7 +69,7 @@ export function formatTransactionReceipt(
   const transactionReceipt = viem_formatTransactionReceipt(receipt as never)
   return {
     ...transactionReceipt,
-    multisig: formatMultisig(receipt.multisig),
+    operation: formatOperation(receipt.operation),
     ...(receipt.status === 'pending'
       ? { status: 'pending', type: 'tempo' }
       : {}),
@@ -77,11 +77,11 @@ export function formatTransactionReceipt(
 }
 
 /** Formats a transaction operation attached to an RPC result. */
-function formatMultisig(value: MultisigOperation.TransactionRpc | undefined) {
+function formatOperation(value: AccountOperation.TransactionRpc | undefined) {
   if (!value) return undefined
-  const operation = MultisigOperation.fromRpc(value)
+  const operation = AccountOperation.fromRpc(value)
   if (operation.type !== 'transaction')
-    throw new Error('Expected a multisig transaction operation.')
+    throw new Error('Expected an account transaction operation.')
   return operation
 }
 
@@ -98,21 +98,21 @@ export function formatTransactionRequest(
     keyData?: Hex.Hex | undefined
     keyId?: Address | undefined
     keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
-    owner?: viem_Account | MultisigAccount | Address | undefined
+    owner?: viem_Account | ConfigurableAccount | Address | undefined
     signatures?: unknown
   }
   const account = request.account
     ? parseAccount<Account | viem_Account | Address>(request.account)
     : undefined
   const owner = request.owner
-    ? parseAccount<Account | MultisigAccount | viem_Account | Address>(
+    ? parseAccount<Account | ConfigurableAccount | viem_Account | Address>(
         request.owner,
       )
     : undefined
 
   if (owner?.type === 'json-rpc')
     throw new Error(
-      'A local owner account is required to approve a multisig transaction.',
+      'A local owner account is required to approve a configurable account transaction.',
     )
 
   // If the request is not a Tempo transaction, route to Viem formatter.
@@ -147,7 +147,7 @@ export function formatTransactionRequest(
   if (request.feePayer === true && !request.feePayerSignature)
     delete request.feeToken
 
-  // Client-only TIP-1061 fields drive local signing and envelope assembly.
+  // Client-only TIP-1107 fields drive local signing and envelope assembly.
   const { owner: _owner, signatures: _signatures, ...rpcRequest } = request
 
   const rpc = ox_TransactionRequest.toRpc({
@@ -191,7 +191,8 @@ export function formatTransactionRequest(
     ...(keyData ? { keyData } : {}),
     ...(keyId ? { keyId } : {}),
     ...(keyType ? { keyType } : {}),
-    // Keep the key visible to `extract`; the undefined value never reaches JSON-RPC.
+    // Keep client-only keys visible to `extract`; undefined values never reach JSON-RPC.
+    ...(request.accountSimulation ? { accountSimulation: undefined } : {}),
     ...(request.owner ? { owner: undefined } : {}),
     ...(typeof request.feePayer !== 'undefined'
       ? {

package/tempo/KeyAuthorizationManager.ts

@@ -1,49 +1,101 @@
 import type { Address } from 'abitype'
-import type { KeyAuthorization } from 'ox/tempo'
+import { KeyAuthorization } from 'ox/tempo'
 import type { MaybePromise } from '../types/utils.js'
+import * as Store from './Store.js'
 
+/** Identifies a pending key authorization by account, access key, and chain. */
 export type Key = {
+  /** Account the access key acts for. */
   address: Address
+  /** Access key address. */
   accessKey: Address
+  /** Chain the authorization is for. */
   chainId: number
 }
 
+/** Pending key authorizations that the client attaches to an access key's next transaction. */
 export type KeyAuthorizationManager = {
+  /** Reads the pending authorization for a key. */
   get(key: Key): MaybePromise<KeyAuthorization.Signed | undefined>
+  /** Removes the pending authorization for a key. */
   remove(key: Key): MaybePromise<void>
+  /** Stores a pending authorization for a key. */
   set(key: Key, keyAuthorization: KeyAuthorization.Signed): MaybePromise<void>
 }
 
+/**
+ * Creates a key authorization manager backed by a store.
+ *
+ * Entries use the same keys as the `Relay.keyAuthorization` plugin, so both can
+ * share one store.
+ *
+ * @example
+ * ```ts
+ * import { Account, KeyAuthorizationManager, Store } from 'viem/tempo'
+ *
+ * const accessKey = Account.fromP256(privateKey, {
+ *   access: root,
+ *   keyAuthorizationManager: KeyAuthorizationManager.from({
+ *     store: Store.session(),
+ *   }),
+ * })
+ * ```
+ *
+ * @param options - Manager options.
+ * @returns A key authorization manager.
+ */
 export function from(options: from.Options): KeyAuthorizationManager {
-  return options.source
+  const { store } = options
+  return {
+    async get(key) {
+      const value = await store.getItem(getStoreKey(key))
+      if (!value) return undefined
+      try {
+        return KeyAuthorization.deserialize(
+          value as `0x${string}`,
+        ) as KeyAuthorization.Signed
+      } catch {
+        return undefined
+      }
+    },
+    async remove(key) {
+      await store.removeItem(getStoreKey(key))
+    },
+    async set(key, keyAuthorization) {
+      await store.setItem(
+        getStoreKey(key),
+        KeyAuthorization.serialize(keyAuthorization),
+      )
+    },
+  }
 }
 
 export declare namespace from {
   type Options = {
-    source: KeyAuthorizationManager
+    /** Store for pending key authorizations. */
+    store: Store.Store
   }
 }
 
+/**
+ * Creates a key authorization manager backed by a process-local memory store.
+ *
+ * @example
+ * ```ts
+ * import { KeyAuthorizationManager } from 'viem/tempo'
+ *
+ * const keyAuthorizationManager = KeyAuthorizationManager.memory()
+ * ```
+ *
+ * @returns A key authorization manager.
+ */
 export function memory(): KeyAuthorizationManager {
-  const keyAuthorizations = new Map<string, KeyAuthorization.Signed>()
-
-  return from({
-    source: {
-      get(key) {
-        return keyAuthorizations.get(serializeKey(key))
-      },
-      remove(key) {
-        keyAuthorizations.delete(serializeKey(key))
-      },
-      set(key, keyAuthorization) {
-        keyAuthorizations.set(serializeKey(key), keyAuthorization)
-      },
-    },
-  })
+  return from({ store: Store.memory() })
 }
 
-function serializeKey(key: Key) {
+function getStoreKey(key: Key) {
   return [
+    'keyAuthorization',
     key.chainId,
     key.address.toLowerCase(),
     key.accessKey.toLowerCase(),