viem 2.55.18 → 2.55.19

package/tempo/actions/multisig.ts

@@ -0,0 +1,356 @@
+import type { Address } from 'abitype'
+import { MultisigConfig } from 'ox/tempo'
+import type { Account } from '../../accounts/types.js'
+import type { ReadContractReturnType } from '../../actions/public/readContract.js'
+import { readContract } from '../../actions/public/readContract.js'
+import type { WriteContractReturnType } from '../../actions/wallet/writeContract.js'
+import { writeContract } from '../../actions/wallet/writeContract.js'
+import { writeContractSync } from '../../actions/wallet/writeContractSync.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BaseErrorType } from '../../errors/base.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetEventArgs } from '../../types/contract.js'
+import type { Log } from '../../types/log.js'
+import type { Compute } from '../../types/utils.js'
+import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
+import * as Abis from '../Abis.js'
+import * as Addresses from '../Addresses.js'
+import type { ReadParameters, WriteParameters } from '../internal/types.js'
+import { defineCall } from '../internal/utils.js'
+import type { TransactionReceipt } from '../Transaction.js'
+
+/**
+ * Checks whether an address is an initialized native multisig account.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const initialized = await Actions.multisig.isInitialized(client, {
+ *   account: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Whether the account is an initialized native multisig account.
+ */
+export async function isInitialized<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: isInitialized.Parameters,
+): Promise<isInitialized.ReturnValue> {
+  const { account, ...rest } = parameters
+  return readContract(client, {
+    ...rest,
+    ...isInitialized.call({ account }),
+  })
+}
+
+export namespace isInitialized {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Account address. */
+    account: Address
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.nativeMultisig,
+    'isMultisigAccount',
+    never
+  >
+
+  /**
+   * Defines a call to the precompile's `isMultisigAccount` function.
+   *
+   * Can be passed to [`multicall`](https://viem.sh/docs/contract/multicall).
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    return defineCall({
+      address: Addresses.nativeMultisig,
+      abi: Abis.nativeMultisig,
+      args: [args.account],
+      functionName: 'isMultisigAccount',
+    })
+  }
+}
+
+/**
+ * Gets the current configuration for an initialized native multisig account.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const config = await Actions.multisig.getConfig(client, {
+ *   account: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The current version, threshold, and owners.
+ */
+export async function getConfig<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: getConfig.Parameters,
+): Promise<getConfig.ReturnValue> {
+  const { account, ...rest } = parameters
+  return readContract(client, {
+    ...rest,
+    ...getConfig.call({ account }),
+  })
+}
+
+export namespace getConfig {
+  export type Parameters = ReadParameters & Args
+
+  export type Args = {
+    /** Initialized multisig account address. */
+    account: Address
+  }
+
+  export type ReturnValue = ReadContractReturnType<
+    typeof Abis.nativeMultisig,
+    'getConfig',
+    never
+  >
+
+  /**
+   * Defines a call to the `getConfig` function.
+   *
+   * Can be passed to [`multicall`](https://viem.sh/docs/contract/multicall).
+   *
+   * @param args - Arguments.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    return defineCall({
+      address: Addresses.nativeMultisig,
+      abi: Abis.nativeMultisig,
+      args: [args.account],
+      functionName: 'getConfig',
+    })
+  }
+}
+
+/**
+ * Replaces the current configuration for a native multisig account.
+ *
+ * The transaction must be authorized directly by the account's current owner
+ * quorum. Local owner-signing flows can include {@link updateConfig.call} in a
+ * prepared transaction before collecting approvals.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { sendTransactionSync } from 'viem/actions'
+ * import { tempoLocalnet } from 'viem/chains'
+ * import { Account, Actions } from 'viem/tempo'
+ *
+ * const owner = Account.fromSecp256k1(
+ *   '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+ * )
+ * const account = Account.fromMultisig({ owners: [owner] })
+ * const client = createClient({
+ *   chain: tempoLocalnet,
+ *   transport: http(),
+ * })
+ *
+ * await sendTransactionSync(client, {
+ *   account,
+ *   to: account.address,
+ * })
+ *
+ * const hash = await Actions.multisig.updateConfig(client, {
+ *   account,
+ *   threshold: 1,
+ *   owners: [{ owner: owner.address, weight: 1 }],
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The transaction hash.
+ */
+export async function updateConfig<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: updateConfig.Parameters<chain, account>,
+): Promise<updateConfig.ReturnValue> {
+  return updateConfig.inner(writeContract, client, parameters)
+}
+
+export namespace updateConfig {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = WriteParameters<chain, account> & Args
+
+  export type Args = {
+    /** New multisig owners and their weights. */
+    owners: MultisigConfig.Config['owners']
+    /** New signature weight required to authorize the account. */
+    threshold: MultisigConfig.Config['threshold']
+  }
+
+  export type ReturnValue = WriteContractReturnType
+
+  // TODO: exhaustive error type
+  export type ErrorType = BaseErrorType
+
+  /** @internal */
+  export async function inner<
+    action extends typeof writeContract | typeof writeContractSync,
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    action: action,
+    client: Client<Transport, chain, account>,
+    parameters: Parameters<chain, account>,
+  ): Promise<ReturnType<action>> {
+    const { owners, threshold, ...rest } = parameters
+    return (await action(client, {
+      ...rest,
+      ...updateConfig.call({ owners, threshold }),
+    } as never)) as never
+  }
+
+  /**
+   * Defines a call to the `updateConfig` function.
+   *
+   * Can be passed as a parameter to:
+   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate gas
+   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the update
+   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): include the update in a call batch
+   *
+   * @example
+   * ```ts
+   * import { Actions } from 'viem/tempo'
+   *
+   * const call = Actions.multisig.updateConfig.call({
+   *   threshold: 1,
+   *   owners: [{ owner: '0x...', weight: 1 }],
+   * })
+   * ```
+   *
+   * @param args - New multisig configuration.
+   * @returns The call.
+   */
+  export function call(args: Args) {
+    const config = MultisigConfig.from(args)
+    return defineCall({
+      address: Addresses.nativeMultisig,
+      abi: Abis.nativeMultisig,
+      args: [config.threshold, config.owners],
+      functionName: 'updateConfig',
+    })
+  }
+
+  /**
+   * Extracts the `MultisigConfigUpdated` event from logs.
+   *
+   * @param logs - Transaction logs.
+   * @returns The configuration update event.
+   */
+  export function extractEvent(logs: Log[]) {
+    const [log] = parseEventLogs({
+      abi: Abis.nativeMultisig,
+      logs,
+      eventName: 'MultisigConfigUpdated',
+      strict: true,
+    })
+    if (!log) throw new Error('`MultisigConfigUpdated` event not found.')
+    return log
+  }
+}
+
+/**
+ * Replaces a native multisig configuration and waits for confirmation.
+ *
+ * @example
+ * ```ts
+ * import { createWalletClient, custom, type EIP1193Provider } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * declare const provider: EIP1193Provider
+ *
+ * const client = createWalletClient({
+ *   account: '0x...',
+ *   chain: tempo,
+ *   transport: custom(provider),
+ * })
+ *
+ * const { receipt } = await Actions.multisig.updateConfigSync(client, {
+ *   threshold: 1,
+ *   owners: [{ owner: '0x...', weight: 1 }],
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The updated configuration event and transaction receipt.
+ */
+export async function updateConfigSync<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: updateConfigSync.Parameters<chain, account>,
+): Promise<updateConfigSync.ReturnValue> {
+  const { throwOnReceiptRevert = true, ...rest } = parameters
+  const receipt = await updateConfig.inner(writeContractSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+  } as never)
+  const { args } = updateConfig.extractEvent(receipt.logs)
+  return { ...args, receipt } as never
+}
+
+export namespace updateConfigSync {
+  export type Parameters<
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  > = updateConfig.Parameters<chain, account>
+
+  export type Args = updateConfig.Args
+
+  export type ReturnValue = Compute<
+    GetEventArgs<
+      typeof Abis.nativeMultisig,
+      'MultisigConfigUpdated',
+      { IndexedOnly: false; Required: true }
+    > & {
+      receipt: TransactionReceipt
+    }
+  >
+
+  export type ErrorType = updateConfig.ErrorType
+}

