mppx 0.8.13 → 0.8.15

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

@@ -113,6 +113,20 @@ function makeChannelStore(seed: readonly ChannelEntry[] = []) {
   return { store, set, delete: remove, map }
 }
 
+function makeDurableChannelStore() {
+  const backend = new Map<string, string>()
+  const store = createJsonChannelStore({
+    get: (key) => backend.get(key),
+    set: (key, value) => {
+      backend.set(key, value)
+    },
+    delete: (key) => {
+      backend.delete(key)
+    },
+  })
+  return { backend, store }
+}
+
 function makeChallenge(overrides: Record<string, unknown> = {}): Challenge.Challenge {
   return Challenge.from({
     id: challengeId,
@@ -609,7 +623,55 @@ describe('Session', () => {
       expect(s.channelId).not.toBe(storedChannelId)
     })
 
-    test('rolls back an optimistic open when a replacement challenge does not reference it', async () => {
+    test('keeps a persisted channel after its committed top-up when the paid retry fails', async () => {
+      const seeded = channelEntry({ cumulativeAmount: 10_000_000n, deposit: 10_000_000n })
+      const { store, delete: remove, map } = makeChannelStore([seeded])
+      const postedPayloads: SessionCredentialPayload[] = []
+      let probes = 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) {
+          probes++
+          if (probes > 1) throw new Error('unexpected fresh-channel retry')
+          return Promise.resolve(make402Response())
+        }
+
+        postedPayloads.push(payload)
+        if (payload.action === 'topUp') return Promise.resolve(new Response(null, { status: 204 }))
+        if (payload.action === 'voucher')
+          return Promise.resolve(new Response('upstream failed', { status: 500 }))
+        throw new Error(`unexpected ${payload.action} credential`)
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '20',
+        channelStore: store,
+      })
+
+      const response = await s.fetch('https://api.example.com/data')
+
+      expect(response.status).toBe(500)
+      expect(postedPayloads.map((payload) => payload.action)).toEqual(['topUp', 'voucher'])
+      expect(remove).not.toHaveBeenCalled()
+      expect(map.get(entryKey(seeded))).toMatchObject({
+        channelId: storedChannelId,
+        cumulativeAmount: 10_000_000n,
+        deposit: 11_000_000n,
+      })
+      expect(s.channelId).toBe(storedChannelId)
+      expect(s.state).toMatchObject({
+        status: 'active',
+        channelId: storedChannelId,
+        deposit: '11000000',
+      })
+    })
+
+    test('rolls back optimistic opens across replacement challenges', async () => {
       const { store, delete: remove } = makeChannelStore()
       const postedPayloads: SessionCredentialPayload[] = []
       const challenge = (feePayer: boolean) =>
@@ -621,6 +683,8 @@ describe('Session', () => {
             feePayer,
           },
         })
+      const original = challenge(true)
+      const replacement = challenge(false)
       let openCount = 0
       const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
         const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
@@ -629,10 +693,11 @@ describe('Session', () => {
           : undefined
         if (payload) postedPayloads.push(payload)
 
-        if (!payload) return Promise.resolve(make402Response(challenge(true)))
+        if (!payload) return Promise.resolve(make402Response(original))
         if (payload.action === 'open') {
           openCount++
-          if (openCount === 1) return Promise.resolve(make402Response(challenge(false)))
+          if (openCount === 1) return Promise.resolve(make402Response(replacement))
+          if (openCount === 2) return Promise.resolve(make402Response(original))
           return Promise.resolve(makeOkResponse())
         }
         return Promise.resolve(new Response('unexpected voucher', { status: 500 }))
@@ -648,12 +713,33 @@ describe('Session', () => {
       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)
+      expect(postedPayloads.map((payload) => payload.action)).toEqual(['open', 'open', 'open'])
+      expect(new Set(postedPayloads.map((payload) => payload.channelId)).size).toBe(3)
+      expect(remove).toHaveBeenCalledTimes(2)
+      expect(s.channelId).toBe(postedPayloads[2]?.channelId)
+    })
+
+    test('reuses prepared voucher state when an identical challenge succeeds', async () => {
+      const vouchers: Extract<SessionCredentialPayload, { action: 'voucher' }>[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization) return Promise.resolve(make402Response())
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        if (payload.action !== 'voucher') throw new Error('expected voucher')
+        vouchers.push(payload)
+        return Promise.resolve(vouchers.length === 1 ? make402Response() : makeOkResponse())
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        channelStore: makeChannelStore([channelEntry()]).store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(200)
+      expect(vouchers.map((voucher) => voucher.cumulativeAmount)).toEqual(['2000000', '2000000'])
+      expect(s.cumulative).toBe(2_000_000n)
+      expect(s.state.status).toBe('active')
     })
 
     test('does not bootstrap when disabled', async () => {
@@ -753,10 +839,11 @@ describe('Session', () => {
       await restarted.fetch('https://api.example.com/data')
 
       // The first request carries no hint header; after the 402 the restarted
-      // manager resumes the persisted channel from the entry index with a
-      // voucher rather than opening a new one.
+      // manager tops up and resumes the full persisted channel rather than
+      // opening a new one.
       expect(new Headers(resumeFetch.mock.calls[0]?.[1]?.headers).get('Payment-Session')).toBeNull()
-      expect(posted[0]).toMatchObject({ action: 'voucher', channelId })
+      expect(posted.map((payload) => payload.action)).toEqual(['topUp', 'voucher'])
+      expect(posted[1]).toMatchObject({ channelId })
     })
 
     test('persists opened channels and deletes closed channels when supported', async () => {
@@ -940,6 +1027,60 @@ describe('Session', () => {
       })
     })
 
+    test('preserves a snapshot-acknowledged open when its voucher fails', async () => {
+      const { backend, store } = makeDurableChannelStore()
+      const payloads: SessionCredentialPayload[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization)
+          return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '10000000' })))
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        payloads.push(payload)
+        if (payload.action !== 'open')
+          return Promise.resolve(new Response('failed', { status: 500 }))
+        return Promise.resolve(
+          make402Response(
+            makeChallenge({
+              methodDetails: {
+                escrowContract: tip20ChannelEscrow,
+                chainId: 4217,
+                sessionProtocol: Constants.SessionProtocols.v2,
+                sessionSnapshot: {
+                  acceptedCumulative: '1000000',
+                  chainId: 4217,
+                  channelId: payload.channelId,
+                  deposit: '10000000',
+                  descriptor: payload.descriptor,
+                  escrow: tip20ChannelEscrow,
+                  requiredCumulative: '2000000',
+                  settled: '0',
+                  spent: '1000000',
+                  units: 1,
+                },
+              },
+            }),
+          ),
+        )
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '10',
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(500)
+      expect(payloads.map((payload) => payload.action)).toEqual(['open', 'voucher'])
+      expect(s.channelId).toBe(payloads[0]?.channelId)
+      expect(s.cumulative).toBe(1_000_000n)
+      expect(JSON.parse([...backend.values()][0]!)).toMatchObject({
+        channelId: payloads[0]?.channelId,
+        cumulativeAmount: '1000000',
+        opened: true,
+      })
+    })
+
     test('preemptively top-ups before signing an HTTP voucher that exceeds deposit', async () => {
       const postedPayloads: SessionCredentialPayload[] = []
       let challengeCount = 0
@@ -987,6 +1128,7 @@ describe('Session', () => {
         client,
         fetch: mockFetch as typeof globalThis.fetch,
         maxDeposit: '10',
+        topUpAmount: '5',
       })
 
       await s.fetch('https://api.example.com/data')
@@ -994,14 +1136,132 @@ describe('Session', () => {
 
       expect(response.status).toBe(200)
       expect(postedPayloads.map((payload) => payload.action)).toEqual(['open', 'topUp', 'voucher'])
+      const topUp = postedPayloads[1]
+      if (topUp?.action !== 'topUp') throw new Error('expected top-up payload')
+      expect(topUp.additionalDeposit).toBe('5000000')
       expect(s.state).toMatchObject({
         status: 'active',
         acceptedCumulative: '2000000',
-        deposit: '2000000',
+        deposit: '6000000',
         spent: '2000000',
         units: 2,
       })
     })
+
+    test('preserves a successful automatic top-up when the paid retry fails', async () => {
+      const { map, store } = makeChannelStore()
+      const payloads: SessionCredentialPayload[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization)
+          return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '1000000' })))
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        payloads.push(payload)
+        if (payload.action === 'open')
+          return Promise.resolve(
+            new Response('ok', {
+              headers: {
+                [Constants.Headers.paymentReceipt]: serializeSessionReceipt(
+                  createSessionReceipt({
+                    acceptedCumulative: 1_000_000n,
+                    challengeId,
+                    channelId: payload.channelId,
+                    spent: 1_000_000n,
+                    units: 3,
+                  }),
+                ),
+              },
+            }),
+          )
+        if (payload.action === 'topUp') return Promise.resolve(new Response(null, { status: 204 }))
+        return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '1000000' })))
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '3',
+        channelStore: store,
+      })
+
+      await s.fetch('https://api.example.com/data')
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(402)
+
+      expect(payloads.map((payload) => payload.action)).toEqual([
+        'open',
+        'topUp',
+        'voucher',
+        'voucher',
+        'voucher',
+      ])
+      expect(s.cumulative).toBe(1_000_000n)
+      expect(s.state).toMatchObject({ status: 'active', deposit: '2000000', units: 3 })
+      expect([...map.values()][0]).toMatchObject({
+        cumulativeAmount: 1_000_000n,
+        deposit: 2_000_000n,
+      })
+    })
+
+    test('preserves a topped-up resumed channel in durable storage after payment fails', async () => {
+      const { store } = makeDurableChannelStore()
+      const seeded = channelEntry({ cumulativeAmount: 1_000_000n, deposit: 1_000_000n })
+      await store.set(seeded)
+      const payloads: SessionCredentialPayload[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization)
+          return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '1000000' })))
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        payloads.push(payload)
+        return Promise.resolve(
+          payload.action === 'topUp'
+            ? new Response(null, { status: 204 })
+            : new Response('failed', { status: 500 }),
+        )
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '3',
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(500)
+
+      expect(payloads.map((payload) => payload.action)).toEqual(['topUp', 'voucher'])
+      expect(s.cumulative).toBe(1_000_000n)
+      expect(s.state).toMatchObject({ status: 'active', deposit: '2000000' })
+      await expect(store.get(entryKey(seeded))).resolves.toMatchObject({
+        cumulativeAmount: 1_000_000n,
+        deposit: 2_000_000n,
+        opened: true,
+      })
+    })
+
+    test.each([
+      ['new', false],
+      ['replacement', true],
+    ] as const)('removes a failed %s durable channel', async (_kind, seeded) => {
+      const { backend, store } = makeDurableChannelStore()
+      if (seeded) await store.set(channelEntry())
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        return Promise.resolve(
+          authorization ? new Response('failed', { status: 500 }) : make402Response(),
+        )
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(500)
+      expect(s.channelId).toBeUndefined()
+      expect(backend.size).toBe(0)
+    })
   })
 
   describe('.topUp()', () => {
@@ -1398,6 +1658,51 @@ describe('Session', () => {
     })
   })
 
