mppx 0.8.12 → 0.8.13

package/src/tempo/session/server/Ws.test.ts

@@ -408,6 +408,119 @@ describe('isows', () => {
     expect(channel?.units).toBe(0)
   })
 
+  test('aborts a blocked application generator before sending close-ready', async () => {
+    const socket = new MockSocket()
+    const store = memoryChannelStore()
+    await seedChannel(store, 1n)
+    let generatorAborted = false
+
+    await Ws.serve({
+      socket,
+      store,
+      url: 'ws://example.test/stream',
+      route: async () => ({
+        status: 200,
+        withReceipt(response = new Response(null, { status: 204 })) {
+          response.headers.set(
+            'Payment-Receipt',
+            serializeSessionReceipt(
+              createSessionReceipt({
+                challengeId: challenge.id,
+                channelId,
+                acceptedCumulative: 1n,
+                spent: 0n,
+                units: 0,
+              }),
+            ),
+          )
+          return response
+        },
+      }),
+      generate: async function* (stream) {
+        await new Promise<void>((resolve) => {
+          stream.signal.addEventListener('abort', () => resolve(), { once: true })
+        })
+        generatorAborted = true
+        yield* []
+      },
+    })
+
+    socket.receive(
+      Ws.formatAuthorizationMessage(
+        makeCredential({
+          action: 'open',
+          channelId,
+          cumulativeAmount: '1',
+          signature: `0x${'77'.repeat(65)}`,
+          transaction: '0x01',
+          type: 'transaction',
+        }),
+      ),
+    )
+    await sleep(10)
+    socket.receive(Ws.formatCloseRequestMessage())
+    await sleep(10)
+
+    expect(generatorAborted).toBe(true)
+    expect(
+      socket.sent
+        .map((message) => Ws.parseMessage(message))
+        .some((message) => message?.mpp === 'payment-close-ready'),
+    ).toBe(true)
+  })
+
+  test('meters an explicit per-message amount independently of the challenge tick cost', async () => {
+    const socket = new MockSocket()
+    const store = memoryChannelStore()
+    await seedChannel(store, 25n)
+
+    await Ws.serve({
+      socket,
+      store,
+      url: 'ws://example.test/stream',
+      route: async () => ({
+        status: 200,
+        withReceipt(response = new Response(null, { status: 204 })) {
+          response.headers.set(
+            'Payment-Receipt',
+            serializeSessionReceipt(
+              createSessionReceipt({
+                challengeId: challenge.id,
+                channelId,
+                acceptedCumulative: 25n,
+                spent: 0n,
+                units: 0,
+              }),
+            ),
+          )
+          return response
+        },
+      }),
+      generate: async function* (stream) {
+        await stream.charge(7n)
+        yield 'priced-response'
+      },
+    })
+
+    socket.receive(
+      Ws.formatAuthorizationMessage(
+        makeCredential({
+          action: 'open',
+          channelId,
+          cumulativeAmount: '25',
+          signature: `0x${'77'.repeat(65)}`,
+          transaction: '0x01',
+          type: 'transaction',
+        }),
+      ),
+    )
+
+    await sleep(10)
+
+    expect(await store.getChannel(channelId)).toMatchObject({ spent: 7n, units: 1 })
+    expect(socket.sent.some((message) => message.includes('priced-response'))).toBe(true)
+  })
+
   test('does not meter or emit application messages after close is requested on-chain', async () => {
     const socket = new MockSocket()
     const store = memoryChannelStore()

package/src/tempo/session/server/Ws.ts

@@ -322,6 +322,8 @@ export declare namespace serve {
      *  multiple offers — otherwise a client can select the cheapest offer
      *  and still receive the same stream. */
     amount?: string | undefined
+    /** Application stream. A manual stream can call `charge(amount)` with a
+     *  per-message raw-unit amount; omitting it uses the challenge tick cost. */
     generate: AsyncIterable<string> | ((stream: SessionController) => AsyncIterable<string>)
     pollIntervalMs?: number | undefined
     /** Payment route handler. Receives synthetic `POST` requests with only

package/src/tempo/session/server/index.ts

@@ -3,8 +3,10 @@ export { charge, session, settle, settleBatch } from './Session.js'
 export * as Sse from './Sse.js'
 /** Server-side automatic settlement schedule. */
 export type {
+  OnSessionSettlement,
   ResolveSessionChannelId,
   ResolveSessionChannelIdParameters,
   SessionChannelIdRequest,
+  SessionSettlementContext,
   SettlementSchedule,
 } from './Session.js'

package/src/validation/core.ts

@@ -14,6 +14,7 @@ import {
   parseEndpointArg,
   resolveBodyForEndpoint,
 } from '../cli/validate/helpers.js'
+import { missingDiscoverySuggestion } from '../cli/validate/messages.js'
 import { validatePaymentFlow } from '../cli/validate/payment.js'
 import { validate as validateDiscoveryDoc } from '../discovery/Validate.js'
 
@@ -237,7 +238,7 @@ export async function validate(options: ValidateOptions): Promise<ValidateResult
 
   if (!discovery) throw new Error('Discovery phase did not complete')
 
-  const suggestions = computeSuggestions(endpointResults, { sawTestnet, sawMainnet })
+  const suggestions = computeSuggestions(endpointResults, discovery, { sawTestnet, sawMainnet })
 
   return {
     url: baseUrl,
@@ -250,11 +251,16 @@ export async function validate(options: ValidateOptions): Promise<ValidateResult
 
 function computeSuggestions(
   endpoints: EndpointValidationResult[],
+  discovery: DiscoveryResult,
   flags: { sawTestnet: boolean; sawMainnet: boolean },
 ): string[] {
   const steps: string[] = []
   const allResults = endpoints.flatMap((ep) => [...ep.challenge, ...ep.payment])
 
+  if (!discovery.found) {
+    steps.push(missingDiscoverySuggestion)
+  }
+
   const sawCryptoMainnet = flags.sawMainnet
   const sawCryptoTestnet = flags.sawTestnet
   const sawStripeLive = allResults.some(

package/src/viem/Client.test.ts

@@ -3,12 +3,16 @@ import { privateKeyToAccount } from 'viem/accounts'
 import { signTransaction } from 'viem/actions'
 import { Account as TempoAccount, Transaction } from 'viem/tempo'
 import { tempoLocalnet } from 'viem/tempo/chains'
-import { describe, expect, test } from 'vp/test'
+import { afterEach, describe, expect, test, vi } from 'vp/test'
 
 import * as Client from './Client.js'
 
 const rpcUrl = { 42: 'https://rpc.example.com', 99: 'https://rpc2.example.com' } as const
 
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
 describe('getResolver', () => {
   test('behavior: creates client from rpcUrl for given chainId', async () => {
     const getClient = Client.getResolver({
@@ -61,6 +65,45 @@ describe('getResolver', () => {
       `[Error: No \`rpcUrl\` configured for \`chainId\` (99).]`,
     )
   })
+
+  test('behavior: wraps custom client transports with a hosted fee payer', async () => {
+    const defaultRequests: string[] = []
+    const client = createClient({
+      chain: tempoLocalnet,
+      transport: custom({
+        async request({ method }) {
+          defaultRequests.push(method)
+          return { source: 'default' }
+        },
+      }),
+    })
+    const fetchMock = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      const request = JSON.parse(String(init?.body)) as { id: number; jsonrpc: string }
+      return Response.json({
+        id: request.id,
+        jsonrpc: request.jsonrpc,
+        result: { source: 'relay' },
+      })
+    })
+    vi.stubGlobal('fetch', fetchMock)
+
+    const getClient = Client.getResolver({
+      chain: tempoLocalnet,
+      feePayerUrl: 'https://sponsor.example',
+      getClient: () => client,
+      rpcUrl: { [tempoLocalnet.id]: 'https://rpc.example.com' },
+    })
+    const resolved = await getClient({ chainId: tempoLocalnet.id })
+    const result = await resolved.request({
+      method: 'eth_fillTransaction',
+      params: [{ feePayer: true }],
+    } as never)
+
+    expect(result).toEqual({ source: 'relay' })
+    expect(fetchMock).toHaveBeenCalledOnce()
+    expect(String(fetchMock.mock.calls[0]?.[0])).toBe('https://sponsor.example/')
+    expect(defaultRequests).toEqual([])
+  })
 })
 
 // ---------------------------------------------------------------------------

package/src/viem/Client.ts

@@ -1,4 +1,4 @@
-import { type Chain, type Client, createClient, http } from 'viem'
+import { type Chain, type Client, createClient, createTransport, custom, http } from 'viem'
 import { withFeePayer } from 'viem/tempo'
 
 import type { MaybePromise } from '../internal/types.js'
@@ -23,31 +23,45 @@ export function getResolver(
     if (!chain?.serializers && !feePayerUrl) return getClient
     return async (params) => {
       const client = await getClient(params)
+      let resolvedClient = client
 
       // Wrap the client's transport with `withFeePayer` when a fee payer URL is provided.
       if (feePayerUrl && client.transport.key !== 'feePayer') {
-        const url = (client.transport as { url?: string }).url
-        if (url) {
-          const wrapped = createClient({
-            chain: client.chain,
-            transport: withFeePayer(http(url), http(feePayerUrl)),
-          })
-          Object.assign(client, { transport: wrapped.transport, request: wrapped.request })
-        }
+        const request = client.request.bind(client)
+        // The supplied client already owns retries. Keep the relay middleware retry-free so
+        // failures are not retried once per nested transport layer.
+        const feePayerTransport = withFeePayer(
+          custom({ request: (args) => request(args as never) }, { retryCount: 0 }),
+          http(feePayerUrl, { retryCount: client.transport.retryCount }),
+        )({
+          account: client.account,
+          chain: client.chain,
+          pollingInterval: client.pollingInterval,
+          retryCount: 0,
+        })
+        const wrapped = createTransport(
+          { ...feePayerTransport.config, retryCount: 0 },
+          feePayerTransport.value,
+        )
+        resolvedClient = Object.assign({}, client, {
+          request: wrapped.request,
+          transport: { ...wrapped.config, ...wrapped.value },
+        })
       }
 
-      if (!chain?.serializers || client.chain?.serializers?.transaction) return client
-      return Object.assign({}, client, {
+      if (!chain?.serializers || resolvedClient.chain?.serializers?.transaction)
+        return resolvedClient
+      return Object.assign({}, resolvedClient, {
         chain: {
           ...chain,
-          ...client.chain,
-          formatters: client.chain?.formatters ?? chain.formatters,
+          ...resolvedClient.chain,
+          formatters: resolvedClient.chain?.formatters ?? chain.formatters,
           prepareTransactionRequest:
-            client.chain?.prepareTransactionRequest ?? chain.prepareTransactionRequest,
-          serializers: client.chain?.serializers?.transaction
-            ? client.chain.serializers
+            resolvedClient.chain?.prepareTransactionRequest ?? chain.prepareTransactionRequest,
+          serializers: resolvedClient.chain?.serializers?.transaction
+            ? resolvedClient.chain.serializers
             : chain.serializers,
-        } as typeof client.chain,
+        } as typeof resolvedClient.chain,
       })
     }
   }