package/tempo/chainConfig.ts

@@ -15,9 +15,14 @@ import { keccak256 } from '../utils/hash/keccak256.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
 import type { Account, MultisigAccount } from './Account.js'
 import { getMetadata } from './actions/accessKey.js'
+import * as multisig from './actions/multisig.js'
 import * as Formatters from './Formatters.js'
 import type { Hardfork } from './Hardfork.js'
 import * as Concurrent from './internal/concurrent.js'
+import {
+  createMultisigStateResolver,
+  getMultisigOwnerStates,
+} from './internal/multisig.js'
 import * as Transaction from './Transaction.js'
 
 const maxExpirySecs = 25
@@ -60,7 +65,10 @@ export const chainConfig = {
           | undefined
         feePayerSignature?: Transaction.TransactionSerializableTempo['feePayerSignature']
         from?: Address | undefined
-        multisig?: MultisigConfig.Config | undefined
+        keyData?: Hex.Hex | undefined
+        keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
+        multisig?: Address | MultisigConfig.Config | undefined
+        multisigOwnerStates?: Transaction.TransactionRequestTempo['multisigOwnerStates']
         signatures?: readonly unknown[] | undefined
       }
 
@@ -82,36 +90,88 @@ export const chainConfig = {
         return request as unknown as typeof r
       }
 
