viem 2.56.0 → 2.56.2

package/tempo/actions/multisig.ts

@@ -1,5 +1,11 @@
 import type { Address } from 'abitype'
-import { MultisigConfig } from 'ox/tempo'
+import type * as Hex from 'ox/Hex'
+import type * as RpcSchema from 'ox/RpcSchema'
+import {
+  MultisigConfig,
+  MultisigOperation,
+  type RpcSchemaTempo,
+} 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'
@@ -10,87 +16,65 @@ 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 { fromMultisig, type MultisigAccount } from '../Account.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'
+import type * as Transaction from '../Transaction.js'
 
 /**
- * Checks whether an address is an initialized native multisig account.
+ * Gets the current cached config for a multisig account.
+ *
+ * The coordinator reads the account's current onchain commitment and returns
+ * the matching config from its store. It returns `null` when the config is not
+ * cached.
  *
  * @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...',
+ * const config = await client.multisig.getConfig({
+ *   address: '0x...',
  * })
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns Whether the account is an initialized native multisig account.
+ * @returns The config, or `null` when it is unknown.
  */
-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 async function getConfig(
+  client: Client,
+  parameters: getConfig.Parameters,
+): Promise<getConfig.ReturnValue> {
+  const config = await client.request<{
+    Method: 'multisig_getConfig'
+    Parameters: [{ address: Address }]
+    ReturnType: MultisigConfig.Rpc | null
+  }>({
+    method: 'multisig_getConfig',
+    params: [{ address: parameters.address }],
   })
+  return config ? MultisigConfig.fromRpc(config) : null
 }
 
