mppx 0.8.5 → 0.8.7

package/src/Receipt.ts

@@ -3,17 +3,7 @@ import { Base64 } from 'ox'
 import * as Constants from './Constants.js'
 import * as z from './zod.js'
 
-/**
- * Schema for a payment receipt.
- *
- * @example
- * ```ts
- * import { Receipt } from 'mppx'
- *
- * const receipt = Receipt.Schema.parse(data)
- * ```
- */
-export const Schema = z.object({
+const shape = {
   /** Payment method used (e.g., "tempo", "stripe"). */
   method: z.string(),
   /** Method-specific reference (e.g., transaction hash). */
@@ -26,11 +16,34 @@ export const Schema = z.object({
   status: z.literal('success'),
   /** RFC 3339 settlement timestamp. */
   timestamp: z.datetime(),
-})
+}
+
+/** Base-field schema used only to derive the {@link Receipt} type without an index signature. */
+const BaseSchema = z.object(shape)
+
+/**
+ * Schema for a payment receipt.
+ *
+ * Method specifications may define additional receipt fields beyond the
+ * base set (per the core spec's Payment-Receipt section); unknown fields
+ * are preserved through parse/serialize round-trips rather than stripped.
+ *
+ * @example
+ * ```ts
+ * import { Receipt } from 'mppx'
+ *
+ * const receipt = Receipt.Schema.parse(data)
+ * ```
+ */
+export const Schema = z.looseObject(shape)
 
 /**
  * Payment receipt returned after verification.
  *
+ * Method-specific extension fields are preserved at runtime but not part of
+ * this base type; method packages can type them via intersection
+ * (e.g. `Receipt.Receipt & { originTxHash: string }`).
+ *
  * @example
  * ```ts
  * import { Receipt } from 'mppx'
@@ -43,7 +56,7 @@ export const Schema = z.object({
  * }
  * ```
  */
-export type Receipt = z.infer<typeof Schema>
+export type Receipt = z.infer<typeof BaseSchema>
 
 /**
  * Deserializes a Payment-Receipt header value to a receipt.

package/src/cli/cli.test.ts

@@ -43,7 +43,7 @@ afterAll(() => {
 })
 
 async function serve(argv: string[], options?: { env?: Record<string, string | undefined> }) {
-  let output = ''
+  const stdoutChunks: Buffer[] = []
   let stderr = ''
   let exitCode: number | undefined
   const saved: Record<string, string | undefined> = {}
@@ -58,7 +58,9 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
   const origLog = console.log
   const origError = console.error
   process.stdout.write = ((chunk: unknown) => {
-    output += typeof chunk === 'string' ? chunk : String(chunk)
+    if (typeof chunk === 'string') stdoutChunks.push(Buffer.from(chunk))
+    else if (chunk instanceof Uint8Array) stdoutChunks.push(Buffer.from(chunk))
+    else stdoutChunks.push(Buffer.from(String(chunk)))
     return true
   }) as typeof process.stdout.write
   process.stderr.write = ((chunk: unknown) => {
@@ -66,7 +68,7 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
     return true
   }) as typeof process.stderr.write
   console.log = (...args: unknown[]) => {
-    output += `${args.map(String).join(' ')}\n`
+    stdoutChunks.push(Buffer.from(`${args.map(String).join(' ')}\n`))
   }
   console.error = (...args: unknown[]) => {
     stderr += `${args.map(String).join(' ')}\n`
@@ -74,7 +76,7 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
   try {
     await cli.serve(argv, {
       stdout(s: string) {
-        output += s
+        stdoutChunks.push(Buffer.from(s))
       },
       exit(code: number) {
         exitCode = code
@@ -90,7 +92,8 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
       else process.env[key] = value
     }
   }
-  return { output, stderr, exitCode }
+  const stdoutBytes = Buffer.concat(stdoutChunks)
+  return { output: stdoutBytes.toString(), stderr, exitCode, stdoutBytes }
 }
 
 function createMockChargeMethod(name: string) {
@@ -430,6 +433,24 @@ describe('services', () => {
   })
 })
 
+describe('request output', () => {
+  test('writes non-402 response bodies to stdout without text decoding', async () => {
+    const body = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x0a, 0x0a])
+    const httpServer = await Http.createServer((_req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/pdf' })
+      res.end(body)
+    })
+
+    try {
+      const { exitCode, stdoutBytes } = await serve([httpServer.url, '-s'])
+      expect(exitCode).toBeUndefined()
+      expect(stdoutBytes).toEqual(body)
+    } finally {
+      httpServer.close()
+    }
+  })
+})
+
 describe('basic charge (examples/basic)', () => {
   test('happy path: makes payment and receives response', { timeout: 120_000 }, async () => {
     const { Actions } = await import('viem/tempo')
@@ -1819,6 +1840,21 @@ test('mppx --help', async () => {
   expect(output).toContain('sign')
 })
 
+describe('account fund help', () => {
+  test('only advertises testnet network funding', async () => {
+    const { output } = await serve(['account', 'fund', '--help'])
+    expect(output).toContain('--network <testnet>')
+    expect(output).not.toContain('mainnet|testnet')
+  })
+
+  test('rejects mainnet network funding', async () => {
+    const { exitCode, output } = await serve(['account', 'fund', '--network', 'mainnet'])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('Invalid input')
+    expect(output).toContain('testnet')
+  })
+})
+
 // ---------------------------------------------------------------------------
 // sign
 // ---------------------------------------------------------------------------

package/src/cli/cli.ts

@@ -99,6 +99,10 @@ function outputResult<Data>(
   return undefined as unknown as Data
 }
 
+async function writeResponseBody(response: Response) {
+  process.stdout.write(Buffer.from(await response.arrayBuffer()))
+}
+
 function canReadCommandStdin() {
   if (process.stdin.isTTY !== false) return false
   return process.stdin.listenerCount('data') === 0 && process.stdin.listenerCount('readable') === 0
@@ -371,7 +375,7 @@ const cli = Cli.create('mppx', {
             exitCode: 22,
           })
         printResponseHeaders(challengeResponse, headerOpts)
-        console.log((await challengeResponse.text()).replace(/\n+$/, ''))
+        await writeResponseBody(challengeResponse)
         return
       }
 
@@ -625,8 +629,7 @@ const cli = Cli.create('mppx', {
           } catch {}
         }
 
-        const body = (await credentialResponse.text()).replace(/\n+$/, '')
-        console.log(body)
+        await writeResponseBody(credentialResponse)
       }
     } catch (err) {
       // Re-throw IncurError so incur's error handler formats it properly
@@ -864,7 +867,7 @@ const account = Cli.create('account', {
     description: 'Fund account with testnet tokens',
     options: z.object({
       account: z.string().optional().describe('Account name (env: MPPX_ACCOUNT)'),
-      network: z.enum(['mainnet', 'testnet']).optional().describe('Tempo network'),
+      network: z.enum(['testnet']).optional().describe('Tempo network'),
       rpcUrl: z.string().optional().describe('RPC endpoint (env: MPPX_RPC_URL)'),
     }),
     output: z.object({ account: z.string(), chain: z.string(), transactions: z.array(z.string()) }),

package/src/cli/internal.ts

@@ -5,10 +5,10 @@ import type * as Challenge from '../Challenge.js'
 import * as AcceptPayment from '../internal/AcceptPayment.js'
 import type * as Method from '../Method.js'
 import type { Config } from './config.js'
-import { stripe as stripePlugin, tempo as tempoPlugin } from './plugins/index.js'
+import { evm as evmPlugin, stripe as stripePlugin, tempo as tempoPlugin } from './plugins/index.js'
 import type { Plugin } from './plugins/plugin.js'
 
-const builtinPlugins: Plugin[] = [tempoPlugin(), stripePlugin()]
+const builtinPlugins: Plugin[] = [tempoPlugin(), stripePlugin(), evmPlugin()]
 
 export function resolvePlugin(
   challenge: Challenge.Challenge,

package/src/cli/plugins/evm.ts

@@ -0,0 +1,55 @@
+import { type Address, type Chain, createClient, erc20Abi, http } from 'viem'
+import { readContract } from 'viem/actions'
+import * as viemChains from 'viem/chains'
+
+import { evm as evmMethods, assets as evmAssets } from '../../evm/client/index.js'
+import { resolveAccount } from '../account.js'
+import { createPlugin } from './plugin.js'
+
+export function evm() {
+  return createPlugin({
+    method: 'evm',
+
+    async setup({ challenge }) {
+      const request = challenge.request as Record<string, unknown>
+      const methodDetails = request.methodDetails as Record<string, unknown> | undefined
+      const chainId = methodDetails?.chainId as number | undefined
+      const chain = chainId ? resolveChain(chainId) : undefined
+      const currency = request.currency as string | undefined
+
+      const account = await resolveAccount()
+      // Known assets provide EIP-712 domain metadata (token name/version) needed for EIP-3009 signing
+      const knownCurrencies = [
+        ...Object.values(evmAssets.base),
+        ...Object.values(evmAssets.baseSepolia),
+        ...Object.values(evmAssets.celo),
+        ...Object.values(evmAssets.celoSepolia),
+      ]
+
+      let tokenSymbol = currency ?? ''
+      if (chain && currency) {
+        try {
+          const client = createClient({ chain, transport: http() })
+          const symbol = await readContract(client, {
+            address: currency as Address,
+            abi: erc20Abi,
+            functionName: 'symbol',
+          })
+          if (symbol) tokenSymbol = symbol
+        } catch {}
+      }
+
+      return {
+        tokenSymbol,
+        tokenDecimals: (methodDetails?.decimals as number | undefined) ?? 6,
+        explorerUrl: chain?.blockExplorers?.default?.url,
+        methods: [...evmMethods({ account, currencies: knownCurrencies })],
+      }
+    },
+  })
+}
+
+function resolveChain(chainId: number): Chain | undefined {
+  const all = Object.values(viemChains) as Chain[]
+  return all.find((c) => c.id === chainId)
+}

package/src/cli/plugins/index.ts

@@ -1,3 +1,4 @@
+export { evm } from './evm.js'
 export { createPlugin, type Plugin } from './plugin.js'
 export { stripe } from './stripe.js'
 export { tempo } from './tempo.js'

package/src/cli/plugins/tempo.ts

@@ -42,6 +42,11 @@ const booleanOption = z.union([
   z.literal('true').transform(() => true),
   z.literal('false').transform(() => false),
 ])
+
+async function writeResponseBody(response: Response) {
+  process.stdout.write(Buffer.from(await response.arrayBuffer()))
+}
+
 const tempoOptionSchema = z.object({
   autoSwap: z.optional(booleanOption),
   channel: z.optional(z.coerce.string()),
@@ -425,8 +430,7 @@ export function tempo() {
         })
       } else {
         // Non-SSE: print body, then close channel
-        const body = (await credentialResponse.text()).replace(/\n+$/, '')
-        console.log(body)
+        await writeResponseBody(credentialResponse)
 
         if (channelId && escrowContract && chainId) {
           if (confirmEnabled) info('\n')