mppx 0.6.31 → 0.8.0

package/src/tempo/{client → legacy/client}/SessionManager.test.ts

@@ -3,14 +3,11 @@ import { privateKeyToAccount } from 'viem/accounts'
 import { Account as TempoAccount } from 'viem/tempo'
 import { describe, expect, test, vi } from 'vp/test'
 
-import * as Challenge from '../../Challenge.js'
-import * as PaymentCredential from '../../Credential.js'
-import { formatNeedVoucherEvent, parseEvent } from '../session/Sse.js'
-import type {
-  NeedVoucherEvent,
-  SessionCredentialPayload,
-  SessionReceipt,
-} from '../session/Types.js'
+import * as Challenge from '../../../Challenge.js'
+import * as PaymentCredential from '../../../Credential.js'
+import type { NeedVoucherEvent, SessionReceipt } from '../../session/precompile/Protocol.js'
+import { formatNeedVoucherEvent, parseEvent } from '../../session/precompile/Protocol.js'
+import type { LegacySessionCredentialPayload } from '../session/Types.js'
 import { sessionManager } from './SessionManager.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
@@ -140,7 +137,8 @@ describe('Session', () => {
         expect(response.status).toBe(200)
         expect(authorization).toBeDefined()
         if (!authorization) throw new Error('missing authorization header')
-        const credential = PaymentCredential.deserialize<SessionCredentialPayload>(authorization)
+        const credential =
+          PaymentCredential.deserialize<LegacySessionCredentialPayload>(authorization)
         expect(credential.payload.action).toBe('open')
         if (credential.payload.action !== 'open') throw new Error('unexpected action')
         expect(credential.payload.authorizedSigner).toBe(voucherSigner.accessKeyAddress)
@@ -273,6 +271,80 @@ describe('Session', () => {
   })
 
   describe('.sse() event parsing', () => {
+    test('sends SSE Accept header on voucher POST updates', async () => {
+      vi.resetModules()
+      vi.doMock('viem/actions', () => ({
+        prepareTransactionRequest: vi.fn(async () => ({})),
+        sendCallsSync: vi.fn(),
+        signTransaction: vi.fn(async () => '0xdeadbeef'),
+        signTypedData: vi.fn(),
+      }))
+
+      try {
+        const { sessionManager: sessionManagerWithMocks } = await import('./SessionManager.js')
+        const account = privateKeyToAccount(
+          '0x0000000000000000000000000000000000000000000000000000000000000001',
+        )
+        const voucherSigner = TempoAccount.fromSecp256k1(
+          '0x0000000000000000000000000000000000000000000000000000000000000002',
+          { access: account },
+        )
+        const client = createClient({
+          account,
+          transport: http('http://127.0.0.1'),
+        })
+        const challenge = makeChallenge({
+          recipient: '0x742d35cc6634c0532925a3b844bc9e7595f8fe00',
+          methodDetails: {
+            escrowContract: '0x9d136eea063ede5418a6bc7beaff009bbb6cfa70',
+            chainId: 4217,
+          },
+        })
+        const needVoucher: NeedVoucherEvent = {
+          channelId,
+          requiredCumulative: '2000000',
+          acceptedCumulative: '1000000',
+          deposit: '10000000',
+        }
+        const mockFetch = vi
+          .fn()
+          .mockResolvedValueOnce(make402Response(challenge))
+          .mockResolvedValueOnce(
+            makeSseResponse([
+              formatNeedVoucherEvent(needVoucher),
+              'event: message\ndata: chunk\n\n',
+            ]),
+          )
+          .mockResolvedValueOnce(makeOkResponse())
+
+        const s = sessionManagerWithMocks({
+          account,
+          client,
+          fetch: mockFetch as typeof globalThis.fetch,
+          maxDeposit: '10',
+          voucherSigner,
+        })
+
+        const iterable = await s.sse('https://api.example.com/stream')
+
+        const messages: string[] = []
+        for await (const msg of iterable) {
+          messages.push(msg)
+        }
+
+        const voucherRequest = mockFetch.mock.calls[2]![1] as RequestInit
+        const voucherHeaders = new Headers(voucherRequest.headers)
+
+        expect(messages).toEqual(['chunk'])
+        expect(voucherRequest.method).toBe('POST')
+        expect(voucherHeaders.get('accept')).toBe('text/event-stream')
+        expect(voucherHeaders.get('authorization')).toBeTruthy()
+      } finally {
+        vi.doUnmock('viem/actions')
+        vi.resetModules()
+      }
+    })
+
     test('yields only message data from SSE stream', async () => {
       const events = [
         'event: message\ndata: chunk1\n\n',

package/src/tempo/{client → legacy/client}/SessionManager.ts

@@ -1,16 +1,18 @@
 import type { Hex } from 'ox'
 import { parseUnits, type Account as viem_Account, type Address } from 'viem'
 
-import * as Challenge from '../../Challenge.js'
-import * as Fetch from '../../client/internal/Fetch.js'
-import * as PaymentCredential from '../../Credential.js'
-import * as AcceptPayment from '../../internal/AcceptPayment.js'
-import type * as Account from '../../viem/Account.js'
-import type * as Client from '../../viem/Client.js'
-import { deserializeSessionReceipt } from '../session/Receipt.js'
-import { parseEvent } from '../session/Sse.js'
-import type { SessionCredentialPayload, SessionReceipt } from '../session/Types.js'
-import * as Ws from '../session/Ws.js'
+import * as Challenge from '../../../Challenge.js'
+import * as Fetch from '../../../client/internal/Fetch.js'
+import * as Constants from '../../../Constants.js'
+import * as PaymentCredential from '../../../Credential.js'
+import * as AcceptPayment from '../../../internal/AcceptPayment.js'
+import type * as Account from '../../../viem/Account.js'
+import type * as Client from '../../../viem/Client.js'
+import { deserializeSessionReceipt } from '../../session/precompile/Protocol.js'
+import type { SessionReceipt } from '../../session/precompile/Protocol.js'
+import { parseEvent } from '../../session/precompile/Protocol.js'
+import * as Ws from '../../session/precompile/Protocol.js'
+import type { LegacySessionCredentialPayload } from '../session/Types.js'
 import type { ChannelEntry } from './ChannelOps.js'
 import { session as sessionPlugin } from './Session.js'
 
@@ -46,13 +48,20 @@ const WebSocketReadyState = {
 // Keep protocol/policy close codes on the server side and use an app-defined code here.
 const ClientWebSocketProtocolErrorCloseCode = 3008
 
+/** Auto-driving legacy client manager for HTTP, SSE, and WebSocket sessions. */
 export type SessionManager = {
+  /** Active legacy channel ID, when opened or recovered. */
   readonly channelId: Hex.Hex | undefined
+  /** Local cumulative voucher authorization in raw token units. */
   readonly cumulative: bigint
+  /** Whether the manager currently has an open local channel. */
   readonly opened: boolean
 
+  /** Opens a legacy contract-backed channel before the first paid request. */
   open(options?: { deposit?: bigint }): Promise<void>
+  /** Performs the HTTP 402 challenge/retry flow and returns receipt metadata. */
   fetch(input: RequestInfo | URL, init?: SessionRequestInit): Promise<PaymentResponse>
+  /** Opens a paid SSE stream and responds to voucher requests. */
   sse(
     input: RequestInfo | URL,
     init?: SessionRequestInit & {
@@ -60,6 +69,7 @@ export type SessionManager = {
       signal?: AbortSignal | undefined
     },
   ): Promise<AsyncIterable<string>>
+  /** Opens a paid WebSocket session and manages in-band payment frames. */
   ws(
     input: string | URL,
     init?: {
@@ -69,13 +79,19 @@ export type SessionManager = {
       signal?: AbortSignal | undefined
     },
   ): Promise<WebSocket>
+  /** Cooperatively closes the active legacy channel. */
   close(): Promise<SessionReceipt | undefined>
 }
 
+/** HTTP response enriched with latest legacy session metadata. */
 export type PaymentResponse = Response & {
+  /** Parsed payment receipt, when the response included one. */
   receipt: SessionReceipt | null
+  /** Last session challenge observed by the manager. */
   challenge: Challenge.Challenge | null
+  /** Active channel ID, when available. */
   channelId: Hex.Hex | null
+  /** Local cumulative voucher authorization in raw token units. */
   cumulative: bigint
 }
 
@@ -111,6 +127,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
   let channel: ChannelEntry | null = null
   let lastChallenge: Challenge.Challenge | null = null
   let lastUrl: RequestInfo | URL | null = null
+  let acceptedCumulative = 0n
   let spent = 0n
   let activeSocketChallenge: Challenge.Challenge | null = null
   let activeSocketChannelId: Hex.Hex | null = null
@@ -130,7 +147,10 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
     decimals: parameters.decimals,
     maxDeposit: parameters.maxDeposit,
     onChannelUpdate(entry) {
-      if (entry.channelId !== channel?.channelId) spent = 0n
+      if (entry.channelId !== channel?.channelId) {
+        acceptedCumulative = 0n
+        spent = 0n
+      }
       channel = entry
     },
   })
@@ -148,7 +168,10 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
   function updateSpentFromReceipt(receipt: SessionReceipt | null | undefined) {
     if (!receipt || receipt.channelId !== channel?.channelId) return
     assertReceiptWithinLocalState(receipt)
+    const nextAcceptedCumulative = BigInt(receipt.acceptedCumulative)
     const next = BigInt(receipt.spent)
+    acceptedCumulative =
+      acceptedCumulative > nextAcceptedCumulative ? acceptedCumulative : nextAcceptedCumulative
     spent = spent > next ? spent : next
   }
 
@@ -237,8 +260,9 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       return (bestSpent > cumulative ? cumulative : bestSpent).toString()
     }
 
-    // SSE/HTTP: spent is kept in sync by inline receipts, use it directly.
-    return spent.toString()
+    // Some legacy servers report receipt.spent as a per-request delta while
+    // still requiring close at the highest accepted cumulative voucher.
+    return (spent > acceptedCumulative ? spent : acceptedCumulative).toString()
   }
 
   function assertVoucherWithinLocalLimit(cumulativeAmount: bigint) {
@@ -250,7 +274,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
   }
 
   function toPaymentResponse(response: Response): PaymentResponse {
-    const receiptHeader = response.headers.get('Payment-Receipt')
+    const receiptHeader = response.headers.get(Constants.Headers.paymentReceipt)
     const receipt = receiptHeader ? deserializeSessionReceipt(receiptHeader) : null
     updateSpentFromReceipt(receipt)
     return Object.assign(response, {
@@ -425,13 +449,13 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       if (!lastUrl) throw new Error('No URL available — call fetch() or sse() before open().')
       const response = await fetchFn(lastUrl, {
         method: 'POST',
-        headers: { Authorization: credential },
+        headers: { [Constants.Headers.authorization]: credential },
       })
       if (!response.ok) {
         const body = await response.text().catch(() => '')
-        const wwwAuth = response.headers.get('WWW-Authenticate') ?? ''
+        const wwwAuth = response.headers.get(Constants.Headers.wwwAuthenticate) ?? ''
         throw new Error(
-          `Open request failed with status ${response.status}${body ? `: ${body}` : ''}${wwwAuth ? ` [WWW-Authenticate: ${wwwAuth}]` : ''}`,
+          `Open request failed with status ${response.status}${body ? `: ${body}` : ''}${wwwAuth ? ` [${Constants.Headers.wwwAuthenticate}: ${wwwAuth}]` : ''}`,
         )
       }
     },
@@ -504,7 +528,10 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
                   })
                   const voucherResponse = await fetchFn(input, {
                     method: 'POST',
-                    headers: { Authorization: credential },
+                    headers: {
+                      Accept: 'text/event-stream',
+                      [Constants.Headers.authorization]: credential,
+                    },
                   })
                   if (!voucherResponse.ok) {
                     throw new Error(`Voucher POST failed with status ${voucherResponse.status}`)
@@ -575,7 +602,8 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       activeSocketChallenge = challenge
       wsDeliveredChunks = 0n
       wsTickCost = BigInt(challenge.request.amount as string)
-      const openCredential = PaymentCredential.deserialize<SessionCredentialPayload>(credential)
+      const openCredential =
+        PaymentCredential.deserialize<LegacySessionCredentialPayload>(credential)
       activeSocketChannelId = openCredential.payload.channelId
       const rawSocket = new WebSocketImpl(wsUrl, protocols)
       activeSocket = rawSocket
@@ -819,7 +847,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
 
       const response = await fetchFn(lastUrl, {
         method: 'POST',
-        headers: { Authorization: credential },
+        headers: { [Constants.Headers.authorization]: credential },
       })
       if (!response.ok) {
         const body = await response.text().catch(() => '')
@@ -835,12 +863,12 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
             return body
           }
         })()
-        const wwwAuth = response.headers.get('WWW-Authenticate') ?? ''
+        const wwwAuth = response.headers.get(Constants.Headers.wwwAuthenticate) ?? ''
         throw new Error(
-          `Close request failed with status ${response.status}${detail ? `: ${detail}` : ''}${wwwAuth ? ` [WWW-Authenticate: ${wwwAuth}]` : ''}`,
+          `Close request failed with status ${response.status}${detail ? `: ${detail}` : ''}${wwwAuth ? ` [${Constants.Headers.wwwAuthenticate}: ${wwwAuth}]` : ''}`,
         )
       }
-      const receiptHeader = response.headers.get('Payment-Receipt')
+      const receiptHeader = response.headers.get(Constants.Headers.paymentReceipt)
       const receipt = receiptHeader ? deserializeSessionReceipt(receiptHeader) : undefined
 
       return receipt
@@ -850,6 +878,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
   return self
 }
 
+/** Type helpers for the legacy auto-driving session manager. */
 export declare namespace sessionManager {
   type Parameters = Account.getResolver.Parameters &
     Client.getResolver.Parameters & {

package/src/tempo/legacy/client/index.ts

@@ -0,0 +1,6 @@
+/** Legacy contract-backed session client method. */
+export { session } from './Session.js'
+/** Legacy contract-backed session manager. */
+export { sessionManager } from './SessionManager.js'
+/** Legacy client session manager types. */
+export type { PaymentResponse, SessionManager } from './SessionManager.js'

package/src/tempo/legacy/index.ts

@@ -0,0 +1,6 @@
+/** Legacy contract-backed session client surface. */
+export * as Client from './client/index.js'
+/** Legacy contract-backed session server surface. */
+export * as Server from './server/index.js'
+/** Legacy contract-backed session channel primitives. */
+export * as Session from './session/index.js'