viem 2.57.4 → 2.57.6

package/tempo/actions/{multisig.ts → accounts.ts}

@@ -1,11 +1,7 @@
 import type { Address } from 'abitype'
 import type * as Hex from 'ox/Hex'
 import type * as RpcSchema from 'ox/RpcSchema'
-import {
-  MultisigConfig,
-  MultisigOperation,
-  type RpcSchemaTempo,
-} from 'ox/tempo'
+import { AccountConfig, AccountOperation, 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'
@@ -20,14 +16,16 @@ 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 { type ConfigurableAccount, fromConfig } from '../Account.js'
 import * as Addresses from '../Addresses.js'
+import type * as Errors from '../errors.js'
+import { withExecutionError } from '../internal/errors.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type * as Transaction from '../Transaction.js'
 
 /**
- * Gets the current cached config for a multisig account.
+ * Gets the current cached config for a configurable 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
@@ -35,7 +33,7 @@ import type * as Transaction from '../Transaction.js'
  *
  * @example
  * ```ts
- * const config = await client.multisig.getConfig({
+ * const config = await client.accounts.getConfig({
  *   address: '0x...',
  * })
  * ```
@@ -49,32 +47,32 @@ export async function getConfig(
   parameters: getConfig.Parameters,
 ): Promise<getConfig.ReturnValue> {
   const config = await client.request<{
-    Method: 'multisig_getConfig'
+    Method: 'account_getConfig'
     Parameters: [{ address: Address }]
-    ReturnType: MultisigConfig.Rpc | null
+    ReturnType: AccountConfig.Rpc | null
   }>({
-    method: 'multisig_getConfig',
+    method: 'account_getConfig',
     params: [{ address: parameters.address }],
   })
-  return config ? MultisigConfig.fromRpc(config) : null
+  return config ? AccountConfig.fromRpc(config) : null
 }
 
 export declare namespace getConfig {
   /** Parameters for {@link getConfig}. */
   export type Parameters = {
-    /** Multisig account address. */
+    /** Configurable account address. */
     address: Address
   }
 
   /** Return value for {@link getConfig}. */
-  export type ReturnValue = MultisigConfig.Config | null
+  export type ReturnValue = AccountConfig.Config | null
 
   /** Error type for {@link getConfig}. */
   export type ErrorType = BaseErrorType
 }
 
 /**
- * Gets the current configuration commitment for a native multisig account.
+ * Gets the current configuration commitment for a configurable account.
  *
  * @example
  * ```ts
@@ -87,7 +85,7 @@ export declare namespace getConfig {
  *   transport: http(),
  * })
  *
- * const commitment = await Actions.multisig.getConfigCommitment(client, {
+ * const commitment = await Actions.accounts.getConfigCommitment(client, {
  *   account: '0x...',
  * })
  * ```
@@ -105,7 +103,7 @@ export async function getConfigCommitment<
   parameters: getConfigCommitment.Parameters,
 ): Promise<getConfigCommitment.ReturnValue> {
   const { account, ...rest } = parameters
-  return readContract(client, {
+  return withExecutionError(readContract)(client, {
     ...rest,
     ...getConfigCommitment.call({ account }),
   })
@@ -115,7 +113,7 @@ export namespace getConfigCommitment {
   export type Parameters = ReadParameters & Args
 
   export type Args = {
-    /** Initialized multisig account address. */
+    /** Initialized configurable account address. */
     account: Address
   }
 
