viem 2.57.3 → 2.57.5

package/tempo/actions/{multisig.ts → accounts.ts}

@@ -1,11 +1,7 @@
 import type { Address } from 'abitype'
 import type * as Hex from 'ox/Hex'
 import type * as RpcSchema from 'ox/RpcSchema'
-import {
-  MultisigConfig,
-  MultisigOperation,
-  type RpcSchemaTempo,
-} from 'ox/tempo'
+import { AccountConfig, AccountOperation, type RpcSchemaTempo } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import type { ReadContractReturnType } from '../../actions/public/readContract.js'
 import { readContract } from '../../actions/public/readContract.js'
@@ -20,14 +16,14 @@ import type { Log } from '../../types/log.js'
 import type { Compute } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
 import * as Abis from '../Abis.js'
-import { fromMultisig, type MultisigAccount } from '../Account.js'
+import { type ConfigurableAccount, fromConfig } from '../Account.js'
 import * as Addresses from '../Addresses.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type * as Transaction from '../Transaction.js'
 
 /**
- * Gets the current cached config for a multisig account.
+ * Gets the current cached config for a configurable account.
  *
  * The coordinator reads the account's current onchain commitment and returns
  * the matching config from its store. It returns `null` when the config is not
@@ -35,7 +31,7 @@ import type * as Transaction from '../Transaction.js'
  *
  * @example
  * ```ts
- * const config = await client.multisig.getConfig({
+ * const config = await client.accounts.getConfig({
  *   address: '0x...',
  * })
  * ```
@@ -49,32 +45,32 @@ export async function getConfig(
   parameters: getConfig.Parameters,
 ): Promise<getConfig.ReturnValue> {
   const config = await client.request<{
-    Method: 'multisig_getConfig'
+    Method: 'account_getConfig'
     Parameters: [{ address: Address }]
-    ReturnType: MultisigConfig.Rpc | null
+    ReturnType: AccountConfig.Rpc | null
   }>({
-    method: 'multisig_getConfig',
+    method: 'account_getConfig',
     params: [{ address: parameters.address }],
   })
-  return config ? MultisigConfig.fromRpc(config) : null
+  return config ? AccountConfig.fromRpc(config) : null
 }
 
 export declare namespace getConfig {
   /** Parameters for {@link getConfig}. */
   export type Parameters = {
-    /** Multisig account address. */
+    /** Configurable account address. */
     address: Address
   }
 
   /** Return value for {@link getConfig}. */
-  export type ReturnValue = MultisigConfig.Config | null
+  export type ReturnValue = AccountConfig.Config | null
 
   /** Error type for {@link getConfig}. */
   export type ErrorType = BaseErrorType
 }
 
 /**
- * Gets the current configuration commitment for a native multisig account.
+ * Gets the current configuration commitment for a configurable account.
  *
  * @example
  * ```ts
@@ -87,7 +83,7 @@ export declare namespace getConfig {
  *   transport: http(),
  * })
  *
- * const commitment = await Actions.multisig.getConfigCommitment(client, {
+ * const commitment = await Actions.accounts.getConfigCommitment(client, {
  *   account: '0x...',
  * })
  * ```
@@ -115,7 +111,7 @@ export namespace getConfigCommitment {
   export type Parameters = ReadParameters & Args
 
   export type Args = {
-    /** Initialized multisig account address. */
+    /** Initialized configurable account address. */
     account: Address
   }
 
