viem 2.55.18 → 2.55.19

package/tempo/Formatters.ts

@@ -118,15 +118,14 @@ export function formatTransactionRequest(
   if (request.feePayer === true && !request.feePayerSignature)
     delete request.feeToken
 
-  // `multisig` / `signatures` are client-side only (TIP-1061). They drive
-  // sender derivation, owner signing, and final envelope assembly, but are
-  // never sent as raw RPC fields — the wire payload is the serialized tx.
-  // `multisigInit` / `multisigSignatureCount` are wire fields: the node
-  // prices multisig gas from them during simulation.
+  // Client-only TIP-1061 fields drive local signing and envelope assembly.
+  // `multisigInit` and `multisigSignatureCount` remain wire fields for gas modeling.
   const {
     multisig: _multisig,
     multisigInit,
+    multisigOwnerStates: _multisigOwnerStates,
     multisigSignatureCount,
+    multisigVersion: _multisigVersion,
     signatures: _signatures,
     ...rpcRequest
   } = request

package/tempo/Selectors.ts

@@ -49,6 +49,13 @@ export const addressRegistry = {
   resolveVirtualAddress: '0xe2fc56ef',
 } as const satisfies FunctionSelectors<typeof Abis.addressRegistry>
 
+export const nativeMultisig = {
+  deriveAccount: '0xce8e071c',
+  getConfig: '0xe48a5f7b',
+  isMultisigAccount: '0x9fbf029a',
+  updateConfig: '0xe175d479',
+} as const satisfies FunctionSelectors<typeof Abis.nativeMultisig>
+
 export const nonce = {
   getNonce: '0x89535803',
 } as const satisfies FunctionSelectors<typeof Abis.nonce>

package/tempo/Transaction.ts

@@ -112,6 +112,14 @@ export type TransactionReceiptRpc = TransactionReceipt<
   ox_TransactionReceipt.RpcType
 >
 
+/** @internal */
+export type MultisigOwnerState = {
+  account: Address
+  config?: Pick<MultisigConfig.Config, 'owners' | 'threshold'> | undefined
+  initialized: boolean
+  version: bigint
+}
+
 export type TransactionRequestTempo<
   quantity = bigint,
   index = number,
@@ -124,7 +132,7 @@ export type TransactionRequestTempo<
     feePayer?: Account | true | undefined
     feeToken?: TempoAddress.Address | bigint | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
-    multisig?: MultisigConfig.Config<index> | undefined
+    multisig?: Address | MultisigConfig.Config<index> | undefined
     /** Bootstrap multisig config hint for node-side gas modeling (TIP-1061). Attached automatically when `multisig` is present; the node ignores it for registered senders. */
     multisigInit?:
       | {
@@ -133,8 +141,12 @@ export type TransactionRequestTempo<
           owners: readonly { owner: Address; weight: number }[]
         }
       | undefined
+    /** @internal Local signing state for nested multisig owner accounts. */
+    multisigOwnerStates?: readonly MultisigOwnerState[] | undefined
     /** Modeled owner approval count for node-side gas modeling (TIP-1061). */
     multisigSignatureCount?: number | undefined
+    /** Current multisig config version. Inferred during request preparation; defaults to `0n` for bootstrap. */
+    multisigVersion?: bigint | undefined
     nonceKey?: 'expiring' | quantity | undefined
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined
@@ -157,7 +169,11 @@ export type TransactionSerializableTempo<
     feePayerSignature?: viem_Signature | null | undefined
     from?: Address | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
-    multisig?: MultisigConfig.Config<index> | undefined
+    multisig?: Address | MultisigConfig.Config<index> | undefined
+    /** @internal Local signing state for nested multisig owner accounts. */
+    multisigOwnerStates?: readonly MultisigOwnerState[] | undefined
+    /** Current multisig config version. Inferred during request preparation; defaults to `0n` for bootstrap. */
+    multisigVersion?: bigint | undefined
     nonceKey?: quantity | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
@@ -191,6 +207,7 @@ export function getType(
     typeof transaction.feeToken !== 'undefined' ||
     typeof transaction.keyAuthorization !== 'undefined' ||
     typeof transaction.multisig !== 'undefined' ||
+    typeof transaction.multisigVersion !== 'undefined' ||
     typeof transaction.nonceKey !== 'undefined' ||
     typeof transaction.signature !== 'undefined' ||
     typeof transaction.signatures !== 'undefined' ||
@@ -325,14 +342,17 @@ async function serializeTempo(
   const hasPrefilledFeePayerSignature =
     typeof transaction.feePayerSignature !== 'undefined' &&
     transaction.feePayerSignature !== null
+  const hasSenderSignature =
+    typeof signature_provided !== 'undefined' ||
+    Boolean(transaction.multisig && transaction.signatures)
   // Sponsorship sender signatures omit `feeToken`.
   const shouldStripFeeTokenForSponsorship =
     // Relay fills a partial sender envelope first.
-    (feePayer === true && (!signature_provided || !feePayerSignature)) ||
+    (feePayer === true && (!hasSenderSignature || !feePayerSignature)) ||
     // Local fee-payer accounts sign after sender serialization.
-    (typeof feePayer === 'object' && !signature_provided) ||
+    (typeof feePayer === 'object' && !hasSenderSignature) ||
     // Filled transactions can already include fee-payer approval.
-    (!signature_provided && hasPrefilledFeePayerSignature)
+    (!hasSenderSignature && hasPrefilledFeePayerSignature)
 
   const transaction_ox = {
     ...rest,
@@ -371,15 +391,35 @@ async function serializeTempo(
     const signatures = transaction.signatures.map((approval) =>
       SignatureEnvelope.from(approval),
     )
-    const sorted = SignatureEnvelope.sortMultisigApprovals({
-      payload,
-      signatures,
-      genesisConfig: transaction.multisig,
-    })
+    const sorted =
+      typeof transaction.multisig === 'string'
+        ? SignatureEnvelope.sortMultisigApprovals({
+            account: transaction.multisig,
+            payload,
+            signatures,
+            version: transaction.multisigVersion,
+          })
+        : SignatureEnvelope.sortMultisigApprovals({
+            initialConfig: transaction.multisig,
+            payload,
+            signatures,
+            version: transaction.multisigVersion,
+          })
+    const keyAuthorizationSignature = transaction.keyAuthorization?.signature
+    const keyAuthorizationInitializes =
+      keyAuthorizationSignature?.type === 'multisig' &&
+      typeof keyAuthorizationSignature.init !== 'undefined'
+    if (typeof transaction.multisig === 'string')
+      return SignatureEnvelope.from({
+        account: transaction.multisig,
+        signatures: sorted,
+      })
     return SignatureEnvelope.from({
-      genesisConfig: transaction.multisig,
+      initialConfig: transaction.multisig,
       signatures: sorted,
-      ...(nonce || transaction.nonceKey ? {} : { init: true }),
+      ...(nonce || transaction.nonceKey || keyAuthorizationInitializes
+        ? {}
+        : { init: true }),
     })
   })()
 

package/tempo/actions/accessKey.ts

@@ -1,5 +1,9 @@
 import type { Address } from 'abitype'
-import type { KeyAuthorization } from 'ox/tempo'
+import {
+  type KeyAuthorization,
+  MultisigConfig,
+  type SignatureEnvelope,
+} from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
 import type { ReadContractReturnType } from '../../actions/public/readContract.js'
@@ -21,10 +25,21 @@ import type { Hex } from '../../types/misc.js'
 import type { Compute, UnionOmit } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
 import * as Abis from '../Abis.js'
-import type { AccessKeyAccount, resolveAccessKey } from '../Account.js'
-import { signKeyAuthorization } from '../Account.js'
+import type {
+  AccessKeyAccount,
+  MultisigAccount,
+  resolveAccessKey,
+} from '../Account.js'
+import {
+  getKeyAuthorizationSignPayload,
+  signKeyAuthorization,
+} from '../Account.js'
 import * as Addresses from '../Addresses.js'
 import * as Hardfork from '../Hardfork.js'
+import {
+  createMultisigStateResolver,
+  getMultisigOwnerStates,
+} from '../internal/multisig.js'
 import type {
   GetAccountParameter,
   ReadParameters,
@@ -32,6 +47,7 @@ import type {
 } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
+import * as multisig from './multisig.js'
 
 /** @internal */
 const signatureTypes = {
@@ -155,10 +171,10 @@ export namespace authorize {
     const account_ = rest.account ?? client.account
     if (!account_) throw new Error('account is required.')
     if (!chainId) throw new Error('chainId is required.')
-    const parsed = parseAccount(account_)
-    const keyAuthorization = await signKeyAuthorization(parsed as never, {
-      chainId: BigInt(chainId),
-      key: accessKey,
+    const keyAuthorization = await signAuthorization(client, {
+      account: account_,
+      accessKey,
+      chainId,
       admin,
       expiry,
       limits,
@@ -1003,52 +1019,73 @@ export namespace revokeSync {
 }
 
 /**
- * Signs a key authorization for an access key.
+ * Prepares a key authorization for signing.
  *
  * @example
  * ```ts
- * import { generatePrivateKey } from 'viem/accounts'
- * import { Account, Actions } from 'viem/tempo'
- *
- * const account = Account.from({ privateKey: '0x...' })
- * const accessKey = Account.fromP256(generatePrivateKey(), {
- *   access: account,
+ * const authorization = await Actions.accessKey.prepareAuthorization(client, {
+ *   account,
+ *   accessKey,
  * })
- *
  * const keyAuthorization = await Actions.accessKey.signAuthorization(
  *   client,
- *   {
- *     account,
- *     accessKey,
- *     expiry: Math.floor((Date.now() + 30_000) / 1000),
- *   },
+ *   authorization,
  * )
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The signed key authorization.
+ * @returns Prepared key authorization parameters.
  */
-export async function signAuthorization<
+export async function prepareAuthorization<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: signAuthorization.Parameters<account>,
-): Promise<signAuthorization.ReturnValue> {
-  const { accessKey, chainId = client.chain?.id, ...rest } = parameters
-  const account_ = rest.account ?? client.account
+  parameters: prepareAuthorization.Parameters<account>,
+): Promise<prepareAuthorization.ReturnValue> {
+  const { chainId = client.chain?.id } = parameters
+  const account_ = parameters.account ?? client.account
   if (!account_) throw new Error('account is required.')
   if (!chainId) throw new Error('chainId is required.')
   const parsed = parseAccount(account_)
-  return signKeyAuthorization(parsed as never, {
-    chainId: BigInt(chainId),
-    key: accessKey,
-    ...rest,
-  })
+  const multisigState = await (async () => {
+    if ('multisig' in parameters) return parameters.multisig
+    if (parsed.source !== 'multisig') return undefined
+    const account = parsed as MultisigAccount
+    const getState = createMultisigStateResolver((account) =>
+      multisig.getConfig(client, { account }),
+    )
+    const states = await getMultisigOwnerStates(account, getState)
+    const state = states[0]!
+    return { init: !state.initialized, states, version: state.version }
+  })()
+  const authorizationSignPayload = getKeyAuthorizationSignPayload(
+    parsed as never,
+    {
+      ...parameters,
+      chainId: BigInt(chainId),
+      key: parameters.accessKey,
+    },
+  )
+  const signPayload =
+    parsed.source === 'multisig' && multisigState
+      ? MultisigConfig.getSignPayload({
+          account: parsed.address,
+          payload: authorizationSignPayload,
+          version: multisigState.version,
+        })
+      : authorizationSignPayload
+  return {
+    ...parameters,
+    account: parsed,
+    chainId,
+    multisig: multisigState,
+    signPayload,
+  } as never
 }
 
-export namespace signAuthorization {
+export namespace prepareAuthorization {
   export type Parameters<
     account extends Account | undefined = Account | undefined,
   > = GetAccountParameter<account> & {
@@ -1070,6 +1107,8 @@ export namespace signAuthorization {
     limits?:
       | { token: Address; limit: bigint; period?: number | undefined }[]
       | undefined
+    /** @internal Prepared multisig state. */
+    multisig?: signKeyAuthorization.Parameters['multisig']
     /** Call scopes restricting which contracts/selectors this key can call. */
     scopes?: KeyAuthorization.Scope[] | undefined
     /**
@@ -1085,6 +1124,63 @@ export namespace signAuthorization {
     witness?: Hex | undefined
   }
 
+  export type ReturnValue = Compute<
+    Omit<Parameters<Account | undefined>, 'account' | 'chainId'> & {
+      account: Account
+      chainId: number
+      multisig: signKeyAuthorization.Parameters['multisig']
+      /** Payload that the authorizing account or multisig owners sign. */
+      signPayload: Hex
+    }
+  >
+}
+
+/**
+ * Signs a key authorization for an access key.
+ *
+ * Use {@link prepareAuthorization} before this action when signing requires
+ * transient user activation.
+ *
+ * @param client - Client.
+ * @param parameters - Parameters or the prepared result.
+ * @returns The signed key authorization.
+ */
+export async function signAuthorization<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: signAuthorization.Parameters<account>,
+): Promise<signAuthorization.ReturnValue> {
+  const prepared = (
+    'multisig' in parameters
+      ? parameters
+      : await prepareAuthorization(client, parameters)
+  ) as prepareAuthorization.ReturnValue
+  const {
+    accessKey,
+    account: account_,
+    chainId,
+    multisig: multisigState,
+    signPayload: _,
+    ...rest
+  } = prepared
+  return signKeyAuthorization(account_ as never, {
+    chainId: BigInt(chainId),
+    key: accessKey,
+    multisig: multisigState,
+    ...rest,
+  })
+}
+
+export namespace signAuthorization {
+  export type Parameters<
+    account extends Account | undefined = Account | undefined,
+  > = prepareAuthorization.Parameters<account> & {
+    /** Serialized approvals from external multisig owners. */
+    signatures?: readonly SignatureEnvelope.Serialized[] | undefined
+  }
+
   export type ReturnValue = Awaited<ReturnType<typeof signKeyAuthorization>>
 }
 

package/tempo/actions/index.ts

@@ -6,6 +6,7 @@ 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 receivePolicy from './receivePolicy.js'