mppx 0.4.9 → 0.4.11

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

@@ -100,6 +100,13 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
       const ctx = contextMap.get(challengeId)
       if (ctx) {
         contextMap.delete(challengeId)
+
+        // Null-body statuses (e.g. 204 from management actions) cannot carry a
+        // response body per Fetch/HTTP semantics.
+        if (isNullBodyStatus(baseResponse.status)) {
+          return baseResponse
+        }
+
         const stream = new ReadableStream<Uint8Array>({
           async start(controller) {
             // deduction completes before consumer reads
@@ -191,3 +198,7 @@ function isAsyncGeneratorFunction(
 function isAsyncIterable(value: unknown): value is AsyncIterable<string> {
   return value !== null && typeof value === 'object' && Symbol.asyncIterator in (value as object)
 }
+
+function isNullBodyStatus(status: number): boolean {
+  return [101, 204, 205, 304].includes(status)
+}

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

@@ -1,7 +1,8 @@
 import { type Address, encodeFunctionData, erc20Abi, type Hex } from 'viem'
 import { waitForTransactionReceipt } from 'viem/actions'
 import { Addresses, Transaction } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'vp/test'
+import { nodeEnv } from '~test/config.js'
 import {
   closeChannelOnChain,
   deployEscrow,
@@ -22,6 +23,8 @@ import {
 } from './Chain.js'
 import { signVoucher } from './Voucher.js'
 
+const isLocalnet = nodeEnv === 'localnet'
+
 const UINT128_MAX = 2n ** 128n - 1n
 
 describe('assertUint128 (via settleOnChain / closeOnChain)', () => {
@@ -70,7 +73,7 @@ describe('assertUint128 (via settleOnChain / closeOnChain)', () => {
   })
 })
 
-describe('on-chain', () => {
+describe.runIf(isLocalnet)('on-chain', () => {
   const payer = accounts[2]
   const recipient = accounts[0].address
   const currency = asset

package/src/tempo/session/Chain.ts

@@ -132,7 +132,7 @@ export async function closeOnChain(
   const resolved = account ?? client.account
   if (!resolved)
     throw new Error(
-      'Cannot close channel: no account available. Provide an `account` in the session config or a `getClient` that returns an account-bearing client.',
+      'Cannot close channel: no account available. Pass an `account` (viem Account, e.g. privateKeyToAccount("0x...")) to tempo.session(), or provide a `getClient` that returns an account-bearing client.',
     )
   const args = [voucher.channelId, voucher.cumulativeAmount, voucher.signature] as const
   if (feePayer) {

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

@@ -1,5 +1,5 @@
 import { AbiParameters, Hash } from 'ox'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Channel from './Channel.js'
 

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

@@ -1,5 +1,5 @@
 import type { Address, Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Store from '../../Store.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'

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

@@ -1,5 +1,5 @@
 import type { Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import {
   createSessionReceipt,

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

@@ -0,0 +1,138 @@
+import * as fc from 'fast-check'
+import { describe, expect, test } from 'vp/test'
+
+import * as Sse from './Sse.js'
+
+function createChunkedResponse(chunks: Uint8Array[]): Response {
+  let index = 0
+  const stream = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (index < chunks.length) {
+        controller.enqueue(chunks[index]!)
+        index++
+      } else {
+        controller.close()
+      }
+    },
+  })
+  return new Response(stream, {
+    headers: { 'Content-Type': 'text/event-stream' },
+  })
+}
+
+function splitAtPositions(str: string, positions: number[]): Uint8Array[] {
+  const encoder = new TextEncoder()
+  const sorted = [...new Set([0, ...positions, str.length])]
+    .filter((p) => p >= 0 && p <= str.length)
+    .sort((a, b) => a - b)
+  const chunks: Uint8Array[] = []
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const chunk = str.slice(sorted[i], sorted[i + 1])
+    if (chunk.length > 0) chunks.push(encoder.encode(chunk))
+  }
+  return chunks
+}
+
+async function collectData(response: Response): Promise<string[]> {
+  const results: string[] = []
+  for await (const data of Sse.iterateData(response)) {
+    results.push(data)
+  }
+  return results
+}
+
+describe('parseEvent', () => {
+  test('never throws on arbitrary message-type input', () => {
+    fc.assert(
+      fc.property(fc.string(), (input) => {
+        const result = Sse.parseEvent(input)
+        if (result !== null) {
+          expect(result.type).toBe('message')
+          expect(typeof result.data).toBe('string')
+        }
+      }),
+      { numRuns: 10_000 },
+    )
+  })
+
+  test('parseEvent with valid SSE format', () => {
+    const sseMessageArb = fc
+      .array(
+        fc.string().filter((s) => !s.includes('\n')),
+        { minLength: 1, maxLength: 5 },
+      )
+      .map((lines) => lines.map((l) => `data: ${l}`).join('\n'))
+
+    fc.assert(
+      fc.property(sseMessageArb, (raw) => {
+        const result = Sse.parseEvent(raw)
+        expect(result).not.toBeNull()
+        expect(result!.type).toBe('message')
+        const expectedData = raw
+          .split('\n')
+          .map((l) => l.slice(6))
+          .join('\n')
+        expect(result!.data).toBe(expectedData)
+      }),
+      { numRuns: 5_000 },
+    )
+  })
+})
+
+describe('iterateData', () => {
+  const sseEventArb = fc
+    .array(
+      fc.string().filter((s) => !s.includes('\n\n') && !s.includes('\n')),
+      { minLength: 1, maxLength: 3 },
+    )
+    .map((lines) => lines.map((l) => `data: ${l}`).join('\n'))
+
+  const sseStreamArb = fc
+    .array(sseEventArb, { minLength: 1, maxLength: 5 })
+    .map((events) => events.join('\n\n') + '\n\n')
+
+  test('chunk boundary invariance', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        sseStreamArb,
+        fc.array(fc.nat(), { minLength: 1, maxLength: 10 }),
+        async (stream, positions) => {
+          const encoder = new TextEncoder()
+
+          const singleChunk = createChunkedResponse([encoder.encode(stream)])
+          const singleResult = await collectData(singleChunk)
+
+          const boundedPositions = positions.map((p) => p % (stream.length + 1))
+          const chunks = splitAtPositions(stream, boundedPositions)
+          const multiChunk = createChunkedResponse(chunks)
+          const multiResult = await collectData(multiChunk)
+
+          expect(multiResult).toEqual(singleResult)
+        },
+      ),
+      { numRuns: 1_000 },
+    )
+  })
+
+  test('iterateData never throws on arbitrary chunked input', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        fc.array(fc.uint8Array({ minLength: 1, maxLength: 100 }), {
+          minLength: 1,
+          maxLength: 5,
+        }),
+        async (chunks) => {
+          const response = createChunkedResponse(chunks)
+          const results: string[] = []
+          for await (const data of Sse.iterateData(response)) {
+            results.push(data)
+          }
+          for (const item of results) {
+            expect(typeof item).toBe('string')
+          }
+        },
+      ),
+      { numRuns: 5_000 },
+    )
+  })
+})

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

@@ -1,5 +1,5 @@
 import type { Address, Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type * as ChannelStore from './ChannelStore.js'

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

@@ -1,6 +1,6 @@
 import { createClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import { parseVoucherFromPayload, signVoucher, verifyVoucher } from './Voucher.js'
 

package/src/viem/Account.test.ts

@@ -1,7 +1,7 @@
 import { createClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 import { mainnet } from 'viem/chains'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Account from './Account.js'
 

package/src/viem/Client.test.ts

@@ -3,7 +3,7 @@ import { privateKeyToAccount } from 'viem/accounts'
 import { signTransaction } from 'viem/actions'
 import { tempoLocalnet } from 'viem/chains'
 import { Transaction } from 'viem/tempo'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Client from './Client.js'
 

package/src/zod.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from 'vp/test'
+
+import { address, amount, datetime, hash, period, signature, unwrapOptional, z } from './zod.js'
+
+describe('amount', () => {
+  test.each([
+    { input: '1', expected: true, desc: 'integer' },
+    { input: '1000000', expected: true, desc: 'large integer' },
+    { input: '1.5', expected: true, desc: 'decimal' },
+    { input: '0', expected: true, desc: 'zero' },
+    { input: '007', expected: true, desc: 'leading zeros' },
+    { input: '-1', expected: false, desc: 'negative number' },
+    { input: '', expected: false, desc: 'empty string' },
+    { input: 'abc', expected: false, desc: 'alphabetic string' },
+    { input: '1.', expected: false, desc: 'trailing decimal point' },
+    { input: 123 as unknown as string, expected: false, desc: 'non-string type' },
+  ])('$desc ($input) → $expected', ({ input, expected }) => {
+    expect(amount().safeParse(input).success).toBe(expected)
+  })
+})
+
+describe('datetime', () => {
+  test.each([
+    { input: '2025-01-06T12:00:00Z', expected: true, desc: 'UTC with Z suffix' },
+    { input: '2025-01-06T12:00:00.123Z', expected: true, desc: 'fractional seconds' },
+    { input: '2025-01-06T12:00:00+05:30', expected: true, desc: 'positive UTC offset' },
+    { input: '2025-01-06T12:00:00-08:00', expected: true, desc: 'negative UTC offset' },
+    { input: '2025-01-06T12:00:00', expected: false, desc: 'missing timezone' },
+    { input: '2025-01-06', expected: false, desc: 'date only, no time' },
+    { input: '', expected: false, desc: 'empty string' },
+    { input: 'not-a-date', expected: false, desc: 'non-date string' },
+  ])('$desc ($input) → $expected', ({ input, expected }) => {
+    expect(datetime().safeParse(input).success).toBe(expected)
+  })
+})
+
+describe('address', () => {
+  test.each([
+    { input: '0x1234567890abcdef1234567890abcdef12345678', expected: true, desc: 'lowercase hex' },
+    { input: '0x1234567890ABCDEF1234567890ABCDEF12345678', expected: true, desc: 'uppercase hex' },
+    { input: '0xAbCdEf0123456789AbCdEf0123456789AbCdEf01', expected: true, desc: 'mixed case hex' },
+    { input: '0x1234', expected: false, desc: 'too short' },
+    {
+      input: '0x1234567890abcdef1234567890abcdef1234567890',
+      expected: false,
+      desc: 'too long (42 hex chars)',
+    },
+    {
+      input: '1234567890abcdef1234567890abcdef12345678',
+      expected: false,
+      desc: 'missing 0x prefix',
+    },
+    {
+      input: '0xGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG',
+      expected: false,
+      desc: 'non-hex characters',
+    },
+    { input: '', expected: false, desc: 'empty string' },
+  ])('$desc → $expected', ({ input, expected }) => {
+    expect(address().safeParse(input).success).toBe(expected)
+  })
+})
+
+describe('hash', () => {
+  test.each([
+    {
+      input: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+      expected: true,
+      desc: 'valid 64 hex chars',
+    },
+    {
+      input: '0xABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890',
+      expected: true,
+      desc: 'uppercase hex',
+    },
+    {
+      input: '0x1234567890abcdef1234567890abcdef12345678',
+      expected: false,
+      desc: 'too short (address length)',
+    },
+    {
+      input: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef00',
+      expected: false,
+      desc: 'too long (66 hex chars)',
+    },
+    {
+      input: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+      expected: false,
+      desc: 'missing 0x prefix',
+    },
+    { input: '', expected: false, desc: 'empty string' },
+  ])('$desc → $expected', ({ input, expected }) => {
+    expect(hash().safeParse(input).success).toBe(expected)
+  })
+})
+
+describe('period', () => {
+  test.each([
+    { input: 'day', expected: true, desc: 'day keyword' },
+    { input: 'week', expected: true, desc: 'week keyword' },
+    { input: 'month', expected: true, desc: 'month keyword' },
+    { input: 'year', expected: true, desc: 'year keyword' },
+    { input: '3600', expected: true, desc: 'numeric seconds' },
+    { input: '', expected: false, desc: 'empty string' },
+    { input: 'hourly', expected: false, desc: 'unsupported keyword' },
+    { input: 'day1', expected: false, desc: 'keyword with trailing digits' },
+  ])('$desc ($input) → $expected', ({ input, expected }) => {
+    expect(period().safeParse(input).success).toBe(expected)
+  })
+})
+
+describe('signature', () => {
+  test.each([
+    { input: '0xabcdef', expected: true, desc: 'short hex' },
+    {
+      input:
+        '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b',
+      expected: true,
+      desc: 'full 65-byte secp256k1 signature',
+    },
+    { input: '0x', expected: false, desc: 'bare 0x prefix with no data' },
+    { input: 'abcdef', expected: false, desc: 'missing 0x prefix' },
+    { input: '0xZZZZ', expected: false, desc: 'non-hex characters after 0x' },
+    { input: '', expected: false, desc: 'empty string' },
+  ])('$desc → $expected', ({ input, expected }) => {
+    expect(signature().safeParse(input).success).toBe(expected)
+  })
+})
+
+describe('unwrapOptional', () => {
+  test('unwraps optional string schema to inner type', () => {
+    const inner = z.string()
+    const result = unwrapOptional(z.optional(inner))
+    expect(result).toBe(inner)
+  })
+
+  test('returns non-optional schema unchanged', () => {
+    const schema = z.string()
+    expect(unwrapOptional(schema)).toBe(schema)
+  })
+
+  test('unwraps optional number schema to inner type', () => {
+    const inner = z.number()
+    const result = unwrapOptional(z.optional(inner))
+    expect(result).toBe(inner)
+  })
+})