@@ -144,7 +140,7 @@ export namespace getConfigCommitment {
 }
 
 /**
- * Gets a coordinated multisig operation by its hash.
+ * Gets a coordinated account operation by its hash.
  *
  * @param client - Client.
  * @param parameters - Parameters.
@@ -154,33 +150,33 @@ export async function getOperation(
   client: Client,
   parameters: getOperation.Parameters,
 ): Promise<getOperation.ReturnValue> {
-  type multisig_getOperation = Extract<
-    RpcSchema.ToViem<RpcSchemaTempo.Multisig>[number],
-    { Method: 'multisig_getOperation' }
+  type account_getOperation = Extract<
+    RpcSchema.ToViem<RpcSchemaTempo.Account>[number],
+    { Method: 'account_getOperation' }
   >
-  const operation = await client.request<multisig_getOperation>({
-    method: 'multisig_getOperation',
+  const operation = await client.request<account_getOperation>({
+    method: 'account_getOperation',
     params: [parameters.hash],
   })
-  return operation ? MultisigOperation.fromRpc(operation) : null
+  return operation ? AccountOperation.fromRpc(operation) : null
 }
 
 export declare namespace getOperation {
   /** Parameters for {@link getOperation}. */
   export type Parameters = {
-    /** Multisig operation hash. */
+    /** Account operation hash. */
     hash: Hex.Hex
   }
 
   /** Return value for {@link getOperation}. */
-  export type ReturnValue = MultisigOperation.Operation | null
+  export type ReturnValue = AccountOperation.Operation | null
 
   /** Error type for {@link getOperation}. */
   export type ErrorType = BaseErrorType
 }
 
 /**
- * Replaces the current configuration for a native multisig account.
+ * Replaces the current configuration for a configurable account.
  *
  * The transaction must be authorized directly by the account's current owner
  * quorum. Local owner-signing flows can include {@link updateConfig.call} in a
@@ -196,7 +192,7 @@ export declare namespace getOperation {
  * const owner = Account.fromSecp256k1(
  *   '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
  * )
- * const account = Account.fromMultisig({
+ * const account = Account.fromConfig({
  *   address: 'infer',
  *   owners: [owner],
  * })
@@ -210,7 +206,7 @@ export declare namespace getOperation {
  *   to: account.address,
  * })
  *
- * const hash = await Actions.multisig.updateConfig(client, {
+ * const hash = await Actions.accounts.updateConfig(client, {
  *   account,
  *   nextConfig: {
  *     owners: [{ owner: owner.address, weight: 1 }],
@@ -239,16 +235,16 @@ export namespace updateConfig {
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> & {
     /** Complete current config. Inferred from the account or coordinator when omitted. */
-    currentConfig?: MultisigConfig.Config | undefined
+    currentConfig?: AccountConfig.Config | undefined
     /** Replacement owners and threshold. */
-    nextConfig: Pick<MultisigConfig.Config, 'owners' | 'threshold'>
+    nextConfig: Pick<AccountConfig.Config, 'owners' | 'threshold'>
   }
 
   export type Args = {
     /** Complete current config. */
-    currentConfig: MultisigConfig.Config
+    currentConfig: AccountConfig.Config
     /** Replacement owners and threshold. */
-    nextConfig: Pick<MultisigConfig.Config, 'owners' | 'threshold'>
+    nextConfig: Pick<AccountConfig.Config, 'owners' | 'threshold'>
   }
 
   export type ReturnValue = WriteContractReturnType