@@ -141,10 +139,12 @@ export namespace getConfigCommitment {
       functionName: 'getConfigCommitment',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
- * Gets a coordinated multisig operation by its hash.
+ * Gets a coordinated account operation by its hash.
  *
  * @param client - Client.
  * @param parameters - Parameters.
@@ -154,33 +154,33 @@ export async function getOperation(
   client: Client,
   parameters: getOperation.Parameters,
 ): Promise<getOperation.ReturnValue> {
-  type multisig_getOperation = Extract<
-    RpcSchema.ToViem<RpcSchemaTempo.Multisig>[number],
-    { Method: 'multisig_getOperation' }
+  type account_getOperation = Extract<
+    RpcSchema.ToViem<RpcSchemaTempo.Account>[number],
+    { Method: 'account_getOperation' }
   >
-  const operation = await client.request<multisig_getOperation>({
-    method: 'multisig_getOperation',
+  const operation = await client.request<account_getOperation>({
+    method: 'account_getOperation',
     params: [parameters.hash],
   })
-  return operation ? MultisigOperation.fromRpc(operation) : null
+  return operation ? AccountOperation.fromRpc(operation) : null
 }
 
 export declare namespace getOperation {
   /** Parameters for {@link getOperation}. */
   export type Parameters = {
-    /** Multisig operation hash. */
+    /** Account operation hash. */
     hash: Hex.Hex
   }
 
   /** Return value for {@link getOperation}. */
-  export type ReturnValue = MultisigOperation.Operation | null
+  export type ReturnValue = AccountOperation.Operation | null
 
   /** Error type for {@link getOperation}. */
   export type ErrorType = BaseErrorType
 }
 
 /**
- * Replaces the current configuration for a native multisig account.
+ * Replaces the current configuration for a configurable 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
@@ -196,7 +196,7 @@ export declare namespace getOperation {
  * const owner = Account.fromSecp256k1(
  *   '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
  * )
- * const account = Account.fromMultisig({
+ * const account = Account.fromConfig({
  *   address: 'infer',
  *   owners: [owner],
  * })
@@ -210,7 +210,7 @@ export declare namespace getOperation {
  *   to: account.address,
  * })
  *
- * const hash = await Actions.multisig.updateConfig(client, {
+ * const hash = await Actions.accounts.updateConfig(client, {
  *   account,
  *   nextConfig: {
  *     owners: [{ owner: owner.address, weight: 1 }],
@@ -239,22 +239,22 @@ export namespace updateConfig {
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> & {
     /** Complete current config. Inferred from the account or coordinator when omitted. */
-    currentConfig?: MultisigConfig.Config | undefined
+    currentConfig?: AccountConfig.Config | undefined
     /** Replacement owners and threshold. */
-    nextConfig: Pick<MultisigConfig.Config, 'owners' | 'threshold'>
+    nextConfig: Pick<AccountConfig.Config, 'owners' | 'threshold'>
   }
 
   export type Args = {
     /** Complete current config. */
-    currentConfig: MultisigConfig.Config
+    currentConfig: AccountConfig.Config
     /** Replacement owners and threshold. */
-    nextConfig: Pick<MultisigConfig.Config, 'owners' | 'threshold'>
+    nextConfig: Pick<AccountConfig.Config, 'owners' | 'threshold'>
   }
 
   export type ReturnValue = WriteContractReturnType
 
   // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 
   /** @internal */
   export async function inner<
@@ -276,9 +276,9 @@ export namespace updateConfig {
     const account = (() => {
       if (
         typeof accountValue === 'object' &&
-        accountValue.source === 'multisig'
+        accountValue.source === 'configurable'
       )
-        return accountValue as MultisigAccount
+        return accountValue as ConfigurableAccount
       return undefined
     })()
     const config = (() => {
@@ -293,25 +293,25 @@ export namespace updateConfig {
       return undefined
     })()
     const currentConfig = await (async () => {
-      if (config) return MultisigConfig.from(config)
+      if (config) return AccountConfig.from(config)
       if (!address)
         throw new Error(
-          'A multisig account address or current config is required.',
+          'A configurable 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.`,
+          `No current account 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 })
+      if (address) return fromConfig({ address, ...currentConfig })
       return undefined
     })()
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...(resolvedAccount ? { account: resolvedAccount } : {}),
       ...updateConfig.call({ currentConfig, nextConfig }),
@@ -328,11 +328,11 @@ export namespace updateConfig {
    *
    * @example
    * ```ts
-   * import { Actions, type MultisigConfig } from 'viem/tempo'
+   * import { Actions, type AccountConfig } from 'viem/tempo'
    *
-   * declare const currentConfig: MultisigConfig.Config
+   * declare const currentConfig: AccountConfig.Config
    *
-   * const call = Actions.multisig.updateConfig.call({
+   * const call = Actions.accounts.updateConfig.call({
    *   currentConfig,
    *   nextConfig: {
    *     owners: [{ owner: '0x...', weight: 1 }],
@@ -341,17 +341,12 @@ export namespace updateConfig {
    * })
    * ```
    *
-   * @param args - Current and replacement multisig configurations.
+   * @param args - Current and replacement account configurations.
    * @returns The call.
    */
   export function call(args: 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,
-    })
+    const currentConfig = AccountConfig.from(args.currentConfig)
+    const nextConfig = AccountConfig.update(currentConfig, args.nextConfig)
     return defineCall({
       address: Addresses.nativeMultisig,
       abi: Abis.nativeMultisig,
@@ -379,16 +374,16 @@ export namespace updateConfig {
 }
 
 /**
- * Replaces a native multisig configuration and waits for confirmation.
+ * Replaces a configurable account configuration and waits for confirmation.
  *
  * @example
  * ```ts
  * import { createWalletClient, custom, type EIP1193Provider } from 'viem'
  * import { tempo } from 'viem/chains'
- * import { Actions, type MultisigConfig } from 'viem/tempo'
+ * import { Actions, type AccountConfig } from 'viem/tempo'
  *
  * declare const provider: EIP1193Provider
- * declare const currentConfig: MultisigConfig.Config
+ * declare const currentConfig: AccountConfig.Config
  *
  * const client = createWalletClient({
  *   account: '0x...',
@@ -396,7 +391,7 @@ export namespace updateConfig {
  *   transport: custom(provider),
  * })
  *
- * const { receipt } = await Actions.multisig.updateConfigSync(client, {
+ * const { receipt } = await Actions.accounts.updateConfigSync(client, {
  *   currentConfig,
  *   nextConfig: {
  *     owners: [{ owner: '0x...', weight: 1 }],
@@ -426,7 +421,7 @@ export async function updateConfigSync<
   const { args } = updateConfig.extractEvent(receipt.logs)
   return {
     account: args.account,
-    config: MultisigConfig.from({
+    config: AccountConfig.from({
       owners: args.owners,
       salt: args.salt,
       threshold: args.threshold,
@@ -446,7 +441,7 @@ export namespace updateConfigSync {
 
   export type ReturnValue = Compute<{
     account: Address
-    config: MultisigConfig.Config
+    config: AccountConfig.Config
     receipt: Transaction.TransactionReceipt
   }>
 

package/tempo/actions/amm.ts

@@ -12,6 +12,7 @@ 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 { ExtractAbiItem, GetEventArgs } from '../../types/contract.js'
 import type { Log, Log as viem_Log } from '../../types/log.js'
@@ -19,8 +20,16 @@ import type { Hex } from '../../types/misc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
 import type { Compute, OneOf, UnionOmit } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
+import type * as Errors from '../errors.js'
+import { TempoExecutionError } from '../errors.js'
+import {
+  type Context,
+  type Resolvers,
+  withExecutionError,
+} from '../internal/errors.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type { TransactionReceipt as TempoTransactionReceipt } from '../Transaction.js'
@@ -149,7 +158,7 @@ export async function getLiquidityBalance<chain extends Chain | undefined>(
   parameters: getLiquidityBalance.Parameters,
 ): Promise<getLiquidityBalance.ReturnValue> {
   const { address, poolId, userToken, validatorToken, ...rest } = parameters
-  return readContract(client, {
+  return withExecutionError(readContract)(client, {
     ...rest,
     ...getLiquidityBalance.call({
       address,
@@ -211,6 +220,8 @@ export namespace getLiquidityBalance {
       functionName: 'liquidityBalances',
     })
   }
+
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -287,7 +298,7 @@ export namespace rebalanceSwap {
       amountOut,
       to,
     })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -364,6 +375,9 @@ export namespace rebalanceSwap {
     if (!log) throw new Error('`RebalanceSwap` event not found.')
     return log
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -433,6 +447,8 @@ export namespace rebalanceSwapSync {
       receipt: TransactionReceipt
     }
   >
+
+  export type ErrorType = rebalanceSwap.ErrorType
 }
 
 /**
@@ -515,7 +531,7 @@ export namespace mint {
       validatorTokenAddress,
       validatorTokenAmount,
     })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -597,6 +613,9 @@ export namespace mint {
     if (!log) throw new Error('`Mint` event not found.')
     return log
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -666,6 +685,8 @@ export namespace mintSync {
       receipt: TransactionReceipt
     }
   >
+
+  export type ErrorType = mint.ErrorType
 }
 
 /**
@@ -737,7 +758,7 @@ export namespace burn {
   ): Promise<ReturnType<action>> {
     const { liquidity, to, userToken, validatorToken, ...rest } = parameters
     const call = burn.call({ liquidity, to, userToken, validatorToken })
-    return (await action(client, {
+    return (await withExecutionError(action)(client, {
       ...rest,
       ...call,
     } as never)) as never
@@ -814,6 +835,9 @@ export namespace burn {
     if (!log) throw new Error('`Burn` event not found.')
     return log
   }
+
+  // TODO: exhaustive error type
+  export type ErrorType = Errors.ExecutionErrorType | BaseErrorType
 }
 
 /**
@@ -883,6 +907,8 @@ export namespace burnSync {
       receipt: TransactionReceipt
     }
   >
+
+  export type ErrorType = burn.ErrorType
 }
 
 /**
@@ -1124,3 +1150,99 @@ export declare namespace watchBurn {
     validatorToken?: TokenId.TokenIdOrAddress | undefined
   }
 }
+
+// Errors
+
+/** Errors this module throws for decoded Tempo errors. Narrow with `error.name`. */
+export type ExecutionErrorType = AmmInsufficientLiquidityErrorType
+
+/** `AmmInsufficientLiquidityError` with a literal `name`, for narrowing. */
+export type AmmInsufficientLiquidityErrorType =
+  AmmInsufficientLiquidityError & {
+    name: 'AmmInsufficientLiquidityError'
+  }
+
+/** Thrown when a fee AMM pool cannot cover a swap, deposit, or withdrawal. */
+export class AmmInsufficientLiquidityError extends TempoExecutionError<
+  Errors.TempoExecutionError.Decoded<
+    'InsufficientLiquidity' | 'InsufficientReserves'
+  >
+> {
+  /** Amount of the call (`amountOut`, `amountValidatorToken`, or `liquidity`). */
+  amount: bigint | undefined
+  /** Pool reserve of `userToken`, when known. */
+  reserveUserToken: bigint | undefined
+  /** Pool reserve of `validatorToken`, when known. */
+  reserveValidatorToken: bigint | undefined
+  /** User token of the pool. */
+  userToken: Address | undefined
+  /** Validator token of the pool. */
+  validatorToken: Address | undefined
+
+  constructor(
+    parameters: Errors.TempoExecutionError.Parameters & {
+      amount?: bigint | undefined
+      reserveUserToken?: bigint | undefined
+      reserveValidatorToken?: bigint | undefined
+      userToken?: Address | undefined
+      validatorToken?: Address | undefined
+    },
+  ) {
+    const {
+      amount,
+      reserveUserToken,
+      reserveValidatorToken,
+      userToken,
+      validatorToken,
+    } = parameters
+    super(parameters, {
+      details: {
+        'user token': userToken,
+        'validator token': validatorToken,
+        amount,
+        'user token reserve': reserveUserToken,
+        'validator token reserve': reserveValidatorToken,
+      },
+      name: 'AmmInsufficientLiquidityError',
+    })
+    this.amount = amount
+    this.reserveUserToken = reserveUserToken
+    this.reserveValidatorToken = reserveValidatorToken
+    this.userToken = userToken
+    this.validatorToken = validatorToken
+  }
+}
+
+async function resolvePool(context: Context) {
+  const { call } = context
+  if (!call || !isAddressEqual(call.address, Addresses.feeManager))
+    return undefined
+  const userToken = call.arg<Address>('userToken')
+  const validatorToken = call.arg<Address>('validatorToken')
+  if (!userToken || !validatorToken) return undefined
+  const [pool] = await context.read([
+    {
+      address: Addresses.feeManager,
+      abi: Abis.feeAmm,
+      functionName: 'getPool',
+      args: [userToken, validatorToken],
+    },
+  ])
+  return new AmmInsufficientLiquidityError({
+    ...context.base,
+    amount:
+      call.arg<bigint>('amountOut') ??
+      call.arg<bigint>('amountValidatorToken') ??
+      call.arg<bigint>('liquidity'),
+    reserveUserToken: pool?.result?.reserveUserToken,
+    reserveValidatorToken: pool?.result?.reserveValidatorToken,
+    userToken,
+    validatorToken,
+  })
+}
+
+/** @internal */
+export const errorResolvers: Resolvers = {
+  'InsufficientLiquidity()': resolvePool,
+  'InsufficientReserves()': resolvePool,
+}