mppx 0.1.0 → 0.2.0

package/src/Method.ts

@@ -0,0 +1,228 @@
+import type * as Challenge from './Challenge.js'
+import type * as Credential from './Credential.js'
+import type { ExactPartial, LooseOmit, MaybePromise } from './internal/types.js'
+import type * as Receipt from './Receipt.js'
+import type * as Transport from './server/Transport.js'
+import type * as z from './zod.js'
+
+/**
+ * A payment method.
+ */
+export type Method = {
+  name: string
+  intent: string
+  schema: {
+    credential: {
+      payload: z.ZodMiniType
+    }
+    request: z.ZodMiniType<Record<string, unknown>>
+  }
+}
+
+/**
+ * Creates a payment method.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod/mini'
+ * import { Method } from 'mppx'
+ *
+ * const tempoCharge = Method.from({
+ *   name: 'tempo',
+ *   intent: 'charge',
+ *   schema: {
+ *     credential: {
+ *       payload: z.object({
+ *         signature: z.string(),
+ *         type: z.literal('transaction'),
+ *       }),
+ *     },
+ *     request: z.object({
+ *       amount: z.string(),
+ *       currency: z.string(),
+ *       recipient: z.string(),
+ *     }),
+ *   },
+ * })
+ * ```
+ */
+export function from<const method extends Method>(method: method): method {
+  return method
+}
+
+/**
+ * A client-side configured method with credential creation logic.
+ */
+export type Client<
+  method extends Method = Method,
+  context extends z.ZodMiniType | undefined = z.ZodMiniType | undefined,
+> = method & {
+  context?: context
+  createCredential: CreateCredentialFn<
+    method,
+    context extends z.ZodMiniType ? z.output<context> : Record<never, never>
+  >
+}
+export type AnyClient = Client<any, any>
+
+/**
+ * A server-side configured method with verification logic.
+ */
+export type Server<
+  method extends Method = Method,
+  defaults extends ExactPartial<z.input<method['schema']['request']>> = {},
+  transportOverride = undefined,
+> = method & {
+  defaults?: defaults | undefined
+  request?: RequestFn<method> | undefined
+  respond?: RespondFn<method> | undefined
+  transport?: transportOverride | undefined
+  verify: VerifyFn<method>
+}
+export type AnyServer = Server<any, any, any>
+
+/** Credential creation function for a single method. */
+export type CreateCredentialFn<method extends Method, context = unknown> = (
+  parameters: {
+    challenge: Challenge.Challenge<
+      z.output<method['schema']['request']>,
+      method['intent'],
+      method['name']
+    >
+  } & ([keyof context] extends [never] ? unknown : { context: context }),
+) => Promise<string>
+
+/** Request transform function for a single method. */
+export type RequestFn<method extends Method> = (options: {
+  credential?: Credential.Credential | null | undefined
+  request: z.input<method['schema']['request']>
+}) => MaybePromise<z.input<method['schema']['request']>>
+
+/** Verification function for a single method. */
+export type VerifyFn<method extends Method> = (parameters: {
+  credential: Credential.Credential<
+    z.output<method['schema']['credential']['payload']>,
+    Challenge.Challenge<z.output<method['schema']['request']>, method['intent'], method['name']>
+  >
+  request: z.input<method['schema']['request']>
+}) => Promise<Receipt.Receipt>
+
+/**
+ * Optional respond function for a server-side method.
+ *
+ * Called after `verify` succeeds. If it returns a `Response`, the library
+ * treats the request as fully handled (e.g. channel open/close) and
+ * `withReceipt()` will short-circuit — returning the management response
+ * with the receipt header attached without invoking any user-supplied
+ * response or generator. If it returns `undefined`, the server handler
+ * is expected to serve content via `withReceipt(response)`.
+ *
+ * **HTTP-only.** The `input` parameter is a `Request` object; MCP transports
+ * do not invoke this hook.
+ */
+export type RespondFn<method extends Method> = (parameters: {
+  credential: Credential.Credential<
+    z.output<method['schema']['credential']['payload']>,
+    Challenge.Challenge<z.output<method['schema']['request']>, method['intent'], method['name']>
+  >
+  input: globalThis.Request
+  receipt: Receipt.Receipt
+  request: z.input<method['schema']['request']>
+}) => MaybePromise<globalThis.Response | undefined>
+
+/** Partial request type for defaults. */
+export type RequestDefaults<method extends Method> = ExactPartial<
+  z.input<method['schema']['request']>
+>
+
+/** Makes fields optional if they exist in defaults. */
+export type WithDefaults<request, defaults> = [keyof defaults] extends [never]
+  ? request
+  : LooseOmit<request, keyof defaults & string> &
+      ExactPartial<Pick<request, keyof defaults & keyof request>>
+
+/**
+ * Extends a method with client-side credential creation logic.
+ *
+ * @example
+ * ```ts
+ * import { Method } from 'mppx'
+ * import { Methods } from 'mppx/tempo'
+ *
+ * const tempoCharge = Method.toClient(Methods.charge, {
+ *   async createCredential({ challenge }) {
+ *     return Credential.serialize({ challenge, payload: { ... } })
+ *   },
+ * })
+ * ```
+ */
+export function toClient<
+  const method extends Method,
+  const context extends z.ZodMiniType | undefined = undefined,
+>(method: method, options: toClient.Options<method, context>): Client<method, context> {
+  const { context, createCredential } = options
+  return {
+    ...method,
+    context,
+    createCredential,
+  } as Client<method, context>
+}
+
+export declare namespace toClient {
+  type Options<method extends Method, context extends z.ZodMiniType | undefined = undefined> = {
+    context?: context
+    createCredential: CreateCredentialFn<
+      method,
+      context extends z.ZodMiniType ? z.output<context> : Record<never, never>
+    >
+  }
+}
+
+/**
+ * Extends a method with server-side verification logic.
+ *
+ * @example
+ * ```ts
+ * import { Method } from 'mppx'
+ * import { Methods } from 'mppx/tempo'
+ *
+ * const tempoCharge = Method.toServer(Methods.charge, {
+ *   async verify({ credential }) {
+ *     // verification logic
+ *     return { status: 'success', ... }
+ *   },
+ * })
+ * ```
+ */
+export function toServer<
+  const method extends Method,
+  const defaults extends RequestDefaults<method> = {},
+  const transportOverride extends Transport.AnyTransport | undefined = undefined,
+>(
+  method: method,
+  options: toServer.Options<method, defaults, transportOverride>,
+): Server<method, defaults, transportOverride> {
+  const { defaults, request, respond, transport, verify } = options
+  return {
+    ...method,
+    defaults,
+    request,
+    respond,
+    transport,
+    verify,
+  } as Server<method, defaults, transportOverride>
+}
+
+export declare namespace toServer {
+  type Options<
+    method extends Method,
+    defaults extends RequestDefaults<method> = {},
+    transportOverride extends Transport.AnyTransport | undefined = undefined,
+  > = {
+    defaults?: defaults | undefined
+    request?: RequestFn<method> | undefined
+    respond?: RespondFn<method> | undefined
+    transport?: transportOverride | undefined
+    verify: VerifyFn<method>
+  }
+}

