mppx 0.8.13 → 0.8.14

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

@@ -85,6 +85,7 @@ describe('HttpManagement', () => {
         methodDetails: {
           chainId: 4217,
           escrowContract: undefined,
+          sessionProtocol: Constants.SessionProtocols.v2,
           ...(snapshot && { [Constants.MethodDetailKeys.sessionSnapshot]: snapshot }),
         },
       },
@@ -220,6 +221,36 @@ describe('HttpManagement', () => {
       expect(fetch).toHaveBeenCalledOnce()
     })
 
+    test('postTopUp retries once with the management route challenge', async () => {
+      const routeChallenge = { ...challenge(), id: 'management-challenge' } as TempoSessionChallenge
+      const createSessionCredential = vi.fn(async (challenge_) => `top-up-${challenge_.id}`)
+      const fetch = vi
+        .fn()
+        .mockResolvedValueOnce(response402(routeChallenge))
+        .mockResolvedValueOnce(
+          new Response(null, {
+            status: 204,
+            headers: {
+              [Constants.Headers.paymentReceipt]: receiptHeader(8n, 5n, routeChallenge.id),
+            },
+          }),
+        )
+
+      const receipt = await postTopUp({
+        additionalDeposit: 3n,
+        challenge: challenge(),
+        channel: channel(),
+        channelId,
+        createSessionCredential,
+        fetch,
+        input: 'https://example.test/resource',
+      })
+
+      expect(receipt?.challengeId).toBe(routeChallenge.id)
+      expect(createSessionCredential).toHaveBeenCalledTimes(2)
+      expect(authorizationHeader(fetch.mock.calls[1]?.[1])).toBe(`top-up-${routeChallenge.id}`)
+    })
+
     test('retryHttpPaymentRequired signs the server-required cumulative voucher', async () => {
       let entry = channel({ cumulativeAmount: 5n, deposit: 6n })
       const topUpIfNeeded = vi.fn(async () => {
@@ -874,7 +905,6 @@ describe('SseDriver', () => {
       fetch: vi.fn(async () => new Response(null, { status: 204 })),
       getChallenge: () => currentChallenge,
       getChannel: () => channel,
-      managementInput: (input) => input,
       async topUpIfNeeded() {},
     })
 
@@ -1011,6 +1041,7 @@ describe('WsDriver', () => {
         methodDetails: {
           chainId: 4217,
           escrowContract: tip20ChannelEscrow,
+          sessionProtocol: Constants.SessionProtocols.v2,
         },
         recipient: '0x742d35cc6634c0532925a3b844bc9e7595f8fe00',
       },

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

@@ -268,6 +268,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 +364,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,
     }),
@@ -521,6 +533,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 +619,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 +637,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,
@@ -662,7 +713,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 +756,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 +819,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 +832,6 @@ export type SsePaymentDriver = Pick<
   | 'createSessionCredential'
   | 'fetch'
   | 'getChannel'
-  | 'managementInput'
   | 'topUpIfNeeded'
 >
 
@@ -1018,17 +1066,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}`)
   }
@@ -1186,7 +1230,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.',

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 }