mppx 0.8.12 → 0.8.14

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

@@ -9,6 +9,7 @@ import type { ChannelEntry } from '../client/ChannelOps.js'
 import type { SessionContext } from '../client/CredentialState.js'
 import {
   createSessionReceipt,
+  formatNeedVoucherEvent,
   serializeSessionReceipt,
   tip20ChannelEscrow,
   type ChannelDescriptor,
@@ -18,6 +19,7 @@ import { initialState, type SessionState } from './Runtime.js'
 import {
   applyTopUpResult,
   closeHttpSession,
+  consumeSseSessionResponse,
   createActiveSocketSession,
   driveSseResponse,
   isExpectedSocketReceipt,
@@ -83,6 +85,7 @@ describe('HttpManagement', () => {
         methodDetails: {
           chainId: 4217,
           escrowContract: undefined,
+          sessionProtocol: Constants.SessionProtocols.v2,
           ...(snapshot && { [Constants.MethodDetailKeys.sessionSnapshot]: snapshot }),
         },
       },
@@ -112,9 +115,15 @@ describe('HttpManagement', () => {
     })
   }
 
-  function receiptHeader(acceptedCumulative: bigint, spent: bigint) {
+  function receiptHeader(acceptedCumulative: bigint, spent: bigint, challengeId = 'challenge-1') {
     return serializeSessionReceipt(
-      createSessionReceipt({ acceptedCumulative, challengeId: 'challenge-1', channelId, spent }),
+      createSessionReceipt({
+        acceptedCumulative,
+        challengeId,
+        channelId,
+        spent,
+        txHash: `0x${'aa'.repeat(32)}`,
+      }),
     )
   }
 
@@ -139,9 +148,12 @@ describe('HttpManagement', () => {
       )
     })
 
-    test('strips resource query state from management URLs', () => {
+    test('preserves query state and strips fragments from management URLs', () => {
       expect(managementInput('https://example.test/resource?cursor=abc').toString()).toBe(
-        'https://example.test/resource',
+        'https://example.test/resource?cursor=abc',
+      )
+      expect(managementInput('https://example.test/resource?cursor=abc#result').toString()).toBe(
+        'https://example.test/resource?cursor=abc',
       )
     })
 
@@ -185,7 +197,7 @@ describe('HttpManagement', () => {
         return 'top-up-credential'
       })
       const fetch = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-        expect(input.toString()).toBe('https://example.test/resource')
+        expect(input.toString()).toBe('https://example.test/resource?cursor=abc')
         expect(init?.method).toBe('POST')
         expect(authorizationHeader(init)).toBe('top-up-credential')
         return new Response(null, {
@@ -209,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 () => {
@@ -301,16 +343,20 @@ describe('HttpManagement', () => {
       const entry = channel()
       const retryChallenge = { ...challenge(), id: 'challenge-2' } as TempoSessionChallenge
       const setChallenge = vi.fn()
-      const createSessionCredential = vi.fn(async (challenge_) => {
+      const closeAmounts: string[] = []
+      const createSessionCredential = vi.fn(async (challenge_, context: SessionContext) => {
+        if (context.action !== 'close') throw new Error('expected close context')
+        closeAmounts.push(context.cumulativeAmountRaw!)
         return `close-${challenge_.id}`
       })
+      const resolveSignedCloseAmount = vi.fn(() => '6')
       const fetch = vi
         .fn()
         .mockResolvedValueOnce(response402(retryChallenge))
         .mockResolvedValueOnce(
           new Response(null, {
             status: 200,
-            headers: { [Constants.Headers.paymentReceipt]: receiptHeader(5n, 5n) },
+            headers: { [Constants.Headers.paymentReceipt]: receiptHeader(6n, 6n, 'challenge-2') },
           }),
         )
 
@@ -318,18 +364,71 @@ describe('HttpManagement', () => {
         createSessionCredential,
         fetch,
         lastUrl: 'https://example.test/resource',
+        resolveSignedCloseAmount,
         signedCloseAmount: '5',
         setChallenge,
         target: { challenge: challenge(), channel: entry, channelId },
       })
 
-      expect(receipt?.spent).toBe('5')
+      expect(receipt?.spent).toBe('6')
       expect(setChallenge).toHaveBeenCalledWith(retryChallenge)
+      expect(resolveSignedCloseAmount).toHaveBeenCalledOnce()
+      expect(resolveSignedCloseAmount).toHaveBeenCalledWith(retryChallenge)
+      expect(closeAmounts).toEqual(['5', '6'])
       expect(createSessionCredential).toHaveBeenCalledTimes(2)
       expect(createSessionCredential.mock.calls[1]?.[0]).toMatchObject({ id: retryChallenge.id })
       expect(authorizationHeader(fetch.mock.calls[1]?.[1])).toBe('close-challenge-2')
     })
 
+    test('closeHttpSession rejects a receipt without settlement proof', async () => {
+      const receipt = serializeSessionReceipt(
+        createSessionReceipt({
+          acceptedCumulative: 5n,
+          challengeId: 'challenge-1',
+          channelId,
+          spent: 5n,
+        }),
+      )
+      await expect(
+        closeHttpSession({
+          createSessionCredential: async () => 'close-credential',
+          fetch: async () =>
+            new Response(null, {
+              headers: { [Constants.Headers.paymentReceipt]: receipt },
+            }),
+          lastUrl: 'https://example.test/resource',
+          signedCloseAmount: '5',
+          target: { challenge: challenge(), channel: channel(), channelId },
+        }),
+      ).rejects.toThrow('Session close response included a mismatched payment receipt.')
+    })
+
+    test('closeHttpSession rejects an invalid settlement transaction hash', async () => {
+      for (const txHash of ['0x1234', `0x${'gg'.repeat(32)}`]) {
+        const receipt = serializeSessionReceipt(
+          createSessionReceipt({
+            acceptedCumulative: 5n,
+            challengeId: 'challenge-1',
+            channelId,
+            spent: 5n,
+            txHash: txHash as Hex.Hex,
+          }),
+        )
+        await expect(
+          closeHttpSession({
+            createSessionCredential: async () => 'close-credential',
+            fetch: async () =>
+              new Response(null, {
+                headers: { [Constants.Headers.paymentReceipt]: receipt },
+              }),
+            lastUrl: 'https://example.test/resource',
+            signedCloseAmount: '5',
+            target: { challenge: challenge(), channel: channel(), channelId },
+          }),
+        ).rejects.toThrow('Session close response included a mismatched payment receipt.')
+      }
+    })
+
     test('closeHttpSession includes problem detail and challenge header on failure', async () => {
       await expect(
         closeHttpSession({
@@ -747,6 +846,79 @@ describe('SseDriver', () => {
       await vi.waitFor(() => expect(cancel).toHaveBeenCalledOnce())
     },
   )
+
+  test('keeps voucher events bound to the challenge that opened the stream', async () => {
+    const channelId = `0x${'01'.repeat(32)}` as Hex.Hex
+    const token = '0x20c0000000000000000000000000000000000001' as Address
+    const payee = '0x0000000000000000000000000000000000000002' as Address
+    const descriptor: ChannelDescriptor = {
+      authorizedSigner: '0x0000000000000000000000000000000000000001',
+      expiringNonceHash: `0x${'03'.repeat(32)}` as Hex.Hex,
+      operator: '0x0000000000000000000000000000000000000000',
+      payee,
+      payer: '0x0000000000000000000000000000000000000001',
+      salt: `0x${'02'.repeat(32)}` as Hex.Hex,
+      token,
+    }
+    const makeChallenge = (id: string) =>
+      Challenge.from({
+        id,
+        intent: Constants.Intents.session,
+        method: Constants.Methods.tempo,
+        realm: 'example.test',
+        request: {
+          amount: '1',
+          currency: token,
+          methodDetails: { chainId: 4217, escrowContract: tip20ChannelEscrow },
+          recipient: payee,
+          unitType: 'request',
+        },
+      }) as TempoSessionChallenge
+    const streamChallenge = makeChallenge('challenge-1')
+    let currentChallenge = streamChallenge
+    const createSessionCredential = vi.fn(async () => 'Payment credential')
+    const channel: ChannelEntry = {
+      chainId: 4217,
+      channelId,
+      cumulativeAmount: 1n,
+      deposit: 10n,
+      descriptor,
+      escrow: tip20ChannelEscrow,
+      opened: true,
+    }
+    const response = new Response(
+      formatNeedVoucherEvent({
+        acceptedCumulative: '1',
+        channelId,
+        deposit: '10',
+        requiredCumulative: '2',
+      }),
+      { headers: { 'Content-Type': 'text/event-stream' } },
+    )
+    const stream = consumeSseSessionResponse('https://example.test/stream', response, undefined, {
+      acceptReceipt() {},
+      assertVoucherWithinLocalLimit() {},
+      createSessionCredential,
+      async doFetch() {
+        throw new Error('unexpected resource fetch')
+      },
+      fetch: vi.fn(async () => new Response(null, { status: 204 })),
+      getChallenge: () => currentChallenge,
+      getChannel: () => channel,
+      async topUpIfNeeded() {},
+    })
+
+    currentChallenge = makeChallenge('challenge-2')
+    const frames: string[] = []
+    for await (const frame of stream) frames.push(frame)
+
+    expect(frames).toEqual([])
+    expect(createSessionCredential).toHaveBeenCalledOnce()
+    expect(createSessionCredential).toHaveBeenCalledWith(
+      streamChallenge,
+      expect.objectContaining({ action: 'voucher', cumulativeAmountRaw: '2' }),
+    )
+  })
 })
 
 describe('WsDriver', () => {
@@ -869,6 +1041,7 @@ describe('WsDriver', () => {
         methodDetails: {
           chainId: 4217,
           escrowContract: tip20ChannelEscrow,
+          sessionProtocol: Constants.SessionProtocols.v2,
         },
         recipient: '0x742d35cc6634c0532925a3b844bc9e7595f8fe00',
       },

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

@@ -1,4 +1,4 @@
-import type { Hex } from 'ox'
+import { Hex } from 'ox'
 
 import * as Challenge from '../../../Challenge.js'
 import * as Fetch from '../../../client/internal/Fetch.js'
@@ -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,
     }),
@@ -502,6 +514,8 @@ export type CloseHttpSessionParameters = {
   fetch: typeof globalThis.fetch
   /** Last paid resource URL; used as the management endpoint base. */
   lastUrl: RequestInfo | URL | null
+  /** Resolves the close amount again when the server refreshes the challenge. */
+  resolveSignedCloseAmount?: ((challenge: TempoSessionChallenge) => string) | undefined
   /** Final cumulative amount the client is willing to sign. */
   signedCloseAmount: string
   /** Stores a fresh close challenge when the first close credential expired. */
@@ -519,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>(
@@ -544,7 +571,7 @@ export function requestInitWithAuthorization(
   }
 }
 
-/** Returns the URL used for out-of-band management POSTs, stripping resource query state. */
+/** Returns the exact resource URL used for out-of-band management POSTs, without its fragment. */
 export function managementInput(input: RequestInfo | URL): RequestInfo | URL {
   try {
     const base =
@@ -555,7 +582,7 @@ export function managementInput(input: RequestInfo | URL): RequestInfo | URL {
         : input instanceof URL
           ? new URL(input)
           : new URL(String(input), base)
-    url.search = ''
+    url.hash = ''
     return url
   } catch {
     return input
@@ -592,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}`)
 
@@ -608,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,
@@ -660,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)
@@ -682,12 +735,18 @@ export async function closeHttpSession(
     )
   }
 
-  const postClose = async (challenge: TempoSessionChallenge) => {
+  let closeChallenge = parameters.target.challenge
+  let signedCloseAmount = parameters.signedCloseAmount
+  const postClose = async (challenge: TempoSessionChallenge, refreshed = false) => {
+    closeChallenge = challenge
+    signedCloseAmount =
+      (refreshed ? parameters.resolveSignedCloseAmount?.(challenge) : undefined) ??
+      parameters.signedCloseAmount
     const credential = await parameters.createSessionCredential(challenge, {
       action: 'close',
       channelId: parameters.target.channelId,
       descriptor: parameters.target.channel.descriptor,
-      cumulativeAmountRaw: parameters.signedCloseAmount,
+      cumulativeAmountRaw: signedCloseAmount,
     })
     return parameters.fetch(parameters.lastUrl!, {
       method: 'POST',
@@ -697,10 +756,10 @@ 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)
+      response = await postClose(challenge, true)
     }
   }
   if (!response.ok) {
@@ -712,7 +771,21 @@ export async function closeHttpSession(
   }
 
   const receiptHeader = response.headers.get(Constants.Headers.paymentReceipt)
-  return receiptHeader ? deserializeSessionReceipt(receiptHeader) : undefined
+  if (!receiptHeader) return undefined
+  const receipt = deserializeSessionReceipt(receiptHeader)
+  if (
+    !receipt.txHash ||
+    !Hex.validate(receipt.txHash, { strict: true }) ||
+    Hex.size(receipt.txHash) !== 32 ||
+    !isExpectedCloseReceipt({
+      challengeId: closeChallenge.id,
+      channelId: parameters.target.channelId,
+      expectedCloseAmount: signedCloseAmount,
+      receipt,
+    })
+  )
+    throw new Error('Session close response included a mismatched payment receipt.')
+  return receipt
 }
 
 /** Options accepted by the auto-driving SSE session flow. */
@@ -723,6 +796,12 @@ export type SseDriverOptions = RequestInit & {
   signal?: AbortSignal | undefined
 }
 
+/** @internal Options used when consuming an already-paid SSE response. */
+export type SseResponseOptions = {
+  onReceipt?: ((receipt: SessionReceipt) => void) | undefined
+  signal?: AbortSignal | undefined
+}
+
 /** Dependencies the SSE driver needs from `SessionManager`. */
 export type OpenSseSessionParameters = {
   /** Creates a session credential for the selected challenge/context. */
@@ -740,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. */
@@ -755,7 +832,6 @@ export type SsePaymentDriver = Pick<
   | 'createSessionCredential'
   | 'fetch'
   | 'getChannel'
-  | 'managementInput'
   | 'topUpIfNeeded'
 >
 
@@ -784,18 +860,28 @@ export async function openSseSession(
   if (!isEventStream(response) && driver.getChannel()?.opened)
     response = await driver.doFetch(input, sseInit)
 
-  const challenge = driver.getChallenge()
+  return consumeSseSessionResponse(input, response, { onReceipt, signal }, driver)
+}
+
+/** @internal Consumes an already-paid SSE response with the session transport driver. */
+export function consumeSseSessionResponse(
+  input: RequestInfo | URL,
+  response: Response,
+  options: SseResponseOptions | undefined,
+  driver: OpenSseSessionParameters,
+): AsyncIterable<string> {
   if (!isEventStream(response)) throw new Error('SSE response is not an event stream.')
   if (!response.body) throw new Error('Response has no body.')
+  const challenge = driver.getChallenge()
 
   return iterateSseMessages({
     onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, input }, event),
     onReceipt(receipt) {
       driver.acceptReceipt(receipt)
-      onReceipt?.(receipt)
+      options?.onReceipt?.(receipt)
     },
     response,
-    signal,
+    signal: options?.signal,
   })
 }
 
@@ -980,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}`)
   }
@@ -1148,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/client/internal/SessionManager.ts

@@ -0,0 +1,36 @@
+import type { ChannelEntry } from '../ChannelOps.js'
+import type { PaymentResponse, SessionManager } from '../SessionManager.js'
+import type { SseResponseOptions, TempoSessionChallenge } from '../Transports.js'
+
+type RehydrateParameters = {
+  channel: ChannelEntry
+  challenge: TempoSessionChallenge
+  input: RequestInfo | URL
+  spent: bigint
+}
+
+type SessionManagerInternals = {
+  consumeSseResponse(
+    input: RequestInfo | URL,
+    response: PaymentResponse,
+    options?: SseResponseOptions | undefined,
+  ): AsyncIterable<string>
+  rehydrate(parameters: RehydrateParameters): void
+}
+
+const internals = new WeakMap<SessionManager, SessionManagerInternals>()
+
+/** @internal Registers private transport and recovery hooks for a session manager. */
+export function registerSessionManagerInternals(
+  manager: SessionManager,
+  value: SessionManagerInternals,
+): void {
+  internals.set(manager, value)
+}
+
+/** @internal Returns private transport and recovery hooks for a session manager. */
+export function getSessionManagerInternals(manager: SessionManager): SessionManagerInternals {
+  const value = internals.get(manager)
+  if (!value) throw new Error('Session manager internals are unavailable.')
+  return value
+}

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,