viem 2.56.1 → 2.56.3

package/tempo/Selectors.ts

@@ -51,9 +51,8 @@ export const addressRegistry = {
 
 export const nativeMultisig = {
   deriveAccount: '0xce8e071c',
-  getConfig: '0xe48a5f7b',
-  isMultisigAccount: '0x9fbf029a',
-  updateConfig: '0xe175d479',
+  getConfigCommitment: '0x5bd93359',
+  updateConfig: '0x64203645',
 } as const satisfies FunctionSelectors<typeof Abis.nativeMultisig>
 
 export const currentCommittee = {

package/tempo/Store.ts

@@ -0,0 +1,170 @@
+import type { MaybePromise } from '../types/utils.js'
+
+export type Store = {
+  /** Atomically replaces `expected` with `value` when supported. */
+  compareAndSet?: CompareAndSet | undefined
+  /** Reads a value. */
+  getItem(key: string): MaybePromise<string | null | undefined>
+  /** Removes a value. */
+  removeItem(key: string): MaybePromise<void>
+  /** Writes a value. */
+  setItem(key: string, value: string): MaybePromise<void>
+}
+
+/** Atomic compare-and-set operation. */
+export type CompareAndSet = (
+  key: string,
+  expected: string | null,
+  value: string,
+  options?: CompareAndSet.Options | undefined,
+) => MaybePromise<boolean>
+
+export declare namespace CompareAndSet {
+  /** Compare-and-set options. */
+  export type Options = {
+    /** Unix timestamp in milliseconds after which the value expires. */
+    expiresAt?: number | undefined
+  }
+}
+
+/** Store with atomic compare-and-set support. */
+export type Atomic = Store & {
+  /** Atomically replaces `expected` with `value` and applies its expiration. */
+  compareAndSet: CompareAndSet
+}
+
+/**
+ * Wraps a base store with an optional key prefix and request deduplication.
+ * Concurrent `getItem` calls for the same key share one in-flight promise.
+ *
+ * @example
+ * ```ts
+ * import { Store } from 'viem/tempo'
+ *
+ * const store = Store.from(Store.memory(), { key: 'tempo' })
+ * await store.setItem('foo', 'bar')
+ * // stored under "tempo:foo"
+ * ```
+ */
+export function from(store: Atomic, options?: from.Options | undefined): Atomic
+export function from(store: Store, options?: from.Options | undefined): Store
+export function from(store: Store, options: from.Options = {}): Store {
+  const { key } = options
+  const prefix = key ? `${key}:` : ''
+  const inflight = new Map<string, Promise<string | null | undefined>>()
+  const compareAndSet = store.compareAndSet?.bind(store)
+  return {
+    ...(compareAndSet
+      ? {
+          compareAndSet(k, expected, value, options) {
+            const fullKey = `${prefix}${k}`
+            inflight.delete(fullKey)
+            return compareAndSet(fullKey, expected, value, options)
+          },
+        }
+      : {}),
+    getItem(k) {
+      const fullKey = `${prefix}${k}`
+      const existing = inflight.get(fullKey)
+      if (existing) return existing
+      const result = Promise.resolve(store.getItem(fullKey)).finally(() => {
+        inflight.delete(fullKey)
+      })
+      inflight.set(fullKey, result)
+      return result
+    },
+    setItem(k, value) {
+      const fullKey = `${prefix}${k}`
+      inflight.delete(fullKey)
+      return store.setItem(fullKey, value)
+    },
+    removeItem(k) {
+      const fullKey = `${prefix}${k}`
+      inflight.delete(fullKey)
+      return store.removeItem(fullKey)
+    },
+  }
+}
+
+export declare namespace from {
+  /** Store options. */
+  type Options = {
+    /** Key prefix prepended to all store keys. */
+    key?: string | undefined
+  }
+}
+
+/** Creates an in-memory store backed by a `Map`. */
+export function memory(options: from.Options = {}): Atomic {
+  const store = new Map<
+    string,
+    { expiresAt: number | undefined; value: string }
+  >()
+  const get = (key: string) => {
+    const entry = store.get(key)
+    if (!entry) return undefined
+    if (entry.expiresAt === undefined || entry.expiresAt > Date.now())
+      return entry
+    store.delete(key)
+    return undefined
+  }
+  return from(
+    {
+      compareAndSet(key, expected, value, options) {
+        if ((get(key)?.value ?? null) !== expected) return false
+        store.set(key, { expiresAt: options?.expiresAt, value })
+        return true
+      },
+      getItem(key) {
+        return get(key)?.value ?? null
+      },
+      setItem(key, value) {
+        store.set(key, { expiresAt: undefined, value })
+      },
+      removeItem(key) {
+        store.delete(key)
+      },
+    },
+    options,
+  )
+}
+
+/** Creates a store backed by `globalThis.sessionStorage`. */
+export function session(options: from.Options = {}): Store {
+  return from(
+    {
+      getItem(key) {
+        return globalThis.sessionStorage.getItem(key)
+      },
+      setItem(key, value) {
+        try {
+          globalThis.sessionStorage.setItem(key, value)
+        } catch {}
+      },
+      removeItem(key) {
+        globalThis.sessionStorage.removeItem(key)
+      },
+    },
+    options,
+  )
+}
+
+let _default: Store | undefined
+
+/**
+ * Returns the default store for the current environment.
+ *
+ * Returns a singleton so that the zone transport and actions share the
+ * same instance without requiring explicit plumbing.
+ *
+ * - Browser: `sessionStorage`
+ * - Server/unsupported: in-memory `Map`-based store
+ */
+export function defaultStore(): Store {
+  if (_default) return _default
+  try {
+    if (globalThis.sessionStorage) _default = session()
+  } catch {}
+  _default ??= memory()
+  return _default
+}

package/tempo/Transaction.ts

@@ -6,7 +6,9 @@ import * as Signature from 'ox/Signature'
 import {
   type AuthorizationTempo,
   type KeyAuthorization,
-  type MultisigConfig,
+  MultisigConfig,
+  type MultisigOperation,
+  type MultisigSimulation,
   type TransactionReceipt as ox_TransactionReceipt,
   SignatureEnvelope,
   type TempoAddress,
@@ -40,6 +42,7 @@ import {
   parseTransaction as viem_parseTransaction,
 } from '../utils/transaction/parseTransaction.js'
 import { serializeTransaction as viem_serializeTransaction } from '../utils/transaction/serializeTransaction.js'
+import type { MultisigAccount, RootAccount } from './Account.js'
 
 export type Transaction<
   bigintType = bigint,
@@ -57,6 +60,7 @@ export type TransactionRpc<pending extends boolean = false> = OneOf<
     > & {
       authorizationList?: AuthorizationTempo.ListRpc | undefined
       keyAuthorization?: KeyAuthorization.Rpc | null | undefined
+      multisig?: MultisigOperation.TransactionRpc | undefined
       signature: SignatureEnvelope.SignatureEnvelopeRpc
     })
 >
@@ -77,6 +81,7 @@ export type TransactionTempo<
   feeToken?: Address | undefined
   feePayerSignature?: viem_Signature | undefined
   keyAuthorization?: KeyAuthorization.Signed<quantity, index> | null | undefined
+  multisig?: MultisigOperation.TransactionOperation | undefined
   nonceKey?: quantity | undefined
   signature: SignatureEnvelope.SignatureEnvelope
   type: type
@@ -98,28 +103,23 @@ export type TransactionRequestRpc = OneOf<
 export type TransactionReceipt<
   quantity = bigint,
   index = number,
-  status = 'success' | 'reverted',
+  status = 'success' | 'reverted' | 'pending',
   type = TransactionType,
+  multisig = MultisigOperation.TransactionOperation,
 > = viem_TransactionReceipt<quantity, index, status, type> & {
   feePayer?: Address | undefined
   feeToken?: Address | undefined
+  multisig?: multisig | undefined
 }
 
 export type TransactionReceiptRpc = TransactionReceipt<
   Hex.Hex,
   Hex.Hex,
-  ox_TransactionReceipt.RpcStatus,
-  ox_TransactionReceipt.RpcType
+  ox_TransactionReceipt.RpcStatus | 'pending',
+  ox_TransactionReceipt.RpcType,
+  MultisigOperation.TransactionRpc
 >
 
-/** @internal */
-export type MultisigOwnerState = {
-  account: Address
-  config?: Pick<MultisigConfig.Config, 'owners' | 'threshold'> | undefined
-  initialized: boolean
-  version: bigint
-}
-
 export type TransactionRequestTempo<
   quantity = bigint,
   index = number,
@@ -131,23 +131,11 @@ export type TransactionRequestTempo<
     capabilities?: ExtractCapabilities<'fillTransaction', 'Request'> | undefined
     feePayer?: Account | true | undefined
     feeToken?: TempoAddress.Address | bigint | undefined
+    hash?: Hex.Hex | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, 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?:
-      | {
-          salt: Hex.Hex
-          threshold: number
-          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
+    multisigSimulation?: MultisigSimulation.Spec | undefined
     nonceKey?: 'expiring' | quantity | undefined
+    owner?: MultisigAccount | RootAccount | undefined
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined
     validAfter?: index | undefined
@@ -169,12 +157,9 @@ export type TransactionSerializableTempo<
     feePayerSignature?: viem_Signature | null | undefined
     from?: Address | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, 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
+    multisigSimulation?: MultisigSimulation.Spec | undefined
     nonceKey?: quantity | undefined
+    owner?: MultisigAccount | RootAccount | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined
@@ -206,9 +191,9 @@ export function getType(
     typeof transaction.feePayerSignature !== 'undefined' ||
     typeof transaction.feeToken !== 'undefined' ||
     typeof transaction.keyAuthorization !== 'undefined' ||
-    typeof transaction.multisig !== 'undefined' ||
-    typeof transaction.multisigVersion !== 'undefined' ||
+    typeof transaction.multisigSimulation !== 'undefined' ||
     typeof transaction.nonceKey !== 'undefined' ||
+    typeof transaction.owner !== 'undefined' ||
     typeof transaction.signature !== 'undefined' ||
     typeof transaction.signatures !== 'undefined' ||
     typeof transaction.validBefore !== 'undefined' ||
@@ -326,7 +311,14 @@ async function serializeTempo(
     return undefined
   })()
 
-  const { chainId, feePayer, nonce, ...rest } = transaction
+  const {
+    chainId,
+    feePayer,
+    multisigSimulation,
+    nonce,
+    owner: _owner,
+    ...rest
+  } = transaction
 
   const feePayerSignature = (() => {
     const feePayerSignature = transaction.feePayerSignature
@@ -344,7 +336,7 @@ async function serializeTempo(
     transaction.feePayerSignature !== null
   const hasSenderSignature =
     typeof signature_provided !== 'undefined' ||
-    Boolean(transaction.multisig && transaction.signatures)
+    Boolean(multisigSimulation && transaction.signatures)
   // Sponsorship sender signatures omit `feeToken`.
   const shouldStripFeeTokenForSponsorship =
     // Relay fills a partial sender envelope first.
@@ -385,41 +377,24 @@ async function serializeTempo(
   // Combine owner approvals before fee-payer handling.
   const signature = (() => {
     if (signature_provided) return signature_provided
-    if (!transaction.multisig || !transaction.signatures) return undefined
+    if (!multisigSimulation || !transaction.signatures) return undefined
 
     const payload = TxTempo.getSignPayload(TxTempo.from(transaction_sender_ox))
     const signatures = transaction.signatures.map((approval) =>
       SignatureEnvelope.from(approval),
     )
-    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,
-      })
+    const config = MultisigConfig.from(multisigSimulation.config)
+    const account = multisigSimulation.account
+    const sorted = SignatureEnvelope.sortMultisigApprovals({
+      account,
+      config,
+      payload,
+      signatures,
+    })
     return SignatureEnvelope.from({
-      initialConfig: transaction.multisig,
+      account,
+      config,
       signatures: sorted,
-      ...(nonce || transaction.nonceKey || keyAuthorizationInitializes
-        ? {}
-        : { init: true }),
     })
   })()
 

package/tempo/Transport.ts

@@ -17,24 +17,29 @@ import {
   type HttpTransportConfig,
   http as http_,
 } from '../clients/transports/http.js'
+import {
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+} from '../errors/rpc.js'
 import type { Chain } from '../types/chain.js'
 import type { ChainConfig } from './chainConfig.js'
-import type { Storage } from './Storage.js'
-import * as Storage_ from './Storage.js'
+import * as Multisig from './Multisig.js'
+import type { Store } from './Store.js'
+import * as Store_ from './Store.js'
 import * as Transaction from './Transaction.js'
 
 export type HttpConfig = Omit<
   HttpTransportConfig,
   'batch' | 'raw' | 'rpcSchema'
 > & {
-  /** Storage for reading Zone authorization tokens. Defaults to sessionStorage (web) or memory (server). */
-  storage?: Storage | undefined
+  /** Store for reading Zone authorization tokens. Defaults to sessionStorage (web) or memory (server). */
+  store?: Store | undefined
 }
 
 /**
  * Creates an HTTP transport with support for Zone authentication tokens.
  *
- * Reads the authorization token from Storage and injects the
+ * Reads the authorization token from the store and injects the
  * `X-Authorization-Token` header on every request.
  *
  * @example
@@ -52,8 +57,8 @@ export function http(
   url?: string | undefined,
   config: HttpConfig = {},
 ): HttpTransport {
-  const { storage: storage_, onFetchRequest, ...rest } = config
-  const storage = storage_ ?? Storage_.defaultStorage()
+  const { store: store_, onFetchRequest, ...rest } = config
+  const store = store_ ?? Store_.defaultStore()
 
   return (config) =>
     http_(url, {
@@ -64,7 +69,7 @@ export function http(
 
         const chainId = config.chain?.id
         if (chainId) {
-          const token = (await storage.getItem(`auth:token:${chainId}`)) ?? null
+          const token = (await store.getItem(`auth:token:${chainId}`)) ?? null
           if (token) headers.set('X-Authorization-Token', token)
         }
 
@@ -79,7 +84,64 @@ type RelayProxyParameters = {
 }
 
 export type FeePayer = Transport<typeof withFeePayer.type>
-export type Relay = Transport<typeof withRelay.type>
+export type Relay = Transport<typeof withRelay.type, { multisig: true }>
+
+/**
+ * Wraps a transport with native multisig request handling.
+ *
+ * @example
+ * ```ts
+ * import { http, Store, withMultisig } from 'viem/tempo'
+ *
+ * const transport = withMultisig(http(), {
+ *   store: Store.memory(),
+ * })
+ * ```
+ *
+ * @param transport - Transport to wrap.
+ * @param parameters - Multisig request handler parameters.
+ * @returns The wrapped transport.
+ * @experimental
+ */
+export function withMultisig<transport extends Transport>(
+  transport: transport,
+  parameters: withMultisig.Parameters,
+): withMultisig.ReturnValue<transport> {
+  return ((options: Parameters<Transport>[0]) => {
+    const value = transport(options)
+    return {
+      ...value,
+      request: Multisig.handleRequest(
+        (request, requestOptions) =>
+          value.request(request as never, requestOptions),
+        parameters,
+      ) as typeof value.request,
+      value: { ...value.value, multisig: true },
+    }
+  }) as withMultisig.ReturnValue<transport>
+}
+
+export declare namespace withMultisig {
+  /** Multisig transport parameters. */
+  export type Parameters = Multisig.handleRequest.Parameters
+
+  /** Multisig transport return type. */
+  export type ReturnValue<transport extends Transport = Transport> =
+    transport extends Transport<
+      infer type,
+      infer rpcAttributes,
+      infer eip1193RequestFn
+    >
+      ? Transport<
+          type,
+          rpcAttributes & {
+            /** Whether the transport coordinates native multisig approvals. */
+            multisig: true
+          },
+          eip1193RequestFn
+        >
+      : never
+}
 
 /**
  * Creates a relay transport that routes requests between
@@ -87,6 +149,8 @@ export type Relay = Transport<typeof withRelay.type>
  *
  * All `eth_fillTransaction` requests are sent to the relay with the request's
  * `feePayer` value preserved so the relay can decide whether to sponsor the transaction.
+ * Multisig approvals, configs, operations, and operation-aware transaction
+ * lookups are also sent to the relay so it can coordinate approvals in its store.
  *
  * The policy parameter controls how the relay handles sponsored transactions:
  * - `'sign-only'`: Relay co-signs the transaction and returns it to the client transport, which then broadcasts it via the default transport
@@ -108,13 +172,60 @@ export function withRelay(
     const transport_default = defaultTransport(config)
     const transport_relay = relayTransport(config)
 
-    return createTransport({
+    const transport = createTransport({
       key: withRelay.type,
       name: 'Relay Proxy',
       async request({ method, params }, options) {
         if (method === 'eth_fillTransaction')
           return transport_relay.request({ method, params }, options) as never
 
+        if (
+          method === 'eth_getTransactionByHash' ||
+          method === 'eth_getTransactionReceipt'
+        ) {
+          const result = await transport_default.request(
+            { method, params },
+            options,
+          )
+          if (result !== null && typeof result !== 'undefined')
+            return result as never
+
+          const operation = await (async () => {
+            try {
+              return await transport_relay.request(
+                { method: 'multisig_getOperation', params },
+                options,
+              )
+            } catch (error) {
+              if (
+                error instanceof MethodNotFoundRpcError ||
+                error instanceof MethodNotSupportedRpcError
+              ) {
+                // Relays created before multisig coordination do not expose this method.
+                return null
+              }
+              throw error
+            }
+          })()
+          if (
+            !operation ||
+            typeof operation !== 'object' ||
+            !('type' in operation) ||
+            operation.type !== 'transaction'
+          )
+            return result as never
+          return transport_relay.request({ method, params }, options) as never
+        }
+
+        if (
+          method === 'multisig_approveKeyAuthorization' ||
+          method === 'multisig_approveRawTransaction' ||
+          method === 'multisig_approveRawTransactionSync' ||
+          method === 'multisig_getConfig' ||
+          method === 'multisig_getOperation'
+        )
+          return transport_relay.request({ method, params }, options) as never
+
         if (
           method === 'eth_sendRawTransactionSync' ||
           method === 'eth_sendRawTransaction'
@@ -122,6 +233,9 @@ export function withRelay(
           const serialized = (params as any)[0] as `0x76${string}`
           const transaction = Transaction.deserialize(serialized)
 
+          if (transaction.signature?.type === 'multisig')
+            return transport_relay.request({ method, params }, options) as never
+
           // Serialized Tempo envelopes encode `feePayer: true` as a missing fee payer
           // signature until the relay co-signs the transaction.
           if (transaction.feePayerSignature === null) {
@@ -159,6 +273,7 @@ export function withRelay(
       },
       type: withRelay.type,
     })
+    return { ...transport, value: { multisig: true } }
   }
 }
 

package/tempo/Zone.ts

@@ -1,9 +1,30 @@
-import type { Chain } from '../types/chain.js'
-import { defineChain } from '../utils/chain/defineChain.js'
-import { chainConfig } from './chainConfig.js'
+import type { Chain, ChainFormatters } from '../types/chain.js'
+import type { Assign } from '../types/utils.js'
+import {
+  type DefineChainReturnType,
+  defineChain,
+} from '../utils/chain/defineChain.js'
+import { type ChainConfig, chainConfig } from './chainConfig.js'
+
+type Defaults = {
+  nativeCurrency: {
+    decimals: number
+    name: string
+    symbol: string
+  }
+  rpcUrls: { default: { http: string[] } }
+  supportsTransactionReplacementDetection: boolean
+}
+
+type ZoneChain = Chain<ChainFormatters, ChainConfig['extendSchema']> & {
+  formatters: ChainConfig['formatters']
+}
 
 /** Defines a Tempo Zone chain. */
-export function from<const config extends from.Parameters>(config: config) {
+export function from<const config extends from.Parameters>(
+  config: config,
+): from.ReturnValue<config>
+export function from(config: from.Parameters) {
   const chain = {
     ...chainConfig,
     nativeCurrency: {
@@ -23,6 +44,11 @@ export declare namespace from {
     Partial<Omit<Chain, 'id' | 'name' | 'sourceId'>> & {
       sourceId: number
     }
+
+  type ReturnValue<config extends Parameters = Parameters> = Assign<
+    Assign<DefineChainReturnType<ZoneChain>, Defaults>,
+    config
+  >
 }
 
 export const a = /*#__PURE__*/ from({