viem 2.56.8 → 2.57.0

package/tempo/Addresses.ts

@@ -12,6 +12,8 @@ export const accountImplementation =
 export const accountKeychain = '0xaAAAaaAA00000000000000000000000000000000'
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
+/** Current consensus committee precompile address, used with `Abis.currentCommittee` to read committee members. */
+export const currentCommittee = '0xC077e00000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
 export const nativeMultisig = '0xAACC000000000000000000000000000000000000'
 /** Temporary recovery factory until the production address is finalized. */

package/tempo/Capabilities.ts

@@ -1,8 +1,8 @@
 import type { Address } from 'abitype'
 import type { DefaultCapabilitiesSchema } from '../types/capabilities.js'
 import type { Hex } from '../types/misc.js'
-import type { ExactPartial, OneOf } from '../types/utils.js'
-import type { DecodeErrorResultReturnType } from '../utils/index.js'
+import type { ExactPartial } from '../types/utils.js'
+import type * as ExecutionError from './ExecutionError.js'
 import type { TransactionRequestTempo } from './Transaction.js'
 
 export type Schema = Omit<DefaultCapabilitiesSchema, 'sendCalls'> & {
@@ -18,27 +18,13 @@ export type Schema = Omit<DefaultCapabilitiesSchema, 'sendCalls'> & {
 export type FillTransactionRequestCapabilities = {
   /** Whether to include `balanceDiffs` in the response. */
   balanceDiffs?: boolean | undefined
+  /** Whether execution reverts return error capabilities instead of throwing. */
+  errors?: boolean | undefined
 }
 
 export type FillTransactionCapabilities = {
-  autoSwap?:
-    | {
-        calls: readonly { to: Address; data: Hex; value: Hex }[]
-        maxIn: SwapAmount
-        minOut: SwapAmount
-        slippage: number
-      }
-    | undefined
   balanceDiffs?: Readonly<Record<Address, readonly BalanceDiff[]>> | undefined
-  error?:
-    | OneOf<
-        | (DecodeErrorResultReturnType & {
-            data: Hex
-            message: string
-          })
-        | { errorName: 'unknown'; message: string }
-      >
-    | undefined
+  error?: ExecutionError.Rpc | undefined
   fee?:
     | {
         amount: Hex
@@ -47,7 +33,7 @@ export type FillTransactionCapabilities = {
         symbol: string
       }
     | undefined
-  requireFunds?:
+  insufficientFunds?:
     | {
         amount: Hex
         decimals: number
@@ -68,6 +54,7 @@ export type FillTransactionCapabilities = {
   virtualAddresses?: Readonly<Record<Address, Address | null>> | undefined
 }
 
+/** A token balance preview. Incoming funds and outgoing approval exposure can produce separate entries for the same token. */
 export type BalanceDiff = {
   address: Address
   decimals: number
@@ -78,12 +65,3 @@ export type BalanceDiff = {
   symbol: string
   value: Hex
 }
-
-export type SwapAmount = {
-  decimals: number
-  formatted: string
-  name: string
-  symbol: string
-  token: Address
-  value: Hex
-}

package/tempo/Client.ts

@@ -25,8 +25,6 @@ import type { RpcSchema } from '../types/eip1193.js'
 import type { Prettify } from '../types/utils.js'
 import { tempo, tempoTestnet } from './Chain.js'
 import { type Decorator, decorator as tempoActions } from './Decorator.js'
-import * as Store from './Store.js'
-import { withMultisig } from './Transport.js'
 
 /**
  * Configuration for a Tempo {@link Client}.
@@ -54,19 +52,6 @@ export type ClientConfig<
      * @default tempo (or `tempoTestnet` when `testnet` is truthy)
      */
     chain?: chain | Chain | undefined
-    /**
-     * Enables native multisig approval coordination. Pass `true` to use an
-     * in-memory store or provide a shared store.
-     *
-     * @default undefined
-     */
-    experimental_multisig?:
-      | true
-      | {
-          /** Store shared by multisig coordinators. */
-          store: Store.Atomic
-        }
-      | undefined
     /**
      * Default fee token for the Client. Extended onto the chain so it applies
      * to every transaction sent with the Client.
@@ -121,8 +106,8 @@ export type CreateClientErrorType = ErrorType
  * Defaults to the `tempo` mainnet chain and `http` transport, so a minimal
  * client can be created with `createClient()`. Pass `testnet` to use the
  * Tempo testnet, or `chain` to override the chain entirely. Pass `feeToken`
- * to set a default fee token for every transaction. Pass
- * `experimental_multisig` to coordinate multisig owner approvals.
+ * to set a default fee token for every transaction. Use `withRelay` with a
+ * `Relay.multisig` plugin to coordinate multisig owner approvals.
  *
  * @example
  * ```ts
@@ -156,11 +141,13 @@ export type CreateClientErrorType = ErrorType
  *
  * @example
  * ```ts
- * import { createClient } from 'viem/tempo'
+ * import { createClient, http, Relay, Store, withRelay } from 'viem/tempo'
  *
  * // Multisig coordination with a client-local in-memory store.
  * const client = createClient({
- *   experimental_multisig: true,
+ *   transport: withRelay(http(), {
+ *     plugins: [Relay.multisig({ store: Store.memory() })],
+ *   }),
  * })
  * ```
  *
@@ -182,15 +169,7 @@ export function createClient<
     : accountOrAddress,
   rpcSchema
 > {
-  const {
-    chain,
-    experimental_multisig,
-    feeToken,
-    testnet,
-    tokens,
-    transport,
-    ...rest
-  } = parameters
+  const { chain, feeToken, testnet, tokens, transport, ...rest } = parameters
   const baseChain = chain ?? (testnet ? tempoTestnet : tempo)
   const resolvedChain =
     feeToken && typeof (baseChain as { extend?: unknown }).extend === 'function'
@@ -198,20 +177,11 @@ export function createClient<
           feeToken,
         })
       : baseChain
-  const transport_ = transport ?? http()
-  const resolvedTransport = experimental_multisig
-    ? withMultisig(
-        transport_,
-        experimental_multisig === true
-          ? { store: Store.memory() }
-          : experimental_multisig,
-      )
-    : transport_
   return createClient_({
     ...rest,
     chain: resolvedChain,
     tokens: tokens ?? tokenSets.tempo,
-    transport: resolvedTransport,
+    transport: transport ?? http(),
   } as ClientConfig_)
     .extend(publicActions)
     .extend(walletActions)

package/tempo/Decorator.ts

@@ -13,6 +13,7 @@ import * as feeActions from './actions/fee.js'
 import * as multisigActions from './actions/multisig.js'
 import * as nonceActions from './actions/nonce.js'
 import * as policyActions from './actions/policy.js'
+import * as propAmmActions from './actions/propAmm.js'
 import * as receivePolicyActions from './actions/receivePolicy.js'
 import * as rewardActions from './actions/reward.js'
 import * as simulateActions from './actions/simulate.js'
@@ -3015,6 +3016,228 @@ type DecoratorBase<
       parameters: policyActions.watchBlacklistUpdated.Parameters,
     ) => () => void
   }
+  propAmm: {
+    /**
+     * Reads the base token of a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const base = await client.propAmm.baseToken({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns The base token address.
+     */
+    baseToken: (
+      parameters: propAmmActions.baseToken.Parameters,
+    ) => Promise<propAmmActions.baseToken.ReturnValue>
+    /**
+     * Quotes an exact input or output for a caller, recipient, and customer route.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const { amountOut, price, updatedAt } = await client.propAmm.getSwapQuote({
+     *   amountIn: 1_000_000n,
+     *   mode: 'exactInput',
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     *   taker: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Route, swap mode, amount, and read options.
+     * @returns Quoted amount, oracle observation, rounding credit, and swap request.
+     */
+    getSwapQuote: <
+      const parameters extends propAmmActions.getSwapQuote.Parameters,
+    >(
+      parameters: parameters,
+    ) => Promise<propAmmActions.getSwapQuote.ReturnValue<parameters>>
+    /**
+     * Reads whether a propAMM pool is paused.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const paused = await client.propAmm.paused({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns Whether swaps are paused.
+     */
+    paused: (
+      parameters: propAmmActions.paused.Parameters,
+    ) => Promise<propAmmActions.paused.ReturnValue>
+    /**
+     * Reads whether a resolved address may receive swap output.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const allowed = await client.propAmm.recipientAllowed({
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, resolved recipient, and read options.
+     * @returns Whether the recipient is allowed.
+     */
+    recipientAllowed: (
+      parameters: propAmmActions.recipientAllowed.Parameters,
+    ) => Promise<propAmmActions.recipientAllowed.ReturnValue>
+    /**
+     * Resolves a Tempo recipient to the address checked by the pool's allowlist.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const resolved = await client.propAmm.resolveRecipient({
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, recipient, and read options.
+     * @returns The resolved recipient address.
+     */
+    resolveRecipient: (
+      parameters: propAmmActions.resolveRecipient.Parameters,
+    ) => Promise<propAmmActions.resolveRecipient.ReturnValue>
+    /**
+     * Reads the quote token of a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const quote = await client.propAmm.quoteToken({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns The quote token address.
+     */
+    quoteToken: (
+      parameters: propAmmActions.quoteToken.Parameters,
+    ) => Promise<propAmmActions.quoteToken.ReturnValue>
+    /**
+     * Approves the input token and swaps an exact input or output in one transaction.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     * const hash = await client.propAmm.swap({
+     *   amountIn: 1_000_000n,
+     *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+     *   minAmountOut: 1_000_000n,
+     *   minimumOracleUpdatedAt: 1_799_999_000n,
+     *   mode: 'exactInput',
+     *   pool: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Swap and transaction options.
+     * @returns The transaction hash.
+     */
+    swap: (
+      parameters: propAmmActions.swap.Parameters<chain, account>,
+    ) => Promise<propAmmActions.swap.ReturnValue>
+    /**
+     * Approves the input token, swaps, and returns the confirmed trade and receipt.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     * const trade = await client.propAmm.swapSync({
+     *   amountOut: 1_000_000n,
+     *   baseToQuote: false,
+     *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+     *   maxAmountIn: 1_010_000n,
+     *   minimumOracleUpdatedAt: 1_799_999_000n,
+     *   mode: 'exactOutput',
+     *   pool: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Swap and transaction options.
+     * @returns Confirmed trade data and receipt.
+     */
+    swapSync: (
+      parameters: propAmmActions.swapSync.Parameters<chain, account>,
+    ) => Promise<propAmmActions.swapSync.ReturnValue>
+    /**
+     * Reads whether an address may call swaps on a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const allowed = await client.propAmm.takerAllowed({
+     *   pool: '0x...',
+     *   taker: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, taker, and read options.
+     * @returns Whether the taker is allowed.
+     */
+    takerAllowed: (
+      parameters: propAmmActions.takerAllowed.Parameters,
+    ) => Promise<propAmmActions.takerAllowed.ReturnValue>
+  }
   receivePolicy: {
     /**
      * Burns the funds backing a blocked receipt.
@@ -5774,9 +5997,7 @@ type BoundHelper<helper> = helper extends (
     ? (args: args) => returnType
     : parameters extends [Client<any, any, any>]
       ? () => returnType
-      : parameters extends [infer args, ...unknown[]]
-        ? (args: args) => returnType
-        : () => returnType
+      : helper
   : never
 
 type BoundActionHelpers<action> = (action extends { call: infer helper }
@@ -5879,6 +6100,10 @@ export type Decorator<
     DecoratorBase<chain, account>['policy'],
     typeof policyActions
   >
+  propAmm: DecorateNamespace<
+    DecoratorBase<chain, account>['propAmm'],
+    typeof propAmmActions
+  >
   receivePolicy: DecorateNamespace<
     DecoratorBase<chain, account>['receivePolicy'],
     typeof receivePolicyActions
@@ -6075,6 +6300,17 @@ export function decorator() {
         'watchWhitelistUpdated',
         'watchBlacklistUpdated',
       ]),
+      propAmm: bindActions(client, propAmmActions, [
+        'baseToken',
+        'paused',
+        'getSwapQuote',
+        'quoteToken',
+        'recipientAllowed',
+        'resolveRecipient',
+        'swap',
+        'swapSync',
+        'takerAllowed',
+      ]),
       receivePolicy: bindActions(client, receivePolicyActions, [
         'burn',
         'burnSync',