accounts 0.6.2 → 0.6.4

package/src/server/internal/handlers/relay.ts

@@ -16,7 +16,7 @@ import {
 } from 'viem'
 import { simulateCalls } from 'viem/actions'
 import { tempo, tempoLocalnet, tempoMainnet, tempoModerato } from 'viem/chains'
-import { Abis, Actions, Addresses, Transaction } from 'viem/tempo'
+import { Abis, Actions, Addresses, Capabilities, Transaction } from 'viem/tempo'
 
 import { type Handler, from } from '../../Handler.js'
 import * as FeePayer from './feePayer.js'
@@ -67,7 +67,6 @@ export function relay(options: relay.Options = {}): Handler {
   const {
     chains = [tempo, tempoModerato],
     feePayer: feePayerOptions,
-    feeSwap: feeSwapOptions,
     onRequest,
     path = '/',
     resolveTokens = (chainId) =>
@@ -75,7 +74,11 @@ export function relay(options: relay.Options = {}): Handler {
     transports = {},
     ...rest
   } = options
-  const slippage = feeSwapOptions?.slippage ?? 0.05
+
+  const autoSwap = (() => {
+    if (options.autoSwap === false) return undefined
+    return { slippage: options.autoSwap?.slippage ?? 0.05 }
+  })()
 
   const clients = new Map<number, Client>()
   for (const chain of chains) {
@@ -141,7 +144,7 @@ export function relay(options: relay.Options = {}): Handler {
         ...(feePayerOptions ? { feePayer: true } : {}),
         ...(feeToken ? { feeToken } : {}),
       }
-      let filled = await fill(client, withOverrides, { feeToken, slippage })
+      let filled = await fill(client, { autoSwap, feeToken, transaction: withOverrides })
 
       // 3. Check if the fee payer approves this transaction.
       const sponsored =
@@ -157,17 +160,17 @@ export function relay(options: relay.Options = {}): Handler {
       // gas estimate and nonce are correct for a self-paid transaction.
       if (feePayerOptions && !sponsored) {
         const { feePayer: _, ...withoutFeePayer } = withOverrides
-        filled = await fill(client, withoutFeePayer, { feeToken, slippage })
+        filled = await fill(client, { autoSwap, feeToken, transaction: withoutFeePayer })
       }
 
-      const { transaction, swap: feeSwap } = filled
+      const { transaction, swap } = filled
 
       // 4. Simulate and compute balance diffs + fee.
       const calls = extractCalls(transaction)
       const { balanceDiffs, fee } = await simulateAndParseDiffs(client, {
         account: sender,
         calls,
-        swap: feeSwap,
+        swap,
         feeToken: (transaction as { feeToken?: Address | undefined }).feeToken,
         gas: (transaction as { gas?: bigint | undefined }).gas,
         maxFeePerGas: (transaction as { maxFeePerGas?: bigint | undefined }).maxFeePerGas,
@@ -190,28 +193,29 @@ export function relay(options: relay.Options = {}): Handler {
           }
         : undefined
 
-      // 6. Resolve feeSwap metadata (when AMM path was taken).
-      const feeSwapMeta = await (async (): Promise<relay.Meta['feeSwap']> => {
-        if (!feeSwap) return undefined
+      // 6. Resolve autoSwap metadata (when AMM path was taken).
+      const autoSwap_ = await (async () => {
+        if (!swap) return undefined
         const [inMeta, outMeta] = await Promise.all([
-          resolveTokenMetadata(client, feeSwap.tokenIn).catch(() => undefined),
-          resolveTokenMetadata(client, feeSwap.tokenOut).catch(() => undefined),
+          resolveTokenMetadata(client, swap.tokenIn).catch(() => undefined),
+          resolveTokenMetadata(client, swap.tokenOut).catch(() => undefined),
         ])
         if (!inMeta || !outMeta) return undefined
         return {
-          slippage,
+          calls: swap.calls.map((c) => ({ to: c.to, data: c.data })),
+          slippage: autoSwap!.slippage,
           maxIn: {
-            token: feeSwap.tokenIn,
-            value: Hex.fromNumber(feeSwap.maxAmountIn) as `0x${string}`,
-            formatted: formatUnits(feeSwap.maxAmountIn, inMeta.decimals),
+            token: swap.tokenIn,
+            value: Hex.fromNumber(swap.maxAmountIn) as `0x${string}`,
+            formatted: formatUnits(swap.maxAmountIn, inMeta.decimals),
             decimals: inMeta.decimals,
             symbol: inMeta.symbol,
             name: inMeta.name,
           },
           minOut: {
-            token: feeSwap.tokenOut,
-            value: Hex.fromNumber(feeSwap.amountOut) as `0x${string}`,
-            formatted: formatUnits(feeSwap.amountOut, outMeta.decimals),
+            token: swap.tokenOut,
+            value: Hex.fromNumber(swap.amountOut) as `0x${string}`,
+            formatted: formatUnits(swap.amountOut, outMeta.decimals),
             decimals: outMeta.decimals,
             symbol: outMeta.symbol,
             name: outMeta.name,
@@ -221,12 +225,12 @@ export function relay(options: relay.Options = {}): Handler {
 
       return Utils.rpcResult(request, {
         tx: core_Transaction.toRpc(tx as core_Transaction.Transaction),
-        meta: {
+        capabilities: {
           balanceDiffs,
           fee,
           sponsored: !!sponsor,
           ...(sponsor ? { sponsor } : {}),
-          ...(feeSwapMeta ? { feeSwap: feeSwapMeta } : {}),
+          ...(autoSwap_ ? { autoSwap: autoSwap_ } : {}),
         },
       })
     } catch (error) {
@@ -239,10 +243,13 @@ export function relay(options: relay.Options = {}): Handler {
 
 async function fill(
   client: Client,
-  request: Record<string, unknown>,
-  options: { feeToken?: Address | undefined; slippage?: number | undefined } = {},
+  options: {
+    autoSwap?: { slippage: number } | undefined
+    feeToken?: Address | undefined
+    transaction: Record<string, unknown>
+  },
 ) {
-  const { feeToken, slippage = 0.05 } = options
+  const { autoSwap, feeToken, transaction: request } = options
 
   // Skip re-formatting if already in RPC format (e.g. from viem's fillTransaction).
   const format = (value: Record<string, unknown>) =>
@@ -257,11 +264,11 @@ async function fill(
   } catch (error) {
     if (!(error instanceof Error)) throw error
     const parsed = parseInsufficientBalance(error)
-    if (!parsed || !feeToken) throw error
+    if (!parsed || !feeToken || !autoSwap) throw error
     if (parsed.token.toLowerCase() === feeToken.toLowerCase()) throw error
 
     const deficit = parsed.required - parsed.available
-    const maxAmountIn = deficit + (deficit * BigInt(Math.round(slippage * 1000))) / 1000n
+    const maxAmountIn = deficit + (deficit * BigInt(Math.round(autoSwap.slippage * 1000))) / 1000n
     const swapCalls = buildSwapCalls(feeToken, parsed.token, deficit, maxAmountIn)
     const existingCalls = request.calls as Call[] | undefined
     // If the request was normalized to top-level to/data/value (single call),
@@ -290,6 +297,7 @@ async function fill(
     return {
       transaction: Utils.normalizeTempoTransaction(result.tx),
       swap: {
+        calls: swapCalls,
         tokenIn: feeToken,
         tokenOut: parsed.token,
         amountOut: deficit,
@@ -347,8 +355,12 @@ export namespace relay {
     feePayer?:
       | Omit<FeePayer.feePayer.Options, 'chains' | 'transports' | 'path' | 'onRequest'>
       | undefined
-    /** AMM swap options for automatic InsufficientBalance resolution. */
-    feeSwap?:
+    /**
+     * AMM swap options for automatic insufficient balance resolution.
+     * Set to `false` to disable. @default {}
+     */
+    autoSwap?:
+      | false
       | {
           /** Slippage tolerance (e.g. 0.05 = 5%). @default 0.05 */
           slippage?: number | undefined
@@ -367,65 +379,6 @@ export namespace relay {
     /** Transports keyed by chain ID. Defaults to `http()` for each chain. */
     transports?: Record<number, Transport> | undefined
   }
-
-  /** Metadata returned alongside the filled transaction. */
-  export type Meta = {
-    /** Per-account balance diffs keyed by address. */
-    balanceDiffs?: Record<Address, readonly BalanceDiff[]> | undefined
-    /** Fee estimate for the transaction. */
-    fee: { amount: Hex.Hex; decimals: number; formatted: string; symbol: string } | null
-    /** Whether the transaction is sponsored by a fee payer. */
-    sponsored: boolean
-    /** Sponsor details (when sponsored). */
-    sponsor?: { address: Address; name: string; url: string } | undefined
-    /** AMM swap injected by the relay to cover an InsufficientBalance. */
-    feeSwap?:
-      | {
-          /** Max input amount with slippage. */
-          maxIn: SwapAmount
-          /** Deficit amount that triggered the swap. */
-          minOut: SwapAmount
-          /** Slippage tolerance (e.g. 0.1 = 10%). */
-          slippage: number
-        }
-      | undefined
-  }
-
-  /** Token amount in a fee swap. */
-  export type SwapAmount = {
-    /** Token address. */
-    token: Address
-    /** Amount (hex-encoded). */
-    value: Hex.Hex
-    /** Human-readable formatted amount. */
-    formatted: string
-    /** Token decimals. */
-    decimals: number
-    /** Token symbol (e.g. "USDC.e"). */
-    symbol: string
-    /** Token name (e.g. "USDC.e"). */
-    name: string
-  }
-
-  /** Balance diff for a single token relative to the user account. */
-  export type BalanceDiff = {
-    /** Token address. */
-    address: Address
-    /** Token decimals (e.g. 6). */
-    decimals: number
-    /** Direction relative to the user. */
-    direction: 'incoming' | 'outgoing'
-    /** Human-readable formatted currency value (e.g. "100.00"). */
-    formatted: string
-    /** Token name (e.g. "USDC.e"). */
-    name: string
-    /** Addresses receiving this asset. */
-    recipients: readonly Address[]
-    /** Token symbol (e.g. "USDC.e"). */
-    symbol: string
-    /** Token amount (hex-encoded). */
-    value: Hex.Hex
-  }
 }
 
 async function resolveFeeToken(
@@ -617,7 +570,7 @@ async function buildBalanceDiffs(
     const fromLower = log.args.from.toLowerCase()
     const toLower = log.args.to.toLowerCase()
 
-    // Skip swap-related transfers (reported in meta.feeSwap instead).
+    // Skip swap-related transfers (reported in capabilities.autoSwap instead).
     if (swap) {
       if (token === swapTokenIn && fromLower === accountLower && toLower === dexLower) continue
       if (token === swapTokenOut && fromLower === dexLower && toLower === accountLower) continue
@@ -644,7 +597,7 @@ async function buildBalanceDiffs(
     if (log.args.owner.toLowerCase() !== accountLower) continue
     const token = log.address.toLowerCase()
 
-    // Skip swap-related approvals (reported in meta.feeSwap instead).
+    // Skip swap-related approvals (reported in capabilities.autoSwap instead).
     if (swap && token === swapTokenIn && log.args.spender.toLowerCase() === dexLower) continue
 
     const spenderKey = `${token}:${log.args.spender.toLowerCase()}`
@@ -681,7 +634,7 @@ async function buildBalanceDiffs(
   )
 
   // Build the diff array for this account.
-  const diffs: relay.BalanceDiff[] = []
+  const diffs: Capabilities.BalanceDiff[] = []
   for (const entry of entries) {
     const net =
       entry.outgoing > entry.incoming

package/src/server/internal/handlers/utils.ts

@@ -1,6 +1,6 @@
 import { Hex, RpcRequest, RpcResponse } from 'ox'
 import { Transaction as core_Transaction } from 'ox/tempo'
-import type { Client } from 'viem'
+import { type Client, BaseError } from 'viem'
 import * as z from 'zod/mini'
 
 export function resolveChainId(value: unknown) {
@@ -85,10 +85,13 @@ function resolveError(error: unknown): {
 } {
   if (!error || typeof error !== 'object') return {}
   const e = error as Record<string, unknown>
-  // Walk to the innermost cause with a numeric code (raw RPC error).
-  if (e.cause && typeof e.cause === 'object') {
-    const inner = resolveError(e.cause)
-    if (inner.message) return inner
+  // Use viem's walk() to find the innermost error with a numeric code.
+  if (error instanceof BaseError) {
+    const inner = error.walk(
+      (e) => typeof (e as Record<string, unknown>).code === 'number',
+    ) as Record<string, unknown> | null
+    if (inner && typeof inner.code === 'number' && typeof inner.message === 'string')
+      return { message: inner.message, code: inner.code, data: inner.data }
   }
   if (typeof e.code === 'number' && typeof e.message === 'string')
     return { message: e.message, code: e.code, data: e.data }