package/src/PaymentRequest.test.ts

@@ -1,5 +1,5 @@
 import { PaymentRequest } from 'mppx'
-import { MethodIntents as Intents } from 'mppx/tempo'
+import { Methods } from 'mppx/tempo'
 import { describe, expect, test } from 'vitest'
 
 describe('from', () => {
@@ -21,7 +21,7 @@ describe('from', () => {
 
 describe('fromIntent', () => {
   test('creates a validated request from intent', () => {
-    const request = PaymentRequest.fromIntent(Intents.charge, {
+    const request = PaymentRequest.fromIntent(Methods.charge, {
       amount: '1',
       currency: '0x20c0000000000000000000000000000000000001',
       decimals: 6,
@@ -39,7 +39,7 @@ describe('fromIntent', () => {
   })
 
   test('includes methodDetails fields', () => {
-    const request = PaymentRequest.fromIntent(Intents.charge, {
+    const request = PaymentRequest.fromIntent(Methods.charge, {
       amount: '1',
       currency: '0x20c0000000000000000000000000000000000001',
       decimals: 6,
@@ -62,7 +62,7 @@ describe('fromIntent', () => {
 
   test('throws on invalid request', () => {
     expect(() =>
-      PaymentRequest.fromIntent(Intents.charge, {
+      PaymentRequest.fromIntent(Methods.charge, {
         amount: 123,
         currency: '0x20c0000000000000000000000000000000000001',
         recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f8fE00',

package/src/PaymentRequest.ts

@@ -1,6 +1,6 @@
 import { Base64 } from 'ox'
 import type { Compute } from './internal/types.js'
-import type * as MethodIntent from './MethodIntent.js'
+import type * as Method from './Method.js'
 import type * as z from './zod.js'
 
 /**
@@ -62,16 +62,16 @@ export function from<const request extends Request>(request: request): request {
 /**
  * Creates a validated request from a method intent.
  *
- * @param intent - The method intent to validate against.
+ * @param method - The method to validate against.
  * @param request - Request parameters.
  * @returns A validated request.
  *
  * @example
  * ```ts
  * import { Request } from 'mppx'
- * import { Intents } from 'mppx/tempo'
+ * import { Methods } from 'mppx/tempo'
  *
- * const request = Request.fromIntent(Intents.charge, {
+ * const request = Request.fromIntent(Methods.charge, {
  *   amount: '1000000',
  *   currency: '0x20c0000000000000000000000000000000000001',
  *   recipient: '0x742d35Cc6634C0532925a3b844Bc9e7595f8fE00',
@@ -80,11 +80,11 @@ export function from<const request extends Request>(request: request): request {
  * })
  * ```
  */
-export function fromIntent<const intent extends MethodIntent.MethodIntent>(
-  intent: intent,
-  request: z.input<intent['schema']['request']>,
-): Request<z.output<intent['schema']['request']>> {
-  return intent.schema.request.parse(request) as Request<z.output<intent['schema']['request']>>
+export function fromIntent<const method extends Method.Method>(
+  method: method,
+  request: z.input<method['schema']['request']>,
+): Request<z.output<method['schema']['request']>> {
+  return method.schema.request.parse(request) as Request<z.output<method['schema']['request']>>
 }
 
 /**

package/src/cli.test.ts

@@ -11,7 +11,7 @@ import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
 import * as Store from './Store.js'
 import * as Mppx_server from './server/Mppx.js'
 import { toNodeListener } from './server/Mppx.js'
-import { tempo } from './tempo/server/MethodIntents.js'
+import { tempo } from './tempo/server/Methods.js'
 
 const cliPath = path.resolve(import.meta.dirname, 'cli.ts')
 const cwd = path.resolve(import.meta.dirname, '..')
@@ -117,7 +117,7 @@ describe('basic charge (examples/basic)', () => {
     })
 
     try {
-      const { stdout } = await runAsync([httpServer.url, '--rpc-url', rpcUrl, '--yes', '-s'], {
+      const { stdout } = await runAsync([httpServer.url, '--rpc-url', rpcUrl, '-s'], {
         input: '',
       })
       expect(stdout).toContain('paid')
@@ -179,7 +179,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
 
     try {
       const { stdout } = await runAsync(
-        [httpServer.url, '--rpc-url', rpcUrl, '--yes', '-s', '--deposit', '10'],
+        [httpServer.url, '--rpc-url', rpcUrl, '-s', '--deposit', '10'],
         { input: '' },
       )
       expect(stdout).toContain('scraped-content')
@@ -227,9 +227,10 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
 
       try {
         // First request: open a channel, answer "y" to proceed, "n" to close channel
-        const first = await runAsync([httpServer.url, '--rpc-url', rpcUrl, '--deposit', '10'], {
-          input: 'y\nn\n',
-        })
+        const first = await runAsync(
+          [httpServer.url, '--rpc-url', rpcUrl, '--confirm', '--deposit', '10'],
+          { input: 'y\nn\n' },
+        )
         expect(first.stdout).toContain('scraped-content')
 
         // Extract channel ID from stderr (logged as "Channel opened 0x...")
@@ -239,17 +240,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
 
         // Second request: reuse the channel via --channel
         const second = await runAsync(
-          [
-            httpServer.url,
-            '--rpc-url',
-            rpcUrl,
-            '--yes',
-            '-s',
-            '--channel',
-            channelId,
-            '--deposit',
-            '10',
-          ],
+          [httpServer.url, '--rpc-url', rpcUrl, '-s', '--channel', channelId, '--deposit', '10'],
           { input: '' },
         )
         expect(second.stdout).toContain('scraped-content')
@@ -322,10 +313,9 @@ describe('session sse (examples/session/sse)', () => {
     })
 
     try {
-      const { stdout } = await runAsync(
-        [httpServer.url, '--rpc-url', rpcUrl, '--yes', '--deposit', '10'],
-        { input: '' },
-      )
+      const { stdout } = await runAsync([httpServer.url, '--rpc-url', rpcUrl, '--deposit', '10'], {
+        input: '',
+      })
       expect(stdout.trim()).toBe('Hello world!')
     } finally {
       httpServer.close()
@@ -528,9 +518,9 @@ test('mppx --help', () => {
       -L, --location         Follow redirects 
       -X, --method <method>  HTTP method 
       --channel <id>         Reuse existing stream channel ID 
+      --confirm              Show confirmation prompts 
       --deposit <amount>     Deposit amount for stream payments (human-readable units) 
       --json <json>          Send JSON body (sets Content-Type and Accept, implies POST) 
-      --yes                  Skip confirmation prompts 
       -V, --version          Display version number 
       -h, --help             Display this message 
 

package/src/cli.ts

@@ -42,9 +42,9 @@ cli
   .option('-L, --location', 'Follow redirects')
   .option('-X, --method <method>', 'HTTP method')
   .option('--channel <id>', 'Reuse existing stream channel ID')
+  .option('--confirm', 'Show confirmation prompts')
   .option('--deposit <amount>', 'Deposit amount for stream payments (human-readable units)')
   .option('--json <json>', 'Send JSON body (sets Content-Type and Accept, implies POST)')
-  .option('--yes', 'Skip confirmation prompts')
   .example(`${name} example.com/content`)
   .example(`${name} example.com/api --json '{"key":"value"}'`)
   .action(async (rawUrl: string | undefined, rawOptions: unknown) => {
@@ -52,6 +52,7 @@ cli
       z.object({
         account: z.optional(z.string()),
         channel: z.optional(z.coerce.string()),
+        confirm: z.optional(z.boolean()),
         data: z.optional(z.string()),
         deposit: z.optional(z.union([z.string(), z.number()])),
         fail: z.optional(z.boolean()),
@@ -65,7 +66,6 @@ cli
         silent: z.optional(z.boolean()),
         userAgent: z.optional(z.string()),
         verbose: z.optional(z.boolean()),
-        yes: z.optional(z.boolean()),
       }),
       rawOptions,
     )
@@ -76,7 +76,7 @@ cli
 
     const silent = options.silent ?? false
     const info = silent ? (_msg: string) => {} : (msg: string) => process.stderr.write(msg)
-    if (silent) options.yes = true
+    if (silent) options.confirm = false
 
     const accountName = resolveAccountName(options.account)
     const privateKey = process.env.MPPX_PRIVATE_KEY ?? (await createKeychain(accountName).get())
@@ -266,10 +266,9 @@ cli
             for (const line of rest) info(`${indent}${line}\n`)
           }
         }
-        info('\n')
-
-        if (!options.yes) {
-          const ok = await confirm(`Proceed with ${challenge.intent}?`)
+        if (options.confirm) {
+          info('\n')
+          const ok = await confirm(`Proceed with ${challenge.intent}?`, true)
           if (!ok) {
             info('Aborted.\n')
             process.exit(0)
@@ -336,7 +335,7 @@ cli
           const depositDisplay = depositRaw
             ? ` ${pc.dim(`(deposit ${depositRaw} ${tokenSymbol})`)}`
             : ''
-          info(`${pc.dim(`Channel opened ${parsed.payload.channelId}`)}${depositDisplay}\n`)
+          info(`\n${pc.dim(`Channel opened ${parsed.payload.channelId}`)}${depositDisplay}\n`)
         }
       }
 
@@ -385,11 +384,25 @@ cli
             }
             info(`\n${pc.bold(pc.green('Payment Receipt'))}\n`)
             const rows: [string, string][] = []
+            const channelId = receiptJson.channelId
+            const reference = receiptJson.reference
+            const skipReference = channelId && reference && channelId === reference
+            const receiptBalanceKeys = new Set(['acceptedCumulative', 'spent'])
             for (const [key, value] of Object.entries(receiptJson)) {
               if (value === undefined || shownKeys.has(key)) continue
-              if (key === 'reference' && typeof value === 'string' && explorerUrl)
+              if (key === 'reference' && skipReference) continue
+              if (receiptBalanceKeys.has(key) && typeof value === 'string') {
+                rows.push([
+                  key,
+                  `${value} ${pc.dim(`(${fmtBalance(BigInt(value), tokenSymbol, tokenDecimals)})`)}`,
+                ])
+              } else if (
+                (key === 'reference' || key === 'txHash') &&
+                typeof value === 'string' &&
+                explorerUrl
+              ) {
                 rows.push([key, pc.link(`${explorerUrl}/tx/${value}`, value)])
-              else rows.push([key, String(value)])
+              } else rows.push([key, String(value)])
             }
             rows.sort(([a], [b]) => a.localeCompare(b))
             const pad = Math.max(...rows.map(([k]) => k.length))
@@ -426,7 +439,7 @@ cli
               : 0n
           let _voucherSeq = 0
 
-          const termBg = await detectTerminalBg()
+          const termBg = verbose ? await detectTerminalBg() : undefined
           const chunkBgs = (() => {
             if (!termBg || !pc.isColorSupported) return undefined
             const clamp = (n: number) => Math.max(0, Math.min(255, Math.round(n)))
@@ -513,18 +526,26 @@ cli
                   const receipt = JSON.parse(data) as Record<string, unknown>
                   info(`\n\n${pc.bold(pc.green('Payment Receipt'))}\n`)
                   const rows: [string, string][] = []
+                  const skipRef =
+                    receipt.channelId &&
+                    receipt.reference &&
+                    receipt.channelId === receipt.reference
                   for (const [key, value] of Object.entries(receipt)) {
                     if (value === undefined || shownKeys.has(key)) continue
-                    if (key === 'channelId' && value === receipt.reference) continue
+                    if (key === 'reference' && skipRef) continue
                     const receiptBalanceKeys = ['acceptedCumulative', 'spent']
                     if (receiptBalanceKeys.includes(key) && typeof value === 'string') {
                       rows.push([
                         key,
                         `${value} ${pc.dim(`(${fmtBalance(BigInt(value), tokenSymbol, tokenDecimals)})`)}`,
                       ])
-                    } else if (key === 'reference' && typeof value === 'string' && explorerUrl)
+                    } else if (
+                      (key === 'reference' || key === 'txHash') &&
+                      typeof value === 'string' &&
+                      explorerUrl
+                    ) {
                       rows.push([key, pc.link(`${explorerUrl}/tx/${value}`, value)])
-                    else rows.push([key, String(value)])
+                    } else rows.push([key, String(value)])
                   }
                   rows.sort(([a], [b]) => a.localeCompare(b))
                   const rpad = Math.max(...rows.map(([k]) => k.length))
@@ -586,8 +607,23 @@ cli
               headers: { Authorization: closeCred },
             })
             if (closeRes.ok) {
+              const closeReceiptHeader = closeRes.headers.get('Payment-Receipt')
+              let closeTxHash: string | undefined
+              if (closeReceiptHeader) {
+                try {
+                  const r = JSON.parse(Base64.toString(closeReceiptHeader)) as Record<
+                    string,
+                    unknown
+                  >
+                  if (typeof r.txHash === 'string') closeTxHash = r.txHash
+                } catch {}
+              }
+              const txInfo =
+                closeTxHash && explorerUrl
+                  ? ` ${pc.dim(pc.link(`${explorerUrl}/tx/${closeTxHash}`, closeTxHash))}`
+                  : ''
               info(
-                `\n${pc.dim('Channel closed.')} ${pc.dim(`Spent ${fmtBalance(cumulativeAmount, tokenSymbol, tokenDecimals)}.`)}\n`,
+                `\n${pc.dim('Channel closed.')} ${pc.dim(`Spent ${fmtBalance(cumulativeAmount, tokenSymbol, tokenDecimals)}.`)}${txInfo}\n`,
               )
             } else {
               info(
@@ -605,10 +641,10 @@ cli
             streamChannelId &&
             streamEscrowContract &&
             streamChainId
-          if (shouldClose && !options.yes) {
+          if (shouldClose && options.confirm) {
             info('\n')
           }
-          if (shouldClose && !(options.yes || (await confirm('Close channel?')))) {
+          if (shouldClose && options.confirm && !(await confirm('Close channel?', true))) {
             info(`${pc.dim('Kept channel open.')}\n`)
           } else if (shouldClose) {
             const signature = await signVoucher(
@@ -638,8 +674,23 @@ cli
             })
             if (closeRes.ok) {
               deleteChannelState(streamChannelId!)
+              const closeReceiptHeader = closeRes.headers.get('Payment-Receipt')
+              let closeTxHash: string | undefined
+              if (closeReceiptHeader) {
+                try {
+                  const r = JSON.parse(Base64.toString(closeReceiptHeader)) as Record<
+                    string,
+                    unknown
+                  >
+                  if (typeof r.txHash === 'string') closeTxHash = r.txHash
+                } catch {}
+              }
+              const txInfo =
+                closeTxHash && explorerUrl
+                  ? ` ${pc.dim(pc.link(`${explorerUrl}/tx/${closeTxHash}`, closeTxHash))}`
+                  : ''
               info(
-                `${pc.dim('Channel closed.')} ${pc.dim(`Spent ${fmtBalance(streamCumulativeAmount, tokenSymbol, tokenDecimals)}.`)}\n`,
+                `\n${pc.dim('Channel closed.')} ${pc.dim(`Spent ${fmtBalance(streamCumulativeAmount, tokenSymbol, tokenDecimals)}.`)}${txInfo}\n`,
               )
             } else {
               const closeBody = await closeRes.text().catch(() => '')
@@ -1097,12 +1148,14 @@ function prompt(message: string): Promise<string | undefined> {
   })
 }
 
-function confirm(prompt: string): Promise<boolean> {
+function confirm(prompt: string, defaultYes = false): Promise<boolean> {
   const reader = readline.createInterface({ input: process.stdin, output: process.stderr })
   return new Promise((resolve) => {
-    reader.question(`${pc.bold(`▸ ${prompt}`)} ${pc.dim('(y/N)')} `, (answer) => {
+    const hint = defaultYes ? '(Y/n)' : '(y/N)'
+    reader.question(`${pc.bold(`▸ ${prompt}`)} ${pc.dim(hint)} `, (answer) => {
       reader.close()
-      resolve(answer.trim().toLowerCase() === 'y')
+      const trimmed = answer.trim().toLowerCase()
+      resolve(trimmed === '' ? defaultYes : trimmed === 'y')
     })
   })
 }

package/src/client/Methods.ts

@@ -1,3 +1,3 @@
-export { stripe } from '../stripe/client/MethodIntents.js'
-export { tempo } from '../tempo/client/MethodIntents.js'
+export { stripe } from '../stripe/client/index.js'
+export { tempo } from '../tempo/client/index.js'
 export { session } from '../tempo/client/Session.js'

package/src/client/Mppx.test-d.ts

@@ -1,8 +1,8 @@
 import type { Account } from 'viem'
 import { describe, expectTypeOf, test } from 'vitest'
-import * as MethodIntent from '../MethodIntent.js'
+import * as Method from '../Method.js'
 import { charge } from '../tempo/client/Charge.js'
-import * as Intents from '../tempo/Intents.js'
+import * as Methods from '../tempo/Methods.js'
 import * as z from '../zod.js'
 import * as Mppx from './Mppx.js'
 
@@ -13,8 +13,8 @@ describe('Mppx', () => {
     })
     const mppx = Mppx.create({ methods: [method] })
 
-    expectTypeOf(mppx.methods).toMatchTypeOf<readonly MethodIntent.AnyClient[]>()
-    expectTypeOf(mppx.methods[0]?.name).toEqualTypeOf<'charge'>()
+    expectTypeOf(mppx.methods).toMatchTypeOf<readonly Method.AnyClient[]>()
+    expectTypeOf(mppx.methods[0]?.intent).toEqualTypeOf<'charge'>()
   })
 
   test('has createCredential function', () => {
@@ -38,7 +38,7 @@ describe('create.Config', () => {
 
 describe('Method.toClient', () => {
   test('createCredential receives typed challenge', () => {
-    MethodIntent.toClient(Intents.charge, {
+    Method.toClient(Methods.charge, {
       async createCredential({ challenge }) {
         expectTypeOf(challenge.method).toBeString()
         expectTypeOf(challenge.intent).toBeString()
@@ -52,7 +52,7 @@ describe('Method.toClient', () => {
   })
 
   test('createCredential receives typed context when provided', () => {
-    MethodIntent.toClient(Intents.charge, {
+    Method.toClient(Methods.charge, {
       context: z.object({
         account: z.custom<Account>(),
         extra: z.optional(z.string()),