mppx 0.6.31 → 0.7.0

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

@@ -4,7 +4,7 @@ import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { createClient, defineChain } from 'viem'
 import { describe, expect, test, vi } from 'vp/test'
 import * as Http from '~test/Http.js'
-import { rpcUrl } from '~test/tempo/prool.js'
+import { rpcUrl } from '~test/tempo/rpc.js'
 import { accounts, asset, chain, client, http } from '~test/tempo/viem.js'
 
 import * as Fetch from './Fetch.js'
@@ -669,7 +669,7 @@ describe('Fetch.from: 402 retry path', () => {
     expect(headers.get('Authorization')).toBe('credential')
   })
 
-  test('sends credential retry to the final 402 response URL', async () => {
+  test('sends credential retry to the final same-origin 402 response URL', async () => {
     let callCount = 0
     const calls: { input: RequestInfo | URL; init: RequestInit | undefined }[] = []
     const mockFetch: typeof globalThis.fetch = async (input, init) => {
@@ -678,7 +678,7 @@ describe('Fetch.from: 402 retry path', () => {
       if (callCount === 1) {
         const response = make402()
         Object.defineProperty(response, 'url', {
-          value: 'https://payments.example.com/protected',
+          value: 'https://api.example.com/redirected-protected',
         })
         return response
       }
@@ -694,10 +694,35 @@ describe('Fetch.from: 402 retry path', () => {
 
     expect(response.status).toBe(200)
     expect(calls[0]!.input).toBe('https://api.example.com/protected')
-    expect(calls[1]!.input).toBe('https://payments.example.com/protected')
+    expect(calls[1]!.input).toBe('https://api.example.com/redirected-protected')
     expect(new Headers(calls[1]!.init?.headers).get('Authorization')).toBe('credential')
   })
 
+  test('rejects credential retry to a cross-origin 402 response URL', async () => {
+    const calls: { input: RequestInfo | URL; init: RequestInit | undefined }[] = []
+    const mockFetch: typeof globalThis.fetch = async (input, init) => {
+      calls.push({ input, init })
+      const response = make402()
+      Object.defineProperty(response, 'url', {
+        value: 'https://payments.example.com/protected',
+      })
+      return response
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [noopMethod],
+    })
+
+    await expect(fetch('https://api.example.com/protected')).rejects.toThrow(
+      'Refusing to send payment credential across redirect from https://api.example.com to https://payments.example.com',
+    )
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.input).toBe('https://api.example.com/protected')
+    expect(new Headers(calls[0]!.init?.headers).get('Authorization')).toBeNull()
+  })
+
   test('emits client events and allows challenge handler to provide credential', async () => {
     const events: string[] = []
     const createCredential = vi.fn(async () => 'method-credential')

package/src/client/internal/Fetch.ts

@@ -1,4 +1,5 @@
 import * as Challenge from '../../Challenge.js'
+import * as Constants from '../../Constants.js'
 import * as Expires from '../../Expires.js'
 import * as AcceptPayment from '../../internal/AcceptPayment.js'
 import type { MaybePromise } from '../../internal/types.js'
@@ -173,7 +174,7 @@ export function from<const methods extends readonly Method.AnyClient[]>(
 
   const wrappedFetch = async (input: RequestInfo | URL, init?: from.RequestInit<methods>) => {
     const callerHeaders = getCallerHeaders(input, init?.headers)
-    const hasExplicitAcceptPayment = callerHeaders.has('Accept-Payment')
+    const hasExplicitAcceptPayment = callerHeaders.has(Constants.Headers.acceptPayment)
     const paymentPreferences = resolvePaymentPreferences(callerHeaders, resolvedAcceptPayment)
     const initialRequest = prepareInitialRequest(
       input,
@@ -262,7 +263,7 @@ export function from<const methods extends readonly Method.AnyClient[]>(
       )
 
       const paymentResponse = await baseFetch(
-        resolvePaymentRetryInput(response, initialRequest.input),
+        resolvePaymentRetryInput(response, initialRequest.input, initialRequest.input),
         transport.setCredential(
           {
             ...fetchInit,
@@ -717,7 +718,7 @@ function prepareInitialRequest<methods extends readonly Method.AnyClient[]>(
   callerHeaders.forEach((value, key) => {
     headers.set(key, value)
   })
-  headers.set('Accept-Payment', header)
+  headers.set(Constants.Headers.acceptPayment, header)
 
   if (init) {
     // Preserve init identity for callers like websocket upgrade helpers that
@@ -781,7 +782,7 @@ function resolvePaymentPreferences<methods extends readonly Method.AnyClient[]>(
   headers: Headers,
   acceptPayment: AcceptPayment.Resolved<methods>,
 ): AcceptPayment.Resolved<methods> {
-  const header = headers.get('Accept-Payment')
+  const header = headers.get(Constants.Headers.acceptPayment)
   if (!header) return acceptPayment
 
   try {
@@ -847,6 +848,17 @@ function resolveRequestUrl(input: RequestInfo | URL): URL {
 function resolvePaymentRetryInput(
   response: Response,
   fallback: RequestInfo | URL,
+  initialInput: RequestInfo | URL,
 ): RequestInfo | URL {
-  return response.url ? response.url : fallback
+  if (!response.url) return fallback
+
+  const responseUrl = new URL(response.url)
+  const initialUrl = resolveRequestUrl(initialInput)
+  if (responseUrl.origin !== initialUrl.origin) {
+    throw new Error(
+      `Refusing to send payment credential across redirect from ${initialUrl.origin} to ${responseUrl.origin}`,
+    )
+  }
+
+  return response.url
 }

package/src/env.d.ts

@@ -2,7 +2,7 @@
 
 interface ImportMetaEnv {
   readonly MODE: 'test' | 'production'
-  readonly VITE_NODE_ENV: 'localnet' | 'testnet' | 'mainnet'
+  readonly VITE_TEMPO_NETWORK: 'localnet' | 'moderato' | 'devnet'
   readonly VITE_HTTP_LOG: 'true' | 'false'
   readonly VITE_RPC_CREDENTIALS: string
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 export * as BodyDigest from './BodyDigest.js'
 export * as Challenge from './Challenge.js'
+export * as Constants from './Constants.js'
 export * as Credential from './Credential.js'
 export * as Errors from './Errors.js'
 export * as Expires from './Expires.js'

package/src/internal/AcceptPayment.test.ts

@@ -178,6 +178,67 @@ describe('AcceptPayment', () => {
     ])
   })
 
+  test('selectChallengeCandidates supports duplicate method keys with challenge predicates', () => {
+    const challenges = [
+      {
+        id: 'v2',
+        intent: 'session',
+        method: 'tempo',
+        realm: 'test',
+        request: { methodDetails: { sessionProtocol: 'v2' } },
+      },
+      {
+        id: 'v1',
+        intent: 'session',
+        method: 'tempo',
+        realm: 'test',
+        request: { methodDetails: { sessionProtocol: 'v1' } },
+      },
+      {
+        id: 'old-server',
+        intent: 'session',
+        method: 'tempo',
+        realm: 'test',
+        request: {},
+      },
+    ]
+    const methods = [
+      {
+        name: 'tempo',
+        intent: 'session',
+        canHandleChallenge: ({
+          challenge,
+        }: {
+          challenge: AcceptPayment.ChallengeCandidate['challenge']
+        }) =>
+          (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
+            ?.sessionProtocol === 'v2',
+      },
+      {
+        name: 'tempo',
+        intent: 'session',
+        canHandleChallenge: ({
+          challenge,
+        }: {
+          challenge: AcceptPayment.ChallengeCandidate['challenge']
+        }) => {
+          const sessionProtocol = (
+            challenge.request.methodDetails as { sessionProtocol?: string } | undefined
+          )?.sessionProtocol
+          return sessionProtocol === undefined || sessionProtocol === 'v1'
+        },
+      },
+    ] as const
+
+    const candidates = AcceptPayment.selectChallengeCandidates(
+      challenges,
+      methods,
+      AcceptPayment.parse('tempo/session'),
+    )
+
+    expect(candidates.map(({ challenge }) => challenge.id)).toEqual(['v2', 'v1', 'old-server'])
+  })
+
   test('selectChallenge honors a specific opt-out over a broader wildcard', () => {
     const selected = AcceptPayment.selectChallenge(
       [

package/src/internal/AcceptPayment.ts

@@ -2,6 +2,7 @@ import type * as Challenge from '../Challenge.js'
 import type { MaybePromise } from './types.js'
 
 type MethodLike = {
+  canHandleChallenge?: ((parameters: { challenge: Challenge.Challenge }) => boolean) | undefined
   intent: string
   name: string
 }
@@ -179,28 +180,34 @@ export function selectChallengeCandidates<const methods extends readonly MethodL
   methods: methods,
   preferences: readonly Entry[],
 ): ChallengeCandidate<methods[number]>[] {
-  const methodByKey = new Map<string, methods[number]>()
+  const methodsByKey = new Map<string, methods[number][]>()
   for (const method of methods) {
     const key = keyOf(method)
-    if (!methodByKey.has(key)) methodByKey.set(key, method)
+    const matchingMethods = methodsByKey.get(key)
+    if (matchingMethods) matchingMethods.push(method)
+    else methodsByKey.set(key, [method])
   }
 
   return challenges
-    .map((challenge, index) => {
-      const method = methodByKey.get(keyOf(challenge))
-      if (!method) return undefined
+    .flatMap((challenge, index) => {
+      const matchingMethods = methodsByKey.get(keyOf(challenge))
+      if (!matchingMethods) return []
 
       const match = bestMatch(challenge, preferences)
-      if (!match || match.q <= 0) return undefined
-
-      return {
-        challenge,
-        index,
-        match,
-        method,
-      } as ChallengeCandidate<methods[number]> & { match: Match }
+      if (!match || match.q <= 0) return []
+
+      return matchingMethods
+        .filter((method) => method.canHandleChallenge?.({ challenge }) ?? true)
+        .map(
+          (method) =>
+            ({
+              challenge,
+              index,
+              match,
+              method,
+            }) as ChallengeCandidate<methods[number]> & { match: Match },
+        )
     })
-    .filter((candidate): candidate is NonNullable<typeof candidate> => Boolean(candidate))
     .sort((left, right) => right.match.q - left.match.q || left.index - right.index)
     .map((candidate) => {
       const { match: _match, ...rest } = candidate

package/src/mcp-sdk/client/McpClient.integration.test.ts

@@ -6,21 +6,21 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
-import { session as tempo_session_client, tempo as tempo_client } from 'mppx/client'
+import { sessionLegacy as tempo_session_client, tempo as tempo_client } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import type { Address } from 'viem'
 import { readContract } from 'viem/actions'
 import { Actions, Addresses } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
-import { nodeEnv } from '~test/config.js'
-import { deployEscrow, signTopUpChannel } from '~test/tempo/session.js'
+import { tempoNetwork } from '~test/config.js'
+import { deployEscrow, signTopUpChannel } from '~test/tempo/legacy/session.js'
 import { accounts, asset, client as testClient, fundAccount } from '~test/tempo/viem.js'
 
 import * as Credential from '../../Credential.js'
 import * as core_Mcp from '../../Mcp.js'
 import * as Store from '../../Store.js'
-import * as ChannelStore from '../../tempo/session/ChannelStore.js'
-import type { SessionReceipt } from '../../tempo/session/Types.js'
+import type { SessionReceipt } from '../../tempo/session/precompile/Protocol.js'
+import * as ChannelStore from '../../tempo/session/server/ChannelStore.js'
 import * as McpServer_transport from '../server/Transport.js'
 import * as McpClient from './McpClient.js'
 
@@ -29,6 +29,7 @@ const secretKey = 'test-secret-key'
 const chargeAmountRaw = 1_000_000n
 const doubleSessionAmountRaw = chargeAmountRaw * 2n
 const topUpAmountRaw = chargeAmountRaw * 3n
+const isLocalnet = tempoNetwork === 'localnet'
 
 let escrowContract: Address
 
@@ -40,7 +41,7 @@ beforeAll(async () => {
   await fundAccount({ address: accounts[2].address, token: asset })
 }, 60_000)
 
-describe.runIf(nodeEnv === 'localnet')('McpClient.wrap integration', () => {
+describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
   const scenarios: readonly Scenario[] = [
     {
       name: 'charge intent settles a paid MCP tool against the live chain',
@@ -464,7 +465,7 @@ async function createHarness(options?: {
         currency: asset,
         getClient: () => testClient,
       }),
-      tempo_server.session({
+      tempo_server.sessionLegacy({
         account: accounts[0],
         currency: asset,
         escrowContract,

package/src/mcp-sdk/client/McpClient.test-d.ts

@@ -73,8 +73,15 @@ describe('McpClient.wrap', () => {
     })
 
     expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' })
+    expectTypeOf(wrapped.callTool).toBeCallableWith(null, { name: 'tool' })
+    expectTypeOf(wrapped.callTool).toBeCallableWith(() => true, { name: 'tool' })
     expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, {})
     expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, { timeout: 5000 })
+    expectTypeOf(wrapped.callTool).toBeCallableWith(
+      async (challenge) => challenge.intent === 'charge',
+      { name: 'tool' },
+      { timeout: 5000 },
+    )
   })
 
   test('callTool result includes receipt', () => {

package/src/mcp-sdk/client/McpClient.ts

@@ -11,6 +11,14 @@ import type * as z from '../../zod.js'
 
 type AnyClient = Method.Client<any, any>
 
+export type CallToolParameters = {
+  name: string
+  arguments?: Record<string, unknown>
+  _meta?: Record<string, unknown>
+}
+
+export type OnPaymentRequired = (challenge: Challenge.Challenge) => boolean | Promise<boolean>
+
 /**
  * Result of a tool call with payment handling.
  * Extends the SDK's callTool return type with an optional payment receipt.
@@ -55,69 +63,91 @@ export function wrap<
   const { methods } = config
   const paymentPreferences = AcceptPayment.resolve(methods)
 
-  return {
-    ...client,
-    async callTool(params, options) {
-      const context = options?.context
-      const timeout = options?.timeout
-
-      try {
-        const result = await client.callTool(
-          params,
-          undefined,
-          timeout !== undefined ? { timeout } : undefined,
+  const callTool = (async (
+    first: CallToolParameters | OnPaymentRequired | null | undefined,
+    second?: CallToolParameters | wrap.CallToolOptions<methods>,
+    third?: wrap.CallToolOptions<methods>,
+  ) => {
+    const hasApprovalArgument = typeof first === 'function' || first === null || first === undefined
+    const params = (hasApprovalArgument ? second : first) as CallToolParameters
+    const options = (hasApprovalArgument ? third : second) as
+      | wrap.CallToolOptions<methods>
+      | undefined
+    const onPaymentRequired =
+      first === null
+        ? undefined
+        : hasApprovalArgument
+          ? ((first as OnPaymentRequired | undefined) ?? config.onPaymentRequired)
+          : config.onPaymentRequired
+    const context = options?.context
+    const timeout = options?.timeout
+
+    try {
+      const result = await client.callTool(
+        params,
+        undefined,
+        timeout !== undefined ? { timeout } : undefined,
+      )
+
+      return {
+        ...result,
+        receipt: result._meta?.[core_Mcp.receiptMetaKey] as core_Mcp.Receipt | undefined,
+      }
+    } catch (error) {
+      // Check if this is a payment required error
+      if (!isPaymentRequiredError(error)) throw error
+
+      const challenges = (error.data as { challenges?: Challenge.Challenge[] })?.challenges
+      if (!challenges?.length) throw error
+
+      const selected = AcceptPayment.selectChallenge(
+        challenges,
+        methods,
+        paymentPreferences.entries,
+      )
+      if (!selected) {
+        const available = challenges.map((c) => `${c.method}.${c.intent}`).join(', ')
+        const installed = methods.map((m) => `${m.name}.${m.intent}`).join(', ')
+        throw new Error(
+          `No compatible payment method. Server offers: ${available}. Client has: ${installed}`,
+          { cause: error },
         )
+      }
 
-        return {
-          ...result,
-          receipt: result._meta?.[core_Mcp.receiptMetaKey] as core_Mcp.Receipt | undefined,
-        }
-      } catch (error) {
-        // Check if this is a payment required error
-        if (!isPaymentRequiredError(error)) throw error
-
-        const challenges = (error.data as { challenges?: Challenge.Challenge[] })?.challenges
-        if (!challenges?.length) throw error
-
-        const selected = AcceptPayment.selectChallenge(
-          challenges,
-          methods,
-          paymentPreferences.entries,
-        )
-        if (!selected) {
-          const available = challenges.map((c) => `${c.method}.${c.intent}`).join(', ')
-          const installed = methods.map((m) => `${m.name}.${m.intent}`).join(', ')
-          throw new Error(
-            `No compatible payment method. Server offers: ${available}. Client has: ${installed}`,
-            { cause: error },
-          )
-        }
-
-        const credential = await createCredential(selected.challenge, {
-          context,
-          methods,
-        })
-        const parsed = Credential.deserialize(credential)
-
-        const retryResult = await client.callTool(
-          {
-            ...params,
-            _meta: {
-              ...params._meta,
-              [core_Mcp.credentialMetaKey]: parsed,
-            },
-          },
-          undefined,
-          timeout !== undefined ? { timeout } : undefined,
-        )
+      if (selected.challenge.expires)
+        Expires.assert(selected.challenge.expires, selected.challenge.id)
 
-        return {
-          ...retryResult,
-          receipt: retryResult._meta?.[core_Mcp.receiptMetaKey] as core_Mcp.Receipt | undefined,
-        }
+      if (onPaymentRequired) {
+        const approved = await onPaymentRequired(selected.challenge)
+        if (!approved) throw new Error('Payment declined.', { cause: error })
       }
-    },
-  }
+
+      const credential = await createCredential(selected.challenge, {
+        context,
+        methods,
+      })
+      const parsed = Credential.deserialize(credential)
+
+      const retryResult = await client.callTool(
+        {
+          ...params,
+          _meta: {
+            ...params._meta,
+            [core_Mcp.credentialMetaKey]: parsed,
+          },
+        },
+        undefined,
+        timeout !== undefined ? { timeout } : undefined,
+      )
+
+      return {
+        ...retryResult,
+        receipt: retryResult._meta?.[core_Mcp.receiptMetaKey] as core_Mcp.Receipt | undefined,
+      }
+    }
+  }) as wrap.McpClient<client, methods>['callTool']
+
+  return { ...client, callTool } as wrap.McpClient<client, methods>
 }
 
 /** Union of all context types from all methods that have context schemas. */
@@ -133,6 +163,8 @@ export declare namespace wrap {
   type Config<methods extends readonly Method.AnyClient[] = readonly Method.AnyClient[]> = {
     /** Array of methods to use. */
     methods: methods
+    /** Optional approval hook called before creating a payment credential. */
+    onPaymentRequired?: OnPaymentRequired
   }
 
   type McpClient<
@@ -140,14 +172,14 @@ export declare namespace wrap {
     methods extends readonly AnyClient[] = readonly AnyClient[],
   > = Omit<client, 'callTool'> & {
     /** Call a tool with automatic payment handling. */
-    callTool: (
-      params: {
-        name: string
-        arguments?: Record<string, unknown>
-        _meta?: Record<string, unknown>
-      },
-      options?: CallToolOptions<methods>,
-    ) => Promise<CallToolResult>
+    callTool: {
+      (params: CallToolParameters, options?: CallToolOptions<methods>): Promise<CallToolResult>
+      (
+        onPaymentRequired: OnPaymentRequired | null | undefined,
+        params: CallToolParameters,
+        options?: CallToolOptions<methods>,
+      ): Promise<CallToolResult>
+    }
   }
 
   type CallToolOptions<methods extends readonly AnyClient[] = readonly AnyClient[]> = {

package/src/mcp-sdk/client/McpClient.unit.test.ts

@@ -0,0 +1,131 @@
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { McpError } from '@modelcontextprotocol/sdk/types.js'
+import { Challenge, Credential, Mcp as core_Mcp, Method } from 'mppx'
+import { Methods } from 'mppx/tempo'
+import { describe, expect, test, vi } from 'vp/test'
+
+import * as McpClient from './McpClient.js'
+
+describe('MCP client payment approval', () => {
+  test('calls an approval hook before creating a credential', async () => {
+    const challenge = Challenge.from({
+      id: 'approval-test',
+      intent: 'charge',
+      method: 'tempo',
+      realm: 'api.example.com',
+      request: {},
+    })
+    const calls: unknown[] = []
+    const client = {
+      async callTool(params: unknown) {
+        calls.push(params)
+        if (calls.length === 1)
+          throw new McpError(core_Mcp.paymentRequiredCode, 'Payment Required', {
+            challenges: [challenge],
+            httpStatus: 402,
+          })
+        return {
+          _meta: {
+            [core_Mcp.receiptMetaKey]: {
+              method: 'tempo',
+              reference: 'test',
+              status: 'success',
+              timestamp: new Date().toISOString(),
+            },
+          },
+          content: [{ type: 'text', text: 'ok' }],
+        }
+      },
+    }
+    const createCredential = vi.fn(async ({ challenge }: { challenge: Challenge.Challenge }) =>
+      Credential.serialize({
+        challenge,
+        payload: { signature: '0xsignature', type: 'transaction' },
+      }),
+    )
+    const onPaymentRequired = vi.fn(() => true)
+    const mcp = McpClient.wrap(client as unknown as Pick<Client, 'callTool'>, {
+      methods: [Method.toClient(Methods.charge, { createCredential })],
+    })
+
+    const result = await mcp.callTool(onPaymentRequired, { name: 'paid_tool', arguments: {} })
+
+    expect(result.content).toEqual([{ type: 'text', text: 'ok' }])
+    expect(onPaymentRequired).toHaveBeenCalledWith(challenge)
+    expect(createCredential).toHaveBeenCalledOnce()
+    expect(calls).toHaveLength(2)
+  })
+
+  test('does not create a credential when approval is denied', async () => {
+    const challenge = Challenge.from({
+      id: 'denied-test',
+      intent: 'charge',
+      method: 'tempo',
+      realm: 'api.example.com',
+      request: {},
+    })
+    const client = {
+      async callTool() {
+        throw new McpError(core_Mcp.paymentRequiredCode, 'Payment Required', {
+          challenges: [challenge],
+          httpStatus: 402,
+        })
+      },
+    }
+    const createCredential = vi.fn(async ({ challenge }: { challenge: Challenge.Challenge }) =>
+      Credential.serialize({
+        challenge,
+        payload: { signature: '0xsignature', type: 'transaction' },
+      }),
+    )
+    const mcp = McpClient.wrap(client as unknown as Pick<Client, 'callTool'>, {
+      methods: [Method.toClient(Methods.charge, { createCredential })],
+    })
+
+    await expect(mcp.callTool(() => false, { name: 'paid_tool' })).rejects.toThrow(
+      'Payment declined.',
+    )
+    expect(createCredential).not.toHaveBeenCalled()
+  })
+
+  test('allows null to bypass a config approval hook', async () => {
+    const challenge = Challenge.from({
+      id: 'null-bypass-test',
+      intent: 'charge',
+      method: 'tempo',
+      realm: 'api.example.com',
+      request: {},
+    })
+    let calls = 0
+    const client = {
+      async callTool() {
+        calls += 1
+        if (calls === 1)
+          throw new McpError(core_Mcp.paymentRequiredCode, 'Payment Required', {
+            challenges: [challenge],
+            httpStatus: 402,
+          })
+        return {
+          content: [{ type: 'text', text: 'ok' }],
+        }
+      },
+    }
+    const createCredential = vi.fn(async ({ challenge }: { challenge: Challenge.Challenge }) =>
+      Credential.serialize({
+        challenge,
+        payload: { signature: '0xsignature', type: 'transaction' },
+      }),
+    )
+    const onPaymentRequired = vi.fn(() => false)
+    const mcp = McpClient.wrap(client as unknown as Pick<Client, 'callTool'>, {
+      methods: [Method.toClient(Methods.charge, { createCredential })],
+      onPaymentRequired,
+    })
+
+    await expect(mcp.callTool(null, { name: 'paid_tool' })).resolves.toMatchObject({
+      content: [{ type: 'text', text: 'ok' }],
+    })
+    expect(onPaymentRequired).not.toHaveBeenCalled()
+    expect(createCredential).toHaveBeenCalledOnce()
+  })
+})