mppx 0.8.11 → 0.8.12

package/src/client/internal/Fetch.test.ts

@@ -10,6 +10,7 @@ import { rpcUrl } from '~test/tempo/rpc.js'
 import { accounts, asset, chain, client, http } from '~test/tempo/viem.js'
 
 import * as Fetch from './Fetch.js'
+import * as MethodResponse from './MethodResponse.js'
 
 const realm = 'api.example.com'
 const secretKey = 'test-secret-key-test-secret-key-32'
@@ -391,6 +392,34 @@ function encodeRawPaymentRequiredHeader(value: unknown): string {
   return Base64.fromString(JSON.stringify(value))
 }
 
+describe('Fetch.from: method responses', () => {
+  test('handles successful paid responses without touching free responses', async () => {
+    const method = { ...noopMethod }
+    const handle = vi.fn(
+      async ({ response }: MethodResponse.HandlerParameters) =>
+        new Response(`handled:${await response.text()}`, response),
+    )
+    MethodResponse.register(method, handle)
+
+    let paidResponse: Response | undefined
+    const mockFetch: typeof globalThis.fetch = async (input, init) => {
+      if (input.toString().endsWith('/free')) return new Response('free')
+      if (!new Headers(init?.headers).has('Authorization')) return make402()
+      paidResponse = new Response('paid')
+      vi.spyOn(paidResponse, 'clone')
+      return paidResponse
+    }
+    const fetch = Fetch.from({ fetch: mockFetch, methods: [method] })
+
+    expect(await (await fetch('https://example.com/free')).text()).toBe('free')
+    expect(handle).not.toHaveBeenCalled()
+    expect(await (await fetch('https://example.com/paid')).text()).toBe('handled:paid')
+    expect(handle).toHaveBeenCalledOnce()
+    expect(handle).toHaveBeenCalledWith(expect.objectContaining({ credential: 'credential' }))
+    expect(paidResponse?.clone).not.toHaveBeenCalled()
+  })
+})
+
 describe('Fetch.from: init passthrough (non-402)', () => {
   test('preserves init object identity while adding Accept-Payment', async () => {
     const receivedInits: (RequestInit | undefined)[] = []

package/src/client/internal/Fetch.ts

@@ -6,6 +6,7 @@ import type { MaybePromise } from '../../internal/types.js'
 import type * as Method from '../../Method.js'
 import type * as z from '../../zod.js'
 import * as Transport from '../Transport.js'
+import * as MethodResponse from './MethodResponse.js'
 
 // We tag wrappers with a global symbol so we can recognize wrappers created by mppx,
 // even across multiple module instances/bundles. This lets restore() avoid clobbering
@@ -18,6 +19,7 @@ type WrappedFetch = typeof globalThis.fetch & {
 }
 
 let originalFetch: typeof globalThis.fetch | undefined
+const eventObserverChecks = new WeakMap<object, (name: keyof ClientEventMap) => boolean>()
 
 export type ClientEventMap<
   methods extends readonly Method.AnyClient[] = readonly Method.AnyClient[],
@@ -174,7 +176,11 @@ export function from<const methods extends readonly Method.AnyClient[]>(
   // which can duplicate retries and make restore semantics fragile.
   const baseFetch = unwrapFetch(fetch)
 
-  const wrappedFetch = async (input: RequestInfo | URL, init?: from.RequestInit<methods>) => {
+  const request = async (
+    input: RequestInfo | URL,
+    init: from.RequestInit<methods> | undefined,
+    canRefetch: boolean,
+  ): Promise<Response> => {
     const callerHeaders = getCallerHeaders(input, init?.headers)
     const hasExplicitAcceptPayment = callerHeaders.has(Constants.Headers.acceptPayment)
     const paymentPreferences = resolvePaymentPreferences(callerHeaders, resolvedAcceptPayment)
@@ -272,8 +278,13 @@ export function from<const methods extends readonly Method.AnyClient[]>(
           }),
         )
 
+        const paymentInput = resolvePaymentRetryInput(
+          response,
+          initialRequest.input,
+          initialRequest.input,
+        )
         response = await baseFetch(
-          resolvePaymentRetryInput(response, initialRequest.input, initialRequest.input),
+          paymentInput,
           transport.setCredential(
             {
               ...fetchInit,
@@ -283,7 +294,8 @@ export function from<const methods extends readonly Method.AnyClient[]>(
             { challenge: selectedChallenge },
           ),
         )
-        if (response.ok)
+        // Cloning an unobserved stream would tee and buffer it indefinitely.
+        if (response.ok && hasEventObservers(events, 'payment.response'))
           await events.emit(
             'payment.response',
             createPaymentResponsePayload({
@@ -295,8 +307,23 @@ export function from<const methods extends readonly Method.AnyClient[]>(
               response,
             }),
           )
-        if (!(await transport.isPaymentRequired(response, transportRequest as never)))
-          return response
+        if (!(await transport.isPaymentRequired(response, transportRequest as never))) {
+          if (!response.ok) return response
+          return MethodResponse.handle(selected.method, {
+            challenge: selectedChallenge,
+            credential,
+            fetch: baseFetch,
+            headers: initialRequest.headers,
+            input: paymentInput,
+            ...(canRefetch
+              ? {
+                  refetch: () => request(cloneRequestInput(initialRequest.input), init, false),
+                }
+              : {}),
+            response,
+            signal: resolveRequestSignal(input, init),
+          })
+        }
       }
       return response
     } catch (error) {
@@ -315,6 +342,8 @@ export function from<const methods extends readonly Method.AnyClient[]>(
       throw error
     }
   }
+  const wrappedFetch = (input: RequestInfo | URL, init?: from.RequestInit<methods>) =>
+    request(input, init, true)
 
   // Record the wrapped target so future polyfill() / restore() calls can detect origin
   // and safely unwrap only mppx-installed wrappers.
@@ -491,7 +520,7 @@ export function createEventDispatcher<
     }
   }
 
-  return {
+  const dispatcher: ClientEventDispatcher<methods, response> = {
     async emit(name, payload) {
       switch (name) {
         case 'challenge.received': {
@@ -525,6 +554,15 @@ export function createEventDispatcher<
     },
     on,
   }
+  eventObserverChecks.set(
+    dispatcher,
+    (name) => handlers[name as keyof typeof handlers].size > 0 || handlers['*'].size > 0,
+  )
+  return dispatcher
+}
+
+function hasEventObservers(dispatcher: ClientEventDispatcher, name: keyof ClientEventMap): boolean {
+  return eventObserverChecks.get(dispatcher)?.(name) ?? true
 }
 
 async function emitChallengeReceived<methods extends readonly Method.AnyClient[], response>(
@@ -812,6 +850,13 @@ function cloneRequestInput(input: RequestInfo | URL): RequestInfo | URL {
   }
 }
 
+function resolveRequestSignal(
+  input: RequestInfo | URL,
+  init: RequestInit | undefined,
+): AbortSignal | undefined {
+  return init?.signal ?? (input instanceof Request ? input.signal : undefined)
+}
+
 /** @internal */
 function isWrappedFetch(fetch: typeof globalThis.fetch): fetch is WrappedFetch {
   return Boolean((fetch as WrappedFetch)[MPPX_FETCH_WRAPPER])

package/src/client/internal/MethodResponse.ts

@@ -0,0 +1,39 @@
+import type * as Challenge from '../../Challenge.js'
+import type { MaybePromise } from '../../internal/types.js'
+import type * as Method from '../../Method.js'
+
+const handlers = new WeakMap<Method.AnyClient, Handler>()
+
+/** Inputs available when a client method handles a successful paid response. */
+export type HandlerParameters = {
+  challenge: Challenge.Challenge
+  credential: string
+  fetch: typeof globalThis.fetch
+  headers: Headers
+  input: RequestInfo | URL
+  refetch?: (() => Promise<Response>) | undefined
+  response: Response
+  signal?: AbortSignal | undefined
+}
+
+/** Internal client-method response adapter. */
+export type Handler = (parameters: HandlerParameters) => MaybePromise<Response>
+
+/** Registers an internal response adapter without changing the public method shape. */
+export function register<const method extends Method.AnyClient>(
+  method: method,
+  handler: Handler,
+): method {
+  handlers.set(method, handler)
+  return method
+}
+
+/** Removes response handling from a method whose caller owns the response lifecycle. */
+export function unregister(method: Method.AnyClient): void {
+  handlers.delete(method)
+}
+
+/** Lets the selected client method handle a successful paid response. */
+export function handle(method: Method.AnyClient, parameters: HandlerParameters): Promise<Response> {
+  return Promise.resolve(handlers.get(method)?.(parameters) ?? parameters.response)
+}

package/src/tempo/legacy/client/ChannelOps.test.ts

@@ -340,6 +340,27 @@ describe.runIf(isLocalnet)('tryRecoverChannel', () => {
     expect(result!.opened).toBe(true)
     expect(result!.escrowContract).toBe(escrow)
     expect(result!.chainId).toBe(chain.id)
+    // Channel opened with a zero authorizedSigner: the escrow verifies
+    // vouchers against the payer, so the recovered authority is the payer.
+    expect(result!.authorizedSigner.toLowerCase()).toBe(payer.address.toLowerCase())
+  })
+
+  test('recovers the on-chain authorizedSigner when set', async () => {
+    const authorizedSigner = accounts[4].address
+    const { channelId: signerChannelId } = await openChannel({
+      escrow,
+      payer,
+      payee,
+      token: currency,
+      deposit: 10_000_000n,
+      salt: Hex.random(32) as `0x${string}`,
+      authorizedSigner,
+    })
+
+    const result = await tryRecoverChannel(client, escrow, signerChannelId, chain.id)
+
+    expect(result).not.toBeUndefined()
+    expect(result!.authorizedSigner.toLowerCase()).toBe(authorizedSigner.toLowerCase())
   })
 
   test('returns undefined for non-existent channel', async () => {

package/src/tempo/legacy/client/ChannelOps.ts

@@ -27,6 +27,8 @@ import { signVoucher } from '../session/Voucher.js'
 
 /** Cached channel metadata used by the legacy auto-driving session client. */
 export type ChannelEntry = {
+  /** Voucher authority the channel was opened with. */
+  authorizedSigner: Address
   /** Legacy contract-backed channel ID. */
   channelId: Hex.Hex
   /** Salt used to derive the channel ID. */
@@ -209,6 +211,7 @@ export async function createOpenPayload(
 
   return {
     entry: {
+      authorizedSigner,
       channelId,
       salt,
       cumulativeAmount: initialAmount,
@@ -249,6 +252,10 @@ export async function tryRecoverChannel(
 
     if (onChain.deposit > 0n && !onChain.finalized) {
       return {
+        // A zero on-chain authorizedSigner means the escrow verifies vouchers
+        // against the payer, so record the payer as the voucher authority.
+        authorizedSigner:
+          BigInt(onChain.authorizedSigner) === 0n ? onChain.payer : onChain.authorizedSigner,
         channelId,
         salt: '0x' as Hex.Hex,
         cumulativeAmount: onChain.settled,

package/src/tempo/legacy/client/Session.test.ts

@@ -1,7 +1,16 @@
 import { SignatureEnvelope } from 'ox/tempo'
-import { type Address, createClient, decodeFunctionData, erc20Abi, type Hex, http } from 'viem'
+import {
+  type Address,
+  createClient,
+  custom,
+  decodeFunctionData,
+  erc20Abi,
+  type Hex,
+  http,
+} from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 import { Account as TempoAccount, Addresses, Transaction, WebCryptoP256 } from 'viem/tempo'
+import { tempoModerato } from 'viem/tempo/chains'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import { tempoNetwork } from '~test/config.js'
 import { deployEscrow, openChannel } from '~test/tempo/legacy/session.js'
@@ -374,6 +383,98 @@ describe('session (pure)', () => {
       expect(cred.source).toBe(`did:pkh:eip155:42431:${pureAccount.address}`)
     })
   })
+
+  describe('auto-manage channel reuse', () => {
+    const payerAccount = privateKeyToAccount(
+      '0x59c6995e998f97a5a0044966f09453863d462d2b3f1446a99f0a3d7b5d0f5a0d',
+    )
+    const signerA = TempoAccount.fromSecp256k1(
+      '0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a',
+      { access: payerAccount },
+    )
+    const signerB = TempoAccount.fromSecp256k1(
+      '0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6',
+      { access: payerAccount },
+    )
+
+    function makeAutoClient(account: typeof signerA) {
+      return createClient({
+        account,
+        chain: tempoModerato,
+        transport: custom({
+          async request({ method }: { method: string }) {
+            if (method === 'eth_chainId') return `0x${tempoModerato.id.toString(16)}`
+            if (method === 'eth_fillTransaction')
+              return {
+                raw: '0x',
+                tx: {
+                  chainId: `0x${tempoModerato.id.toString(16)}`,
+                  from: payerAccount.address,
+                  gas: '0x5208',
+                  input: '0x',
+                  maxFeePerGas: '0x1',
+                  maxPriorityFeePerGas: '0x1',
+                  nonce: '0x0',
+                  to: escrowAddress,
+                  type: '0x2',
+                  value: '0x0',
+                },
+              }
+            throw new Error(`unexpected rpc request: ${method}`)
+          },
+        }),
+      })
+    }
+
+    test('reuses the cached channel while the voucher signer is unchanged', async () => {
+      const method = session({
+        getClient: () => makeAutoClient(signerA),
+        maxDeposit: '10',
+      })
+
+      const first = deserializePayload(
+        await method.createCredential({ challenge: makeChallenge(), context: {} }),
+      )
+      const second = deserializePayload(
+        await method.createCredential({ challenge: makeChallenge(), context: {} }),
+      )
+
+      expect(first.payload.action).toBe('open')
+      expect(second.payload.action).toBe('voucher')
+      expect(second.payload.channelId).toBe(first.payload.channelId)
+    })
+
+    test('opens a new channel instead of reusing when the authorizedSigner changes', async () => {
+      let account = signerA
+      const method = session({
+        getClient: () => makeAutoClient(account),
+        maxDeposit: '10',
+      })
+
+      const first = deserializePayload(
+        await method.createCredential({ challenge: makeChallenge(), context: {} }),
+      )
+
+      account = signerB
+
+      const second = deserializePayload(
+        await method.createCredential({ challenge: makeChallenge(), context: {} }),
+      )
+
+      expect(first.payload.action).toBe('open')
+      if (first.payload.action !== 'open') throw new Error('expected open payload')
+      expect(first.payload.authorizedSigner?.toLowerCase()).toBe(
+        signerA.accessKeyAddress.toLowerCase(),
+      )
+
+      expect(second.payload.action).toBe('open')
+      if (second.payload.action !== 'open') throw new Error('expected open payload')
+      expect(second.payload.authorizedSigner?.toLowerCase()).toBe(
+        signerB.accessKeyAddress.toLowerCase(),
+      )
+      expect(second.payload.channelId).not.toBe(first.payload.channelId)
+    })
+  })
 })
 
 describe.runIf(isLocalnet)('session (on-chain)', () => {

package/src/tempo/legacy/client/Session.ts

@@ -175,6 +175,16 @@ export function session(parameters: session.Parameters = {}) {
       }
     }
 
+    // A channel only admits vouchers from the authorizedSigner it was opened
+    // with, so a cached or recovered entry stops being reusable once the
+    // resolved signer changes. Fall through to open a fresh channel instead
+    // of emitting a voucher the escrow would reject.
+    if (
+      entry?.opened &&
+      entry.authorizedSigner.toLowerCase() !== getAccountSignerAddress(voucherSigner).toLowerCase()
+    )
+      entry = undefined
+
     let payload: LegacySessionCredentialPayload
 
     if (entry?.opened) {