tapimo 0.0.2 → 0.2.0

package/src/handlers/internal/multisig.ts

@@ -0,0 +1,823 @@
+import { Hex, Json, RpcResponse, Signature } from 'ox'
+import { MultisigConfig, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
+import type { Address, Client } from 'viem'
+import type { LocalAccount } from 'viem/accounts'
+import { Transaction } from 'viem/tempo'
+
+import * as core_Store from '../../internal/Store.js'
+import * as Sponsorship from './sponsorship.js'
+import * as Utils from './utils.js'
+
+/** Default submission-claim TTL in milliseconds. */
+export const defaultClaimTtl = 30_000
+
+/** Returns whether a raw transaction carries a native multisig signature. */
+export function isMultisigTransaction(serialized: Hex.Hex) {
+  if (!Utils.isSerializedTempoTransaction(serialized)) return false
+  try {
+    const transaction = Transaction.deserialize(serialized as never)
+    return isMultisigSignature((transaction as { signature?: unknown }).signature)
+  } catch {
+    return false
+  }
+}
+
+/** Handles a native multisig raw transaction submission. */
+export async function handleRawTransaction(
+  options: handleRawTransaction.Options,
+): Promise<handleRawTransaction.ReturnType> {
+  const result = await collect(options)
+  if (result.status.status === 'pending' || result.status.status === 'submitting')
+    return result.status.operation.id
+  if (result.status.status === 'submitted')
+    return result.status.operation.submittedHash ?? result.status.operation.id
+  if (options.method === 'eth_sendRawTransactionSync') return result.broadcastResult
+  return result.status.operation.submittedHash!
+}
+
+export declare namespace handleRawTransaction {
+  /** Options for handling a raw multisig transaction submission. */
+  type Options = collect.Options
+
+  /** Raw transaction handler return value. */
+  // oxlint-disable-next-line typescript/no-redundant-type-constituents
+  type ReturnType = Hex.Hex | unknown
+}
+
+async function collect(options: collect.Options): Promise<collect.ReturnType> {
+  const {
+    claimTtl = defaultClaimTtl,
+    finalize = 'sync',
+    getClient,
+    method,
+    request,
+    resolveConfig,
+    sponsor,
+    store,
+  } = options
+  const serialized = request.params?.[0]
+  if (!Utils.isSerializedTempoTransaction(serialized))
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Only Tempo (0x76/0x78) transactions are supported.',
+    })
+
+  const input = parse(serialized)
+  const pending = await store.get(input.id)
+  const config = await resolveValidatedConfig({
+    account: input.account,
+    chainId: input.chainId,
+    init: input.init,
+    pending,
+    resolveConfig,
+  })
+  if (!config)
+    throw new RpcResponse.InvalidParamsError({
+      message:
+        'Multisig config is required to collect approvals. Provide it in the bootstrap transaction or configure `multisig.resolveConfig`.',
+    })
+  const initConfig = resolveInitConfig({
+    config,
+    init: input.init,
+    nonce: input.nonce,
+    pending,
+  })
+
+  const now = Date.now()
+  let operation: Operation = {
+    account: input.account,
+    chainId: input.chainId,
+    claimExpiresAt: pending?.claimExpiresAt,
+    config,
+    createdAt: pending?.createdAt ?? now,
+    id: input.id,
+    init: pending?.init || !!initConfig,
+    initConfig,
+    payload: input.payload,
+    signatures: mergeSignatures([...(pending?.signatures ?? []), ...input.signatures]),
+    status: pending?.status === 'submitted' ? 'submitted' : 'pending',
+    submittedHash: pending?.submittedHash,
+    transaction: serialized as Hex.Hex,
+    updatedAt: now,
+  }
+
+  let approvals = getApprovals({
+    account: input.account,
+    config,
+    payload: input.payload,
+    signatures: operation.signatures,
+  })
+  if (operation.status === 'submitted')
+    return {
+      broadcastResult: operation.submittedHash,
+      status: { operation, status: 'submitted' },
+    }
+
+  if (approvals.weight < approvals.threshold) {
+    operation = await store.savePending(operation)
+    approvals = getApprovals({
+      account: operation.account,
+      config,
+      payload: operation.payload,
+      signatures: operation.signatures,
+    })
+    if (approvals.weight < approvals.threshold)
+      return { status: { operation, status: operation.status } }
+  }
+
+  const claim = await store.claimSubmission(operation, { ttl: claimTtl })
+  if (claim.status !== 'claimed') return { status: claim }
+
+  operation = claim.operation
+  approvals = getApprovals({
+    account: operation.account,
+    config,
+    payload: operation.payload,
+    signatures: operation.signatures,
+  })
+  const client = getClient(operation.chainId)
+  const final = await serializeFinal({
+    account: operation.account,
+    init: operation.initConfig ?? initConfig,
+    signatures: approvals.signatures,
+    transaction: input.transaction,
+  })
+  const broadcastMethod =
+    method === 'eth_sendRawTransaction' && finalize === 'sync'
+      ? 'eth_sendRawTransactionSync'
+      : method
+  const feePayerState = (() => {
+    try {
+      const transaction = Transaction.deserialize(final as never) as Record<string, unknown>
+      // No fee-payer field means finalized transaction does not request sponsorship.
+      if (!('feePayerSignature' in transaction)) return {}
+      // Preserve fee-token/signature marker for sponsorship decision below.
+      return {
+        feeToken:
+          typeof transaction['feeToken'] === 'string'
+            ? (transaction['feeToken'] as Address)
+            : undefined,
+        signature: transaction['feePayerSignature'],
+      }
+    } catch {
+      // Decode failure falls back to direct broadcast.
+      return {}
+    }
+  })()
+  const sponsorFeeToken = await (async () => {
+    // No sponsor configured, so finalized multisig transaction broadcasts as-is.
+    if (!sponsor) return undefined
+    // Already fee-payer signed transactions must not be rewritten by this relay.
+    if (feePayerState.signature !== null) return undefined
+    // Explicit relay fee token wins when the transaction requests sponsorship.
+    if (sponsor.feeToken) return sponsor.feeToken
+    // `null` requests relay-added fee-payer signature.
+    return await sponsor.resolveFeeToken?.(operation.chainId)
+  })()
+  const shouldSponsor = (() => {
+    // No sponsor configured, so no sponsorship path to take.
+    if (!sponsor) return false
+    // `null` requests relay-added fee-payer signature.
+    if (feePayerState.signature === null) return true
+    // Missing or already-present fee-payer signatures broadcast unchanged.
+    return false
+  })()
+  const result = await (async () => {
+    // Sponsorship enabled, so sponsor adds/signs fee-payer fields.
+    if (shouldSponsor && sponsor)
+      return await Sponsorship.handleRawTransaction({
+        account: sponsor.account,
+        feeToken: sponsorFeeToken,
+        getFeeToken: sponsor.resolveFeeToken
+          ? async (chainId) => await sponsor.resolveFeeToken?.(chainId)
+          : undefined,
+        getClient,
+        method: broadcastMethod,
+        onSponsored: sponsor.onSponsored,
+        request: { params: [final] },
+        sender: operation.account,
+        validate: sponsor.validate,
+      })
+    // Otherwise, multisig transaction is final and can broadcast directly.
+    return await client.request({
+      method: broadcastMethod,
+      params: [final],
+    } as never)
+  })()
+  const submittedHash = (() => {
+    if (typeof result === 'string') return result as Hex.Hex
+    if (result && typeof result === 'object' && 'transactionHash' in result) {
+      const response = result as { transactionHash?: unknown }
+      if (typeof response.transactionHash === 'string') return response.transactionHash as Hex.Hex
+    }
+    throw new Error('Expected transaction hash in multisig broadcast result.')
+  })()
+  const submitted = await store.setSubmitted(operation.id, submittedHash)
+
+  return {
+    broadcastResult: result,
+    status: { operation: submitted, status: 'claimed' },
+  }
+}
+
+/** Resolves a multisig operation id for standard transaction lookup methods. */
+export async function handleGetTransaction(
+  options: handleGetTransaction.Options,
+): Promise<handleGetTransaction.ReturnType> {
+  const id = options.request.params?.[0]
+  if (typeof id !== 'string') return undefined
+
+  const operation = await options.store.get(id as Hex.Hex)
+  if (!operation) return undefined
+  if (operation.status !== 'submitted' || !operation.submittedHash) return { result: null }
+
+  const result = await options.getClient(operation.chainId).request({
+    method: options.method,
+    params: [operation.submittedHash],
+  } as never)
+  return { result }
+}
+
+export declare namespace handleGetTransaction {
+  /** Options for resolving a multisig operation id through transaction lookup methods. */
+  type Options = {
+    /** Client resolver keyed by transaction `chainId`. */
+    getClient: (chainId?: number) => Client
+    /** Standard transaction lookup method to handle. */
+    method: 'eth_getTransactionByHash' | 'eth_getTransactionReceipt'
+    /** Incoming JSON-RPC request. */
+    request: { params?: readonly unknown[] | undefined }
+    /** Pending multisig operation store. */
+    store: Store
+  }
+
+  /** Transaction lookup result wrapper. */
+  type ReturnType = { result: unknown } | undefined
+}
+
+declare namespace collect {
+  type Options = {
+    /** Submission claim TTL in milliseconds. @default 30000 */
+    claimTtl?: number | undefined
+    /** How to broadcast once quorum is met. @default 'sync' */
+    finalize?: 'submitted' | 'sync' | undefined
+    /** Client resolver keyed by transaction `chainId`. */
+    getClient: (chainId?: number) => Client
+    /** Raw transaction method to handle. */
+    method: 'eth_sendRawTransaction' | 'eth_sendRawTransactionSync'
+    /** Incoming JSON-RPC request. */
+    request: { params?: readonly unknown[] | undefined }
+    /** Resolves the genesis multisig config for quorum checks. */
+    resolveConfig?: ResolveConfig | undefined
+    /** Optional fee payer used to sponsor finalized multisig transactions. */
+    sponsor?: Sponsor | undefined
+    /** Pending multisig operation store. */
+    store: Store
+  }
+
+  type ReturnType = {
+    /** Raw broadcast result once quorum is met and this caller claimed submission. */
+    broadcastResult?: unknown
+    /** Structured operation claim status. */
+    status: ClaimSubmissionResult | { operation: Operation; status: 'claimed' }
+  }
+}
+
+/** Returns a stored native multisig operation status. */
+export async function getStatus(options: getStatus.Options): Promise<Status | null> {
+  const operation = await options.store.get(options.id)
+  if (!operation) return null
+  const config = await resolveValidatedConfig({
+    account: operation.account,
+    chainId: operation.chainId,
+    pending: operation,
+    resolveConfig: options.resolveConfig,
+  })
+  if (!config)
+    return {
+      account: operation.account,
+      chainId: operation.chainId,
+      id: operation.id,
+      signatures: operation.signatures.length,
+      status: operation.status,
+      submittedHash: operation.submittedHash,
+    }
+  const approvals = getApprovals({
+    account: operation.account,
+    config,
+    payload: operation.payload,
+    signatures: operation.signatures,
+  })
+  return toStatus({ approvals, operation })
+}
+
+export declare namespace getStatus {
+  /** Options for reading one multisig operation status. */
+  type Options = {
+    /** Operation id returned by a pending multisig submission. */
+    id: Hex.Hex
+    /** Resolves the genesis multisig config for quorum status. */
+    resolveConfig?: ResolveConfig | undefined
+    /** Pending multisig operation store. */
+    store: Store
+  }
+}
+
+/** Returns pending native multisig operation statuses for an account. */
+export async function listStatuses(options: listStatuses.Options): Promise<readonly Status[]> {
+  const operations = await options.store.listPendingByAddress(options.account)
+  return await Promise.all(
+    operations.map(async (operation) => {
+      const config = await resolveValidatedConfig({
+        account: operation.account,
+        chainId: operation.chainId,
+        pending: operation,
+        resolveConfig: options.resolveConfig,
+      })
+      if (!config)
+        return {
+          account: operation.account,
+          chainId: operation.chainId,
+          id: operation.id,
+          signatures: operation.signatures.length,
+          status: operation.status,
+          submittedHash: operation.submittedHash,
+        }
+      const approvals = getApprovals({
+        account: operation.account,
+        config,
+        payload: operation.payload,
+        signatures: operation.signatures,
+      })
+      return toStatus({ approvals, operation })
+    }),
+  )
+}
+
+export declare namespace listStatuses {
+  /** Options for listing multisig operation statuses. */
+  type Options = {
+    /** Native multisig account address. */
+    account: Address
+    /** Resolves the genesis multisig config for quorum status. */
+    resolveConfig?: ResolveConfig | undefined
+    /** Pending multisig operation store. */
+    store: Store
+  }
+}
+
+/**
+ * Creates a multisig operation store backed by a Tempo API state store
+ * (`Store.memory()`, a static-name Durable Object store, …).
+ *
+ * Approval merges and submission claims go through `Store.update`, so the
+ * backing store needs the atomic `swap` compare-and-swap to serialize
+ * concurrent writers (the get + put fallback is dev-only). It must also be
+ * enumerable — `listPendingByAddress` scans a key prefix — so sharded Durable
+ * Object stores and caches do not qualify.
+ */
+export function fromStore(state: core_Store.State): Store {
+  const key = (id: Hex.Hex) => `multisig:op:${id.toLowerCase()}`
+  const read = (raw: null | string) => (raw ? (Json.parse(raw) as Operation) : undefined)
+
+  return {
+    async claimSubmission(operation, options) {
+      let result: ClaimSubmissionResult | undefined
+      await core_Store.update(state, key(operation.id), (raw) => {
+        const now = Date.now()
+        const existing = read(raw)
+        if (existing?.status === 'submitted') {
+          result = { operation: existing, status: 'submitted' }
+          return raw as string
+        }
+        if (existing?.status === 'submitting' && (existing.claimExpiresAt ?? 0) > now) {
+          result = { operation: existing, status: 'submitting' }
+          return raw as string
+        }
+        const claimed = mergeOperation(existing, operation, {
+          claimExpiresAt: now + options.ttl,
+          status: 'submitting',
+          updatedAt: now,
+        })
+        result = { operation: claimed, status: 'claimed' }
+        return Json.stringify(claimed)
+      })
+      return result as ClaimSubmissionResult
+    },
+    async get(id) {
+      return read(await state.get(key(id)))
+    },
+    async listPendingByAddress(address) {
+      const { keys } = await state.list({ prefix: 'multisig:op:' })
+      const operations = await Promise.all(keys.map(({ name }) => state.get(name)))
+      return operations
+        .map(read)
+        .filter((operation) => operation !== undefined)
+        .filter(
+          (operation) =>
+            operation.account.toLowerCase() === address.toLowerCase() &&
+            operation.status !== 'submitted',
+        )
+    },
+    async savePending(operation) {
+      let saved: Operation | undefined
+      await core_Store.update(state, key(operation.id), (raw) => {
+        const now = Date.now()
+        const existing = read(raw)
+        if (existing?.status === 'submitted') {
+          saved = existing
+          return raw as string
+        }
+        saved = mergeOperation(existing, operation, {
+          status:
+            existing?.status === 'submitting' && (existing.claimExpiresAt ?? 0) > now
+              ? 'submitting'
+              : 'pending',
+          updatedAt: now,
+        })
+        return Json.stringify(saved)
+      })
+      return saved as Operation
+    },
+    async setSubmitted(id, submittedHash) {
+      let submitted: Operation | undefined
+      await core_Store.update(state, key(id), (raw) => {
+        const existing = read(raw)
+        if (!existing) throw new Error('Cannot mark an unknown multisig operation submitted.')
+        submitted = {
+          ...existing,
+          claimExpiresAt: undefined,
+          status: 'submitted',
+          submittedHash,
+          updatedAt: Date.now(),
+        } satisfies Operation
+        return Json.stringify(submitted)
+      })
+      return submitted as Operation
+    },
+  }
+}
+
+/** Creates an in-memory multisig operation store for development and tests only. */
+export function memoryStore(): Store {
+  return fromStore(core_Store.memory())
+}
+
+/** Native multisig relay options. */
+export type Options = {
+  /** Submission claim TTL in milliseconds. @default 30000 */
+  claimTtl?: number | undefined
+  /** How to broadcast once quorum is met. @default 'sync' */
+  finalize?: 'submitted' | 'sync' | undefined
+  /** Resolves the genesis multisig config for quorum checks. */
+  resolveConfig?: ResolveConfig | undefined
+  /**
+   * State store holding pending multisig operations. Needs the store's atomic
+   * `swap` for correctness (approval merges and submission claims serialize
+   * through it) and must be enumerable, so sharded Durable Object stores and
+   * caches do not qualify.
+   */
+  store: core_Store.State
+}
+
+/** Resolves the genesis multisig config for quorum checks. */
+export type ResolveConfig = (request: {
+  /** Native multisig account address. */
+  account: Address
+  /** Transaction chain id. */
+  chainId: number
+  /** Bootstrap config carried by the transaction, when present. */
+  init?: MultisigConfig.Config | undefined
+}) => MultisigConfig.Config | Promise<MultisigConfig.Config | undefined> | undefined
+
+/** Optional fee payer used to sponsor finalized multisig transactions. */
+export type Sponsor = {
+  /** Account used as the fee payer. */
+  account: LocalAccount
+  /** Fee token to set before fee payer signing. */
+  feeToken?: Address | undefined
+  /** Called once the fee payer has signed, before any broadcast. */
+  onSponsored?: Sponsorship.handleRawTransaction.Options['onSponsored']
+  /** Resolves the default fee token for raw sponsorship. */
+  resolveFeeToken?:
+    | ((chainId: number) => Address | Promise<Address | undefined> | undefined)
+    | undefined
+  /** Optional sponsorship approval callback. */
+  validate?: Sponsorship.handleRawTransaction.Options['validate']
+}
+
+/** Storage for native multisig operation approvals and submission claims. */
+export type Store = {
+  /** Atomically claims submission for a quorum-ready operation. Only a `claimed` result may broadcast. */
+  claimSubmission: (
+    operation: Operation,
+    options: claimSubmission.Options,
+  ) => Promise<ClaimSubmissionResult>
+  /** Reads a stored operation. */
+  get: (id: Hex.Hex) => Promise<Operation | undefined>
+  /** Lists non-submitted operations for a native multisig account address. */
+  listPendingByAddress: (address: Address) => Promise<readonly Operation[]>
+  /** Saves a pending operation, preserving already-stored approvals. */
+  savePending: (operation: Operation) => Promise<Operation>
+  /** Marks a claimed operation submitted with its real transaction hash. */
+  setSubmitted: (id: Hex.Hex, submittedHash: Hex.Hex) => Promise<Operation>
+}
+
+/** `Store.claimSubmission` types. */
+export declare namespace claimSubmission {
+  /** Options for claiming submission. */
+  type Options = {
+    /** Claim TTL in milliseconds. */
+    ttl: number
+  }
+}
+
+/** Result of atomically claiming a multisig operation for submission. */
+export type ClaimSubmissionResult =
+  | {
+      /** Operation this caller may broadcast. */
+      operation: Operation
+      /** Claim status. */
+      status: 'claimed'
+    }
+  | {
+      /** Current stored operation. */
+      operation: Operation
+      /** Current non-claimed status. */
+      status: 'pending' | 'submitting' | 'submitted'
+    }
+
+/** Stored native multisig operation. */
+export type Operation = {
+  /** Native multisig account address. */
+  account: Address
+  /** Transaction chain id. */
+  chainId: number
+  /** Submission claim expiry timestamp in milliseconds. */
+  claimExpiresAt?: number | undefined
+  /** Resolved genesis config used for approval checks. */
+  config?: MultisigConfig.Config | undefined
+  /** Creation timestamp in milliseconds. */
+  createdAt: number
+  /** Deterministic operation id. */
+  id: Hex.Hex
+  /** Whether the finalized transaction must carry the genesis init config. */
+  init?: boolean | undefined
+  /** Genesis init config to attach when finalizing a bootstrap transaction. */
+  initConfig?: MultisigConfig.Config | undefined
+  /** Unsigned Tempo transaction sign payload. */
+  payload: Hex.Hex
+  /** Collected owner approval signatures. */
+  signatures: readonly Hex.Hex[]
+  /** Operation state. */
+  status: 'pending' | 'submitting' | 'submitted'
+  /** Transaction hash once submitted. */
+  submittedHash?: Hex.Hex | undefined
+  /** Last submitted serialized transaction carrying this operation. */
+  transaction: Hex.Hex
+  /** Last update timestamp in milliseconds. */
+  updatedAt: number
+}
+
+/** Native multisig operation status. */
+export type Status = {
+  /** Native multisig account address. */
+  account: Address
+  /** Transaction chain id. */
+  chainId: number
+  /** Deterministic operation id. */
+  id: Hex.Hex
+  /** Number of collected owner approvals. */
+  signatures: number
+  /** Operation state. */
+  status: Operation['status']
+  /** Submitted transaction hash. */
+  submittedHash?: Hex.Hex | undefined
+  /** Required owner weight. */
+  threshold?: number | undefined
+  /** Collected owner weight. */
+  weight?: number | undefined
+}
+
+function parse(serialized: Hex.Hex) {
+  const transaction = Transaction.deserialize(serialized as never) as Record<string, unknown>
+  const signature = transaction['signature']
+  if (!isMultisigSignature(signature))
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Transaction does not contain a native multisig signature.',
+    })
+
+  const { signature: _, ...unsigned } = transaction
+  const payload = TxEnvelopeTempo.getSignPayload(TxEnvelopeTempo.from(unsigned as never))
+  const chainId = Number(transaction['chainId'])
+  const id = MultisigConfig.getSignPayload({
+    account: signature.account,
+    payload,
+  })
+  const init = signature.init ? MultisigConfig.from(signature.init) : undefined
+  const nonce = typeof transaction['nonce'] === 'number' ? transaction['nonce'] : undefined
+
+  return {
+    account: signature.account,
+    chainId,
+    id,
+    init,
+    nonce,
+    payload,
+    signatures: signature.signatures.map((value) => SignatureEnvelope.serialize(value)),
+    transaction,
+  }
+}
+
+function isMultisigSignature(value: unknown): value is SignatureEnvelope.Multisig {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { type?: unknown }).type === 'multisig' &&
+    typeof (value as { account?: unknown }).account === 'string' &&
+    Array.isArray((value as { signatures?: unknown }).signatures)
+  )
+}
+
+async function resolveValidatedConfig(options: {
+  account: Address
+  chainId: number
+  init?: MultisigConfig.Config | undefined
+  pending?: Operation | undefined
+  resolveConfig?: ResolveConfig | undefined
+}) {
+  const { account, chainId, init, pending, resolveConfig } = options
+  const config = (await resolveConfig?.({ account, chainId, init })) ?? pending?.config ?? init
+  if (!config) return undefined
+
+  const normalized = MultisigConfig.from(config)
+  if (
+    init &&
+    MultisigConfig.getAddress(MultisigConfig.from(init)).toLowerCase() !== account.toLowerCase()
+  )
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Bootstrap multisig init config does not match the multisig account.',
+    })
+  return normalized
+}
+
+function resolveInitConfig(options: {
+  config: MultisigConfig.Config
+  init?: MultisigConfig.Config | undefined
+  nonce?: number | undefined
+  pending?: Operation | undefined
+}) {
+  const { config, init, nonce, pending } = options
+  if (pending?.initConfig) return pending.initConfig
+  if (pending?.init && pending.config) return pending.config
+  if (init) return init
+  if (nonce === 0) return config
+  return undefined
+}
+
+function mergeSignatures(signatures: readonly Hex.Hex[]) {
+  const seen = new Set<string>()
+  const out: Hex.Hex[] = []
+  for (const signature of signatures) {
+    const key = signature.toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(signature)
+  }
+  return out
+}
+
+function getApprovals(options: {
+  account: Address
+  config: MultisigConfig.Config
+  payload: Hex.Hex
+  signatures: readonly Hex.Hex[]
+}) {
+  const { account, config, payload } = options
+  const digest = MultisigConfig.getSignPayload({ account, payload })
+  const owners = new Map(
+    config.owners.map((owner) => [
+      owner.owner.toLowerCase(),
+      { address: owner.owner, weight: Number(owner.weight) },
+    ]),
+  )
+  const seen = new Set<string>()
+  const signatures: Hex.Hex[] = []
+  let weight = 0
+
+  for (const value of options.signatures) {
+    const signature = SignatureEnvelope.from(value)
+    const owner = SignatureEnvelope.extractAddress({ payload: digest, signature })
+    const key = owner.toLowerCase()
+    const configured = owners.get(key)
+    if (!configured)
+      throw new RpcResponse.InvalidParamsError({ message: `Signature from non-owner ${owner}.` })
+    if (seen.has(key)) continue
+    const valid = (() => {
+      try {
+        return SignatureEnvelope.verify(signature, { payload: digest, address: configured.address })
+      } catch {
+        return false
+      }
+    })()
+    if (!valid)
+      throw new RpcResponse.InvalidParamsError({
+        message: `Invalid signature from owner ${configured.address}.`,
+      })
+    seen.add(key)
+    signatures.push(SignatureEnvelope.serialize(signature))
+    weight += configured.weight
+  }
+
+  return { signatures, threshold: Number(config.threshold), weight }
+}
+
+async function serializeFinal(options: {
+  account: Address
+  init?: MultisigConfig.Config | undefined
+  signatures: readonly Hex.Hex[]
+  transaction: Record<string, unknown>
+}) {
+  const { signature: _, ...transaction } = options.transaction
+  const envelope = TxEnvelopeTempo.from({
+    ...transaction,
+    feePayerSignature: (() => {
+      const value = transaction['feePayerSignature']
+      // Preserve missing/null fee-payer markers so sponsorship can add signature later.
+      if (!value) return value
+      // Normalize RPC-shaped signatures before rebuilding final transaction envelope.
+      if (typeof value === 'object' && 'r' in value && 's' in value) {
+        const signature = value as {
+          r: bigint | number | string
+          s: bigint | number | string
+          v?: bigint | number | string | undefined
+          yParity?: bigint | number | string | undefined
+        }
+        const yParity = (() => {
+          const value = signature.yParity ?? signature.v
+          // Some signature shapes omit parity until later normalization.
+          if (typeof value === 'undefined') return undefined
+          const number = Number(value)
+          // RPC signatures may carry Ethereum 27/28 `v`; `ox` expects 0/1 parity.
+          if (number === 27 || number === 28) return number - 27
+          return number
+        })()
+        if (typeof yParity === 'number')
+          return Signature.from({ r: BigInt(signature.r), s: BigInt(signature.s), yParity })
+      }
+      // Fall back to `ox` for already-normalized signature inputs.
+      return Signature.from(value as never)
+    })(),
+  } as never)
+  const payload = TxEnvelopeTempo.getSignPayload(envelope)
+  const signatures = options.signatures.map((approval) => SignatureEnvelope.from(approval))
+  const sorted = SignatureEnvelope.sortMultisigApprovals({
+    account: options.account,
+    payload,
+    signatures,
+  })
+  const signature = SignatureEnvelope.from({
+    account: options.account,
+    signatures: sorted,
+    ...(options.init ? { init: options.init } : {}),
+  })
+  return TxEnvelopeTempo.serialize(envelope, {
+    ...('feePayerSignature' in transaction
+      ? { feePayerSignature: transaction['feePayerSignature'] as never }
+      : {}),
+    signature,
+  })
+}
+
+function mergeOperation(
+  existing: Operation | undefined,
+  operation: Operation,
+  patch: Partial<Operation>,
+) {
+  return {
+    ...operation,
+    ...existing,
+    ...patch,
+    config: operation.config ?? existing?.config,
+    init: existing?.init || operation.init,
+    initConfig: existing?.initConfig ?? operation.initConfig,
+    signatures: mergeSignatures([...(existing?.signatures ?? []), ...operation.signatures]),
+    transaction: operation.transaction,
+  } satisfies Operation
+}
+
+function toStatus(options: {
+  approvals: { signatures: readonly Hex.Hex[]; threshold: number; weight: number }
+  operation: Operation
+}): Status {
+  const { approvals, operation } = options
+  return {
+    account: operation.account,
+    chainId: operation.chainId,
+    id: operation.id,
+    signatures: approvals.signatures.length,
+    status: operation.status,
+    submittedHash: operation.submittedHash,
+    threshold: approvals.threshold,
+    weight: approvals.weight,
+  }
+}