accounts 0.8.0 → 0.8.2

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

@@ -281,6 +281,127 @@ describe('behavior: with app-provided feePayer URL', () => {
   })
 })
 
+describe('behavior: with app-provided feePayer URL + autoSwap', () => {
+  let appServer: Server
+  let walletServer: Server
+  let client: ReturnType<typeof getClient<typeof chain>>
+
+  beforeAll(async () => {
+    // App relay sponsors fees AND has `features: 'all'` so it can recover
+    // from InsufficientBalance via autoSwap.
+    appServer = await createServer(
+      relay({
+        chains: [chain],
+        features: 'all',
+        transports: { [chain.id]: http() },
+        feePayer: {
+          account: feePayerAccount,
+          name: 'App Sponsor',
+          url: 'https://app.example.com',
+        },
+      }).listener,
+    )
+
+    // Wallet relay forwards to the app relay; also has features:'all' so its
+    // own fill() can detect upstream `capabilities.error` as InsufficientBalance.
+    walletServer = await createServer(
+      relay({
+        chains: [chain],
+        features: 'all',
+        transports: { [chain.id]: http() },
+      }).listener,
+    )
+
+    client = getClient({ transport: http(walletServer.url) })
+  })
+
+  afterAll(() => {
+    appServer.close()
+    walletServer.close()
+  })
+
+  test('behavior: autoSwap recovers when external feePayer surfaces InsufficientBalance', async () => {
+    const sender = accounts[6]!
+
+    // Token pair + DEX liquidity. Use alphaUsd as the quote token so the
+    // relay can swap alphaUsd → base to cover the deficit.
+    const rpc = getClient({ account: accounts[0]! })
+    const { token: base } = await Actions.token.createSync(rpc, {
+      name: 'External Swap Base',
+      symbol: 'EXTBASE',
+      currency: 'USD',
+      quoteToken: addresses.alphaUsd,
+    })
+    await sendTransactionSync(rpc, {
+      calls: [
+        Actions.token.grantRoles.call({ token: base, role: 'issuer', to: rpc.account!.address }),
+        Actions.token.mint.call({
+          token: base,
+          to: rpc.account!.address,
+          amount: parseUnits('10000', 6),
+        }),
+        Actions.token.mint.call({
+          token: addresses.alphaUsd,
+          to: rpc.account!.address,
+          amount: parseUnits('10000', 6),
+        }),
+        Actions.token.approve.call({
+          token: base,
+          spender: Addresses.stablecoinDex,
+          amount: parseUnits('10000', 6),
+        }),
+        Actions.token.approve.call({
+          token: addresses.alphaUsd,
+          spender: Addresses.stablecoinDex,
+          amount: parseUnits('10000', 6),
+        }),
+      ],
+    })
+    await Actions.dex.createPairSync(rpc, { base })
+    await Actions.dex.placeSync(rpc, {
+      token: base,
+      amount: parseUnits('500', 6),
+      type: 'sell',
+      tick: Tick.fromPrice('1.001'),
+    })
+
+    // Give sender alphaUsd (fee + swap source) but NO base tokens.
+    await Actions.token.mintSync(rpc, {
+      token: addresses.alphaUsd,
+      amount: parseUnits('1000', 6),
+      to: sender.address,
+    })
+    await Actions.fee.setUserToken(getClient({ account: sender }), { token: addresses.alphaUsd })
+
+    // Sender attempts to transfer base via the wallet relay, which forwards
+    // to the app relay. The app relay returns 200 with capabilities.error =
+    // InsufficientBalance and a stub tx; the wallet relay must convert that
+    // into a synthetic throw so its own fill() autoSwap branch can recover.
+    const transferAmount = parseUnits('5', 6)
+    const result = await fillTransaction(client, {
+      account: sender.address,
+      ...Actions.token.transfer.call({
+        token: base,
+        to: accounts[7]!.address,
+        amount: transferAmount,
+      }),
+      feePayer: appServer.url as never,
+    })
+
+    const { transaction, capabilities } = result
+
+    // Tx is filled with the swap calls prepended (approve + buy + transfer).
+    expect(transaction.calls).toHaveLength(3)
+    expect(transaction.feePayerSignature).toBeDefined()
+
+    // autoSwap metadata is surfaced.
+    expect(capabilities?.autoSwap?.slippage).toBe(0.05)
+    expect(capabilities?.autoSwap?.maxIn.symbol).toBe('AlphaUSD')
+    expect(capabilities?.autoSwap?.minOut.symbol).toBe('EXTBASE')
+    expect(capabilities?.autoSwap?.minOut.formatted).toBe('5')
+  })
+})
+
 describe('behavior: chainId path parameter', () => {
   let server: Server
   let client: ReturnType<typeof getClient<typeof chain>>

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

@@ -569,13 +569,40 @@ async function fill(
     // FIXME: node estimates gas with secp256k1 dummy sig + null feePayerSignature.
     // Actual tx has larger keychain/webAuthn sigs + real fee payer sig, costing
     // more intrinsic gas. Mirror the bump from viem's tempo chainConfig.
+    // Skip if another relay already bumped (indicated by feePayerSignature).
     // @ts-expect-error
-    if (result.tx.gas && result.tx.feePayer)
+    if (result.tx.gas && request.feePayer && !result.tx.feePayerSignature)
       result.tx.gas = Hex.fromNumber(BigInt(result.tx.gas) + 20_000n)
-    const sponsor = (result as Record<string, any>).capabilities?.sponsor as
+    const upstreamCapabilities = (result as { capabilities?: Record<string, unknown> }).capabilities
+    const sponsor = upstreamCapabilities?.sponsor as
       | { address: Address; name?: string; url?: string }
       | undefined
-    return { transaction: Utils.normalizeTempoTransaction(result.tx), sponsor }
+    // External fee-payer relays surface chain reverts (e.g. InsufficientBalance)
+    // inside `capabilities.error` with a stub `tx` instead of throwing. Detect
+    // that here and re-throw so the autoSwap branch below can recover the same
+    // way it does for the direct-chain path.
+    const upstreamError = upstreamCapabilities?.error as
+      | { errorName?: string; message?: string; data?: `0x${string}` }
+      | undefined
+    if (upstreamError?.errorName === 'InsufficientBalance') {
+      const synthetic = new Error(upstreamError.message ?? 'InsufficientBalance')
+      synthetic.name = 'UpstreamRevertError'
+      ;(synthetic as { data?: `0x${string}` | undefined }).data = upstreamError.data
+      throw synthetic
+    }
+    // Reconstruct a `swap` shape from upstream's `capabilities.autoSwap` so the
+    // wallet relay's outer code can re-resolve autoSwap metadata locally —
+    // otherwise upstream-driven swaps are silently dropped from the response.
+    const swap = extractSwapFromCapabilities(upstreamCapabilities?.autoSwap)
+    // The chain's `eth_fillTransaction` doesn't echo back `calls`, so merge
+    // them in from the original request before normalizing — otherwise the
+    // typed envelope built for sponsorship signing throws CallsEmptyError.
+    const mergedTx = mergeCallsFromRequest(result.tx as Record<string, unknown>, request)
+    return {
+      transaction: Utils.normalizeTempoTransaction(mergedTx),
+      sponsor,
+      ...(swap ? { swap } : {}),
+    }
   } catch (error) {
     if (!(error instanceof Error)) throw error
     if (!autoSwap) throw error
@@ -612,8 +639,12 @@ async function fill(
     const sponsor = (result as Record<string, any>).capabilities?.sponsor as
       | { address: Address; name?: string; url?: string }
       | undefined
+    const mergedTx = mergeCallsFromRequest(result.tx as Record<string, unknown>, {
+      ...request,
+      calls: [...swapCalls, ...originalCalls],
+    })
     return {
-      transaction: Utils.normalizeTempoTransaction(result.tx),
+      transaction: Utils.normalizeTempoTransaction(mergedTx),
       sponsor,
       swap: {
         calls: swapCalls,
@@ -1014,3 +1045,75 @@ function buildSwapCalls(
     { to: buy.to, data: buy.data, value: 0n },
   ] as const
 }
+
+/**
+ * Merges the original fill request into the result tx. The chain's
+ * `eth_fillTransaction` returns only the "filled" gas/nonce/fee fields and
+ * omits envelope inputs like `calls`, `chainId`, `validBefore`, `nonceKey`,
+ * `keyData`, `keyType`, `feePayer`. Without these the typed Tempo envelope
+ * built for sponsorship signing throws `CallsEmptyError` or
+ * `Cannot convert undefined to a BigInt` when serializing.
+ *
+ * Result fields take precedence (they are the chain's authoritative filled
+ * values); request fields fill in everything else. Calls are normalized
+ * separately so legacy `to`/`data`/`value` requests are also supported.
+ */
+function mergeCallsFromRequest(
+  resultTx: Record<string, unknown>,
+  request: Record<string, unknown>,
+): Record<string, unknown> {
+  const merged: Record<string, unknown> = { ...request, ...resultTx }
+  const resultCalls = resultTx.calls
+  if (Array.isArray(resultCalls) && resultCalls.length > 0) return merged
+
+  const reqCalls = request.calls
+  if (Array.isArray(reqCalls) && reqCalls.length > 0) {
+    merged.calls = reqCalls
+    return merged
+  }
+
+  const { to, data, value } = request
+  if (typeof to === 'undefined' && typeof data === 'undefined' && typeof value === 'undefined')
+    return merged
+
+  merged.calls = [
+    {
+      ...(typeof to !== 'undefined' ? { to } : {}),
+      ...(typeof data !== 'undefined' ? { data } : {}),
+      ...(typeof value !== 'undefined' ? { value } : {}),
+    },
+  ]
+  return merged
+}
+
+/**
+ * Reconstructs a `swap` shape (matching the inner autoSwap branch's return
+ * value) from an upstream relay's `capabilities.autoSwap`. Used so a wallet
+ * relay forwarding to an external feePayer URL can re-emit autoSwap metadata
+ * locally without losing track of the upstream's swap.
+ */
+function extractSwapFromCapabilities(autoSwap: unknown):
+  | {
+      calls: readonly { to: Address; data: `0x${string}` }[]
+      tokenIn: Address
+      tokenOut: Address
+      amountOut: bigint
+      maxAmountIn: bigint
+    }
+  | undefined {
+  if (!autoSwap || typeof autoSwap !== 'object') return undefined
+  const a = autoSwap as {
+    calls?: readonly { to: Address; data: `0x${string}` }[]
+    maxIn?: { token?: Address; value?: `0x${string}` }
+    minOut?: { token?: Address; value?: `0x${string}` }
+  }
+  if (!a.calls || !a.maxIn?.token || !a.maxIn.value || !a.minOut?.token || !a.minOut.value)
+    return undefined
+  return {
+    calls: a.calls,
+    tokenIn: a.maxIn.token,
+    tokenOut: a.minOut.token,
+    amountOut: BigInt(a.minOut.value),
+    maxAmountIn: BigInt(a.maxIn.value),
+  }
+}