mppx 0.6.17 → 0.6.18

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) }))