+  describe('.ws()', () => {
+    test('tops up a full persisted channel before constructing the socket', async () => {
+      const events: string[] = []
+      const { map, set, store } = makeChannelStore([
+        channelEntry({ cumulativeAmount: 1_000_000n, deposit: 1_000_000n }),
+      ])
+      set.mockImplementation((entry) => {
+        map.set(entryKey(entry), entry)
+        events.push(`set:${entry.deposit}:${entry.cumulativeAmount}`)
+      })
+      const fetch = vi.fn(async (_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization) {
+          events.push('probe')
+          return make402Response(makeChallenge({ suggestedDeposit: '1000000' }))
+        }
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        if (payload.action !== 'topUp') throw new Error(`unexpected ${payload.action} fetch`)
+        events.push('topUp')
+        return new Response(null, { status: 204 })
+      })
+      function WebSocket() {
+        events.push('socket')
+        throw new Error('stop after preparation')
+      }
+      const s = sessionManager({
+        account,
+        client,
+        fetch: fetch as typeof globalThis.fetch,
+        maxDeposit: '3',
+        channelStore: store,
+        webSocket: WebSocket as never,
+      })
+
+      await expect(s.ws('wss://api.example.com/socket')).rejects.toThrow('stop after preparation')
+      expect(events).toEqual([
+        'probe',
+        'topUp',
+        'set:2000000:1000000',
+        'set:2000000:2000000',
+        'socket',
+      ])
+    })
+  })
+
   describe('.close()', () => {
     test('is no-op when not opened', async () => {
       const mockFetch = vi.fn()