fix: resolve session settlement fee token (#419)

Author: brendanjryan

.changeset/tempo-session-fee-token-settlement.md

@@ -0,0 +1,5 @@
+---
+'mppx': patch
+---
+
+Fixed Tempo session close and settle transactions to resolve funded Tempo fee tokens before signing.

src/tempo/internal/fee-token.test.ts

@@ -0,0 +1,123 @@
+import type { Account } from 'viem'
+import { createClient } from 'viem'
+import { Actions, Addresses } from 'viem/tempo'
+import { describe, expect, test } from 'vp/test'
+import { nodeEnv } from '~test/config.js'
+import { accounts, asset, chain, fundAccount, http } from '~test/tempo/viem.js'
+
+import { resolveFeeToken } from './fee-token.js'
+
+const isLocalnet = nodeEnv === 'localnet'
+
+function clientFor(account: Account) {
+  return createClient({
+    account,
+    chain,
+    transport: http(),
+  })
+}
+
+function expectAddress(actual: string | undefined, expected: string) {
+  expect(actual?.toLowerCase()).toBe(expected.toLowerCase())
+}
+
+describe.runIf(isLocalnet)('resolveFeeToken', () => {
+  test('uses the funded account fee preference first', async () => {
+    const account = accounts[11]
+    const client = clientFor(account)
+    await fundAccount({ address: account.address, token: asset })
+    await Actions.fee.setUserTokenSync(client, {
+      feeToken: asset,
+      token: asset,
+    } as never)
+
+    const feeToken = await resolveFeeToken({
+      account: account.address,
+      candidateTokens: [Addresses.pathUsd],
+      client,
+    })
+
+    expectAddress(feeToken, asset)
+  })
+
+  test('falls through to the first funded candidate token', async () => {
+    const account = accounts[12]
+    const client = clientFor(account)
+    await fundAccount({ address: account.address, token: asset })
+
+    const feeToken = await resolveFeeToken({
+      account: account.address,
+      candidateTokens: [Addresses.pathUsd, asset],
+      client,
+    })
+
+    expectAddress(feeToken, asset)
+  })
+
+  test('falls through from an unfunded account fee preference', async () => {
+    const account = accounts[13]
+    const client = clientFor(account)
+    await fundAccount({ address: account.address, token: asset })
+    await Actions.fee.setUserTokenSync(client, {
+      feeToken: asset,
+      token: Addresses.pathUsd,
+    } as never)
+
+    const feeToken = await resolveFeeToken({
+      account: account.address,
+      candidateTokens: [asset],
+      client,
+    })
+
+    expectAddress(feeToken, asset)
+  })
+
+  test('uses a funded chain fee token when configured', async () => {
+    const account = accounts[14]
+    const client = createClient({
+      account,
+      chain: { ...chain, feeToken: asset },
+      transport: http(),
+    })
+    await fundAccount({ address: account.address, token: asset })
+
+    const feeToken = await resolveFeeToken({
+      account: account.address,
+      candidateTokens: [Addresses.pathUsd],
+      client,
+    })
+
+    expectAddress(feeToken, asset)
+  })
+
+  test('falls through from an unfunded chain fee token', async () => {
+    const account = accounts[15]
+    const client = createClient({
+      account,
+      chain: { ...chain, feeToken: Addresses.pathUsd },
+      transport: http(),
+    })
+    await fundAccount({ address: account.address, token: asset })
+
+    const feeToken = await resolveFeeToken({
+      account: account.address,
+      candidateTokens: [asset],
+      client,
+    })
+
+    expectAddress(feeToken, asset)
+  })
+
+  test('falls back to the first known token when none are funded', async () => {
+    const account = accounts[16]
+    const client = clientFor(account)
+
+    const feeToken = await resolveFeeToken({
+      account: account.address,
+      candidateTokens: [asset, Addresses.pathUsd],
+      client,
+    })
+
+    expectAddress(feeToken, asset)
+  })
+})

src/tempo/internal/fee-token.ts

@@ -0,0 +1,51 @@
+import type { Address, Client } from 'viem'
+import { Actions, TokenId } from 'viem/tempo'
+
+import * as TempoAddress from './address.js'
+import * as defaults from './defaults.js'
+
+function pushUnique(tokens: Address[], token: Address | undefined) {
+  if (!token) return
+  if (tokens.some((t) => TempoAddress.isEqual(t, token))) return
+  tokens.push(token)
+}
+
+async function hasBalance(client: Client, account: Address, token: Address): Promise<boolean> {
+  try {
+    return (await Actions.token.getBalance(client as never, { account, token })) > 0n
+  } catch {
+    return false
+  }
+}
+
+function getChainFeeToken(client: Client): Address | undefined {
+  const feeToken = (client.chain as { feeToken?: Address | bigint | undefined } | undefined)
+    ?.feeToken
+  if (feeToken) return TokenId.toAddress(feeToken)
+
+  const chainId = client.chain?.id
+  return chainId ? defaults.currency[chainId as keyof typeof defaults.currency] : undefined
+}
+
+export async function resolveFeeToken(parameters: {
+  account: Address
+  candidateTokens?: readonly Address[] | undefined
+  client: Client
+}): Promise<Address | undefined> {
+  const { account, candidateTokens, client } = parameters
+  const tokens: Address[] = []
+
+  const userToken = await Actions.fee
+    .getUserToken(client as never, { account })
+    .then((token) => token?.address as Address | undefined)
+    .catch(() => undefined)
+  pushUnique(tokens, userToken)
+  pushUnique(tokens, getChainFeeToken(client))
+  for (const token of candidateTokens ?? []) pushUnique(tokens, token)
+
+  for (const token of tokens) {
+    if (await hasBalance(client, account, token)) return token
+  }
+
+  return tokens[0]
+}

src/tempo/server/Charge.test.ts

@@ -4268,9 +4268,17 @@ describe('tempo', () => {
         ],
       })
 