-export namespace isInitialized {
-  export type Parameters = ReadParameters & Args
-
-  export type Args = {
-    /** Account address. */
-    account: Address
+export declare namespace getConfig {
+  /** Parameters for {@link getConfig}. */
+  export type Parameters = {
+    /** Multisig account address. */
+    address: Address
   }
 
-  export type ReturnValue = ReadContractReturnType<
-    typeof Abis.nativeMultisig,
-    'isMultisigAccount',
-    never
-  >
+  /** Return value for {@link getConfig}. */
+  export type ReturnValue = MultisigConfig.Config | null
 
-  /**
-   * 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',
-    })
-  }
+  /** Error type for {@link getConfig}. */
+  export type ErrorType = BaseErrorType
 }
 
 /**
- * Gets the current configuration for an initialized native multisig account.
+ * Gets the current configuration commitment for a native multisig account.
  *
  * @example
  * ```ts
@@ -103,30 +87,31 @@ export namespace isInitialized {
  *   transport: http(),
  * })
  *
- * const config = await Actions.multisig.getConfig(client, {
+ * const commitment = await Actions.multisig.getConfigCommitment(client, {
  *   account: '0x...',
  * })
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The current version, threshold, and owners.
+ * @returns The current configuration commitment, or zero when no config has
+ * been committed.
  */
-export async function getConfig<
+export async function getConfigCommitment<
   chain extends Chain | undefined,
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: getConfig.Parameters,
-): Promise<getConfig.ReturnValue> {
+  parameters: getConfigCommitment.Parameters,
+): Promise<getConfigCommitment.ReturnValue> {
   const { account, ...rest } = parameters
   return readContract(client, {
     ...rest,
-    ...getConfig.call({ account }),
+    ...getConfigCommitment.call({ account }),
   })
 }
 
-export namespace getConfig {
+export namespace getConfigCommitment {
   export type Parameters = ReadParameters & Args
 
   export type Args = {
@@ -136,12 +121,12 @@ export namespace getConfig {
 
   export type ReturnValue = ReadContractReturnType<
     typeof Abis.nativeMultisig,
-    'getConfig',
+    'getConfigCommitment',
     never
   >
 
   /**
-   * Defines a call to the `getConfig` function.
+   * Defines a call to the `getConfigCommitment` function.
    *
    * Can be passed to [`multicall`](https://viem.sh/docs/contract/multicall).
    *
@@ -153,11 +138,47 @@ export namespace getConfig {
       address: Addresses.nativeMultisig,
       abi: Abis.nativeMultisig,
       args: [args.account],
-      functionName: 'getConfig',
+      functionName: 'getConfigCommitment',
     })
   }
 }
 
+/**
+ * Gets a coordinated multisig operation by its hash.
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The operation, or `null` when it is unknown.
+ */
+export async function getOperation(
+  client: Client,
+  parameters: getOperation.Parameters,
+): Promise<getOperation.ReturnValue> {
+  type multisig_getOperation = Extract<
+    RpcSchema.ToViem<RpcSchemaTempo.Multisig>[number],
+    { Method: 'multisig_getOperation' }
+  >
+  const operation = await client.request<multisig_getOperation>({
+    method: 'multisig_getOperation',
+    params: [parameters.hash],
+  })
+  return operation ? MultisigOperation.fromRpc(operation) : null
+}
+
+export declare namespace getOperation {
+  /** Parameters for {@link getOperation}. */
+  export type Parameters = {
+    /** Multisig operation hash. */
+    hash: Hex.Hex
+  }
+
+  /** Return value for {@link getOperation}. */
+  export type ReturnValue = MultisigOperation.Operation | null
+
+  /** Error type for {@link getOperation}. */
+  export type ErrorType = BaseErrorType
+}
+
 /**
  * Replaces the current configuration for a native multisig account.
  *
@@ -175,7 +196,10 @@ export namespace getConfig {
  * const owner = Account.fromSecp256k1(
  *   '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
  * )
- * const account = Account.fromMultisig({ owners: [owner] })
+ * const account = Account.fromMultisig({
+ *   address: 'infer',
+ *   owners: [owner],
+ * })
  * const client = createClient({
  *   chain: tempoLocalnet,
  *   transport: http(),
@@ -188,8 +212,10 @@ export namespace getConfig {
  *
  * const hash = await Actions.multisig.updateConfig(client, {
  *   account,
- *   threshold: 1,
- *   owners: [{ owner: owner.address, weight: 1 }],
+ *   nextConfig: {
+ *     owners: [{ owner: owner.address, weight: 1 }],
+ *     threshold: 1,
+ *   },
  * })
  * ```
  *
@@ -211,13 +237,18 @@ export namespace updateConfig {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> & Args
+  > = WriteParameters<chain, account> & {
+    /** Complete current config. Inferred from the account or coordinator when omitted. */
+    currentConfig?: MultisigConfig.Config | undefined
+    /** Replacement owners and threshold. */
+    nextConfig: Pick<MultisigConfig.Config, 'owners' | 'threshold'>
+  }
 
   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']
+    /** Complete current config. */
+    currentConfig: MultisigConfig.Config
+    /** Replacement owners and threshold. */
+    nextConfig: Pick<MultisigConfig.Config, 'owners' | 'threshold'>
   }
 
   export type ReturnValue = WriteContractReturnType
@@ -235,10 +266,55 @@ export namespace updateConfig {
     client: Client<Transport, chain, account>,
     parameters: Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const { owners, threshold, ...rest } = parameters
+    const {
+      account: account_,
+      currentConfig: currentConfig_,
+      nextConfig,
+      ...rest
+    } = parameters
+    const accountValue = account_ ?? client.account
+    const account = (() => {
+      if (
+        typeof accountValue === 'object' &&
+        accountValue.source === 'multisig'
+      )
+        return accountValue as MultisigAccount
+      return undefined
+    })()
+    const config = (() => {
+      if (currentConfig_) return currentConfig_
+      if (account?.config) return account.config
+      return undefined
+    })()
+    const address = (() => {
+      if (account) return account.address
+      if (typeof accountValue === 'string') return accountValue as Address
+      if (accountValue) return accountValue.address
+      return undefined
+    })()
+    const currentConfig = await (async () => {
+      if (config) return MultisigConfig.from(config)
+      if (!address)
+        throw new Error(
+          'A multisig account address or current config is required.',
+        )
+      const cachedConfig = await getConfig(client, { address })
+      if (!cachedConfig)
+        throw new Error(
+          `No current multisig config is cached for account ${address}. Provide the current config.`,
+        )
+      return cachedConfig
+    })()
+    const resolvedAccount = (() => {
+      if (account) return { ...account, config: currentConfig }
+      if (typeof accountValue === 'object') return accountValue
+      if (address) return fromMultisig({ address, ...currentConfig })
+      return undefined
+    })()
     return (await action(client, {
       ...rest,
-      ...updateConfig.call({ owners, threshold }),
+      ...(resolvedAccount ? { account: resolvedAccount } : {}),
+      ...updateConfig.call({ currentConfig, nextConfig }),
     } as never)) as never
   }
 
@@ -252,23 +328,34 @@ export namespace updateConfig {
    *
    * @example
    * ```ts
-   * import { Actions } from 'viem/tempo'
+   * import { Actions, type MultisigConfig } from 'viem/tempo'
+   *
+   * declare const currentConfig: MultisigConfig.Config
    *
    * const call = Actions.multisig.updateConfig.call({
-   *   threshold: 1,
-   *   owners: [{ owner: '0x...', weight: 1 }],
+   *   currentConfig,
+   *   nextConfig: {
+   *     owners: [{ owner: '0x...', weight: 1 }],
+   *     threshold: 1,
+   *   },
    * })
    * ```
    *
-   * @param args - New multisig configuration.
+   * @param args - Current and replacement multisig configurations.
    * @returns The call.
    */
   export function call(args: Args) {
-    const config = MultisigConfig.from(args)
+    const currentConfig = MultisigConfig.from(args.currentConfig)
+    const nextConfig = MultisigConfig.from({
+      owners: args.nextConfig.owners,
+      salt: currentConfig.salt,
+      threshold: args.nextConfig.threshold,
+      version: currentConfig.version + 1n,
+    })
     return defineCall({
       address: Addresses.nativeMultisig,
       abi: Abis.nativeMultisig,
-      args: [config.threshold, config.owners],
+      args: [currentConfig, nextConfig.threshold, nextConfig.owners],
       functionName: 'updateConfig',
     })
   }
@@ -298,9 +385,10 @@ export namespace updateConfig {
  * ```ts
  * import { createWalletClient, custom, type EIP1193Provider } from 'viem'
  * import { tempo } from 'viem/chains'
- * import { Actions } from 'viem/tempo'
+ * import { Actions, type MultisigConfig } from 'viem/tempo'
  *
  * declare const provider: EIP1193Provider
+ * declare const currentConfig: MultisigConfig.Config
  *
  * const client = createWalletClient({
  *   account: '0x...',
@@ -309,8 +397,11 @@ export namespace updateConfig {
  * })
  *
  * const { receipt } = await Actions.multisig.updateConfigSync(client, {
- *   threshold: 1,
- *   owners: [{ owner: '0x...', weight: 1 }],
+ *   currentConfig,
+ *   nextConfig: {
+ *     owners: [{ owner: '0x...', weight: 1 }],
+ *     threshold: 1,
+ *   },
  * })
  * ```
  *
@@ -330,8 +421,19 @@ export async function updateConfigSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as Transaction.TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = updateConfig.extractEvent(receipt.logs)
-  return { ...args, receipt } as never
+  return {
+    account: args.account,
+    config: MultisigConfig.from({
+      owners: args.owners,
+      salt: args.salt,
+      threshold: args.threshold,
+      version: args.version,
+    }),
+    receipt,
+  } as never
 }
 
 export namespace updateConfigSync {
@@ -342,15 +444,11 @@ export namespace updateConfigSync {
 
   export type Args = updateConfig.Args
 
-  export type ReturnValue = Compute<
-    GetEventArgs<
-      typeof Abis.nativeMultisig,
-      'MultisigConfigUpdated',
-      { IndexedOnly: false; Required: true }
-    > & {
-      receipt: TransactionReceipt
-    }
-  >
+  export type ReturnValue = Compute<{
+    account: Address
+    config: MultisigConfig.Config
+    receipt: Transaction.TransactionReceipt
+  }>
 
   export type ErrorType = updateConfig.ErrorType
 }

package/tempo/actions/policy.ts

@@ -233,6 +233,8 @@ export async function createSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = create.extractEvent(receipt.logs)
   return {
     ...args,
@@ -436,6 +438,8 @@ export async function setAdminSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = setAdmin.extractEvent(receipt.logs)
   return {
     ...args,
@@ -649,6 +653,8 @@ export async function modifyWhitelistSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = modifyWhitelist.extractEvent(receipt.logs)
   return {
     ...args,
@@ -862,6 +868,8 @@ export async function modifyBlacklistSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = modifyBlacklist.extractEvent(receipt.logs)
   return {
     ...args,

package/tempo/actions/receivePolicy.ts

@@ -239,6 +239,8 @@ export async function burnSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = burn.extractEvent(receipt.logs)
   return {
     ...args,
@@ -423,6 +425,8 @@ export async function claimSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = claim.extractEvent(receipt.logs)
   return {
     ...args,
@@ -805,6 +809,8 @@ export async function setSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { tokenFilterId, ...args } = set.extractEvent(receipt.logs).args
   return {
     ...args,

package/tempo/actions/reward.ts

@@ -21,6 +21,7 @@ import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
 import * as Abis from '../Abis.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
+import type { TransactionReceipt } from '../Transaction.js'
 
 /**
  * Claims accumulated rewards for a recipient.
@@ -305,6 +306,8 @@ export async function distributeSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = distribute.extractEvent(receipt.logs)
   return {
     ...args,
@@ -725,6 +728,8 @@ export async function setRecipientSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = setRecipient.extractEvent(receipt.logs)
   return {
     ...args,

package/tempo/actions/token.ts

@@ -254,6 +254,8 @@ export async function approveSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = approve.extractEvent(receipt.logs)
   return {
     ...args,
@@ -469,6 +471,8 @@ export async function burnBlockedSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = burnBlocked.extractEvent(receipt.logs)
   return {
     ...args,
@@ -686,6 +690,8 @@ export async function burnSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = burn.extractEvent(receipt.logs)
   return {
     ...args,
@@ -890,6 +896,8 @@ export async function changeTransferPolicySync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = changeTransferPolicy.extractEvent(receipt.logs)
   return {
     ...args,
@@ -1157,6 +1165,9 @@ export async function createSync<
     throwOnReceiptRevert,
   } as never)
 
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
+
   const { args } = create.extractEvent(receipt.logs)
   const tokenId = TokenId.fromAddress(args.token)
 
@@ -2068,6 +2079,8 @@ export async function grantRolesSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const events = grantRoles.extractEvents(receipt.logs)
   const value = events.map((event) => event.args)
   return {
@@ -2286,6 +2299,8 @@ export async function mintSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = mint.extractEvent(receipt.logs)
   return {
     ...args,
@@ -2485,6 +2500,8 @@ export async function pauseSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = pause.extractEvent(receipt.logs)
   return {
     ...args,
@@ -2694,6 +2711,8 @@ export async function renounceRolesSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const events = renounceRoles.extractEvents(receipt.logs)
   const value = events.map((event) => event.args)
   return {
@@ -2911,6 +2930,8 @@ export async function revokeRolesSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const events = revokeRoles.extractEvents(receipt.logs)
   const value = events.map((event) => event.args)
   return {
@@ -3112,6 +3133,8 @@ export async function setSupplyCapSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = setSupplyCap.extractEvent(receipt.logs)
   return {
     ...args,
@@ -3318,6 +3341,8 @@ export async function setRoleAdminSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = setRoleAdmin.extractEvent(receipt.logs)
   return {
     ...args,
@@ -3568,6 +3593,8 @@ export async function transferSync<
     ...parameters,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = transfer.extractEvent(receipt.logs)
   return {
     ...args,
@@ -3769,6 +3796,8 @@ export async function unpauseSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = unpause.extractEvent(receipt.logs)
   return {
     ...args,
@@ -3968,6 +3997,8 @@ export async function prepareUpdateQuoteTokenSync<
     client,
     parameters,
   )
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = prepareUpdateQuoteToken.extractEvent(receipt.logs)
   return {
     ...args,
@@ -4167,6 +4198,8 @@ export async function updateQuoteTokenSync<
     client,
     parameters,
   )
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = updateQuoteToken.extractEvent(receipt.logs)
   return {
     ...args,

package/tempo/actions/virtualAddress.ts

@@ -301,6 +301,8 @@ export async function registerMasterSync<
     ...rest,
     throwOnReceiptRevert,
   } as never)
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as never
   const { args } = registerMaster.extractEvent(receipt.logs)
   return {
     ...args,