@@ -276,9 +272,9 @@ export namespace updateConfig {
     const account = (() => {
       if (
         typeof accountValue === 'object' &&
-        accountValue.source === 'multisig'
+        accountValue.source === 'configurable'
       )
-        return accountValue as MultisigAccount
+        return accountValue as ConfigurableAccount
       return undefined
     })()
     const config = (() => {
@@ -293,22 +289,22 @@ export namespace updateConfig {
       return undefined
     })()
     const currentConfig = await (async () => {
-      if (config) return MultisigConfig.from(config)
+      if (config) return AccountConfig.from(config)
       if (!address)
         throw new Error(
-          'A multisig account address or current config is required.',
+          'A configurable account address or current config is required.',
         )
       const cachedConfig = await getConfig(client, { address })
       if (!cachedConfig)
         throw new Error(
-          `No current multisig config is cached for account ${address}. Provide the current config.`,
+          `No current account config is cached for account ${address}. Provide the current config.`,
         )
       return cachedConfig
     })()
     const resolvedAccount = (() => {
       if (account) return { ...account, config: currentConfig }
       if (typeof accountValue === 'object') return accountValue
-      if (address) return fromMultisig({ address, ...currentConfig })
+      if (address) return fromConfig({ address, ...currentConfig })
       return undefined
     })()
     return (await action(client, {
@@ -328,11 +324,11 @@ export namespace updateConfig {
    *
    * @example
    * ```ts
-   * import { Actions, type MultisigConfig } from 'viem/tempo'
+   * import { Actions, type AccountConfig } from 'viem/tempo'
    *
-   * declare const currentConfig: MultisigConfig.Config
+   * declare const currentConfig: AccountConfig.Config
    *
-   * const call = Actions.multisig.updateConfig.call({
+   * const call = Actions.accounts.updateConfig.call({
    *   currentConfig,
    *   nextConfig: {
    *     owners: [{ owner: '0x...', weight: 1 }],
@@ -341,17 +337,12 @@ export namespace updateConfig {
    * })
    * ```
    *
-   * @param args - Current and replacement multisig configurations.
+   * @param args - Current and replacement account configurations.
    * @returns The call.
    */
   export function call(args: Args) {
-    const currentConfig = MultisigConfig.from(args.currentConfig)
-    const nextConfig = MultisigConfig.from({
-      owners: args.nextConfig.owners,
-      salt: currentConfig.salt,
-      threshold: args.nextConfig.threshold,
-      version: currentConfig.version + 1n,
-    })
+    const currentConfig = AccountConfig.from(args.currentConfig)
+    const nextConfig = AccountConfig.update(currentConfig, args.nextConfig)
     return defineCall({
       address: Addresses.nativeMultisig,
       abi: Abis.nativeMultisig,
@@ -379,16 +370,16 @@ export namespace updateConfig {
 }
 
 /**
- * Replaces a native multisig configuration and waits for confirmation.
+ * Replaces a configurable account configuration and waits for confirmation.
  *
  * @example
  * ```ts
  * import { createWalletClient, custom, type EIP1193Provider } from 'viem'
  * import { tempo } from 'viem/chains'
- * import { Actions, type MultisigConfig } from 'viem/tempo'
+ * import { Actions, type AccountConfig } from 'viem/tempo'
  *
  * declare const provider: EIP1193Provider
- * declare const currentConfig: MultisigConfig.Config
+ * declare const currentConfig: AccountConfig.Config
  *
  * const client = createWalletClient({
  *   account: '0x...',
@@ -396,7 +387,7 @@ export namespace updateConfig {
  *   transport: custom(provider),
  * })
  *
- * const { receipt } = await Actions.multisig.updateConfigSync(client, {
+ * const { receipt } = await Actions.accounts.updateConfigSync(client, {
  *   currentConfig,
  *   nextConfig: {
  *     owners: [{ owner: '0x...', weight: 1 }],
@@ -426,7 +417,7 @@ export async function updateConfigSync<
   const { args } = updateConfig.extractEvent(receipt.logs)
   return {
     account: args.account,
-    config: MultisigConfig.from({
+    config: AccountConfig.from({
       owners: args.owners,
       salt: args.salt,
       threshold: args.threshold,
@@ -446,7 +437,7 @@ export namespace updateConfigSync {
 
   export type ReturnValue = Compute<{
     account: Address
-    config: MultisigConfig.Config
+    config: AccountConfig.Config
     receipt: Transaction.TransactionReceipt
   }>
 

package/tempo/actions/index.ts

@@ -1,12 +1,12 @@
 // biome-ignore lint/performance/noBarrelFile: _
 export * as accessKey from './accessKey.js'
+export * as accounts from './accounts.js'
 export * as amm from './amm.js'
 export * as channel from './channel.js'
 export * as dex from './dex.js'
 export * as earn from './earn.js'
 export * as faucet from './faucet.js'
 export * as fee from './fee.js'
-export * as multisig from './multisig.js'
 export * as nonce from './nonce.js'
 export * as policy from './policy.js'
 export * as propAmm from './propAmm.js'

package/tempo/chainConfig.ts

@@ -1,9 +1,9 @@
 import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
 import {
-  MultisigConfig,
-  MultisigOperation,
-  type MultisigSimulation,
+  AccountConfig,
+  AccountOperation,
+  type AccountSimulation,
   SignatureEnvelope,
   type TokenId,
 } from 'ox/tempo'
@@ -20,9 +20,9 @@ import { defineTransactionRequest } from '../utils/formatters/transactionRequest
 import { getAction } from '../utils/getAction.js'
 import { keccak256 } from '../utils/hash/keccak256.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
-import type { Account, MultisigAccount } from './Account.js'
+import type { Account, ConfigurableAccount } from './Account.js'
 import { getMetadata } from './actions/accessKey.js'
-import { getConfig } from './actions/multisig.js'
+import { getConfig } from './actions/accounts.js'
 import * as Formatters from './Formatters.js'
 import type { Hardfork } from './Hardfork.js'
 import * as Concurrent from './internal/concurrent.js'
@@ -55,7 +55,7 @@ export const chainConfig = {
   prepareTransactionRequest: [
     async (r, { client, phase }) => {
       const request = r as Transaction.TransactionRequest & {
-        account?: Account | MultisigAccount | undefined
+        account?: Account | ConfigurableAccount | undefined
         chainId?: number | undefined
         chain?:
           | (Chain & {
@@ -67,8 +67,8 @@ export const chainConfig = {
         hash?: Hex.Hex | undefined
         keyData?: Hex.Hex | undefined
         keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
-        multisigSimulation?: MultisigSimulation.Spec | undefined
-        owner?: Account | MultisigAccount | Address | undefined
+        accountSimulation?: AccountSimulation.Spec | undefined
+        owner?: Account | ConfigurableAccount | Address | undefined
         signatures?: readonly unknown[] | undefined
       }
 
@@ -76,18 +76,18 @@ export const chainConfig = {
         if (
           !request.account ||
           typeof request.account === 'string' ||
-          request.account.source !== 'multisig'
+          request.account.source !== 'configurable'
         )
           throw new Error(
-            'A local multisig account is required to approve a stored multisig transaction.',
+            'A local configurable account is required to approve a stored configurable account transaction.',
           )
         if (!request.owner || typeof request.owner === 'string')
           throw new Error(
-            'A local owner account is required to approve a stored multisig transaction.',
+            'A local owner account is required to approve a stored configurable account transaction.',
           )
         if (request.owner.source !== 'root')
           throw new Error(
-            'A Tempo owner account is required to approve a stored multisig transaction.',
+            'A Tempo owner account is required to approve a stored configurable account transaction.',
           )
         const transaction = await getAction(
           client,
@@ -95,28 +95,28 @@ export const chainConfig = {
           'getTransaction',
         )({ hash: request.hash })
         const operation =
-          'multisig' in transaction
-            ? (transaction.multisig as
-                | MultisigOperation.TransactionOperation
+          'operation' in transaction
+            ? (transaction.operation as
+                | AccountOperation.TransactionOperation
                 | undefined)
             : undefined
         if (!operation)
-          throw new Error('Expected a multisig operation transaction.')
+          throw new Error('Expected an account operation transaction.')
         if (!isAddressEqual(operation.account, request.account.address))
           throw new Error(
-            'Multisig operation account does not match the requested account.',
+            'Account operation account does not match the requested account.',
           )
         const storedTransaction = Transaction.deserialize(
           operation.transaction as Transaction.TransactionSerializedTempo,
         )
-        const hash = MultisigOperation.getHash({
+        const hash = AccountOperation.getHash({
           account: operation.account,
           config: operation.config,
           transaction: operation.transaction,
           type: 'transaction',
         })
         if (hash.toLowerCase() !== request.hash.toLowerCase())
-          throw new Error('Multisig operation hash does not match transaction.')
+          throw new Error('Account operation hash does not match transaction.')
         return {
           ...storedTransaction,
           // Serialized zero values must not trigger a new fill of an approved transaction.
@@ -125,7 +125,7 @@ export const chainConfig = {
           maxPriorityFeePerGas: storedTransaction.maxPriorityFeePerGas ?? 0n,
           account: request.account,
           from: operation.account,
-          multisigSimulation: getMultisigSimulation({
+          accountSimulation: getAccountSimulation({
             config: operation.config,
             local: request.account,
           }),
@@ -151,40 +151,40 @@ export const chainConfig = {
         return request as unknown as typeof r
       }
 
-      const multisigIdentity = (() => {
-        if (request.account?.source === 'multisig')
+      const configurableIdentity = (() => {
+        if (request.account?.source === 'configurable')
           return {
             account: request.account.address,
-            config: (request.account as MultisigAccount).config,
-            local: request.account as MultisigAccount,
+            config: (request.account as ConfigurableAccount).config,
+            local: request.account as ConfigurableAccount,
           }
         return undefined
       })()
-      if (request.owner && !multisigIdentity)
+      if (request.owner && !configurableIdentity)
         throw new Error(
-          'A multisig account is required when an owner is provided.',
+          'A configurable account is required when an owner is provided.',
         )
       if (request.owner && typeof request.owner === 'string')
         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 (request.owner && request.owner.source !== 'root')
         throw new Error(
-          'A Tempo owner account is required to approve a multisig transaction.',
+          'A Tempo owner account is required to approve a configurable account transaction.',
         )
-      const coordinatedMultisig =
-        !!multisigIdentity &&
+      const coordinated =
+        !!configurableIdentity &&
         !!request.owner &&
-        (client.transport as { multisig?: boolean }).multisig === true
-      if (multisigIdentity) {
-        const { account, local } = multisigIdentity
+        (client.transport as { accounts?: boolean }).accounts === true
+      if (configurableIdentity) {
+        const { account, local } = configurableIdentity
         if (!account)
           throw new Error(
-            'A multisig account address is required with a current config.',
+            'A configurable account address is required with a current config.',
           )
         const config = await (async () => {
-          if (multisigIdentity.config) return multisigIdentity.config
-          if (!coordinatedMultisig) return undefined
+          if (configurableIdentity.config) return configurableIdentity.config
+          if (!coordinated) return undefined
           const cachedConfig = await getAction(
             client,
             getConfig,
@@ -192,16 +192,16 @@ export const chainConfig = {
           )({ address: account })
           if (!cachedConfig)
             throw new Error(
-              `No current multisig config is cached for account ${account}. Provide the current config.`,
+              `No current account config is cached for account ${account}. Provide the current config.`,
             )
           return cachedConfig
         })()
         if (!config)
           throw new Error(
-            'A multisig config is required to prepare a transaction.',
+            'An account config is required to prepare a transaction.',
           )
         request.from = account
-        request.multisigSimulation = getMultisigSimulation({
+        request.accountSimulation = getAccountSimulation({
           config,
           local,
         })
@@ -213,12 +213,12 @@ export const chainConfig = {
         if (request.nonceKey === 'expiring' || request.nonceKey === maxUint256)
           return true
         if (typeof request.nonceKey !== 'undefined') return false
-        if (multisigIdentity) return false
+        if (configurableIdentity) return false
         if (request.feePayer && typeof request.nonceKey === 'undefined')
           return true
         const account = request.account as
           | Account
-          | MultisigAccount
+          | ConfigurableAccount
           | Address
           | undefined
         const address = typeof account === 'string' ? account : account?.address
@@ -227,7 +227,7 @@ export const chainConfig = {
         return false
       })()
 
-      if (coordinatedMultisig && typeof request.nonceKey === 'undefined') {
+      if (coordinated && typeof request.nonceKey === 'undefined') {
         // A random nonce lane lets a stored approval ceremony remain valid
         // indefinitely without blocking other pending operations.
         request.nonceKey = Hex.toBigInt(Hex.random(31)) + 1n
@@ -294,17 +294,17 @@ export const chainConfig = {
     transaction: serializeTransaction,
     async transactionEnvelope({ serializedTransaction, transaction }) {
       const request = transaction as Transaction.TransactionSerializableTempo
-      if (!request.multisigSimulation) return serializedTransaction
+      if (!request.accountSimulation) return serializedTransaction
       try {
         SignatureEnvelope.deserialize(serializedTransaction)
       } catch {
         const transaction = Transaction.deserialize(
           serializedTransaction as Transaction.TransactionSerializedTempo,
         )
-        if (transaction.signature?.type === 'multisig')
+        if (transaction.signature?.type === 'configurable')
           return serializedTransaction
         throw new Error(
-          'A Tempo owner account is required to approve a multisig transaction.',
+          'A Tempo owner account is required to approve a configurable account transaction.',
         )
       }
       return await serializeTransaction({
@@ -402,11 +402,11 @@ export const chainConfig = {
 
 export type ChainConfig = typeof chainConfig
 
-/** Builds a bounded multisig spec for gas simulation. */
-function getMultisigSimulation(options: {
-  config: MultisigConfig.Config
-  local?: MultisigAccount | undefined
-}): MultisigSimulation.Spec {
+/** Builds a bounded account spec for gas simulation. */
+function getAccountSimulation(options: {
+  config: AccountConfig.Config
+  local?: ConfigurableAccount | undefined
+}): AccountSimulation.Spec {
   const { config, local } = options
   return {
     approvals: selectOwners(config).map((owner) => {
@@ -453,7 +453,7 @@ function randomValidAfter(): number {
 }
 
 /** Selects a deterministic minimum-cardinality owner quorum. */
-function selectOwners(config: MultisigConfig.Config) {
+function selectOwners(config: AccountConfig.Config) {
   const owners = [...config.owners].sort(
     (a, b) =>
       Number(b.weight) - Number(a.weight) ||
@@ -461,7 +461,7 @@ function selectOwners(config: MultisigConfig.Config) {
   )
   const selected: typeof owners = []
   let weight = 0
-  for (const owner of owners.slice(0, MultisigConfig.maxSignatures)) {
+  for (const owner of owners.slice(0, AccountConfig.maxSignatures)) {
     if (weight >= Number(config.threshold)) break
     selected.push(owner)
     weight += Number(owner.weight)

package/tempo/index.ts

@@ -12,10 +12,10 @@ export type {
   TxEnvelopeTempo as z_TxEnvelopeTempo,
 } from 'ox/tempo'
 export {
+  AccountConfig,
+  AccountOperation,
   Channel,
   EarnShares,
-  MultisigConfig,
-  MultisigOperation,
   Period,
   ReceivePolicyReceipt,
   TempoAddress,
@@ -26,8 +26,8 @@ export {
 } from 'ox/tempo'
 export type {
   /** @deprecated */
-  Owner as z_MultisigConfigOwner,
-} from 'ox/tempo/MultisigConfig'
+  Owner as z_AccountConfigOwner,
+} from 'ox/tempo/AccountConfig'
 export {
   type CustomTransport,
   type CustomTransportConfig,
@@ -73,6 +73,7 @@ export * as Expiry from './Expiry.js'
 export * from './errors.js'
 export * as Formatters from './Formatters.js'
 export * as Hardfork from './Hardfork.js'
+/** Client-side storage for pending key authorizations, backed by a `Store`. */
 export * as KeyAuthorizationManager from './KeyAuthorizationManager.js'
 export * as P256 from './P256.js'
 /**