viem 2.56.1 → 2.56.3

package/tempo/Abis.ts

@@ -464,21 +464,22 @@ export const nativeMultisig = [
     outputs: [{ type: 'address', name: 'account' }],
   },
   {
-    name: 'isMultisigAccount',
+    name: 'getConfigCommitment',
     type: 'function',
     stateMutability: 'view',
     inputs: [{ type: 'address', name: 'account' }],
-    outputs: [{ type: 'bool' }],
+    outputs: [{ type: 'bytes32', name: 'commitment' }],
   },
   {
-    name: 'getConfig',
+    name: 'updateConfig',
     type: 'function',
-    stateMutability: 'view',
-    inputs: [{ type: 'address', name: 'account' }],
-    outputs: [
+    stateMutability: 'nonpayable',
+    inputs: [
       {
         type: 'tuple',
+        name: 'current',
         components: [
+          { type: 'bytes32', name: 'salt' },
           { type: 'uint64', name: 'version' },
           { type: 'uint8', name: 'threshold' },
           {
@@ -491,13 +492,6 @@ export const nativeMultisig = [
           },
         ],
       },
-    ],
-  },
-  {
-    name: 'updateConfig',
-    type: 'function',
-    stateMutability: 'nonpayable',
-    inputs: [
       { type: 'uint8', name: 'threshold' },
       {
         type: 'tuple[]',
@@ -510,16 +504,13 @@ export const nativeMultisig = [
     ],
     outputs: [],
   },
-  {
-    name: 'MultisigInitialized',
-    type: 'event',
-    inputs: [{ type: 'address', name: 'account', indexed: true }],
-  },
   {
     name: 'MultisigConfigUpdated',
     type: 'event',
     inputs: [
       { type: 'address', name: 'account', indexed: true },
+      { type: 'bytes32', name: 'salt' },
+      { type: 'uint64', name: 'version' },
       { type: 'uint8', name: 'threshold' },
       {
         type: 'tuple[]',
@@ -531,18 +522,15 @@ export const nativeMultisig = [
       },
     ],
   },
-  { name: 'NotMultisigAccount', type: 'error', inputs: [] },
   { name: 'InvalidAccount', type: 'error', inputs: [] },
   { name: 'InvalidConfig', type: 'error', inputs: [] },
   { name: 'InvalidThreshold', type: 'error', inputs: [] },
-  { name: 'InvalidOwner', type: 'error', inputs: [] },
+  { name: 'InvalidMultisigOwner', type: 'error', inputs: [] },
   { name: 'InvalidWeight', type: 'error', inputs: [] },
   { name: 'TooManyOwners', type: 'error', inputs: [] },
   { name: 'DuplicateOwner', type: 'error', inputs: [] },
   { name: 'InvalidOwnerOrder', type: 'error', inputs: [] },
-  { name: 'AccountAlreadyInitialized', type: 'error', inputs: [] },
-  { name: 'UnauthorizedCaller', type: 'error', inputs: [] },
-  { name: 'SameTransactionUpdateNotAllowed', type: 'error', inputs: [] },
+  { name: 'UnauthorizedMultisigCaller', type: 'error', inputs: [] },
 ] as const
 
 export const currentCommittee = [

package/tempo/Account.ts

@@ -277,26 +277,28 @@ export declare namespace fromSecp256k1 {
 /**
  * Instantiates an Account for a native multisig (TIP-1061) config.
  *
- * The returned account does not hold a key itself. Pass an initial config to
- * derive and bootstrap an account, or pass the address of an initialized
- * account to reconstruct it without retaining the initial config.
+ * The returned account does not hold a key itself. Omit `address` or set it to
+ * `infer` to derive an account address from its initial config. For a current
+ * config, set `address` to the stable account address. Pass the address directly
+ * for an address-only account.
  *
  * Owners can be accounts or addresses directly, or weighted `{ owner, weight }`
  * entries. Direct owners default to weight `1`, and `threshold` defaults to `1`.
  * Local owner accounts are retained for signing, including nested multisigs.
- * Address-only configs keep the external approval flow, where owner approvals
- * are collected separately and provided via `signatures`.
+ * Configs containing only owner addresses require external approvals through
+ * `signatures`.
  *
- * Accepts a raw config and normalizes it internally (via `MultisigConfig.from`),
- * so callers don't need to call `MultisigConfig.from` themselves.
+ * Normalizes supplied config fields with `MultisigConfig.from`, so callers do
+ * not need to normalize owner ordering themselves.
  *
  * @example
  * ```ts
  * import { Account } from 'viem/tempo'
  *
  * const account = Account.fromMultisig({
- *   threshold: 2,
+ *   address: 'infer',
  *   owners: [owner_1, owner_2],
+ *   threshold: 2,
  * })
  *
  * // The multisig config is inferred from the account.
@@ -305,46 +307,70 @@ export declare namespace fromSecp256k1 {
  * const transaction = await client.signTransaction(request)
  * ```
  *
- * @param value Initial multisig config or initialized multisig address.
+ * @param value Initial config, current config, or multisig address.
  * @returns Multisig account.
  */
 export function fromMultisig(
-  config: fromMultisig.Config,
+  value: fromMultisig.InitialConfig,
+): MultisigAccount<MultisigConfig.Config>
+export function fromMultisig(
+  value: fromMultisig.CurrentConfig,
 ): MultisigAccount<MultisigConfig.Config>
 export function fromMultisig(
   address: Address.Address,
 ): MultisigAccount<undefined>
 export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount
 export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
-  const config = (() => {
+  const configInput = (() => {
     if (typeof value === 'string') return undefined
-    const ownerEntries = value.owners.map((value) =>
+    const { address: _, ...config } = value
+    return config
+  })()
+  const config = (() => {
+    if (!configInput) return undefined
+    const ownerEntries = configInput.owners.map((value) =>
       typeof value === 'string' || 'address' in value
         ? { owner: value, weight: 1 }
         : value,
     )
     return MultisigConfig.from({
-      ...value,
+      ...configInput,
       owners: ownerEntries.map(({ owner, weight }) => ({
         owner: typeof owner === 'string' ? owner : owner.address,
         weight,
       })),
-      threshold: value.threshold ?? 1,
+      threshold: configInput.threshold ?? 1,
     })
   })()
+  if (typeof value !== 'string') {
+    if (
+      (value.address === undefined || value.address === 'infer') &&
+      config!.version !== 0n
+    )
+      throw new Error('An initial multisig config must have version zero.')
+    if (
+      value.address !== undefined &&
+      value.address !== 'infer' &&
+      config!.version === 0n
+    )
+      throw new Error('A current multisig config must have a version.')
+  }
   const address = Address.checksum(
-    typeof value === 'string' ? value : MultisigConfig.getAddress(config!),
+    (() => {
+      if (typeof value === 'string') return value
+      if (value.address === undefined || value.address === 'infer')
+        return MultisigConfig.getAddress(config!)
+      return value.address
+    })(),
   )
-  const ownerAccounts =
-    typeof value === 'string'
-      ? []
-      : value.owners.flatMap((value) => {
-          const owner =
-            typeof value === 'string' || 'address' in value
-              ? value
-              : value.owner
-          return typeof owner === 'string' ? [] : [parseAccount(owner)]
-        })
+  const ownerAccounts = (() => {
+    if (!configInput) return []
+    return configInput.owners.flatMap((value) => {
+      const owner =
+        typeof value === 'string' || 'address' in value ? value : value.owner
+      return typeof owner === 'string' ? [] : [parseAccount(owner)]
+    })
+  })()
   const owners =
     config?.owners.flatMap(({ owner }) => {
       const account = ownerAccounts.find((account) =>
@@ -360,8 +386,10 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
     publicKey: '0x',
     source: 'multisig',
     type: 'local',
-    async sign() {
-      throw new Error('`sign` is not supported for multisig accounts.')
+    async sign({ hash }) {
+      return SignatureEnvelope.serialize(
+        await signMultisig(account, { payload: hash }),
+      )
     },
     async signMessage() {
       throw new Error('`signMessage` is not supported for multisig accounts.')
@@ -369,6 +397,19 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
     async signTransaction(transaction, options) {
       const { serializer = Transaction.serialize } = options ?? {}
       const request = transaction as Transaction.TransactionSerializableTempo
+      if (request.owner) {
+        const owner = parseAccount(request.owner)
+        if (owner.type !== 'local')
+          throw new Error(
+            'A local owner account is required to approve a multisig transaction.',
+          )
+        if (owner.source !== 'root' && owner.source !== 'multisig')
+          throw new Error(
+            'A Tempo owner account is required to approve a multisig transaction.',
+          )
+        const { owner: _, ...ownerRequest } = request
+        return await owner.signTransaction(ownerRequest as never, options)
+      }
       if (owners.length === 0)
         return (await serializer(transaction as never)) as Hex.Hex
 
@@ -380,51 +421,31 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
           : { feePayerSignature: null }),
       }
       const payload = keccak256(await serializer(presign as never))
-      const requestMultisig = request.multisig
-      const requestAccount = requestMultisig
-        ? typeof requestMultisig === 'string'
-          ? requestMultisig
-          : MultisigConfig.getAddress(requestMultisig)
-        : address
+      const simulation = request.multisigSimulation
+      const requestAccount = simulation?.account ?? address
 
       if (!Address.isEqual(requestAccount, address)) {
-        const state = request.multisigOwnerStates?.find((state) =>
-          Address.isEqual(state.account, address),
-        )
-        if (state && !state.initialized)
-          throw new Error('Nested multisig owners must be initialized.')
+        if (!simulation)
+          throw new Error('A multisig config is required for local signing.')
+        const parentConfig = MultisigConfig.from(simulation.config)
         const parentDigest = MultisigConfig.getSignPayload({
-          ...(typeof requestMultisig === 'string'
-            ? { account: requestMultisig }
-            : { initialConfig: requestMultisig! }),
+          account: requestAccount,
+          config: parentConfig,
           payload,
-          version: request.multisigVersion,
         })
         return SignatureEnvelope.serialize(
           await signMultisig(account, {
             payload: parentDigest,
-            states: request.multisigOwnerStates,
-            version: state?.version,
           }),
         )
       }
 
-      const keyAuthorizationSignature = request.keyAuthorization?.signature
-      const keyAuthorizationInitializes =
-        keyAuthorizationSignature?.type === 'multisig' &&
-        typeof keyAuthorizationSignature.init !== 'undefined'
       const signature = await signMultisig(account, {
-        init:
-          typeof config !== 'undefined' &&
-          !request.nonce &&
-          !request.nonceKey &&
-          !keyAuthorizationInitializes,
+        config: simulation?.config,
         payload,
         signatures: request.signatures?.map((signature) =>
           SignatureEnvelope.from(signature),
         ),
-        states: request.multisigOwnerStates,
-        version: request.multisigVersion,
       })
       return (await serializer(
         transaction as never,
@@ -439,6 +460,38 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
 }
 
 export declare namespace fromMultisig {
+  /** Initial version-zero multisig config. */
+  export type Config = InitialConfig
+
+  /** Stable multisig account address and its current config. */
+  export type CurrentConfig = {
+    /** Stable multisig account address. */
+    address: Address.Address
+    /** Weighted owners. */
+    owners: readonly Owner[]
+    /** Caller-chosen 32-byte salt. */
+    salt: MultisigConfig.Config['salt']
+    /** Minimum total owner weight required for authorization. */
+    threshold: MultisigConfig.Config['threshold']
+    /** Current configuration version. */
+    version: MultisigConfig.Config<bigint | number>['version']
+  }
+
+  /** Initial version-zero multisig config. */
+  export type InitialConfig = {
+    /** Derives the stable account address from this initial config. */
+    address?: 'infer' | undefined
+    /** Weighted owners. */
+    owners: readonly Owner[]
+    /** Caller-chosen 32-byte salt. */
+    salt?: MultisigConfig.Input['salt'] | undefined
+    /** Minimum owner weight required for authorization. */
+    threshold?: number | undefined
+    /** Initial configuration version. */
+    version?: 0 | 0n | undefined
+  }
+
+  /** Multisig owner account or address, optionally with an explicit weight. */
   export type Owner =
     | Address.Address
     | LocalAccount
@@ -446,20 +499,16 @@ export declare namespace fromMultisig {
         owner: Address.Address | LocalAccount
       })
 
-  export type Config = Omit<MultisigConfig.Config, 'owners' | 'threshold'> & {
-    owners: readonly Owner[]
-    threshold?: number | undefined
-  }
-
-  export type Parameters = Address.Address | Config
+  /** Parameters for {@link fromMultisig}. */
+  export type Parameters = Address.Address | CurrentConfig | InitialConfig
 }
 
 export type MultisigAccount<
   config extends MultisigConfig.Config | undefined =
     | MultisigConfig.Config
     | undefined,
-> = LocalAccount<'multisig'> & {
-  /** Normalized initial config, or `undefined` when instantiated from an address. */
+> = RequiredBy<LocalAccount<'multisig'>, 'sign'> & {
+  /** Normalized config, or `undefined` for an address-only account. */
   config: config
   /** @internal Local owner accounts available for signing. */
   owners: readonly LocalAccount[]
@@ -472,30 +521,19 @@ function isMultisigAccount(account: LocalAccount): account is MultisigAccount {
 async function signMultisig(
   account: MultisigAccount,
   parameters: {
-    init?: boolean | undefined
+    config?: MultisigConfig.Config | undefined
     payload: Hex.Hex
     signatures?: readonly SignatureEnvelope.SignatureEnvelope[] | undefined
-    states?: readonly Transaction.MultisigOwnerState[] | undefined
-    version?: bigint | undefined
   },
 ): Promise<SignatureEnvelope.Multisig> {
-  const {
-    init = false,
-    payload,
-    signatures: providedSignatures = [],
-    states = [],
-    version = 0n,
-  } = parameters
-  const state = states.find((state) =>
-    Address.isEqual(state.account, account.address),
-  )
-  const currentConfig = state?.config ?? account.config
+  const { config, payload, signatures: providedSignatures = [] } = parameters
+  const currentConfig = config ?? account.config
   if (!currentConfig)
-    throw new Error('Current multisig config is required for local signing.')
+    throw new Error('A current multisig config is required for local signing.')
   const digest = MultisigConfig.getSignPayload({
     account: account.address,
+    config: currentConfig,
     payload,
-    version,
   })
   const signatures = [...providedSignatures]
   const signedOwners = new Set<Address.Address>()
@@ -514,7 +552,12 @@ async function signMultisig(
     weight += Number(owner.weight)
   }
 
-  for (const owner of currentConfig.owners) {
+  const owners = [...currentConfig.owners].sort(
+    (a, b) =>
+      Number(b.weight) - Number(a.weight) ||
+      a.owner.toLowerCase().localeCompare(b.owner.toLowerCase()),
+  )
+  for (const owner of owners) {
     const address = owner.owner.toLowerCase() as Address.Address
     if (signedOwners.has(address)) continue
     const ownerAccount = account.owners.find((account) =>
@@ -523,16 +566,9 @@ async function signMultisig(
     if (!ownerAccount) continue
 
     if (isMultisigAccount(ownerAccount)) {
-      const state = states.find((state) =>
-        Address.isEqual(state.account, ownerAccount.address),
-      )
-      if (state && !state.initialized)
-        throw new Error('Nested multisig owners must be initialized.')
       signatures.push(
         await signMultisig(ownerAccount, {
           payload: digest,
-          states,
-          version: state?.version,
         }),
       )
     } else {
@@ -551,16 +587,14 @@ async function signMultisig(
   if (weight < Number(currentConfig.threshold))
     throw new Error('Local multisig owners do not meet the threshold.')
 
-  if (init && !account.config)
-    throw new Error('Initial multisig config is required for bootstrap.')
   return SignatureEnvelope.from({
     account: account.address,
-    ...(init ? { init: account.config } : {}),
+    config: currentConfig,
     signatures: SignatureEnvelope.sortMultisigApprovals({
       account: account.address,
+      config: currentConfig,
       payload,
       signatures,
-      version,
     }),
   }) as SignatureEnvelope.Multisig
 }
@@ -820,13 +854,11 @@ export async function signKeyAuthorization(
         )
       return SignatureEnvelope.serialize(
         await signMultisig(account, {
-          init: multisigState.init,
+          config: multisigState.config,
           payload: hash,
           signatures: signatures?.map((signature) =>
             SignatureEnvelope.from(signature),
           ),
-          states: multisigState.states,
-          version: multisigState.version,
         }),
       )
     }
@@ -861,9 +893,7 @@ export declare namespace signKeyAuthorization {
     /** @internal Current state used when a multisig account signs the authorization. */
     multisig?:
       | {
-          init: boolean
-          states?: readonly Transaction.MultisigOwnerState[] | undefined
-          version: bigint
+          config: MultisigConfig.Config
         }
       | undefined
     /** Serialized approvals from external multisig owners. */
@@ -952,17 +982,18 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
       // primitive signature over the multisig owner approval digest, instead of
       // a full serialized transaction. Approvals are combined later in
       // `sendTransaction({ signatures })`.
-      const { multisig, multisigVersion } = transaction as {
-        multisig?: Address.Address | MultisigConfig.Config | undefined
-        multisigVersion?: bigint | undefined
+      const { multisigSimulation } = transaction as {
+        multisigSimulation?: {
+          account: Address.Address
+          config: MultisigConfig.Config
+        }
       }
-      if (multisig) {
+      if (multisigSimulation) {
+        const config = MultisigConfig.from(multisigSimulation.config)
         const digest = MultisigConfig.getSignPayload({
-          ...(typeof multisig === 'string'
-            ? { account: multisig }
-            : { initialConfig: multisig }),
+          account: multisigSimulation.account,
+          config,
           payload,
-          version: multisigVersion,
         })
         return await sign({ hash: digest, raw: true })
       }

package/tempo/Client.ts

@@ -25,6 +25,8 @@ import type { RpcSchema } from '../types/eip1193.js'
 import type { Prettify } from '../types/utils.js'
 import { tempo, tempoTestnet } from './Chain.js'
 import { type Decorator, decorator as tempoActions } from './Decorator.js'
+import * as Store from './Store.js'
+import { withMultisig } from './Transport.js'
 
 /**
  * Configuration for a Tempo {@link Client}.
@@ -52,6 +54,19 @@ export type ClientConfig<
      * @default tempo (or `tempoTestnet` when `testnet` is truthy)
      */
     chain?: chain | Chain | undefined
+    /**
+     * Enables native multisig approval coordination. Pass `true` to use an
+     * in-memory store or provide a shared store.
+     *
+     * @default undefined
+     */
+    experimental_multisig?:
+      | true
+      | {
+          /** Store shared by multisig coordinators. */
+          store: Store.Atomic
+        }
+      | undefined
     /**
      * Default fee token for the Client. Extended onto the chain so it applies
      * to every transaction sent with the Client.
@@ -106,7 +121,8 @@ export type CreateClientErrorType = ErrorType
  * Defaults to the `tempo` mainnet chain and `http` transport, so a minimal
  * client can be created with `createClient()`. Pass `testnet` to use the
  * Tempo testnet, or `chain` to override the chain entirely. Pass `feeToken`
- * to set a default fee token for every transaction.
+ * to set a default fee token for every transaction. Pass
+ * `experimental_multisig` to coordinate multisig owner approvals.
  *
  * @example
  * ```ts
@@ -138,6 +154,16 @@ export type CreateClientErrorType = ErrorType
  * })
  * ```
  *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem/tempo'
+ *
+ * // Multisig coordination with a client-local in-memory store.
+ * const client = createClient({
+ *   experimental_multisig: true,
+ * })
+ * ```
+ *
  * @param parameters - Parameters.
  * @returns The Tempo Client.
  */
@@ -156,7 +182,15 @@ export function createClient<
     : accountOrAddress,
   rpcSchema
 > {
-  const { chain, feeToken, testnet, tokens, transport, ...rest } = parameters
+  const {
+    chain,
+    experimental_multisig,
+    feeToken,
+    testnet,
+    tokens,
+    transport,
+    ...rest
+  } = parameters
   const baseChain = chain ?? (testnet ? tempoTestnet : tempo)
   const resolvedChain =
     feeToken && typeof (baseChain as { extend?: unknown }).extend === 'function'
@@ -164,11 +198,20 @@ export function createClient<
           feeToken,
         })
       : baseChain
+  const transport_ = transport ?? http()
+  const resolvedTransport = experimental_multisig
+    ? withMultisig(
+        transport_,
+        experimental_multisig === true
+          ? { store: Store.memory() }
+          : experimental_multisig,
+      )
+    : transport_
   return createClient_({
     ...rest,
     chain: resolvedChain,
     tokens: tokens ?? tokenSets.tempo,
-    transport: transport ?? http(),
+    transport: resolvedTransport,
   } as ClientConfig_)
     .extend(publicActions)
     .extend(walletActions)

package/tempo/Decorator.ts

@@ -306,6 +306,33 @@ type DecoratorBase<
     revokeSync: (
       parameters: accessKeyActions.revokeSync.Parameters<chain, account>,
     ) => Promise<accessKeyActions.revokeSync.ReturnValue>
+    /**
+     * Signs a key authorization or adds one coordinated multisig approval.
+     *
+     * @example
+     * ```ts
+     * const pending = await client.accessKey.signAuthorization({
+     *   accessKey,
+     *   account: multisig,
+     *   owner: owner_1,
+     * })
+     * const success = await client.accessKey.signAuthorization({
+     *   hash: pending.hash,
+     *   owner: owner_2,
+     * })
+     * ```
+     *
+     * @param parameters - Authorization fields, or a stored operation hash.
+     * @returns A signed key authorization with multisig operation metadata when coordinated.
+     */
+    signAuthorization: {
+      (
+        parameters: accessKeyActions.signAuthorization.CoordinatedParameters,
+      ): Promise<accessKeyActions.signAuthorization.CoordinatedReturnValue>
+      (
+        parameters: accessKeyActions.signAuthorization.LocalParameters<account>,
+      ): Promise<accessKeyActions.signAuthorization.ReturnValue>
+    }
     /**
      * Updates the spending limit for a specific token on an authorized access key.
      *
@@ -2366,23 +2393,27 @@ type DecoratorBase<
   }
   multisig: {
     /**
-     * Gets the current configuration for an initialized multisig account.
+     * Gets the current cached config for a multisig account.
      *
      * @param parameters - Parameters.
-     * @returns The current version, threshold, and owners.
+     * @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>
     /**
-     * Checks whether an address is an initialized native multisig account.
+     * Gets a coordinated multisig operation by its hash.
      *
      * @param parameters - Parameters.
-     * @returns Whether the account is initialized.
+     * @returns The operation, or `null` when it is unknown.
      */
-    isInitialized: (
-      parameters: multisigActions.isInitialized.Parameters,
-    ) => Promise<multisigActions.isInitialized.ReturnValue>
+    getOperation: (
+      parameters: multisigActions.getOperation.Parameters,
+    ) => Promise<multisigActions.getOperation.ReturnValue>
     /**
      * Replaces the current configuration for a native multisig account.
      *
@@ -6008,7 +6039,8 @@ export function decorator() {
       faucet: bindActions(client, faucetActions, ['fund', 'fundSync']),
       multisig: bindActions(client, multisigActions, [
         'getConfig',
-        'isInitialized',
+        'getConfigCommitment',
+        'getOperation',
         'updateConfig',
         'updateConfigSync',
       ]),