-      // Native multisig (TIP-1061). The transaction sender is the derived
-      // multisig account, not a signing account (owner accounts only contribute
-      // approvals later via `signTransaction`). Derive the sender from the
-      // config; core fills nonce/gas/fees for it via `request.from`, and the
-      // serializer auto-detects bootstrap (`init`) from `nonce == 0`.
+      // Native multisig (TIP-1061). The transaction sender is the stable
+      // multisig address, not a signing account. Initial configs support
+      // bootstrap; initialized accounts can be reconstructed from their
+      // address and resolved through the multisig precompile.
       //
       // The config is taken from an explicit `multisig` field, or inferred from
       // a multisig account (so callers can just pass `account` to
       // `prepareTransactionRequest` without also passing `multisig`).
-      const multisig =
+      const multisigIdentity =
         request.multisig ??
         (request.account?.source === 'multisig'
-          ? (request.account as MultisigAccount).config
+          ? ((request.account as MultisigAccount).config ??
+            request.account.address)
           : undefined)
-      if (multisig) {
-        const config = MultisigConfig.from(multisig)
-        request.multisig = config
-        request.from = MultisigConfig.getAddress(config)
-        request.multisigInit = {
-          salt: config.salt ?? MultisigConfig.zeroSalt,
-          threshold: Number(config.threshold),
-          owners: config.owners.map((owner) => ({
-            owner: owner.owner,
-            weight: Number(owner.weight),
-          })),
+      if (multisigIdentity) {
+        const initialConfig =
+          typeof multisigIdentity === 'string'
+            ? undefined
+            : MultisigConfig.from(multisigIdentity)
+        const multisigAddress =
+          typeof multisigIdentity === 'string'
+            ? multisigIdentity
+            : MultisigConfig.getAddress(initialConfig!)
+        request.multisig = initialConfig ?? multisigIdentity
+        request.from = multisigAddress
+        // Key types are not part of the config, so conservatively model every
+        // approval as a maximum-size WebAuthn signature.
+        if (typeof request.keyType === 'undefined') {
+          request.keyType = 'webAuthn'
+          if (typeof request.keyData === 'undefined') request.keyData = '0x0578'
+        }
+        const getState = createMultisigStateResolver((account) =>
+          getAction(client, multisig.getConfig, 'getConfig')({ account }),
+        )
+        const ownerStates =
+          request.account?.source === 'multisig'
+            ? getMultisigOwnerStates(
+                request.account as MultisigAccount,
+                getState,
+              )
+            : undefined
+        const state = ownerStates
+          ? (await ownerStates)[0]!
+          : await getState(multisigAddress)
+        if (!initialConfig && !state.initialized)
+          throw new Error(
+            'Cannot prepare an uninitialized multisig account from an address. Provide its initial config instead.',
+          )
+        if (typeof request.multisigVersion === 'undefined')
+          request.multisigVersion = state.version
+        const authorizationSignature = request.keyAuthorization?.signature
+        if (
+          authorizationSignature?.type === 'multisig' &&
+          typeof authorizationSignature.init !== 'undefined'
+        )
+          request.keyAuthorization = {
+            ...request.keyAuthorization!,
+            signature: SignatureEnvelope.from({
+              initialConfig: authorizationSignature.init,
+              signatures: authorizationSignature.signatures,
+            }),
+          }
+        const keyAuthorizationSignature = request.keyAuthorization?.signature
+        const keyAuthorizationInitializes =
+          keyAuthorizationSignature?.type === 'multisig' &&
+          typeof keyAuthorizationSignature.init !== 'undefined'
+        if (initialConfig && !keyAuthorizationInitializes)
+          request.multisigInit = {
+            salt: initialConfig.salt ?? MultisigConfig.zeroSalt,
+            threshold: Number(initialConfig.threshold),
+            owners: initialConfig.owners.map((owner) => ({
+              owner: owner.owner,
+              weight: Number(owner.weight),
+            })),
+          }
+        if (ownerStates) {
+          const states = await ownerStates
+          if (states.length > 0) request.multisigOwnerStates = states
         }
-        request.multisigSignatureCount ??= inferMultisigSignatureCount(config)
         // A non-multisig `account` (e.g. the client's default) isn't the sender,
         // so drop it: core then fills nonce/gas/fees for the multisig sender via
-        // `request.from`. A multisig account *is* the sender — keep it so the
+        // `request.from`. A multisig account *is* the sender, so keep it so the
         // prepared request can be sent without re-passing `account`.
         if (request.account?.source !== 'multisig') delete request.account
       }
@@ -121,7 +181,7 @@ export const chainConfig = {
       const useExpiringNonce = await (async () => {
         if (request.nonceKey === 'expiring' || request.nonceKey === maxUint256)
           return true
-        if (multisig) return false
+        if (multisigIdentity) return false
         if (request.feePayer && typeof request.nonceKey === 'undefined')
           return true
         const account = request.account as
@@ -286,16 +346,3 @@ export const chainConfig = {
 } as const satisfies viem_ChainConfig & { blockTime: number }
 
 export type ChainConfig = typeof chainConfig
-
-function inferMultisigSignatureCount(config: MultisigConfig.Config) {
-  const threshold = Number(config.threshold)
-  const weights = config.owners
-    .map((owner) => Number(owner.weight))
-    .sort((a, b) => b - a)
-  let total = 0
-  for (const [index, weight] of weights.entries()) {
-    total += weight
-    if (total >= threshold) return index + 1
-  }
-  return weights.length
-}

package/tempo/internal/multisig.ts

@@ -0,0 +1,72 @@
+import type { Address } from 'abitype'
+import type { MultisigConfig } from 'ox/tempo'
+import { BaseError } from '../../errors/base.js'
+import { ContractFunctionRevertedError } from '../../errors/contract.js'
+import type { MultisigAccount } from '../Account.js'
+import type { MultisigOwnerState } from '../Transaction.js'
+
+/** @internal */
+export function createMultisigStateResolver(
+  getConfig: (account: Address) => Promise<{
+    owners: MultisigConfig.Config['owners']
+    threshold: MultisigConfig.Config['threshold']
+    version: bigint
+  }>,
+) {
+  // Cache only within one operation because config versions can change between requests.
+  const cache = new Map<Address, Promise<MultisigOwnerState>>()
+  return (account: Address): Promise<MultisigOwnerState> => {
+    const address = account.toLowerCase() as Address
+    const cached = cache.get(address)
+    if (cached) return cached
+
+    const state = (async () => {
+      try {
+        const config = await getConfig(account)
+        return {
+          account,
+          config: { owners: config.owners, threshold: config.threshold },
+          initialized: true,
+          version: config.version,
+        }
+      } catch (error) {
+        const cause =
+          error instanceof BaseError
+            ? error.walk(
+                (error) => error instanceof ContractFunctionRevertedError,
+              )
+            : undefined
+        if (
+          !(cause instanceof ContractFunctionRevertedError) ||
+          cause.data?.errorName !== 'NotMultisigAccount'
+        )
+          throw error
+        return { account, initialized: false, version: 0n }
+      }
+    })()
+    cache.set(address, state)
+    return state
+  }
+}
+
+/** @internal */
+export function getMultisigOwnerStates(
+  account: MultisigAccount,
+  getState: (account: Address) => Promise<MultisigOwnerState>,
+): Promise<readonly MultisigOwnerState[]> {
+  // Collect locally first so all config reads start in one latency wave.
+  const owners: MultisigAccount[] = [account]
+  const seen = new Set<Address>([account.address.toLowerCase() as Address])
+  const visit = (account: MultisigAccount) => {
+    for (const owner of account.owners) {
+      if (owner.source !== 'multisig') continue
+      const address = owner.address.toLowerCase() as Address
+      if (seen.has(address)) continue
+      seen.add(address)
+      owners.push(owner as MultisigAccount)
+      visit(owner as MultisigAccount)
+    }
+  }
+  visit(account)
+  return Promise.all(owners.map((owner) => getState(owner.address)))
+}