mppx 0.4.12 → 0.5.0

package/src/tempo/server/internal/transport.test.ts

@@ -82,6 +82,19 @@ function makeReceipt() {
   }
 }
 
+async function readResponseText(response: Response): Promise<string> {
+  if (!response.body) return ''
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let result = ''
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    result += decoder.decode(value, { stream: true })
+  }
+  return result
+}
+
 describe('sse transport', () => {
   test('getCredential returns null when no Authorization header', () => {
     const store = memoryStore()
@@ -152,6 +165,19 @@ describe('sse transport', () => {
       challengeId,
     })
     expect(response.headers.get('Content-Type')).toContain('text/event-stream')
+
+    const body = await readResponseText(response)
+    const receiptRaw = body.split('event: payment-receipt\ndata: ')[1]?.split('\n\n')[0]
+    const terminalReceipt = JSON.parse(receiptRaw!)
+
+    expect(response.headers.get('Payment-Receipt')).toBeNull()
+    expect(body).toContain('event: message\ndata: hello\n\n')
+    expect(body).toContain('event: message\ndata: world\n\n')
+    expect(body).toContain('event: payment-receipt\n')
+    expect(terminalReceipt.challengeId).toBe(challengeId)
+    expect(terminalReceipt.channelId).toBe(channelId)
+    expect(terminalReceipt.units).toBe(2)
+    expect(terminalReceipt.spent).toBe('2000000')
   })
 
   test('respondReceipt with AsyncGeneratorFunction passes stream controller', async () => {
@@ -197,6 +223,12 @@ describe('sse transport', () => {
       challengeId,
     })
     expect(response.headers.get('Content-Type')).toContain('text/event-stream')
+
+    const body = await readResponseText(response)
+    expect(response.headers.get('Payment-Receipt')).toBeNull()
+    expect(body).toContain('event: message\ndata: chunk1\n\n')
+    expect(body).toContain('event: message\ndata: chunk2\n\n')
+    expect(body).toContain('event: payment-receipt\n')
   })
 
   test('respondReceipt with plain Response delegates to base http transport', () => {

package/src/tempo/session/Chain.test.ts

@@ -539,6 +539,41 @@ describe.runIf(isLocalnet)('on-chain', () => {
       ).rejects.toThrow('topUp transaction amount')
     })
 
+    test('rejects when post-broadcast deposit does not exceed declared previousDeposit', async () => {
+      const salt = nextSalt()
+      const deposit = 5_000_000n
+      const topUpAmount = 1_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const { serializedTransaction } = await signTopUpChannel({
+        escrow: escrowContract,
+        payer,
+        channelId,
+        token: currency,
+        amount: topUpAmount,
+      })
+
+      await expect(
+        broadcastTopUpTransaction({
+          client,
+          serializedTransaction,
+          escrowContract,
+          channelId,
+          currency: asset,
+          declaredDeposit: topUpAmount,
+          previousDeposit: deposit + topUpAmount,
+        }),
+      ).rejects.toThrow('channel deposit did not increase after topUp')
+    })
+
     test('successful broadcast returns txHash and newDeposit', async () => {
       const salt = nextSalt()
       const deposit = 5_000_000n

package/src/tempo/session/Sse.test.ts

@@ -366,6 +366,37 @@ describe('serve', () => {
     expect(receipt.challengeId).toBe(challengeId)
   })
 
+  test('emits exactly one terminal payment-receipt event at stream end', async () => {
+    const storage = memoryStore()
+    await seedChannel(storage, 2000000n)
+
+    const stream = serve({
+      store: storage,
+      channelId,
+      challengeId,
+      tickCost: 1000000n,
+      generate: generate(['one', 'two']),
+    })
+
+    const output = await readStream(stream)
+    const events = output
+      .trim()
+      .split('\n\n')
+      .filter((chunk) => chunk.length > 0)
+      .map((chunk) => parseEvent(`${chunk}\n\n`))
+      .filter((event): event is NonNullable<typeof event> => event !== null)
+
+    const terminal = events.at(-1)
+    expect(terminal?.type).toBe('payment-receipt')
+    if (terminal?.type !== 'payment-receipt') throw new Error('expected terminal payment receipt')
+
+    expect(events.filter((event) => event.type === 'payment-receipt')).toHaveLength(1)
+    expect(terminal.data.challengeId).toBe(challengeId)
+    expect(terminal.data.channelId).toBe(channelId)
+    expect(terminal.data.units).toBe(2)
+    expect(terminal.data.spent).toBe('2000000')
+  })
+
   test('handles empty generator', async () => {
     const storage = memoryStore()
     await seedChannel(storage, 1000000n)