+      let challengeNonce = 0
       const httpServer = await Http.createServer(async (req, res) => {
+        // This replay check requires distinct challenge IDs. Default expires can collide
+        // when the paired 402s are issued in the same millisecond.
         const result = await Mppx_server.toNodeListener(
-          chargeServer.charge({ amount: '1', currency: asset, recipient: accounts[0].address }),
+          chargeServer.charge({
+            amount: '1',
+            currency: asset,
+            expires: new Date(Date.now() + 300_000 + challengeNonce++).toISOString(),
+            recipient: accounts[0].address,
+          }),
         )(req, res)
         if (result.status === 402) return
         res.end('OK')
@@ -4339,9 +4347,17 @@ describe('tempo', () => {
         ],
       })
 
+      let challengeNonce = 0
       const httpServer = await Http.createServer(async (req, res) => {
+        // This replay check requires distinct challenge IDs. Default expires can collide
+        // when the paired 402s are issued in the same millisecond.
         const result = await Mppx_server.toNodeListener(
-          chargeServer.charge({ amount: '1', currency: asset, recipient: accounts[0].address }),
+          chargeServer.charge({
+            amount: '1',
+            currency: asset,
+            expires: new Date(Date.now() + 300_000 + challengeNonce++).toISOString(),
+            recipient: accounts[0].address,
+          }),
         )(req, res)
         if (result.status === 402) return
         res.end('OK')

src/tempo/server/Session.ts

@@ -432,6 +432,7 @@ export async function settle(
     ...(options?.feePayer && options?.account
       ? { feePayer: options.feePayer, account: options.account }
       : { account: options?.account }),
+    candidateFeeTokens: [channel.token],
   })
 
   await store.updateChannel(channelId, (current) => {
@@ -965,6 +966,7 @@ async function handleClose(
 
     txHash = await closeOnChain(client, methodDetails.escrowContract, voucher, {
       ...(feePayer && account ? { feePayer, account } : { account }),
+      candidateFeeTokens: [channel.token],
     })
   } catch (error) {
     if (pendingCloseMarked) {