mppx 0.8.1 → 0.8.2

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

@@ -466,6 +466,53 @@ describe('Session', () => {
       expect(s.channelId).not.toBe(storedChannelId)
     })
 
+    test('rolls back an optimistic open when a replacement challenge does not reference it', async () => {
+      const { store, delete: remove } = makeChannelStore()
+      const postedPayloads: SessionCredentialPayload[] = []
+      const challenge = (feePayer: boolean) =>
+        makeChallenge({
+          methodDetails: {
+            escrowContract: tip20ChannelEscrow,
+            chainId: 4217,
+            sessionProtocol: Constants.SessionProtocols.v2,
+            feePayer,
+          },
+        })
+      let openCount = 0
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        const payload = authorization
+          ? Credential.deserialize<SessionCredentialPayload>(authorization).payload
+          : undefined
+        if (payload) postedPayloads.push(payload)
+
+        if (!payload) return Promise.resolve(make402Response(challenge(true)))
+        if (payload.action === 'open') {
+          openCount++
+          if (openCount === 1) return Promise.resolve(make402Response(challenge(false)))
+          return Promise.resolve(makeOkResponse())
+        }
+        return Promise.resolve(new Response('unexpected voucher', { status: 500 }))
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '10',
+        channelStore: store,
+      })
+
+      const response = await s.fetch('https://api.example.com/data')
+
+      expect(response.status).toBe(200)
+      // A replacement challenge with no snapshot means the server did not
+      // acknowledge the optimistic open, so the next credential must open again.
+      expect(postedPayloads.map((payload) => payload.action)).toEqual(['open', 'open'])
+      expect(postedPayloads[0]?.channelId).not.toBe(postedPayloads[1]?.channelId)
+      expect(remove).toHaveBeenCalledOnce()
+      expect(s.channelId).toBe(postedPayloads[1]?.channelId)
+    })
+
     test('does not bootstrap when disabled', async () => {
       const mockFetch = vi.fn().mockResolvedValue(makeOkResponse())
       const s = sessionManager({
@@ -686,6 +733,7 @@ describe('Session', () => {
                 methodDetails: {
                   escrowContract: tip20ChannelEscrow,
                   chainId: 4217,
+                  sessionProtocol: Constants.SessionProtocols.v2,
                   sessionSnapshot: {
                     acceptedCumulative: '2000000',
                     chainId: 4217,
@@ -887,8 +935,7 @@ describe('Session', () => {
         }
         if (callCount === 1)
           return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '3000000' })))
-        if (callCount === 3) return Promise.resolve(make402Response())
-        if (callCount === 4) return Promise.resolve(make402Response())
+        if (callCount >= 3 && callCount <= 6) return Promise.resolve(make402Response())
         return Promise.resolve(makeOkResponse())
       })
 
@@ -907,8 +954,14 @@ describe('Session', () => {
       expect(s.cumulative).toBe(1000000n)
 
       await s.topUp('1')
-      expect(postedPayloads.map((payload) => payload.action)).toEqual(['open', 'voucher', 'topUp'])
-      const topUpPayload = postedPayloads[2]
+      expect(postedPayloads.map((payload) => payload.action)).toEqual([
+        'open',
+        'voucher',
+        'voucher',
+        'voucher',
+        'topUp',
+      ])
+      const topUpPayload = postedPayloads[4]
       if (topUpPayload?.action !== 'topUp') throw new Error('expected top-up payload')
       expect(topUpPayload.additionalDeposit).toBe('1000000')
     })

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

@@ -201,9 +201,12 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
 
   // Tracks one fetch's channel reuse so stale stored entries can be evicted once.
   type ChannelUse = {
+    challengesReceived: number
+    created: Map<string, ChannelEntry>
     seenExisting: Set<string>
-    createdKeys: Set<string>
+    previous: RuntimeSnapshot
     resumed: ChannelEntry | undefined
+    trackCreates: boolean
   }
   let channelUse: ChannelUse | undefined
 
@@ -219,14 +222,15 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       const entry = await getReusable(key)
       if (entry && channelUse) {
         channelUse.seenExisting.add(key)
-        if (!channelUse.createdKeys.has(key)) channelUse.resumed ??= entry
+        if (!channelUse.created.has(key)) channelUse.resumed ??= entry
       }
       return entry
     },
     async set(entry) {
       const key = entryKey(entry)
       if (entry.opened) ignoredChannelIds.delete(entry.channelId)
-      if (channelUse && !channelUse.seenExisting.has(key)) channelUse.createdKeys.add(key)
+      if (channelUse?.trackCreates && !channelUse.seenExisting.has(key))
+        channelUse.created.set(key, entry)
       await backing.set(entry)
     },
     delete: (key) => backing.delete(key),
@@ -238,6 +242,31 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
     await Promise.resolve(backing.delete(entryKey(entry))).catch(() => undefined)
   }
 
+  async function rollbackCreatedChannelsForRetry() {
+    const use = channelUse
+    if (!use?.created.size) return
+    for (const [key, entry] of use.created) {
+      ignoredChannelIds.add(entry.channelId)
+      await Promise.resolve(backing.delete(key)).catch(() => undefined)
+    }
+    use.created.clear()
+    restoreRuntime(use.previous)
+  }
+
+  function referencesCreatedChannel(challenge: Challenge.Challenge): boolean {
+    const snapshot = Constants.getMethodDetail<{ channelId?: unknown }>(
+      challenge.request.methodDetails,
+      Constants.MethodDetailKeys.sessionSnapshot,
+    )
+    if (typeof snapshot?.channelId !== 'string') return false
+    const use = channelUse
+    if (!use?.created.size) return false
+    for (const entry of use.created.values()) {
+      if (entry.channelId.toLowerCase() === snapshot.channelId.toLowerCase()) return true
+    }
+    return false
+  }
+
   function dispatch(event: Parameters<typeof dispatchSessionEvent>[1]) {
     return dispatchSessionEvent(runtime, event)
   }
@@ -273,6 +302,14 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
     methods: [method],
     onChallenge: async (challenge, _helpers) => {
       if (!isTempoSessionChallenge(challenge)) return undefined
+      const use = channelUse
+      const isRepeatedRetryChallenge =
+        use && use.challengesReceived > 0 && challenge.id === runtime.lastChallenge?.id
+      if (!referencesCreatedChannel(challenge)) {
+        if (use?.created.size) await rollbackCreatedChannelsForRetry()
+        else if (isRepeatedRetryChallenge) restoreRuntime(use.previous)
+      }
+      if (use) use.challengesReceived++
       runtime.lastChallenge = challenge
       dispatch({ type: 'challengeReceived', challengeId: challenge.id })
       if (runtime.channel?.opened && runtime.lastUrl) {
@@ -498,9 +535,6 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       throw new Error(
         'SessionManager: a request is already in flight; concurrent requests on one manager are not supported',
       )
-    const use: ChannelUse = { seenExisting: new Set(), createdKeys: new Set(), resumed: undefined }
-    channelUse = use
-
     runtime.lastUrl = input
 
     const previous = captureRuntimeStateSnapshot({
@@ -508,12 +542,22 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       spent: runtime.spent,
       state: runtime.state,
     })
+    const use: ChannelUse = {
+      challengesReceived: 0,
+      created: new Map(),
+      previous,
+      seenExisting: new Set(),
+      resumed: undefined,
+      trackCreates: false,
+    }
+    channelUse = use
 
     // Cold starts resume from `channelStore` after the 402 reveals the scope.
     const liveHint = runtime.channel?.opened ? runtime.channel.channelId : undefined
 
     try {
       await bootstrapSession(input, init)
+      use.trackCreates = true
 
       let effectiveInit = requestInitWithSessionHint(input, init, liveHint)
       // Stored channels may be stale, so retry once after evicting the resumed entry.

package/src/x402/Header.ts

@@ -1,11 +1,18 @@
+import { Base64 } from 'ox'
+
 import * as HeaderCodec from '../internal/HeaderCodec.js'
 import {
+  ExtensionsSchema,
   PaymentPayloadSchema,
   PaymentRequiredSchema,
+  ResourceInfoSchema,
   SettleResponseSchema,
+  type Extensions,
   type PaymentPayload,
   type PaymentRequired,
+  type ResourceInfo,
   type SettleResponse,
+  type Version,
 } from './Types.js'
 
 const paymentRequired = HeaderCodec.createJson(PaymentRequiredSchema)
@@ -19,6 +26,24 @@ export const encodePaymentRequired: (paymentRequired: PaymentRequired) => string
 /** Decodes an x402 `PAYMENT-REQUIRED` header value. */
 export const decodePaymentRequired: (value: string) => PaymentRequired = paymentRequired.decode
 
+/** Tolerant x402 `PAYMENT-REQUIRED` envelope used before filtering supported accepts. @internal */
+export type PaymentRequiredEnvelope = {
+  accepts: unknown[]
+  extensions?: Extensions | undefined
+  resource: ResourceInfo
+  x402Version: Version
+}
+
+/** Decodes only the x402 `PAYMENT-REQUIRED` envelope, leaving accepts unvalidated. @internal */
+export function decodePaymentRequiredEnvelope(value: string): PaymentRequiredEnvelope {
+  try {
+    const parsed = JSON.parse(Base64.toString(value)) as unknown
+    return parsePaymentRequiredEnvelope(parsed)
+  } catch {
+    throw new HeaderCodec.InvalidJsonHeaderError()
+  }
+}
+
 /** Encodes an x402 payment payload for the `PAYMENT-SIGNATURE` header. */
 export const encodePaymentSignature: (paymentPayload: PaymentPayload) => string =
   paymentSignature.encode
@@ -32,3 +57,23 @@ export const encodePaymentResponse: (paymentResponse: SettleResponse) => string
 
 /** Decodes an x402 `PAYMENT-RESPONSE` header value. */
 export const decodePaymentResponse: (value: string) => SettleResponse = paymentResponse.decode
+
+const parsePaymentRequiredEnvelope = (value: unknown): PaymentRequiredEnvelope => {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new HeaderCodec.InvalidJsonHeaderError()
+
+  const record = value as Record<string, unknown>
+  if (record.x402Version !== 2 || !Array.isArray(record.accepts))
+    throw new HeaderCodec.InvalidJsonHeaderError()
+
+  const resource = ResourceInfoSchema.parse(record.resource)
+  const extensions =
+    record.extensions === undefined ? undefined : ExtensionsSchema.parse(record.extensions)
+
+  return {
+    accepts: record.accepts,
+    ...(extensions ? { extensions } : {}),
+    resource,
+    x402Version: 2,
+  }
+}