mppx 0.8.11 → 0.8.13

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,
@@ -32,6 +34,7 @@ import {
   validateSocketCloseReadyReceipt,
   validateSocketPaymentReceipt,
   webSocketProbeUrl,
+  wrapSseResponse,
   type TempoSessionChallenge,
   type TopUpRequirement,
 } from './Transports.js'
@@ -111,9 +114,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)}`,
+      }),
     )
   }
 
@@ -138,9 +147,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',
       )
     })
 
@@ -184,7 +196,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, {
@@ -300,16 +312,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') },
           }),
         )
 
@@ -317,18 +333,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({
@@ -672,6 +741,154 @@ describe('SseDriver', () => {
     ])
     expect(acceptReceipt).toHaveBeenCalledWith(receipt)
   })
+
+  test('wraps standard CRLF streams and preserves response metadata', async () => {
+    const receipt = createSessionReceipt({
+      acceptedCumulative: 2n,
+      challengeId: 'challenge-1',
+      channelId: `0x${'01'.repeat(32)}`,
+      spent: 2n,
+    })
+    const encoder = new TextEncoder()
+    const source = new Response(
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoder.encode(': keepalive\r\n\r'))
+          controller.enqueue(
+            encoder.encode(
+              [
+                '\nevent: custom\r\ndata: hello\r\n\r\n',
+                `event: payment-receipt\r\ndata: ${JSON.stringify(receipt)}\r\n\r\n`,
+              ].join(''),
+            ),
+          )
+          controller.close()
+        },
+      }),
+      {
+        headers: { 'content-length': '100', 'content-type': 'text/event-stream' },
+        status: 201,
+        statusText: 'Created',
+      },
+    )
+    Object.defineProperty(source, 'url', { value: 'https://example.com/stream' })
+
+    const response = wrapSseResponse({
+      async onNeedVoucher() {},
+      onReceipt() {},
+      response: source,
+    })
+
+    expect(response.status).toBe(201)
+    expect(response.statusText).toBe('Created')
+    expect(response.url).toBe('https://example.com/stream')
+    expect(response.headers.get('content-type')).toBe('text/event-stream')
+    expect(response.headers.has('content-length')).toBe(false)
+    expect(await response.text()).toBe(': keepalive\r\n\r\nevent: custom\r\ndata: hello\r\n\r\n')
+  })
+
+  test.each(['consumer', 'signal'] as const)(
+    'cancels the source stream from %s',
+    async (source) => {
+      const abortController = new AbortController()
+      const cancel = vi.fn()
+      const sourceResponse = new Response(
+        new ReadableStream({
+          cancel,
+          start(controller) {
+            controller.enqueue(new TextEncoder().encode('data: first\n\n'))
+          },
+        }),
+      )
+      const response = wrapSseResponse({
+        async onNeedVoucher() {},
+        onReceipt() {},
+        response: sourceResponse,
+        signal: abortController.signal,
+      })
+
+      const reader = response.body!.getReader()
+      await reader.read()
+      if (source === 'signal') abortController.abort()
+      else await reader.cancel()
+
+      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,
+      managementInput: (input) => input,
+      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', () => {

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'
@@ -502,6 +502,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. */
@@ -544,7 +546,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 +557,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
@@ -682,12 +684,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',
@@ -700,7 +708,7 @@ export async function closeHttpSession(
     const challenge = Challenge.fromResponseList(response).find(isTempoSessionChallenge)
     if (challenge) {
       parameters.setChallenge?.(challenge)
-      response = await postClose(challenge)
+      response = await postClose(challenge, true)
     }
   }
   if (!response.ok) {
@@ -712,7 +720,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 +745,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. */
@@ -748,6 +776,17 @@ export type OpenSseSessionParameters = {
   topUpIfNeeded(parameters: TopUpRequirement): Promise<void>
 }
 
+/** Session payment operations shared with fetch-backed streams. */
+export type SsePaymentDriver = Pick<
+  OpenSseSessionParameters,
+  | 'assertVoucherWithinLocalLimit'
+  | 'createSessionCredential'
+  | 'fetch'
+  | 'getChannel'
+  | 'managementInput'
+  | 'topUpIfNeeded'
+>
+
 /**
  * Opens an auto-driving paid SSE stream.
  *
@@ -773,18 +812,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,
   })
 }
 
@@ -822,22 +871,32 @@ export async function* driveSseResponse(
   const reader = parameters.response.body.getReader()
   const decoder = new TextDecoder()
   let buffer = ''
+  let complete = false
+  const cancel = () => {
+    void reader.cancel(parameters.signal?.reason).catch(() => undefined)
+  }
+  parameters.signal?.addEventListener('abort', cancel, { once: true })
+  if (parameters.signal?.aborted) cancel()
 
   try {
     while (true) {
       if (parameters.signal?.aborted) break
 
       const { done, value } = await reader.read()
-      if (done) break
-
-      buffer += decoder.decode(value, { stream: true })
-      const parts = buffer.split('\n\n')
-      buffer = parts.pop()!
-
-      for (const part of parts) {
+      if (done) {
+        complete = true
+        buffer += decoder.decode()
+      } else buffer += decoder.decode(value, { stream: true })
+
+      while (true) {
+        const separator = findSseSeparator(buffer, done)
+        if (!separator) break
+        const end = separator.index + separator.length
+        const part = buffer.slice(0, separator.index)
+        const raw = buffer.slice(0, end)
+        buffer = buffer.slice(end)
         if (!part.trim()) continue
-        const event = parseEvent(part)
-        const raw = `${part}\n\n`
+        const event = parseEvent(part.replace(/\r\n|\r/g, '\n'))
         if (!event) {
           yield { raw }
           continue
@@ -855,16 +914,92 @@ export async function* driveSseResponse(
             break
         }
       }
+      if (done) break
     }
   } finally {
+    parameters.signal?.removeEventListener('abort', cancel)
+    if (!complete) await reader.cancel().catch(() => undefined)
     reader.releaseLock()
   }
 }
 
-async function handleSseNeedVoucher(
+function findSseSeparator(
+  value: string,
+  complete: boolean,
+): { index: number; length: number } | undefined {
+  for (let index = 0; index < value.length; index++) {
+    const first = lineEndingLength(value, index, complete)
+    if (!first) continue
+    const second = lineEndingLength(value, index + first, complete)
+    if (second) return { index, length: first + second }
+    index += first - 1
+  }
+  return undefined
+}
+
+function lineEndingLength(value: string, index: number, complete: boolean): number {
+  if (value[index] === '\n') return 1
+  if (value[index] !== '\r') return 0
+  if (value[index + 1] === '\n') return 2
+  if (index + 1 === value.length && !complete) return 0
+  return 1
+}
+
+/** Wraps an SSE response while handling session payment frames in-band. */
+export function wrapSseResponse(parameters: DriveSseResponseParameters): Response {
+  const abortController = new AbortController()
+  const abort = () => abortController.abort(parameters.signal?.reason)
+  parameters.signal?.addEventListener('abort', abort, { once: true })
+  if (parameters.signal?.aborted) abort()
+
+  const iterator = driveSseResponse({ ...parameters, signal: abortController.signal })
+  const encoder = new TextEncoder()
+  const headers = new Headers(parameters.response.headers)
+  headers.delete('content-length')
+  const cleanup = () => parameters.signal?.removeEventListener('abort', abort)
+
+  const response = new Response(
+    new ReadableStream({
+      async pull(controller) {
+        try {
+          const frame = await iterator.next()
+          if (frame.done) {
+            cleanup()
+            return controller.close()
+          }
+          controller.enqueue(encoder.encode(frame.value.raw))
+        } catch (error) {
+          cleanup()
+          throw error
+        }
+      },
+      async cancel() {
+        cleanup()
+        abortController.abort()
+        await iterator.return(undefined)
+      },
+    }),
+    {
+      headers,
+      status: parameters.response.status,
+      statusText: parameters.response.statusText,
+    },
+  )
+
+  for (const property of ['redirected', 'type', 'url'] as const)
+    Object.defineProperty(response, property, {
+      configurable: true,
+      get: () => parameters.response[property],
+    })
+
+  return response
+}
+
+/** Handles an in-band voucher request using the shared SSE payment driver. */
+export async function handleSseNeedVoucher(
   parameters: {
     challenge: TempoSessionChallenge | null
-    driver: OpenSseSessionParameters
+    driver: SsePaymentDriver
     input: RequestInfo | URL
   },
   event: NeedVoucherEvent,

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.test.ts

@@ -62,6 +62,7 @@ function createMockClient(
         parameters.rpcMethods?.push(args.method)
         parameters.onRequest?.(args.method, args.params)
         if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
+        if (args.method === 'eth_sendTransaction') return txHash
         if (args.method === 'eth_sendRawTransaction') return txHash
         if (args.method === 'eth_sendRawTransactionSync') return parameters.receipt ?? receipt([])
         if (args.method === 'eth_getTransactionReceipt') return parameters.receipt ?? null
@@ -290,6 +291,31 @@ describe('precompile receipt wait', () => {
   })
 })
 
+describe('precompile server transactions', () => {
+  test('does not add a fee-payer signature when the sender and fee payer are the same account', async () => {
+    const rpcMethods: string[] = []
+    const client = createMockClient({ rpcMethods })
+    const sender = { address: feePayer.address, type: 'json-rpc' } as const
+
+    await Chain.closeOnChain(
+      client,
+      descriptor,
+      1n,
+      1n,
+      `0x${'11'.repeat(65)}`,
+      tip20ChannelEscrow,
+      {
+        account: sender,
+        candidateFeeTokens: [descriptor.token],
+        feePayer,
+      },
+    )
+
+    expect(rpcMethods).toContain('eth_sendTransaction')
+    expect(rpcMethods).not.toContain('eth_sendRawTransactionSync')
+  })
+})
+
 describe('precompile open calldata parsing', () => {
   test('parseOpenCall accepts TIP-1034 open calldata', () => {
     const data = encodeFunctionData({