fix(tempo): sponsor machine-token sessions with pathUSD

Author: parvahuja

src/tempo/internal/defaults.ts

@@ -29,8 +29,8 @@ export const machineToken = {
   [chainId.testnet]: {
     feeToken: tokens.pathUsd,
     session: true,
-    swap: '0x0EdC4d63Daf0FdeA89C95357eC85D6Fc2eD41cB8',
-    token: '0x20c00000000000000000000004645c8f96629cE6',
+    swap: '0xD2E54024506079A62ceb2b698148D240036662E4',
+    token: '0x20C000000000000000000000785C8D7ebcC0b982',
   },
 } as const satisfies Partial<
   Record<

src/tempo/session/precompile/Chain.test.ts

@@ -12,7 +12,7 @@ import {
   type Hex,
 } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
-import { Abis, Addresses, Transaction } from 'viem/tempo'
+import { Abis, Addresses, Chain as TempoChain, Transaction } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
 
 import { VerificationFailedError } from '../../../Errors.js'
@@ -57,7 +57,7 @@ function createMockClient(
 ) {
   return createClient({
     account: feePayer,
-    chain: { id: chainId } as never,
+    chain: TempoChain.testnet,
     transport: custom({
       async request(args) {
         parameters.rpcMethods?.push(args.method)
@@ -168,13 +168,14 @@ async function createSerializedTransaction(parameters: {
     data?: `0x${string}` | undefined
     value?: bigint | undefined
   }[]
+  feeToken?: Address | false | undefined
   gas?: bigint | undefined
   signed?: boolean | undefined
 }) {
   return (await Transaction.serialize({
     chainId,
     calls: parameters.calls,
-    feeToken: descriptor.token,
+    ...(parameters.feeToken === false ? {} : { feeToken: parameters.feeToken ?? descriptor.token }),
     nonce: 0,
     ...(parameters.gas !== undefined ? { gas: parameters.gas } : {}),
     ...(parameters.signed
@@ -222,6 +223,7 @@ function autoSwapCalls(amountOut: bigint = deposit) {
 async function createOpenTransaction(
   parameters: {
     authorizedSigner?: `0x${string}` | undefined
+    feeToken?: Address | false | undefined
     gas?: bigint | undefined
     operator?: `0x${string}` | undefined
     payee?: `0x${string}` | undefined
@@ -251,6 +253,7 @@ async function createOpenTransaction(
   })
   return createSerializedTransaction({
     calls: [...(parameters.prefixCalls ?? []), { to: parameters.to ?? tip20ChannelEscrow, data }],
+    feeToken: parameters.feeToken,
     gas: parameters.gas,
     signed: parameters.signed,
   })
@@ -260,6 +263,7 @@ async function createTopUpTransaction(
   parameters: {
     additionalDeposit?: bigint | undefined
     descriptor_?: Channel.ChannelDescriptor | undefined
+    feeToken?: Address | false | undefined
     gas?: bigint | undefined
     signed?: boolean | undefined
     to?: `0x${string}` | undefined
@@ -282,6 +286,7 @@ async function createTopUpTransaction(
   })
   return createSerializedTransaction({
     calls: [...(parameters.prefixCalls ?? []), { to: parameters.to ?? tip20ChannelEscrow, data }],
+    feeToken: parameters.feeToken,
     gas: parameters.gas,
     signed: parameters.signed,
   })
@@ -827,6 +832,57 @@ describe('precompile broadcastOpenTransaction', () => {
     ).toHaveLength(2)
   })
 
+  test('fee-payer completes open with an explicit allowed fee token', async () => {
+    let broadcast: Hex | undefined
+    const serializedTransaction = await createOpenTransaction({
+      feeToken: false,
+      gas: 100_000n,
+      signed: true,
+    })
+    const transaction = Transaction.deserialize(
+      serializedTransaction as Transaction.TransactionSerializedTempo,
+    )
+    const payer = transaction.from!
+    const expiringNonceHash = Channel.computeExpiringNonceHash(
+      Channel.transactionForExpiringNonceHash({ feePayer, transaction }),
+      { sender: payer },
+    )
+    const expectedDescriptor = { ...descriptor, payer, expiringNonceHash }
+    const channelId = Channel.computeId({
+      ...expectedDescriptor,
+      chainId,
+      escrow: tip20ChannelEscrow,
+    })
+    const state = { settled: 0n, deposit, closeRequestedAt: 0 }
+
+    await Chain.broadcastOpenTransaction({
+      allowedFeeTokens: [sourceToken],
+      chainId,
+      client: createMockClient({
+        channel: { descriptor: expectedDescriptor, state },
+        onRequest(method, params) {
+          if (method === 'eth_sendRawTransactionSync') broadcast = (params as readonly [Hex])[0]
+        },
+        receipt: receipt([openedLog({ channelId, expiringNonceHash })]),
+      }),
+      escrowContract: tip20ChannelEscrow,
+      expectedAuthorizedSigner: descriptor.authorizedSigner,
+      expectedChannelId: channelId,
+      expectedCurrency: descriptor.token,
+      expectedExpiringNonceHash: expiringNonceHash,
+      expectedOperator: descriptor.operator,
+      expectedPayee: descriptor.payee,
+      expectedPayer: payer,
+      feePayer,
+      serializedTransaction,
+    })
+
+    expect(broadcast).toBeDefined()
+    expect(
+      Transaction.deserialize(broadcast as Transaction.TransactionSerializedTempo).feeToken,
+    ).toBe(sourceToken)
+  })
+
   test('hosted fee-payer relays a sender-signed open without local co-signing', async () => {
     const rpcMethods: string[] = []
     const serializedTransaction = await createOpenTransaction({ signed: true })
@@ -1195,6 +1251,41 @@ describe('precompile broadcastTopUpTransaction', () => {
     ).toHaveLength(2)
   })
 
+  test('fee-payer completes top-up with an explicit allowed fee token', async () => {
+    let broadcast: Hex | undefined
+    const serializedTransaction = await createTopUpTransaction({
+      feeToken: false,
+      gas: 100_000n,
+      signed: true,
+    })
+    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
+    const newDeposit = deposit * 2n
+
+    await Chain.broadcastTopUpTransaction({
+      additionalDeposit: deposit,
+      allowedFeeTokens: [sourceToken],
+      chainId,
+      client: createMockClient({
+        channel: { descriptor, state: { settled: 0n, deposit: newDeposit, closeRequestedAt: 0 } },
+        onRequest(method, params) {
+          if (method === 'eth_sendRawTransactionSync') broadcast = (params as readonly [Hex])[0]
+        },
+        receipt: receipt([topUpLog({ channelId, newDeposit })]),
+      }),
+      descriptor,
+      escrowContract: tip20ChannelEscrow,
+      expectedChannelId: channelId,
+      expectedCurrency: descriptor.token,
+      feePayer,
+      serializedTransaction,
+    })
+
+    expect(broadcast).toBeDefined()
+    expect(
+      Transaction.deserialize(broadcast as Transaction.TransactionSerializedTempo).feeToken,
+    ).toBe(sourceToken)
+  })
+
   test('rejects top-up calldata amount mismatches before broadcasting', async () => {
     const serializedTransaction = await createTopUpTransaction({ additionalDeposit: 1n })
 

src/tempo/session/precompile/Chain.ts

@@ -957,6 +957,8 @@ export type BroadcastOpenTransactionResult = {
 
 /** Inputs for broadcasting and verifying a client-signed TIP-1034 open transaction. */
 export type BroadcastOpenTransactionParameters = {
+  /** Fee tokens allowed when the server completes a sponsored transaction. Defaults to the channel currency. */
+  allowedFeeTokens?: readonly Address[] | undefined
   /** Hook invoked after calldata validation but before broadcasting. */
   beforeBroadcast?:
     | ((result: Omit<BroadcastOpenTransactionResult, 'txHash' | 'state'>) => Promise<void> | void)
@@ -1042,7 +1044,7 @@ export function validateOpenCredentialTransaction(
   })
   if (parameters.feePayer) assertSenderSigned(transaction)
   validateCredentialSponsorship({
-    allowedFeeTokens: [parameters.expectedCurrency],
+    allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
     challengeExpires: parameters.challengeExpires,
     chainId: parameters.chainId,
     details: {
@@ -1083,7 +1085,7 @@ export async function broadcastOpenTransaction(
     challengeExpires: parameters.challengeExpires,
     chainId: parameters.chainId,
     client: parameters.client,
-    allowedFeeTokens: [parameters.expectedCurrency],
+    allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
     details: {
       channelId: parameters.expectedChannelId,
       currency: parameters.expectedCurrency,
@@ -1136,6 +1138,8 @@ export type BroadcastTopUpTransactionResult = {
 export type BroadcastTopUpTransactionParameters = {
   /** Additional deposit amount expected in the top-up calldata. */
   additionalDeposit: bigint
+  /** Fee tokens allowed when the server completes a sponsored transaction. Defaults to the channel currency. */
+  allowedFeeTokens?: readonly Address[] | undefined
   /** Challenge expiration propagated into fee-payer policy checks. */
   challengeExpires?: string | undefined
   /** Chain ID used for fee-payer transaction signing. */
@@ -1195,7 +1199,7 @@ export function validateTopUpCredentialTransaction(
   })
   if (parameters.feePayer) assertSenderSigned(transaction)
   validateCredentialSponsorship({
-    allowedFeeTokens: [parameters.expectedCurrency],
+    allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
     challengeExpires: parameters.challengeExpires,
     chainId: parameters.chainId,
     details: {
@@ -1219,7 +1223,7 @@ export async function broadcastTopUpTransaction(
     challengeExpires: parameters.challengeExpires,
     chainId: parameters.chainId,
     client: parameters.client,
-    allowedFeeTokens: [parameters.expectedCurrency],
+    allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
     details: {
       additionalDeposit: parameters.additionalDeposit.toString(),
       channelId: parameters.expectedChannelId,

src/tempo/session/server/CredentialVerification.ts

@@ -424,7 +424,7 @@ export type BroadcastCredentialPayloadParameters = {
   feePayer?: viem_Account | true | undefined
   /** Optional policy for fee-sponsored close/open/top-up transactions. */
   feePayerPolicy?: Partial<FeePayer.Policy> | undefined
-  /** Optional fee token override for close transactions. */
+  /** Optional fee token override for sponsored management and settlement transactions. */
   feeToken?: Address | undefined
   /** Last successful on-chain refresh timestamp per channel ID. */
   lastOnChainVerified: Map<Hex, number>
@@ -483,6 +483,7 @@ export type ValidateCredentialPayloadParameters = Pick<
   | 'expectedOperator'
   | 'feePayer'
   | 'feePayerPolicy'
+  | 'feeToken'
   | 'lastOnChainVerified'
   | 'minVoucherDelta'
   | 'payload'
@@ -549,6 +550,7 @@ async function validateOpenCredential(
     expectedOperator,
   )
   const transaction = Chain.validateOpenCredentialTransaction({
+    ...(parameters.feeToken ? { allowedFeeTokens: [parameters.feeToken] } : {}),
     challengeExpires: challenge.expires,
     chainId,
     escrowContract: escrow,
@@ -614,6 +616,7 @@ async function validateTopUpCredential(
   })
   const transaction = Chain.validateTopUpCredentialTransaction({
     additionalDeposit,
+    ...(parameters.feeToken ? { allowedFeeTokens: [parameters.feeToken] } : {}),
     challengeExpires: challenge.expires,
     chainId,
     descriptor: channel.descriptor,
@@ -861,6 +864,7 @@ async function handleOpenCredential(
   )
 
   const result = await Chain.broadcastOpenTransaction({
+    ...(parameters.feeToken ? { allowedFeeTokens: [parameters.feeToken] } : {}),
     challengeExpires: challenge.expires,
     chainId,
     client,
@@ -950,6 +954,7 @@ async function handleTopUpCredential(
   })
   const result = await Chain.broadcastTopUpTransaction({
     additionalDeposit,
+    ...(parameters.feeToken ? { allowedFeeTokens: [parameters.feeToken] } : {}),
     challengeExpires: challenge.expires,
     chainId,
     client,

src/tempo/session/server/Session.ts

@@ -425,6 +425,7 @@ export function session<const parameters extends session.Parameters>(
       expectedOperator: context.methodDetails.operator,
       feePayer: context.feePayer,
       feePayerPolicy: parameters.feePayerPolicy,
+      feeToken: parameters.feeToken,
       lastOnChainVerified,
       minVoucherDelta: context.minVoucherDelta,
       payload,