mppx 0.6.16 → 0.6.18

package/src/cli/cli.ts

@@ -60,6 +60,24 @@ const discoveryIssueSchema = z.object({
   severity: z.string(),
 })
 
+const serviceSummarySchema = z.object({
+  description: z.string().optional(),
+  id: z.string(),
+  name: z.string().optional(),
+  paidEndpoints: z.number(),
+  status: z.string().optional(),
+  url: z.string().optional(),
+})
+
+const serviceEndpointSchema = z.object({
+  description: z.string().optional(),
+  method: z.string(),
+  path: z.string(),
+  payment: z.unknown().optional(),
+})
+
+const servicesRegistryUrl = 'https://mpp.dev/api/services'
+
 function shouldReturnStructured(c: { format: string; formatExplicit: boolean }) {
   return c.format === 'json' && c.formatExplicit
 }
@@ -79,6 +97,93 @@ function canReadCommandStdin() {
   return process.stdin.listenerCount('data') === 0 && process.stdin.listenerCount('readable') === 0
 }
 
+type ServiceRegistryService = Record<string, unknown>
+type ServiceRegistryEndpoint = Record<string, unknown>
+
+function getString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+function getEndpoints(service: ServiceRegistryService): ServiceRegistryEndpoint[] {
+  return Array.isArray(service.endpoints)
+    ? service.endpoints.filter(
+        (endpoint): endpoint is ServiceRegistryEndpoint =>
+          typeof endpoint === 'object' && endpoint !== null,
+      )
+    : []
+}
+
+function summarizeService(service: ServiceRegistryService) {
+  const endpoints = getEndpoints(service)
+  return {
+    ...(getString(service.description) ? { description: getString(service.description) } : {}),
+    id: getString(service.id) ?? getString(service.name) ?? 'unknown',
+    ...(getString(service.name) ? { name: getString(service.name) } : {}),
+    paidEndpoints: endpoints.filter((endpoint) => endpoint.payment).length,
+    ...(getString(service.status) ? { status: getString(service.status) } : {}),
+    ...(getString(service.serviceUrl) || getString(service.url)
+      ? { url: getString(service.serviceUrl) ?? getString(service.url) }
+      : {}),
+  }
+}
+
+function summarizeEndpoint(endpoint: ServiceRegistryEndpoint) {
+  return {
+    ...(getString(endpoint.description) ? { description: getString(endpoint.description) } : {}),
+    method: getString(endpoint.method) ?? 'GET',
+    path: getString(endpoint.path) ?? '/',
+    ...(endpoint.payment !== undefined ? { payment: endpoint.payment } : {}),
+  }
+}
+
+function formatPayment(payment: unknown): string {
+  if (!payment) return 'free'
+  if (typeof payment !== 'object') return String(payment)
+  const p = payment as Record<string, unknown>
+  const amount = getString(p.amount)
+  const currency = getString(p.currency)
+  const method = getString(p.method)
+  const intent = getString(p.intent)
+  return [amount, currency, method && intent ? `${method}/${intent}` : (method ?? intent)]
+    .filter(Boolean)
+    .join(' ')
+}
+
+async function fetchServicesRegistry(): Promise<ServiceRegistryService[]> {
+  const url = process.env.MPPX_SERVICES_URL ?? servicesRegistryUrl
+  const response = await globalThis.fetch(url)
+  if (!response.ok)
+    throw new Errors.IncurError({
+      code: 'SERVICES_FETCH_FAILED',
+      message: `Failed to fetch services registry: HTTP ${response.status}`,
+      exitCode: 1,
+    })
+  const json = (await response.json()) as unknown
+  if (
+    !json ||
+    typeof json !== 'object' ||
+    !Array.isArray((json as { services?: unknown }).services)
+  )
+    throw new Errors.IncurError({
+      code: 'SERVICES_INVALID',
+      message: 'Services registry response did not contain a services array.',
+      exitCode: 1,
+    })
+  return (json as { services: ServiceRegistryService[] }).services
+}
+
+function findService(
+  services: ServiceRegistryService[],
+  id: string,
+): ServiceRegistryService | undefined {
+  const needle = id.toLowerCase()
+  return services.find((service) => {
+    const serviceId = getString(service.id)?.toLowerCase()
+    const serviceName = getString(service.name)?.toLowerCase()
+    return serviceId === needle || serviceName === needle
+  })
+}
+
 const cli = Cli.create('mppx', {
   version: packageJson.version,
   description: 'Make HTTP requests with automatic payment handling',
@@ -88,6 +193,7 @@ const cli = Cli.create('mppx', {
   }),
   options: z.object({
     account: z.string().optional().describe('Account name (env: MPPX_ACCOUNT)'),
+    autoSwap: z.boolean().optional().describe('Auto-swap source tokens into payment currency'),
     config: z.string().optional().describe('Path to config file'),
     confirm: z.boolean().optional().default(false).describe('Show confirmation prompts'),
     data: z.string().optional().describe('Send request body (implies POST unless -X is set)'),
@@ -108,11 +214,14 @@ const cli = Cli.create('mppx', {
       .array(z.string())
       .optional()
       .describe('Method-specific option (key=value, repeatable)'),
+    network: z.enum(['mainnet', 'testnet']).optional().describe('Tempo network'),
+    payWith: z.string().optional().describe('Source token for Tempo auto-swap'),
     rpcUrl: z
       .string()
       .optional()
       .describe('RPC endpoint, defaults to public RPC for chain (env: MPPX_RPC_URL)'),
     silent: z.boolean().default(false).describe('Silent mode (suppress progress and info)'),
+    slippage: z.number().optional().describe('Tempo auto-swap max slippage percentage'),
     userAgent: z
       .string()
       .optional()
@@ -274,7 +383,14 @@ const cli = Cli.create('mppx', {
       if (plugin) {
         pluginResult = await plugin.setup({
           challenge,
-          options: { account: c.options.account, rpcUrl: c.options.rpcUrl },
+          options: {
+            account: c.options.account,
+            autoSwap: c.options.autoSwap,
+            network: c.options.network,
+            payWith: c.options.payWith,
+            rpcUrl: c.options.rpcUrl,
+            slippage: c.options.slippage,
+          },
           methodOpts: parseMethodOpts(c.options.methodOpt),
         })
         tokenSymbol = pluginResult.tokenSymbol
@@ -542,6 +658,7 @@ const account = Cli.create('account', {
     description: 'Create new account',
     options: z.object({
       account: z.string().optional().describe('Account name (env: MPPX_ACCOUNT)'),
+      network: z.enum(['mainnet', 'testnet']).optional().describe('Tempo network'),
       rpcUrl: z.string().optional().describe('RPC endpoint (env: MPPX_RPC_URL)'),
     }),
     output: z.object({ address: z.string(), name: z.string() }),
@@ -587,8 +704,8 @@ const account = Cli.create('account', {
       const addrDisplay = explorerUrl
         ? link(`${explorerUrl}/address/${acct.address}`, acct.address)
         : acct.address
-      const rpcUrl = resolveRpcUrl(c.options.rpcUrl)
-      resolveChain({ rpcUrl })
+      const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: c.options.network })
+      resolveChain({ network: c.options.network, rpcUrl })
         .then((chain) => createClient({ chain, transport: http(rpcUrl) }))
         .then((client) =>
           import('viem/tempo').then(({ Actions }) =>
@@ -702,6 +819,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'),
       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()) }),
@@ -722,8 +840,8 @@ const account = Cli.create('account', {
           return c.error({ code: 'ACCOUNT_NOT_FOUND', message: 'No account found.', exitCode: 69 })
       }
       const acct = privateKeyToAccount(key as `0x${string}`)
-      const rpcUrl = resolveRpcUrl(c.options.rpcUrl)
-      const chain = await resolveChain({ rpcUrl })
+      const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: c.options.network })
+      const chain = await resolveChain({ network: c.options.network, rpcUrl })
       const client = createClient({ chain, transport: http(rpcUrl) })
       if (!structured) console.log(`Funding "${accountName}" on ${chainName(chain)}`)
       try {
@@ -852,6 +970,7 @@ const account = Cli.create('account', {
     description: 'View account address',
     options: z.object({
       account: z.string().optional().describe('Account name (env: MPPX_ACCOUNT)'),
+      network: z.enum(['mainnet', 'testnet']).optional().describe('Tempo network'),
       rpcUrl: z.string().optional().describe('RPC endpoint (env: MPPX_RPC_URL)'),
     }),
     output: accountViewSchema,
@@ -869,8 +988,8 @@ const account = Cli.create('account', {
           })
         }
         const address = tempoEntry.wallet_address as Address
-        const rpcUrl = resolveRpcUrl(c.options.rpcUrl)
-        const chain = await resolveChain({ rpcUrl })
+        const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: c.options.network })
+        const chain = await resolveChain({ network: c.options.network, rpcUrl })
         const explorerUrl = chain.blockExplorers?.default?.url
         const addrDisplay = explorerUrl
           ? link(`${explorerUrl}/address/${address}`, address)
@@ -913,8 +1032,8 @@ const account = Cli.create('account', {
           return c.error({ code: 'ACCOUNT_NOT_FOUND', message: 'No account found.', exitCode: 69 })
       }
       const acct = privateKeyToAccount(key as `0x${string}`)
-      const rpcUrl = resolveRpcUrl(c.options.rpcUrl)
-      const chain = await resolveChain({ rpcUrl })
+      const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: c.options.network })
+      const chain = await resolveChain({ network: c.options.network, rpcUrl })
       const explorerUrl = chain.blockExplorers?.default?.url
       const addrDisplay = explorerUrl
         ? link(`${explorerUrl}/address/${acct.address}`, acct.address)
@@ -948,14 +1067,18 @@ const sign = Cli.create('sign', {
     challenge: z.string().optional().describe('WWW-Authenticate challenge value'),
     config: z.string().optional().describe('Path to config file'),
     dryRun: z.boolean().optional().describe('Validate and parse the challenge without signing'),
+    autoSwap: z.boolean().optional().describe('Auto-swap source tokens into payment currency'),
     methodOpt: z
       .array(z.string())
       .optional()
       .describe('Method-specific option (key=value, repeatable)'),
+    network: z.enum(['mainnet', 'testnet']).optional().describe('Tempo network'),
+    payWith: z.string().optional().describe('Source token for Tempo auto-swap'),
     rpcUrl: z
       .string()
       .optional()
       .describe('RPC endpoint, defaults to public RPC for chain (env: MPPX_RPC_URL)'),
+    slippage: z.number().optional().describe('Tempo auto-swap max slippage percentage'),
   }),
   output: z.object({ authorization: z.string() }),
   alias: {
@@ -1029,7 +1152,14 @@ const sign = Cli.create('sign', {
     if (plugin) {
       const result = await plugin.setup({
         challenge,
-        options: { account: c.options.account, rpcUrl: c.options.rpcUrl },
+        options: {
+          account: c.options.account,
+          autoSwap: c.options.autoSwap,
+          network: c.options.network,
+          payWith: c.options.payWith,
+          rpcUrl: c.options.rpcUrl,
+          slippage: c.options.slippage,
+        },
         methodOpts,
       })
       if (result.createCredential) {
@@ -1104,6 +1234,119 @@ export default defineConfig({
   },
 })
 
+const services = Cli.create('services', {
+  description: 'Browse the MPP services registry',
+})
+  .command('list', {
+    description: 'List registered MPP services',
+    options: z.object({
+      query: z.string().optional().describe('Filter by id, name, category, tag, or description'),
+    }),
+    output: z.object({ services: z.array(serviceSummarySchema) }),
+    alias: { query: 'q' },
+    async run(c) {
+      const query = c.options.query?.toLowerCase()
+      const registry = await fetchServicesRegistry()
+      const filtered = query
+        ? registry.filter((service) =>
+            [
+              service.id,
+              service.name,
+              service.description,
+              ...(Array.isArray(service.categories) ? service.categories : []),
+              ...(Array.isArray(service.tags) ? service.tags : []),
+            ]
+              .filter((value): value is string => typeof value === 'string')
+              .some((value) => value.toLowerCase().includes(query)),
+          )
+        : registry
+      const summaries = filtered.map(summarizeService).sort((a, b) => a.id.localeCompare(b.id))
+      return outputResult(c, { services: summaries }, () => {
+        if (summaries.length === 0) {
+          console.log('No services found.')
+          return
+        }
+        const idWidth = Math.max(...summaries.map((service) => service.id.length))
+        const paidWidth = Math.max(
+          ...summaries.map((service) => String(service.paidEndpoints).length),
+        )
+        for (const service of summaries) {
+          const name = service.name && service.name !== service.id ? `  ${service.name}` : ''
+          const url = service.url ? `  ${pc.dim(service.url)}` : ''
+          console.log(
+            `${service.id.padEnd(idWidth)}  ${String(service.paidEndpoints).padStart(paidWidth)} paid${name}${url}`,
+          )
+        }
+      })
+    },
+  })
+  .command('show', {
+    description: 'Show one registered MPP service',
+    args: z.object({
+      service: z.string().describe('Service id or name'),
+    }),
+    output: z.object({ service: z.record(z.string(), z.unknown()) }),
+    async run(c) {
+      const registry = await fetchServicesRegistry()
+      const service = findService(registry, c.args.service)
+      if (!service)
+        return c.error({
+          code: 'SERVICE_NOT_FOUND',
+          message: `Service not found: ${c.args.service}`,
+          exitCode: 1,
+        })
+      const summary = summarizeService(service)
+      const endpoints = getEndpoints(service)
+      return outputResult(c, { service }, () => {
+        console.log(`${summary.name ?? summary.id} ${pc.dim(`(${summary.id})`)}`)
+        if (summary.description) console.log(summary.description)
+        if (summary.url) console.log(`${pc.dim('URL')}       ${link(summary.url, summary.url)}`)
+        if (summary.status) console.log(`${pc.dim('Status')}    ${summary.status}`)
+        console.log(`${pc.dim('Endpoints')} ${endpoints.length} (${summary.paidEndpoints} paid)`)
+        const docs = service.docs as Record<string, unknown> | undefined
+        const homepage = docs && getString(docs.homepage)
+        if (homepage) console.log(`${pc.dim('Docs')}      ${link(homepage, homepage)}`)
+      })
+    },
+  })
+  .command('endpoints', {
+    description: 'List endpoints for a registered MPP service',
+    args: z.object({
+      service: z.string().describe('Service id or name'),
+    }),
+    output: z.object({
+      endpoints: z.array(serviceEndpointSchema),
+      service: serviceSummarySchema,
+    }),
+    async run(c) {
+      const registry = await fetchServicesRegistry()
+      const service = findService(registry, c.args.service)
+      if (!service)
+        return c.error({
+          code: 'SERVICE_NOT_FOUND',
+          message: `Service not found: ${c.args.service}`,
+          exitCode: 1,
+        })
+      const summary = summarizeService(service)
+      const endpoints = getEndpoints(service).map(summarizeEndpoint)
+      return outputResult(c, { endpoints, service: summary }, () => {
+        if (endpoints.length === 0) {
+          console.log(`No endpoints found for ${summary.id}.`)
+          return
+        }
+        const methodWidth = Math.max(...endpoints.map((endpoint) => endpoint.method.length))
+        const pathWidth = Math.max(...endpoints.map((endpoint) => endpoint.path.length))
+        for (const endpoint of endpoints) {
+          const payment = formatPayment(endpoint.payment)
+          const description = endpoint.description ? `  ${pc.dim(endpoint.description)}` : ''
+          console.log(
+            `${endpoint.method.padEnd(methodWidth)}  ${endpoint.path.padEnd(pathWidth)}  ${payment}${description}`,
+          )
+        }
+      })
+    },
+  })
+
 const discover = Cli.create('discover', {
   description: 'Discovery tooling',
 })
@@ -1281,6 +1524,7 @@ const discover = Cli.create('discover', {
 cli.command(account)
 cli.command(discover)
 cli.command(init)
+cli.command(services)
 cli.command(sign)
 
 export default cli

package/src/cli/mcp.test.ts

@@ -176,6 +176,9 @@ test('tools/list exposes mppx commands with input and output schemas', async ()
     'discover_generate',
     'discover_validate',
     'init',
+    'services_endpoints',
+    'services_list',
+    'services_show',
     'sign',
   ])
   expect(tools.find((tool: { name: string }) => tool.name === 'account_list').outputSchema).toEqual(

package/src/cli/plugins/plugin.ts

@@ -1,5 +1,6 @@
 import type * as Challenge from '../../Challenge.js'
 import type * as Method from '../../Method.js'
+import type { Network } from '../utils.js'
 
 export function createPlugin(plugin: Plugin): Plugin {
   return plugin
@@ -18,7 +19,14 @@ export interface Plugin {
    */
   setup(ctx: {
     challenge: Challenge.Challenge
-    options: { account?: string | undefined; rpcUrl?: string | undefined }
+    options: {
+      account?: string | undefined
+      autoSwap?: boolean | undefined
+      network?: Network | undefined
+      payWith?: string | undefined
+      rpcUrl?: string | undefined
+      slippage?: number | undefined
+    }
     methodOpts: Record<string, string>
   }): Promise<{
     /** Token symbol for display (e.g., 'PathUSD', 'USD') */

package/src/cli/plugins/stripe.ts

@@ -20,6 +20,7 @@ export function stripe() {
           paymentMethod: z.string(),
         }),
         methodOpts,
+        ['paymentMethod'],
       )
 
       const stripeSecretKey = process.env.MPPX_STRIPE_SECRET_KEY
@@ -134,7 +135,13 @@ export function stripe() {
 function parseOptions<const schema extends z.ZodType>(
   schema: schema,
   rawOptions: unknown,
+  allowedKeys: readonly string[],
 ): z.output<schema> {
+  if (rawOptions && typeof rawOptions === 'object' && !Array.isArray(rawOptions)) {
+    const unknownKeys = Object.keys(rawOptions).filter((key) => !allowedKeys.includes(key))
+    if (unknownKeys.length)
+      throw new Error(`Unsupported CLI method option(s): ${unknownKeys.join(', ')}`)
+  }
   const result = schema.safeParse(rawOptions ?? {})
   if (result.success) return result.data
   const summary = result.error.issues

package/src/cli/plugins/tempo.ts

@@ -54,6 +54,29 @@ export function tempo() {
       const accountName = resolveAccountName(options.account)
       const challengeRequest = challenge.request as Record<string, unknown>
       const currency = challengeRequest.currency as string | undefined
+      const booleanOption = z.union([
+        z.boolean(),
+        z.literal('true').transform(() => true),
+        z.literal('false').transform(() => false),
+      ])
+      const tempoOpts = parseOptions(
+        z.object({
+          autoSwap: z.optional(booleanOption),
+          channel: z.optional(z.coerce.string()),
+          deposit: z.optional(z.union([z.string(), z.number()])),
+          payWith: z.optional(z.string()),
+          slippage: z.optional(z.coerce.number()),
+          tokenIn: z.optional(z.string()),
+        }),
+        methodOpts,
+        ['autoSwap', 'channel', 'deposit', 'payWith', 'slippage', 'tokenIn'],
+      )
+      const autoSwap = resolveAutoSwap({
+        autoSwap: tempoOpts.autoSwap ?? options.autoSwap,
+        payWith: tempoOpts.payWith ?? options.payWith,
+        slippage: tempoOpts.slippage ?? options.slippage,
+        tokenIn: tempoOpts.tokenIn,
+      })
 
       let tokenSymbol = currency ?? ''
       let tokenDecimals = (challengeRequest.decimals as number | undefined) ?? 6
@@ -71,11 +94,12 @@ export function tempo() {
         useTempoCliSign = true
         const tempoEntry = resolveTempoAccount(accountName)
         if (tempoEntry) {
-          const rpcUrl = resolveRpcUrl(options.rpcUrl)
+          const rpcUrl = resolveRpcUrl(options.rpcUrl, { network: options.network })
           client = createClient({
-            chain: await resolveChain({ rpcUrl }),
+            chain: await resolveChain({ network: options.network, rpcUrl }),
             transport: http(rpcUrl),
           })
+          assertChallengeChain({ challenge, clientChainId: client.chain?.id })
           explorerUrl = client.chain?.blockExplorers?.default?.url
           const tokenInfo = currency
             ? await fetchTokenInfo(
@@ -111,11 +135,12 @@ export function tempo() {
       } else account = privateKeyToAccount(privateKey as `0x${string}`)
 
       if (!useTempoCliSign && account) {
-        const rpcUrl = resolveRpcUrl(options.rpcUrl)
+        const rpcUrl = resolveRpcUrl(options.rpcUrl, { network: options.network })
         client = createClient({
-          chain: await resolveChain({ rpcUrl }),
+          chain: await resolveChain({ network: options.network, rpcUrl }),
           transport: http(rpcUrl),
         })
+        assertChallengeChain({ challenge, clientChainId: client.chain?.id })
         explorerUrl = client.chain?.blockExplorers?.default?.url
         const tokenInfo = currency
           ? await fetchTokenInfo(client, currency as Address, account.address).catch(
@@ -147,17 +172,10 @@ export function tempo() {
           exitCode: 69,
         })
 
-      const tempoOpts = parseOptions(
-        z.object({
-          channel: z.optional(z.coerce.string()),
-          deposit: z.optional(z.union([z.string(), z.number()])),
-        }),
-        methodOpts,
-      )
-
       const methods = tempoMethods({
         account,
         getClient: () => client!,
+        ...(autoSwap !== undefined ? { autoSwap } : {}),
         deposit: (() => {
           if (challenge.intent !== 'session') return undefined
           const suggestedDeposit = (challenge.request as Record<string, unknown>)
@@ -718,7 +736,13 @@ function detectTerminalBg(
 function parseOptions<const schema extends z.ZodType>(
   schema: schema,
   rawOptions: unknown,
+  allowedKeys: readonly string[],
 ): z.output<schema> {
+  if (rawOptions && typeof rawOptions === 'object' && !Array.isArray(rawOptions)) {
+    const unknownKeys = Object.keys(rawOptions).filter((key) => !allowedKeys.includes(key))
+    if (unknownKeys.length)
+      throw new Error(`Unsupported CLI method option(s): ${unknownKeys.join(', ')}`)
+  }
   const result = schema.safeParse(rawOptions ?? {})
   if (result.success) return result.data
   const summary = result.error.issues
@@ -730,6 +754,53 @@ function parseOptions<const schema extends z.ZodType>(
   throw new Error(`Invalid CLI options (${summary})`)
 }
 
+function assertChallengeChain(opts: {
+  challenge: { request: Record<string, unknown> }
+  clientChainId?: number | undefined
+}) {
+  const methodDetails = opts.challenge.request.methodDetails as
+    | { chainId?: number | undefined }
+    | undefined
+  const requiredChainId = methodDetails?.chainId
+  if (!requiredChainId || !opts.clientChainId || requiredChainId === opts.clientChainId) return
+  const hint =
+    requiredChainId === 4217
+      ? ' Use --network mainnet or --rpc-url https://rpc.tempo.xyz.'
+      : requiredChainId === 42431
+        ? ' Use --network testnet or --rpc-url https://rpc.moderato.tempo.xyz.'
+        : ''
+  throw new Errors.IncurError({
+    code: 'CHAIN_MISMATCH',
+    message: `Challenge requires chainId ${requiredChainId}, but RPC is chainId ${opts.clientChainId}.${hint}`,
+    exitCode: 2,
+  })
+}
+
+function parseTokenList(value: string | undefined): Address[] | undefined {
+  if (!value) return undefined
+  return value
+    .split(',')
+    .map((token) => token.trim())
+    .filter(Boolean) as Address[]
+}
+
+function resolveAutoSwap(opts: {
+  autoSwap?: boolean | undefined
+  payWith?: string | undefined
+  slippage?: number | undefined
+  tokenIn?: string | undefined
+}) {
+  const tokenIn = parseTokenList(opts.tokenIn) ?? parseTokenList(opts.payWith)
+  if (!opts.autoSwap && !tokenIn && opts.slippage === undefined) return undefined
+  if (opts.autoSwap === false && !tokenIn && opts.slippage === undefined) return false
+  if (opts.slippage !== undefined && (!Number.isFinite(opts.slippage) || opts.slippage < 0))
+    throw new Error('Invalid CLI options (slippage: expected a non-negative number)')
+  return {
+    ...(tokenIn ? { tokenIn } : {}),
+    ...(opts.slippage !== undefined ? { slippage: opts.slippage } : {}),
+  }
+}
+
 function channelStateDir() {
   return path.join(
     process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),

package/src/cli/utils.test.ts

@@ -1,7 +1,7 @@
 import { tempo as tempoMainnet, tempoModerato } from 'viem/chains'
 import { afterEach, describe, expect, test } from 'vp/test'
 
-import { resolveChain, resolveRpcUrl } from './utils.js'
+import { networkRpcUrls, resolveChain, resolveRpcUrl } from './utils.js'
 
 describe('resolveRpcUrl', () => {
   afterEach(() => {
@@ -14,6 +14,17 @@ describe('resolveRpcUrl', () => {
     expect(resolveRpcUrl('https://explicit.example.com')).toBe('https://explicit.example.com')
   })
 
+  test('uses network default before env vars', () => {
+    process.env.MPPX_RPC_URL = 'https://env.example.com'
+    expect(resolveRpcUrl(undefined, { network: 'testnet' })).toBe(networkRpcUrls.testnet)
+  })
+
+  test('prefers explicit rpc url over network default', () => {
+    expect(resolveRpcUrl('https://explicit.example.com', { network: 'mainnet' })).toBe(
+      'https://explicit.example.com',
+    )
+  })
+
   test('falls back to MPPX_RPC_URL env var', () => {
     process.env.MPPX_RPC_URL = 'https://mppx.example.com'
     process.env.RPC_URL = 'https://rpc.example.com'

package/src/cli/utils.ts

@@ -4,6 +4,8 @@ import type { Chain } from 'viem'
 import { type Address, createClient, http } from 'viem'
 import { tempo as tempoMainnet, tempoModerato } from 'viem/chains'
 
+import * as defaults from '../tempo/internal/defaults.js'
+
 // Inlined from https://github.com/alexeyraspopov/picocolors (ISC License)
 export const pc = (() => {
   const p = process || ({} as NodeJS.Process)
@@ -221,13 +223,29 @@ export function fmtBalance(
   return `${dec ? `${formatted}.${dec}` : formatted} ${sym}`
 }
 
-/** Resolve RPC URL from explicit option, then MPPX_RPC_URL, then RPC_URL env vars. */
-export function resolveRpcUrl(explicit?: string | undefined): string | undefined {
-  return explicit ?? (process.env.MPPX_RPC_URL?.trim() || process.env.RPC_URL?.trim() || undefined)
+export type Network = 'mainnet' | 'testnet'
+
+export const networkRpcUrls = {
+  mainnet: defaults.rpcUrl[defaults.chainId.mainnet],
+  testnet: defaults.rpcUrl[defaults.chainId.testnet],
+} as const satisfies Record<Network, string>
+
+/** Resolve RPC URL from explicit option, network option, then MPPX_RPC_URL/RPC_URL env vars. */
+export function resolveRpcUrl(
+  explicit?: string | undefined,
+  options: { network?: Network | undefined } = {},
+): string | undefined {
+  return (
+    explicit ??
+    (options.network ? networkRpcUrls[options.network] : undefined) ??
+    (process.env.MPPX_RPC_URL?.trim() || process.env.RPC_URL?.trim() || undefined)
+  )
 }
 
-export async function resolveChain(opts: { rpcUrl?: string | undefined } = {}): Promise<Chain> {
-  const rpcUrl = resolveRpcUrl(opts.rpcUrl)
+export async function resolveChain(
+  opts: { network?: Network | undefined; rpcUrl?: string | undefined } = {},
+): Promise<Chain> {
+  const rpcUrl = resolveRpcUrl(opts.rpcUrl, { network: opts.network })
   if (!rpcUrl) return tempoMainnet
   const { getChainId } = await import('viem/actions')
   const chainId = await getChainId(createClient({ transport: http(rpcUrl) }))

package/src/stripe/server/internal/html/node_modules/.bin/mppx

@@ -0,0 +1,22 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/mppx/mppx/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/mppx/mppx/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../mppx/dist/bin.js" "$@"
+else
+  exec node  "$basedir/../mppx/dist/bin.js" "$@"
+fi
+# cmd-shim-target=/home/runner/work/mppx/mppx/src/stripe/server/internal/html/node_modules/mppx/dist/bin.js