mppx 0.8.13 → 0.8.15

package/src/tempo/session/client/Transports.ts

@@ -47,6 +47,8 @@ export const WebSocketReadyState = {
 /** Client-side close code used for payment protocol errors. */
 export const ClientWebSocketProtocolErrorCloseCode = 3008
 
+const webSocketChallengeRefreshWindowMs = 5_000
+
 type EventType = 'close' | 'error' | 'message' | 'open'
 type ManagedEventMap = {
   close: { code: number; reason: string; type: 'close'; wasClean: boolean }
@@ -268,6 +270,8 @@ export type ApplyTopUpResultParameters = {
   challengeId?: string | undefined
   /** Current active machine state, used to preserve paid unit count when possible. */
   currentState: SessionState
+  /** Highest deposit known before the top-up. */
+  knownDeposit?: bigint | undefined
   /** Receipt returned by the top-up POST, when present. */
   receipt?: SessionReceipt | undefined
   /** Latest locally observed spend in raw units. */
@@ -362,26 +366,36 @@ export function resolveManualTopUp(parameters: ResolveManualTopUpParameters): Ma
 /**
  * Applies local deposit and state bookkeeping for a top-up response.
  *
- * `deposit` is updated from the top-up amount. Receipt cumulative values only
- * update accepted spend authorization; they do not replace deposit.
+ * Deposit advances from the highest known baseline. Receipt cumulative values
+ * only update accepted spend authorization; they do not replace deposit.
  */
 export function applyTopUpResult(
   parameters: ApplyTopUpResultParameters,
 ): AppliedTopUpResult | undefined {
-  const { additionalDeposit, channel, channelId, challengeId, currentState, receipt, spent } =
-    parameters
+  const {
+    additionalDeposit,
+    channel,
+    channelId,
+    challengeId,
+    currentState,
+    knownDeposit,
+    receipt,
+    spent,
+  } = parameters
   if (channel?.channelId !== channelId) return undefined
 
-  channel.deposit += additionalDeposit
+  const baseline =
+    knownDeposit !== undefined && knownDeposit > channel.deposit ? knownDeposit : channel.deposit
+  const updated = { ...channel, deposit: baseline + additionalDeposit }
 
-  if (receipt) return { channel, state: activeStateFromReceipt(receipt, channel) }
-  if (!challengeId) return { channel }
+  if (receipt) return { channel: updated, state: activeStateFromReceipt(receipt, updated) }
+  if (!challengeId) return { channel: updated }
 
   return {
-    channel,
+    channel: updated,
     state: activeStateFromChannel({
       challengeId,
-      entry: channel,
+      entry: updated,
       spent: spent.toString(),
       units: currentState.status === 'active' ? currentState.units : 0,
     }),
@@ -477,7 +491,7 @@ export type RetryHttpPaymentRequiredParameters = {
   /** Failed HTTP response that may contain a session challenge. */
   response: Response
   /** Restores local cumulative authorization if the voucher retry fails. */
-  restoreCumulative(channelId: Hex.Hex, cumulativeAmount: bigint): void
+  restoreCumulative(channelId: Hex.Hex, cumulativeAmount: bigint): void | Promise<void>
   /** Stores the selected follow-up challenge on the manager. */
   setChallenge(challenge: TempoSessionChallenge): void
   /** Performs automatic top-up before the voucher retry when deposit is insufficient. */
@@ -521,6 +535,19 @@ export function isTempoSessionChallenge(
   )
 }
 
+/** Returns true when a challenge selects the TIP-1034 session protocol. */
+export function isTip1034SessionChallenge(
+  challenge: Challenge.Challenge,
+): challenge is TempoSessionChallenge {
+  return (
+    isTempoSessionChallenge(challenge) &&
+    Constants.getMethodDetail(
+      challenge.request.methodDetails,
+      Constants.MethodDetailKeys.sessionProtocol,
+    ) === Constants.SessionProtocols.v2
+  )
+}
+
 /** Reads a server-provided session snapshot from challenge method details. */
 export function getSessionSnapshot(challenge: TempoSessionChallenge): SessionSnapshot | undefined {
   return Constants.getMethodDetail<SessionSnapshot>(
@@ -594,15 +621,17 @@ export async function postTopUp(
     throw new Error('Cannot top up session: no local channel descriptor available.')
   }
 
-  const credential = await parameters.createSessionCredential(parameters.challenge, {
-    action: 'topUp',
-    channelId,
-    descriptor: channel.descriptor,
-    additionalDepositRaw: parameters.additionalDeposit.toString(),
-  })
-  const response = await parameters.fetch(managementInput(parameters.input), {
-    method: 'POST',
-    headers: { [Constants.Headers.authorization]: credential },
+  const response = await postManagementCredential({
+    challenge: parameters.challenge,
+    context: {
+      action: 'topUp',
+      channelId,
+      descriptor: channel.descriptor,
+      additionalDepositRaw: parameters.additionalDeposit.toString(),
+    },
+    createSessionCredential: parameters.createSessionCredential,
+    fetch: parameters.fetch,
+    input: parameters.input,
   })
   if (!response.ok) throw new Error(`Top-up POST failed with status ${response.status}`)
 
@@ -610,6 +639,30 @@ export async function postTopUp(
   return receiptHeader ? deserializeSessionReceipt(receiptHeader) : undefined
 }
 
+/** Posts a management credential and retries once with a refreshed TIP-1034 challenge. */
+async function postManagementCredential(parameters: {
+  challenge: TempoSessionChallenge
+  context: SessionContext
+  createSessionCredential: CreateSessionCredential
+  fetch: typeof globalThis.fetch
+  input: RequestInfo | URL
+}): Promise<Response> {
+  const post = async (challenge: TempoSessionChallenge) =>
+    parameters.fetch(managementInput(parameters.input), {
+      method: 'POST',
+      headers: {
+        [Constants.Headers.authorization]: await parameters.createSessionCredential(
+          challenge,
+          parameters.context,
+        ),
+      },
+    })
+  const response = await post(parameters.challenge)
+  if (response.status !== 402) return response
+  const challenge = Challenge.fromResponseList(response).find(isTip1034SessionChallenge)
+  return challenge ? post(challenge) : response
+}
+
 /** Retries an HTTP 402 when the server snapshot asks for more voucher headroom. */
 export async function retryHttpPaymentRequired(
   parameters: RetryHttpPaymentRequiredParameters,
@@ -641,18 +694,25 @@ export async function retryHttpPaymentRequired(
     currentChannel.cumulativeAmount > requiredCumulative
       ? currentChannel.cumulativeAmount
       : requiredCumulative
-  const credential = await parameters.createSessionCredential(challenge, {
-    action: 'voucher',
-    channelId: snapshot.channelId,
-    descriptor: currentChannel.descriptor,
-    cumulativeAmountRaw: cumulativeAmount.toString(),
-  })
-  const retry = await parameters.fetch(
-    parameters.input,
-    requestInitWithAuthorization(parameters.input, parameters.init, credential),
-  )
+  const restore = () => parameters.restoreCumulative(snapshot.channelId, cumulativeBeforeVoucher)
+  let retry: Response
+  try {
+    const credential = await parameters.createSessionCredential(challenge, {
+      action: 'voucher',
+      channelId: snapshot.channelId,
+      descriptor: currentChannel.descriptor,
+      cumulativeAmountRaw: cumulativeAmount.toString(),
+    })
+    retry = await parameters.fetch(
+      parameters.input,
+      requestInitWithAuthorization(parameters.input, parameters.init, credential),
+    )
+  } catch (error) {
+    await restore()
+    throw error
+  }
   if (!retry.ok && !retry.headers.get(Constants.Headers.paymentReceipt)) {
-    parameters.restoreCumulative(snapshot.channelId, cumulativeBeforeVoucher)
+    await restore()
   }
   return retry
 }
@@ -662,7 +722,7 @@ export function resolveRetryHttpPaymentContext(parameters: {
   channel: ChannelEntry | null
   response: Response
 }): RetryHttpPaymentContext | undefined {
-  const challenge = Challenge.fromResponseList(parameters.response).find(isTempoSessionChallenge)
+  const challenge = Challenge.fromResponseList(parameters.response).find(isTip1034SessionChallenge)
   if (!challenge) return undefined
 
   const snapshot = getSessionSnapshot(challenge)
@@ -705,7 +765,7 @@ export async function closeHttpSession(
 
   let response = await postClose(parameters.target.challenge)
   if (response.status === 402) {
-    const challenge = Challenge.fromResponseList(response).find(isTempoSessionChallenge)
+    const challenge = Challenge.fromResponseList(response).find(isTip1034SessionChallenge)
     if (challenge) {
       parameters.setChallenge?.(challenge)
       response = await postClose(challenge, true)
@@ -768,8 +828,6 @@ export type OpenSseSessionParameters = {
   getChallenge(): TempoSessionChallenge | null
   /** Validates a cumulative amount against local client policy. */
   assertVoucherWithinLocalLimit(cumulativeAmount: bigint): void
-  /** Converts a resource URL to the server's session management URL. */
-  managementInput(input: RequestInfo | URL): RequestInfo | URL
   /** Applies an incoming receipt to manager state. */
   acceptReceipt(receipt: SessionReceipt): void
   /** Performs an automatic channel top-up when deposit is insufficient. */
@@ -783,7 +841,6 @@ export type SsePaymentDriver = Pick<
   | 'createSessionCredential'
   | 'fetch'
   | 'getChannel'
-  | 'managementInput'
   | 'topUpIfNeeded'
 >
 
@@ -1018,17 +1075,13 @@ export async function handleSseNeedVoucher(
   })
   if (resolution.status !== 'ready') return
 
-  const credential = await parameters.driver.createSessionCredential(
-    parameters.challenge,
-    resolution.context,
-  )
-  const voucherResponse = await parameters.driver.fetch(
-    parameters.driver.managementInput(parameters.input),
-    {
-      method: 'POST',
-      headers: { [Constants.Headers.authorization]: credential },
-    },
-  )
+  const voucherResponse = await postManagementCredential({
+    challenge: parameters.challenge,
+    context: resolution.context,
+    createSessionCredential: parameters.driver.createSessionCredential,
+    fetch: parameters.driver.fetch,
+    input: parameters.input,
+  })
   if (!voucherResponse.ok) {
     throw new Error(`Voucher POST failed with status ${voucherResponse.status}`)
   }
@@ -1066,6 +1119,15 @@ export type PrepareWebSocketSessionParameters = {
   signal?: AbortSignal | undefined
 }
 
+/** Inputs for probing a paid WebSocket endpoint without creating a credential. */
+export type ProbeWebSocketSessionParameters = Omit<
+  PrepareWebSocketSessionParameters,
+  'createSessionCredential'
+>
+
+/** Result of resolving the current payment challenge for a WebSocket endpoint. */
+export type ProbedWebSocketSession = Omit<PreparedWebSocketSession, 'credential'>
+
 /** Result of the HTTP probe and opening credential creation for a WebSocket session. */
 export type PreparedWebSocketSession = {
   /** Selected tempo/session challenge from the HTTP probe. */
@@ -1129,6 +1191,8 @@ export type OpenWebSocketSessionParameters = {
   getChannel(): ChannelEntry | null
   /** Stores the active socket state in the manager. */
   setSocketSession(session: ActiveSocketSession): void
+  /** Fetches the route's current challenge after the active one expires. */
+  refreshChallenge(): Promise<TempoSessionChallenge>
   /** Validates a cumulative amount against local client policy. */
   assertVoucherWithinLocalLimit(cumulativeAmount: bigint): void
   /** Applies an incoming receipt to manager state. */
@@ -1169,10 +1233,10 @@ export type ValidateSocketPaymentReceiptParameters = ExpectedSocketReceiptParame
   expectedCloseAmount: string | null
 }
 
-/** Probes a WebSocket endpoint over HTTP and creates the opening credential. */
-export async function prepareWebSocketSession(
-  parameters: PrepareWebSocketSessionParameters,
-): Promise<PreparedWebSocketSession> {
+/** Probes a WebSocket endpoint over HTTP and returns its current session challenge. */
+export async function probeWebSocketSession(
+  parameters: ProbeWebSocketSessionParameters,
+): Promise<ProbedWebSocketSession> {
   const wsUrl = new URL(parameters.input.toString())
   const httpUrl = webSocketProbeUrl(wsUrl)
   parameters.onProbeUrl?.(httpUrl)
@@ -1186,7 +1250,7 @@ export async function prepareWebSocketSession(
     )
   }
 
-  const challenge = Challenge.fromResponseList(probe).find(isTempoSessionChallenge)
+  const challenge = Challenge.fromResponseList(probe).find(isTip1034SessionChallenge)
   if (!challenge) {
     throw new Error(
       'No payment challenge received from HTTP endpoint for this WebSocket URL. The server may not require payment or did not advertise a challenge.',
@@ -1195,12 +1259,22 @@ export async function prepareWebSocketSession(
 
   return {
     challenge,
-    credential: await parameters.createSessionCredential(challenge, {}),
     httpUrl,
     wsUrl,
   }
 }
 
+/** Probes a WebSocket endpoint over HTTP and creates the opening credential. */
+export async function prepareWebSocketSession(
+  parameters: PrepareWebSocketSessionParameters,
+): Promise<PreparedWebSocketSession> {
+  const probed = await probeWebSocketSession(parameters)
+  return {
+    ...probed,
+    credential: await parameters.createSessionCredential(probed.challenge, {}),
+  }
+}
+
 /** Creates the initial runtime state for a paid WebSocket from its opening credential. */
 export function createActiveSocketSession(
   parameters: CreateActiveSocketSessionParameters,
@@ -1408,9 +1482,18 @@ async function handleNeedVoucher(
   event: NeedVoucherEvent,
 ) {
   try {
+    let challenge = parameters.driver.challenge
+    if (
+      challenge.expires &&
+      new Date(challenge.expires).getTime() <= Date.now() + webSocketChallengeRefreshWindowMs
+    ) {
+      challenge = await parameters.driver.refreshChallenge()
+      parameters.driver.challenge = challenge
+      parameters.socketState.challenge = challenge
+    }
     const resolution = await resolveNeedVoucherContext({
       assertVoucherWithinLocalLimit: parameters.driver.assertVoucherWithinLocalLimit,
-      challenge: parameters.driver.challenge,
+      challenge,
       event,
       expectedChannelId: parameters.socketState.channelId,
       getChannel: parameters.driver.getChannel,
@@ -1425,10 +1508,7 @@ async function handleNeedVoucher(
       )
       return
     }
-    const voucher = await parameters.driver.createSessionCredential(
-      parameters.driver.challenge,
-      resolution.context,
-    )
+    const voucher = await parameters.driver.createSessionCredential(challenge, resolution.context)
     parameters.rawSocket.send(Ws.formatAuthorizationMessage(voucher))
   } catch (error) {
     parameters.failSocketFlow(

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

@@ -1,5 +1,12 @@
 import { Hex } from 'ox'
-import { type Address, encodeFunctionData, isAddressEqual, parseEventLogs, zeroAddress } from 'viem'
+import {
+  type Address,
+  encodeFunctionData,
+  isAddressEqual,
+  maxUint256,
+  parseEventLogs,
+  zeroAddress,
+} from 'viem'
 import { sendTransaction, waitForTransactionReceipt } from 'viem/actions'
 import { Transaction } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
@@ -42,6 +49,15 @@ function getSingleEvent(receipt: { logs: readonly unknown[] }, name: string) {
   return logs[0] as unknown as { args: Record<string, unknown> }
 }
 
+function expectExpiringNonce(serializedTransaction: Hex.Hex) {
+  const transaction = Transaction.deserialize(
+    serializedTransaction as Transaction.TransactionSerializedTempo,
+  ) as unknown as { nonce: number; nonceKey: bigint; validBefore?: bigint }
+  expect(transaction.nonce).toBe(0)
+  expect(transaction.nonceKey).toBe(maxUint256)
+  expect(transaction.validBefore).toBeDefined()
+}
+
 async function openChannel(parameters: { deposit?: bigint | undefined } = {}) {
   const deposit = uint96(parameters.deposit ?? 1_000n)
   const salt = Hex.random(32)
@@ -120,6 +136,7 @@ describe.runIf(isPrecompileTestnet)('TIP20EscrowChannel precompile chain operati
       token: asset,
     })
     if (payload.action !== 'open') throw new Error('expected open payload')
+    expectExpiringNonce(payload.transaction)
 
     const transaction = Transaction.deserialize(
       payload.transaction as Transaction.TransactionSerializedTempo,
@@ -224,6 +241,7 @@ describe.runIf(isPrecompileTestnet)('TIP20EscrowChannel precompile chain operati
       chain.id,
     )
     if (topUp.action !== 'topUp') throw new Error('expected topUp payload')
+    expectExpiringNonce(topUp.transaction)
 
     const result = await Chain.broadcastTopUpTransaction({
       additionalDeposit,

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

@@ -12,7 +12,7 @@ import {
   type Hex,
 } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
-import { Transaction } from 'viem/tempo'
+import { Abis, Addresses, Transaction } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
 
 import { VerificationFailedError } from '../../../Errors.js'
@@ -36,6 +36,7 @@ const descriptor = {
 const deposit = Types.uint96(1_000_000n)
 const chainId = 42431
 const txHash = `0x${'ab'.repeat(32)}` as const
+const sourceToken = '0x6666666666666666666666666666666666666666' as const
 const feePayer = privateKeyToAccount(
   '0x59c6995e998f97a5a0044966f0945389d1fc6e60e7346d6c36c49d32f75b9a1b',
 )
@@ -162,7 +163,11 @@ function topUpLog(parameters: { channelId: `0x${string}`; newDeposit: bigint })
 }
 
 async function createSerializedTransaction(parameters: {
-  calls: { to: `0x${string}`; data?: `0x${string}` | undefined }[]
+  calls: {
+    to?: `0x${string}` | undefined
+    data?: `0x${string}` | undefined
+    value?: bigint | undefined
+  }[]
   gas?: bigint | undefined
   signed?: boolean | undefined
 }) {
@@ -192,6 +197,28 @@ async function createSerializedTransaction(parameters: {
   } as never)) as `0x${string}`
 }
 
+function autoSwapCalls(amountOut: bigint = deposit) {
+  const maxAmountIn = amountOut + 1_000n
+  return [
+    {
+      to: sourceToken,
+      data: encodeFunctionData({
+        abi: Abis.tip20,
+        functionName: 'approve',
+        args: [Addresses.stablecoinDex, maxAmountIn],
+      }),
+    },
+    {
+      to: Addresses.stablecoinDex,
+      data: encodeFunctionData({
+        abi: Abis.stablecoinDex,
+        functionName: 'swapExactAmountOut',
+        args: [sourceToken, descriptor.token, amountOut, maxAmountIn],
+      }),
+    },
+  ] as const
+}
+
 async function createOpenTransaction(
   parameters: {
     authorizedSigner?: `0x${string}` | undefined
@@ -201,6 +228,13 @@ async function createOpenTransaction(
     signed?: boolean | undefined
     token?: `0x${string}` | undefined
     to?: `0x${string}` | undefined
+    prefixCalls?:
+      | readonly {
+          to?: `0x${string}` | undefined
+          data?: `0x${string}` | undefined
+          value?: bigint | undefined
+        }[]
+      | undefined
   } = {},
 ) {
   const data = encodeFunctionData({
@@ -216,7 +250,7 @@ async function createOpenTransaction(
     ],
   })
   return createSerializedTransaction({
-    calls: [{ to: parameters.to ?? tip20ChannelEscrow, data }],
+    calls: [...(parameters.prefixCalls ?? []), { to: parameters.to ?? tip20ChannelEscrow, data }],
     gas: parameters.gas,
     signed: parameters.signed,
   })
@@ -229,6 +263,13 @@ async function createTopUpTransaction(
     gas?: bigint | undefined
     signed?: boolean | undefined
     to?: `0x${string}` | undefined
+    prefixCalls?:
+      | readonly {
+          to?: `0x${string}` | undefined
+          data?: `0x${string}` | undefined
+          value?: bigint | undefined
+        }[]
+      | undefined
   } = {},
 ) {
   const data = encodeFunctionData({
@@ -240,7 +281,7 @@ async function createTopUpTransaction(
     ],
   })
   return createSerializedTransaction({
-    calls: [{ to: parameters.to ?? tip20ChannelEscrow, data }],
+    calls: [...(parameters.prefixCalls ?? []), { to: parameters.to ?? tip20ChannelEscrow, data }],
     gas: parameters.gas,
     signed: parameters.signed,
   })
@@ -446,8 +487,152 @@ describe('precompile broadcastOpenTransaction', () => {
         expectedPayer: descriptor.payer,
         serializedTransaction,
       }),
-    ).rejects.toThrow('TIP-1034 open transaction must contain exactly one call')
+    ).rejects.toThrow(
+      'TIP-1034 open transaction must contain one management call, optionally preceded by an auto-swap',
+    )
+  })
+
+  const [validApprove, validSwap] = autoSwapCalls()
+  const wrongToken = '0x7777777777777777777777777777777777777777' as const
+  const maxAmountIn = deposit + 1_000n
+  const approve = (parameters: {
+    amount?: bigint | undefined
+    spender?: Address | undefined
+    token?: Address | undefined
+  }) => ({
+    to: parameters.token ?? sourceToken,
+    data: encodeFunctionData({
+      abi: Abis.tip20,
+      functionName: 'approve',
+      args: [parameters.spender ?? Addresses.stablecoinDex, parameters.amount ?? maxAmountIn],
+    }),
+  })
+  const swap = (parameters: {
+    amountOut?: bigint | undefined
+    maxAmount?: bigint | undefined
+    tokenIn?: Address | undefined
+    tokenOut?: Address | undefined
+  }) => ({
+    to: Addresses.stablecoinDex as Address,
+    data: encodeFunctionData({
+      abi: Abis.stablecoinDex,
+      functionName: 'swapExactAmountOut',
+      args: [
+        parameters.tokenIn ?? sourceToken,
+        parameters.tokenOut ?? descriptor.token,
+        parameters.amountOut ?? deposit,
+        parameters.maxAmount ?? maxAmountIn,
+      ],
+    }),
   })
+  const invalidAutoSwapPrefixes = [
+    {
+      name: 'missing call target',
+      prefixCalls: [{ data: validApprove.data }, validSwap],
+      reason: 'call is missing a target or calldata',
+    },
+    {
+      name: 'native value',
+      prefixCalls: [{ ...validApprove, value: 1n }, validSwap],
+      reason: 'calls must not transfer native value',
+    },
+    {
+      name: 'wrong DEX target',
+      prefixCalls: [validApprove, { ...validSwap, to: wrongToken }],
+      reason: 'targets the wrong DEX',
+    },
+    {
+      name: 'invalid approval calldata',
+      prefixCalls: [{ ...validApprove, data: '0x12345678' as const }, validSwap],
+      reason: 'approval calldata is invalid',
+    },
+    {
+      name: 'invalid swap calldata',
+      prefixCalls: [validApprove, { ...validSwap, data: '0x12345678' as const }],
+      reason: 'swap calldata is invalid',
+    },
+    {
+      name: 'wrong approval function',
+      prefixCalls: [
+        {
+          to: sourceToken,
+          data: encodeFunctionData({
+            abi: Abis.tip20,
+            functionName: 'transfer',
+            args: [Addresses.stablecoinDex, maxAmountIn],
+          }),
+        },
+        validSwap,
+      ],
+      reason: 'must contain approve followed by swapExactAmountOut',
+    },
+    {
+      name: 'approval token mismatch',
+      prefixCalls: [approve({ token: wrongToken }), validSwap],
+      reason: 'approval token does not match swap input',
+    },
+    {
+      name: 'approval spender mismatch',
+      prefixCalls: [approve({ spender: wrongToken }), validSwap],
+      reason: 'approval spender is not the DEX',
+    },
+    {
+      name: 'approval amount mismatch',
+      prefixCalls: [approve({ amount: maxAmountIn + 1n }), validSwap],
+      reason: 'approval amount does not match swap maximum input',
+    },
+    {
+      name: 'output token mismatch',
+      prefixCalls: [validApprove, swap({ tokenOut: wrongToken })],
+      reason: 'output token does not match channel currency',
+    },
+    {
+      name: 'output amount mismatch',
+      prefixCalls: [
+        approve({ amount: maxAmountIn + 1n }),
+        swap({ amountOut: deposit + 1n, maxAmount: maxAmountIn + 1n }),
+      ],
+      reason: 'output amount does not match channel deposit',
+    },
+    {
+      name: 'identical input and output tokens',
+      prefixCalls: [approve({ token: descriptor.token }), swap({ tokenIn: descriptor.token })],
+      reason: 'input and output tokens must differ',
+    },
+    {
+      name: 'non-canonical approval calldata',
+      prefixCalls: [{ ...validApprove, data: `${validApprove.data}00` as Hex }, validSwap],
+      reason: 'approval calldata is not canonical',
+    },
+    {
+      name: 'non-canonical swap calldata',
+      prefixCalls: [validApprove, { ...validSwap, data: `${validSwap.data}00` as Hex }],
+      reason: 'swap calldata is not canonical',
+    },
+  ] as const
+
+  test.each(invalidAutoSwapPrefixes)(
+    'rejects an auto-swap with $name',
+    async ({ prefixCalls, reason }) => {
+      const serializedTransaction = await createOpenTransaction({ prefixCalls })
+
+      await expect(
+        Chain.broadcastOpenTransaction({
+          chainId,
+          client: createMockClient(),
+          escrowContract: tip20ChannelEscrow,
+          expectedAuthorizedSigner: descriptor.authorizedSigner,
+          expectedChannelId: `0x${'11'.repeat(32)}`,
+          expectedCurrency: descriptor.token,
+          expectedExpiringNonceHash: expectedExpiringNonceHash(serializedTransaction),
+          expectedOperator: descriptor.operator,
+          expectedPayee: descriptor.payee,
+          expectedPayer: descriptor.payer,
+          serializedTransaction,
+        }),
+      ).rejects.toThrow(`TIP-1034 open auto-swap ${reason}`)
+    },
+  )
 
   test('rejects open transactions targeting the wrong escrow contract', async () => {
     const serializedTransaction = await createOpenTransaction({ to: descriptor.token })
@@ -715,8 +900,8 @@ describe('precompile broadcastOpenTransaction', () => {
     ).rejects.toThrow('credential expiringNonceHash does not match transaction')
   })
 
-  test('returns tx hash, descriptor, event fields, and read-back state on success', async () => {
-    const serializedTransaction = await createOpenTransaction()
+  test('accepts an exact-output auto-swap before open', async () => {
+    const serializedTransaction = await createOpenTransaction({ prefixCalls: autoSwapCalls() })
     const expiringNonceHash = expectedExpiringNonceHash(serializedTransaction)
     const expectedDescriptor = { ...descriptor, expiringNonceHash }
     const channelId = Channel.computeId({
@@ -858,7 +1043,9 @@ describe('precompile broadcastTopUpTransaction', () => {
         expectedCurrency: descriptor.token,
         serializedTransaction,
       }),
-    ).rejects.toThrow('TIP-1034 topUp transaction must contain exactly one call')
+    ).rejects.toThrow(
+      'TIP-1034 topUp transaction must contain one management call, optionally preceded by an auto-swap',
+    )
   })
 
   test('rejects top-up transactions targeting the wrong escrow contract', async () => {
@@ -1025,8 +1212,8 @@ describe('precompile broadcastTopUpTransaction', () => {
     ).rejects.toThrow('topUp deposit does not match credential')
   })
 
-  test('returns tx hash, new deposit, and read-back state on success', async () => {
-    const serializedTransaction = await createTopUpTransaction()
+  test('accepts an exact-output auto-swap before top-up', async () => {
+    const serializedTransaction = await createTopUpTransaction({ prefixCalls: autoSwapCalls() })
     const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
     const newDeposit = deposit * 2n
     const state = { settled: 0n, deposit: newDeposit, closeRequestedAt: 0 }