mppx 0.3.3 → 0.3.5

package/src/cli.ts

@@ -15,9 +15,10 @@ import { type ZodMiniType, z } from 'zod/mini'
 import * as Challenge from './Challenge.js'
 import * as Credential from './Credential.js'
 import * as Mppx from './client/Mppx.js'
+import { stripe } from './stripe/client/index.js'
 import { tempo } from './tempo/client/index.js'
-import type { StreamCredentialPayload } from './tempo/stream/Types.js'
-import { signVoucher } from './tempo/stream/Voucher.js'
+import type { SessionCredentialPayload } from './tempo/session/Types.js'
+import { signVoucher } from './tempo/session/Voucher.js'
 
 const require = createRequire(import.meta.url)
 const { name, version } = require('../package.json') as { name: string; version: string }
@@ -41,9 +42,8 @@ cli
   .option('-H, --header <header>', 'Add header (repeatable)')
   .option('-L, --location', 'Follow redirects')
   .option('-X, --method <method>', 'HTTP method')
-  .option('--channel <id>', 'Reuse existing stream channel ID')
+  .option('-M, --method-opt <opt>', 'Method-specific option (key=value, repeatable)')
   .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)')
   .example(`${name} example.com/content`)
   .example(`${name} example.com/api --json '{"key":"value"}'`)
@@ -51,10 +51,8 @@ cli
     const options = parseOptions(
       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()),
         header: z.optional(z.union([z.string(), z.array(z.string())])),
         include: z.optional(z.boolean()),
@@ -62,6 +60,7 @@ cli
         json: z.optional(z.string()),
         location: z.optional(z.boolean()),
         method: z.optional(z.string()),
+        methodOpt: z.optional(z.union([z.string(), z.array(z.string())])),
         rpcUrl: z.optional(z.string()),
         silent: z.optional(z.boolean()),
         userAgent: z.optional(z.string()),
@@ -69,6 +68,7 @@ cli
       }),
       rawOptions,
     )
+    const methodOpts = parseMethodOpts(options.methodOpt)
     if (!rawUrl) {
       cli.outputHelp()
       return
@@ -79,12 +79,6 @@ cli
     if (silent) options.confirm = false
 
     const accountName = resolveAccountName(options.account)
-    const privateKey = process.env.MPPX_PRIVATE_KEY ?? (await createKeychain(accountName).get())
-    if (!privateKey) {
-      if (options.account) console.log(`Account "${accountName}" not found.`)
-      else console.log(`No account found.`)
-      process.exit(1)
-    }
 
     const headers: Record<string, string> = {}
     if (options.header) {
@@ -157,24 +151,43 @@ cli
         return
       }
 
-      const account = privateKeyToAccount(privateKey as `0x${string}`)
-      const rpcUrl = options.rpcUrl ?? process.env.MPPX_RPC_URL
-      const client = createClient({
-        chain: await resolveChain({ ...options, rpcUrl }),
-        transport: http(rpcUrl),
-      })
-
       const challenge = Challenge.fromResponse(challengeResponse)
-      const explorerUrl = client.chain?.blockExplorers?.default?.url
-      const shownKeys = new Set<string>()
       const challengeRequest = challenge.request as Record<string, unknown>
       const currency = challengeRequest.currency as string | undefined
-      const tokenInfo = currency
-        ? await fetchTokenInfo(client, currency as Address, account.address).catch(() => undefined)
-        : undefined
-      const tokenSymbol = tokenInfo?.symbol ?? currency ?? ''
-      const tokenDecimals =
-        tokenInfo?.decimals ?? (challengeRequest.decimals as number | undefined) ?? 6
+      const shownKeys = new Set<string>()
+
+      let tokenSymbol =
+        challenge.method === 'stripe' ? (currency?.toUpperCase() ?? '') : (currency ?? '')
+      let tokenDecimals =
+        (challengeRequest.decimals as number | undefined) ?? (challenge.method === 'stripe' ? 2 : 6)
+      let explorerUrl: string | undefined
+
+      // Tempo-specific setup (private key, viem account/client, token info)
+      let account: ReturnType<typeof privateKeyToAccount> | undefined
+      let client: ReturnType<typeof createClient> | undefined
+      if (challenge.method === 'tempo') {
+        const privateKey = process.env.MPPX_PRIVATE_KEY ?? (await createKeychain(accountName).get())
+        if (!privateKey) {
+          if (options.account) console.error(`Account "${accountName}" not found.`)
+          else console.error(`No account found.`)
+          process.exit(1)
+        }
+        account = privateKeyToAccount(privateKey as `0x${string}`)
+        const rpcUrl = options.rpcUrl ?? process.env.RPC_URL
+        client = createClient({
+          chain: await resolveChain({ ...options, rpcUrl }),
+          transport: http(rpcUrl),
+        })
+        explorerUrl = client.chain?.blockExplorers?.default?.url
+        const tokenInfo = currency
+          ? await fetchTokenInfo(client, currency as Address, account.address).catch(
+              () => undefined,
+            )
+          : undefined
+        tokenSymbol = tokenInfo?.symbol ?? currency ?? ''
+        tokenDecimals =
+          tokenInfo?.decimals ?? (challengeRequest.decimals as number | undefined) ?? 6
+      }
 
       {
         printResponseHeaders(challengeResponse)
@@ -276,66 +289,178 @@ cli
         }
       }
 
-      const mppx = Mppx.create({
-        methods: tempo({
-          account,
-          getClient: () => client,
-          deposit: (() => {
-            if (challenge.intent !== 'session') return undefined
-            const suggestedDeposit = (challenge.request as Record<string, unknown>)
-              .suggestedDeposit as string | undefined
-            const cliDeposit = options.deposit !== undefined ? String(options.deposit) : undefined
-            const resolved =
-              suggestedDeposit ?? cliDeposit ?? (isTestnet(client.chain!) ? '10' : undefined)
-            if (!resolved) {
-              console.error(
-                'Stream payment requires a deposit. Use --deposit <amount> or connect to testnet.',
-              )
-              process.exit(1)
+      let credential: string
+      if (challenge.method === 'tempo') {
+        if (!account || !client) {
+          console.error('Tempo requires a configured account.')
+          process.exit(1)
+        }
+        const tempoOpts = parseOptions(
+          z.object({
+            channel: z.optional(z.coerce.string()),
+            deposit: z.optional(z.union([z.string(), z.number()])),
+          }),
+          methodOpts,
+        )
+        const mppx = Mppx.create({
+          methods: tempo({
+            account,
+            getClient: () => client!,
+            deposit: (() => {
+              if (challenge.intent !== 'session') return undefined
+              const suggestedDeposit = (challenge.request as Record<string, unknown>)
+                .suggestedDeposit as string | undefined
+              const cliDeposit =
+                tempoOpts.deposit !== undefined ? String(tempoOpts.deposit) : undefined
+              const resolved =
+                suggestedDeposit ?? cliDeposit ?? (isTestnet(client!.chain!) ? '10' : undefined)
+              if (!resolved) {
+                console.error(
+                  'Session payment requires a deposit. Use -M deposit=<amount> or connect to testnet.',
+                )
+                process.exit(1)
+              }
+              return resolved
+            })(),
+          }),
+          polyfill: false,
+        })
+        credential = await mppx.createCredential(
+          challengeResponse,
+          (() => {
+            if (!tempoOpts.channel) return undefined
+            const channelId = tempoOpts.channel
+            const saved = readChannelCumulative(channelId)
+            return {
+              channelId,
+              ...(saved !== undefined && { cumulativeAmountRaw: saved.toString() }),
             }
-            return resolved
           })(),
-        }),
-        polyfill: false,
-      })
-
-      const credential = await mppx.createCredential(
-        challengeResponse,
-        (() => {
-          if (!options.channel) return undefined
-          const idx = process.argv.indexOf('--channel')
-          const channelId = idx !== -1 ? process.argv[idx + 1]! : String(options.channel)
-          const saved = readChannelCumulative(channelId)
-          return {
-            channelId,
-            ...(saved !== undefined && { cumulativeAmountRaw: saved.toString() }),
-          }
-        })(),
-      )
+        )
+      } else if (challenge.method === 'stripe') {
+        const stripeOpts = parseOptions(
+          z.object({
+            paymentMethod: z.string(),
+          }),
+          methodOpts,
+        )
+        const stripeSecretKey = process.env.MPPX_STRIPE_SECRET_KEY
+        if (!stripeSecretKey) {
+          console.error(
+            '\nMPPX_STRIPE_SECRET_KEY environment variable is required for Stripe payments.',
+          )
+          process.exit(1)
+        }
+        if (!stripeSecretKey.startsWith('sk_test_')) {
+          console.error(
+            '\nStripe CLI payments are currently only supported in test mode (sk_test_... keys).',
+          )
+          process.exit(1)
+        }
+        const mppx = Mppx.create({
+          methods: [
+            stripe.charge({
+              paymentMethod: stripeOpts.paymentMethod,
+              createToken: async ({
+                paymentMethod,
+                amount,
+                currency,
+                networkId,
+                expiresAt,
+                metadata,
+              }) => {
+                const body = new URLSearchParams({
+                  payment_method: paymentMethod!,
+                  'usage_limits[currency]': currency,
+                  'usage_limits[max_amount]': amount,
+                  'usage_limits[expires_at]': expiresAt.toString(),
+                })
+                if (networkId) body.set('seller_details[network_id]', networkId)
+                if (metadata) {
+                  for (const [key, value] of Object.entries(metadata)) {
+                    body.set(`metadata[${key}]`, value)
+                  }
+                }
+                const sptUrl =
+                  process.env.MPPX_STRIPE_SPT_URL ??
+                  'https://api.stripe.com/v1/test_helpers/shared_payment/granted_tokens'
+                const sptHeaders = {
+                  Authorization: `Basic ${btoa(`${stripeSecretKey}:`)}`,
+                  'Content-Type': 'application/x-www-form-urlencoded',
+                }
+                let response = await globalThis.fetch(sptUrl, {
+                  method: 'POST',
+                  headers: sptHeaders,
+                  body,
+                })
+                if (!response.ok) {
+                  const errorBody = (await response.json()) as { error: { message: string } }
+                  if (
+                    (metadata || networkId) &&
+                    errorBody.error.message.includes('Received unknown parameter')
+                  ) {
+                    const fallbackBody = new URLSearchParams({
+                      payment_method: paymentMethod!,
+                      'usage_limits[currency]': currency,
+                      'usage_limits[max_amount]': amount,
+                      'usage_limits[expires_at]': expiresAt.toString(),
+                    })
+                    response = await globalThis.fetch(sptUrl, {
+                      method: 'POST',
+                      headers: sptHeaders,
+                      body: fallbackBody,
+                    })
+                    if (!response.ok) {
+                      const fallbackError = (await response.json()) as {
+                        error: { message: string }
+                      }
+                      throw new Error(`Failed to create SPT: ${fallbackError.error.message}`)
+                    }
+                  } else {
+                    throw new Error(`Failed to create SPT: ${errorBody.error.message}`)
+                  }
+                }
+                const { id } = (await response.json()) as { id: string }
+                return id
+              },
+            }),
+          ],
+          polyfill: false,
+        })
+        credential = await mppx.createCredential(challengeResponse)
+      } else {
+        console.error(`Unsupported payment method: ${challenge.method}`)
+        process.exit(1)
+      }
 
-      const streamMd = challenge.request.methodDetails as
+      const sessionMd = challenge.request.methodDetails as
         | { escrowContract?: string; chainId?: number }
         | undefined
-      let streamChannelId: `0x${string}` | undefined
-      let streamEscrowContract: Address | undefined
-      let streamChainId = 0
-      let streamCumulativeAmount = 0n
+      let sessionChannelId: `0x${string}` | undefined
+      let sessionEscrowContract: Address | undefined
+      let sessionChainId = 0
+      let sessionCumulativeAmount = 0n
 
       if (challenge.intent === 'session') {
-        const parsed = Credential.deserialize<StreamCredentialPayload>(credential)
-        streamChannelId = parsed.payload.channelId
-        streamChainId = streamMd?.chainId ?? client.chain?.id ?? 0
-        streamEscrowContract = streamMd?.escrowContract as Address | undefined
+        const parsed = Credential.deserialize<SessionCredentialPayload>(credential)
+        sessionChannelId = parsed.payload.channelId
+        sessionChainId = sessionMd?.chainId ?? client?.chain?.id ?? 0
+        sessionEscrowContract = sessionMd?.escrowContract as Address | undefined
         if ('cumulativeAmount' in parsed.payload && parsed.payload.cumulativeAmount)
-          streamCumulativeAmount = BigInt(parsed.payload.cumulativeAmount)
+          sessionCumulativeAmount = BigInt(parsed.payload.cumulativeAmount)
 
         if (parsed.payload.action === 'open') {
-          const depositRaw =
-            (challengeRequest.suggestedDeposit as string | undefined) ?? options.deposit
+          const depositRaw = challengeRequest.suggestedDeposit as string | undefined
           const depositDisplay = depositRaw
             ? ` ${pc.dim(`(deposit ${depositRaw} ${tokenSymbol})`)}`
             : ''
-          info(`\n${pc.dim(`Channel opened ${parsed.payload.channelId}`)}${depositDisplay}\n`)
+          const prefix = options.confirm ? '' : '\n'
+          info(
+            `${prefix}${pc.dim(`Channel opened ${parsed.payload.channelId}`)}${depositDisplay}\n`,
+          )
+        } else {
+          const prefix = options.confirm ? '' : '\n'
+          info(`${prefix}${pc.dim(`Channel reused ${parsed.payload.channelId}`)}\n`)
         }
       }
 
@@ -379,8 +504,9 @@ cli
               typeof receiptJson.acceptedCumulative === 'string' &&
               receiptJson.acceptedCumulative
             ) {
-              streamCumulativeAmount = BigInt(receiptJson.acceptedCumulative)
-              if (streamChannelId) writeChannelCumulative(streamChannelId, streamCumulativeAmount)
+              sessionCumulativeAmount = BigInt(receiptJson.acceptedCumulative)
+              if (sessionChannelId)
+                writeChannelCumulative(sessionChannelId, sessionCumulativeAmount)
             }
             info(`\n${pc.bold(pc.green('Payment Receipt'))}\n`)
             const rows: [string, string][] = []
@@ -402,6 +528,15 @@ cli
                 explorerUrl
               ) {
                 rows.push([key, pc.link(`${explorerUrl}/tx/${value}`, value)])
+              } else if (
+                key === 'reference' &&
+                typeof value === 'string' &&
+                challenge.method === 'stripe' &&
+                value.startsWith('pi_')
+              ) {
+                const isTest = process.env.MPPX_STRIPE_SECRET_KEY?.startsWith('sk_test_')
+                const dashboardUrl = `https://dashboard.stripe.com${isTest ? '/test' : ''}/payments/${value}`
+                rows.push([key, pc.link(dashboardUrl, value)])
               } else rows.push([key, String(value)])
             }
             rows.sort(([a], [b]) => a.localeCompare(b))
@@ -421,21 +556,21 @@ cli
           let buffer = ''
           let currentEvent = ''
 
-          const streamCred =
+          const sessionCred =
             challenge.intent === 'session'
-              ? Credential.deserialize<StreamCredentialPayload>(credential)
+              ? Credential.deserialize<SessionCredentialPayload>(credential)
               : undefined
-          const channelId = streamCred?.payload.channelId
+          const channelId = sessionCred?.payload.channelId
           const md = challenge.request.methodDetails as
             | { escrowContract?: string; chainId?: number }
             | undefined
-          const streamChainId = md?.chainId ?? client.chain?.id ?? 0
+          const sessionChainId = md?.chainId ?? client?.chain?.id ?? 0
           const escrowContract = md?.escrowContract as Address | undefined
           let cumulativeAmount =
-            streamCred?.payload &&
-            'cumulativeAmount' in streamCred.payload &&
-            streamCred.payload.cumulativeAmount
-              ? BigInt(streamCred.payload.cumulativeAmount)
+            sessionCred?.payload &&
+            'cumulativeAmount' in sessionCred.payload &&
+            sessionCred.payload.cumulativeAmount
+              ? BigInt(sessionCred.payload.cumulativeAmount)
               : 0n
           let _voucherSeq = 0
 
@@ -481,7 +616,7 @@ cli
                 currentEvent === 'payment-need-voucher' &&
                 channelId &&
                 escrowContract &&
-                streamChainId
+                sessionChainId
               ) {
                 try {
                   const event = JSON.parse(data) as {
@@ -492,11 +627,11 @@ cli
                   cumulativeAmount = cumulativeAmount > required ? cumulativeAmount : required
 
                   const signature = await signVoucher(
-                    client,
-                    account,
+                    client!,
+                    account!,
                     { channelId, cumulativeAmount },
                     escrowContract,
-                    streamChainId,
+                    sessionChainId,
                   )
                   const voucherCred = Credential.serialize({
                     challenge,
@@ -506,7 +641,7 @@ cli
                       cumulativeAmount: cumulativeAmount.toString(),
                       signature,
                     },
-                    source: `did:pkh:eip155:${streamChainId}:${account.address}`,
+                    source: `did:pkh:eip155:${sessionChainId}:${account!.address}`,
                   })
                   await globalThis.fetch(url, {
                     method: 'POST',
@@ -583,15 +718,15 @@ cli
           }
           if (buffer.trim()) await processLines([buffer])
 
-          if (channelId && escrowContract && streamChainId) {
+          if (channelId && escrowContract && sessionChainId) {
             const signature = await signVoucher(
-              client,
-              account,
+              client!,
+              account!,
               { channelId, cumulativeAmount },
               escrowContract,
-              streamChainId,
+              sessionChainId,
             )
-            const closePayload: StreamCredentialPayload = {
+            const closePayload: SessionCredentialPayload = {
               action: 'close',
               channelId,
               cumulativeAmount: cumulativeAmount.toString(),
@@ -600,7 +735,7 @@ cli
             const closeCred = Credential.serialize({
               challenge,
               payload: closePayload,
-              source: `did:pkh:eip155:${streamChainId}:${account.address}`,
+              source: `did:pkh:eip155:${sessionChainId}:${account!.address}`,
             })
             const closeRes = await globalThis.fetch(url, {
               method: 'POST',
@@ -638,9 +773,9 @@ cli
           const shouldClose =
             challenge.intent === 'session' &&
             credentialResponse.ok &&
-            streamChannelId &&
-            streamEscrowContract &&
-            streamChainId
+            sessionChannelId &&
+            sessionEscrowContract &&
+            sessionChainId
           if (shouldClose && options.confirm) {
             info('\n')
           }
@@ -648,22 +783,22 @@ cli
             info(`${pc.dim('Kept channel open.')}\n`)
           } else if (shouldClose) {
             const signature = await signVoucher(
-              client,
-              account,
-              { channelId: streamChannelId!, cumulativeAmount: streamCumulativeAmount },
-              streamEscrowContract!,
-              streamChainId,
+              client!,
+              account!,
+              { channelId: sessionChannelId!, cumulativeAmount: sessionCumulativeAmount },
+              sessionEscrowContract!,
+              sessionChainId,
             )
-            const closePayload: StreamCredentialPayload = {
+            const closePayload: SessionCredentialPayload = {
               action: 'close',
-              channelId: streamChannelId!,
-              cumulativeAmount: streamCumulativeAmount.toString(),
+              channelId: sessionChannelId!,
+              cumulativeAmount: sessionCumulativeAmount.toString(),
               signature,
             }
             const closeCred = Credential.serialize({
               challenge,
               payload: closePayload,
-              source: `did:pkh:eip155:${streamChainId}:${account.address}`,
+              source: `did:pkh:eip155:${sessionChainId}:${account!.address}`,
             })
             const closeRes = await globalThis.fetch(url, {
               ...fetchInit,
@@ -673,7 +808,7 @@ cli
               },
             })
             if (closeRes.ok) {
-              deleteChannelState(streamChannelId!)
+              deleteChannelState(sessionChannelId!)
               const closeReceiptHeader = closeRes.headers.get('Payment-Receipt')
               let closeTxHash: string | undefined
               if (closeReceiptHeader) {
@@ -689,20 +824,21 @@ cli
                 closeTxHash && explorerUrl
                   ? ` ${pc.dim(pc.link(`${explorerUrl}/tx/${closeTxHash}`, closeTxHash))}`
                   : ''
+              const closePrefix = options.confirm ? '' : '\n'
               info(
-                `\n${pc.dim('Channel closed.')} ${pc.dim(`Spent ${fmtBalance(streamCumulativeAmount, tokenSymbol, tokenDecimals)}.`)}${txInfo}\n`,
+                `${closePrefix}${pc.dim('Channel closed.')} ${pc.dim(`Spent ${fmtBalance(sessionCumulativeAmount, tokenSymbol, tokenDecimals)}.`)}${txInfo}\n`,
               )
             } else {
               const closeBody = await closeRes.text().catch(() => '')
               info(
-                `${pc.dim(pc.yellow('Channel close failed'))} ${pc.dim(`(${closeRes.status})`)}\n`,
+                `\n${pc.dim(pc.yellow('Channel close failed'))} ${pc.dim(`(${closeRes.status})`)}\n`,
               )
               info(
-                `${pc.dim(`  channelId:          ${streamChannelId}`)}\n` +
-                  `${pc.dim(`  cumulativeAmount:   ${streamCumulativeAmount}`)}\n` +
-                  `${pc.dim(`  escrowContract:     ${streamEscrowContract}`)}\n` +
-                  `${pc.dim(`  chainId:            ${streamChainId}`)}\n` +
-                  `${pc.dim(`  account:            ${account.address}`)}\n` +
+                `${pc.dim(`  channelId:          ${sessionChannelId}`)}\n` +
+                  `${pc.dim(`  cumulativeAmount:   ${sessionCumulativeAmount}`)}\n` +
+                  `${pc.dim(`  escrowContract:     ${sessionEscrowContract}`)}\n` +
+                  `${pc.dim(`  chainId:            ${sessionChainId}`)}\n` +
+                  `${pc.dim(`  account:            ${account?.address}`)}\n` +
                   `${pc.dim(`  response:           ${closeBody || '(empty)'}`)}\n`,
               )
             }
@@ -784,7 +920,11 @@ cli
         const accounts = await createKeychain().list()
         if (accounts.length === 1) createDefaultStore().set(resolvedName)
         console.log(`Account "${resolvedName}" saved to keychain.`)
-        console.log(pc.dim(`Address ${account.address}`))
+        const explorerUrl = tempoMainnet.blockExplorers?.default?.url
+        const addrDisplay = explorerUrl
+          ? pc.link(`${explorerUrl}/address/${account.address}`, account.address)
+          : account.address
+        console.log(pc.dim(`Address ${addrDisplay}`))
         resolveChain(options)
           .then((chain) => createClient({ chain, transport: http(options.rpcUrl) }))
           .then((client) =>
@@ -823,8 +963,12 @@ cli
         const account = privateKeyToAccount(key as `0x${string}`)
         const balanceLines = await fetchBalanceLines(account.address, { includeTestnet: false })
         if (!options.yes) {
+          const explorerUrl = tempoMainnet.blockExplorers?.default?.url
+          const addrDisplay = explorerUrl
+            ? pc.link(`${explorerUrl}/address/${account.address}`, account.address)
+            : account.address
           process.stderr.write(pc.dim(`Delete account "${options.account}"\n`))
-          process.stderr.write(pc.dim(`  Address  ${account.address}\n`))
+          process.stderr.write(pc.dim(`  Address  ${addrDisplay}\n`))
           for (let i = 0; i < balanceLines.length; i++)
             process.stderr.write(
               pc.dim(`  ${i === 0 ? 'Balance' : '       '}  ${balanceLines[i]}\n`),
@@ -897,6 +1041,7 @@ cli
           }),
         )
         const resolved = entries.filter((e) => e !== undefined)
+        const explorerUrl = tempoMainnet.blockExplorers?.default?.url
         const maxWidth = Math.max(
           ...resolved.map((e) => e.name.length + (e.name === currentDefault ? 1 : 0)),
         )
@@ -904,7 +1049,10 @@ cli
           const isDefault = entry.name === currentDefault
           const label = isDefault ? `${entry.name}${pc.dim('*')}` : entry.name
           const width = entry.name.length + (isDefault ? 1 : 0)
-          console.log(`${label}${' '.repeat(maxWidth - width + 2)}${pc.dim(entry.address)}`)
+          const addrDisplay = explorerUrl
+            ? pc.link(`${explorerUrl}/address/${entry.address}`, entry.address)
+            : entry.address
+          console.log(`${label}${' '.repeat(maxWidth - width + 2)}${pc.dim(addrDisplay)}`)
         }
         return
       }
@@ -918,10 +1066,14 @@ cli
           process.exit(1)
         }
         const account = privateKeyToAccount(key as `0x${string}`)
-        console.log(`${pc.dim('Address')}  ${account.address}`)
+        const rpcUrl = options.rpcUrl ?? (process.env.MPPX_RPC_URL || undefined)
+        const chain = rpcUrl ? await resolveChain({ rpcUrl }) : tempoMainnet
+        const explorerUrl = chain.blockExplorers?.default?.url
+        const addrDisplay = explorerUrl
+          ? pc.link(`${explorerUrl}/address/${account.address}`, account.address)
+          : account.address
+        console.log(`${pc.dim('Address')}  ${addrDisplay}`)
 
-        const rpcUrl = options.rpcUrl ?? process.env.MPPX_RPC_URL
-        const chain = rpcUrl ? await resolveChain({ rpcUrl }) : undefined
         const balanceLines = await fetchBalanceLines(
           account.address,
           chain && rpcUrl ? { chain, rpcUrl } : undefined,
@@ -971,6 +1123,21 @@ try {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
+function parseMethodOpts(raw: string | string[] | undefined): Record<string, string> {
+  if (!raw) return {}
+  const list = Array.isArray(raw) ? raw : [raw]
+  const result: Record<string, string> = {}
+  for (const item of list) {
+    const idx = item.indexOf('=')
+    if (idx === -1) {
+      console.error(`Invalid method option format: ${item} (expected key=value)`)
+      process.exit(1)
+    }
+    result[item.slice(0, idx)] = item.slice(idx + 1)
+  }
+  return result
+}
+
 function parseOptions<const schema extends ZodMiniType>(
   schema: schema,
   rawOptions: unknown,
@@ -1054,7 +1221,7 @@ function createDefaultStore() {
 
 function resolveAccountName(explicit?: string): string {
   if (explicit) return explicit
-  if (process.env.MPPX_ACCOUNT) return process.env.MPPX_ACCOUNT
+  if (process.env.MPPX_ACCOUNT?.trim()) return process.env.MPPX_ACCOUNT
   return createDefaultStore().get()
 }
 
@@ -1238,9 +1405,9 @@ const pc = (() => {
     bgMagentaBright: f('\x1b[105m', '\x1b[49m'),
     bgCyanBright: f('\x1b[106m', '\x1b[49m'),
     bgWhiteBright: f('\x1b[107m', '\x1b[49m'),
-    link(url: string, text: string) {
+    link(url: string, text: string, noUnderline?: boolean) {
       if (!isColorSupported) return text
-      return `\x1b]8;;${url}\x07${pc.underline(text)}\x1b]8;;\x07`
+      return `\x1b]8;;${url}\x07${noUnderline ? text : pc.underline(text)}\x1b]8;;\x07`
     },
   }
 })()
@@ -1268,6 +1435,8 @@ function chainName(chain: { id: number; name: string }) {
 }
 
 const pathUsd = '0x20c0000000000000000000000000000000000000' as Address
+const usdc = '0x20C000000000000000000000b9537d11c60E8b50' as Address
+const mainnetTokens = [pathUsd, usdc] as const
 const testnetTokens = [
   '0x20c0000000000000000000000000000000000000',
   '0x20c0000000000000000000000000000000000001',
@@ -1275,11 +1444,20 @@ const testnetTokens = [
   '0x20c0000000000000000000000000000000000003',
 ] as const
 
-function fmtBalance(b: bigint, symbol: string, decimals = 6) {
+function fmtBalance(
+  b: bigint,
+  symbol: string,
+  decimals = 6,
+  opts?: { explorerUrl?: string | undefined; token?: string | undefined },
+) {
   const value = Number(b) / 10 ** decimals
   const [int, dec] = value.toString().split('.')
   const formatted = int!.replace(/\B(?=(\d{3})+(?!\d))/g, '_')
-  return `${dec ? `${formatted}.${dec}` : formatted} ${pc.dim(symbol)}`
+  const sym =
+    opts?.explorerUrl && opts.token
+      ? pc.dim(pc.link(`${opts.explorerUrl}/token/${opts.token}`, symbol, true))
+      : pc.dim(symbol)
+  return `${dec ? `${formatted}.${dec}` : formatted} ${sym}`
 }
 
 function isTestnet(chain: Chain) {
@@ -1296,9 +1474,13 @@ async function fetchTokenInfo(
     Actions.token.getBalance(client, { account, token }).catch(() => 0n),
     Actions.token.getMetadata(client, { token }).catch(() => ({ symbol: token as string })),
   ])
-  const symbol = token === pathUsd ? 'PathUSD' : metadata.symbol
+  const knownSymbols: Record<string, string> = {
+    [pathUsd]: 'PathUSD',
+    [usdc]: 'USDC',
+  }
+  const symbol = knownSymbols[token] ?? metadata.symbol
   const decimals = 'decimals' in metadata ? metadata.decimals : 6
-  return { balance, symbol, decimals }
+  return { balance, symbol, decimals, token }
 }
 
 function detectTerminalBg(
@@ -1340,6 +1522,7 @@ async function fetchBalanceLines(
 ): Promise<string[]> {
   if (opts?.chain) {
     const client = createClient({ chain: opts.chain, transport: http(opts.rpcUrl) })
+    const explorerUrl = opts.chain.blockExplorers?.default?.url
     const label = pc.dim(`(${chainName(opts.chain)})`)
     if (isTestnet(opts.chain)) {
       const results = await Promise.all(
@@ -1347,24 +1530,46 @@ async function fetchBalanceLines(
       )
       return results
         .filter((t) => t.balance > 0n)
-        .map((t) => `${fmtBalance(t.balance, t.symbol, t.decimals)} ${label}`)
+        .map(
+          (t) =>
+            `${fmtBalance(t.balance, t.symbol, t.decimals, { explorerUrl, token: t.token })} ${label}`,
+        )
     }
-    const { balance, symbol, decimals } = await fetchTokenInfo(client, pathUsd, address)
-    return [`${fmtBalance(balance, symbol, decimals)} ${label}`]
+    const results = await Promise.all(
+      mainnetTokens.map((token) => fetchTokenInfo(client, token, address)),
+    )
+    return results.map(
+      (t) =>
+        `${fmtBalance(t.balance, t.symbol, t.decimals, { explorerUrl, token: t.token })} ${label}`,
+    )
   }
 
-  const mainnetClient = createClient({ chain: tempoMainnet, transport: http() })
-  const mainnetInfo = await fetchTokenInfo(mainnetClient, pathUsd, address)
-  const lines = [fmtBalance(mainnetInfo.balance, mainnetInfo.symbol, mainnetInfo.decimals)]
+  const mainnetClient = createClient({
+    chain: tempoMainnet,
+    transport: http(process.env.MPPX_RPC_URL || undefined),
+  })
+  const mainnetExplorerUrl = tempoMainnet.blockExplorers?.default?.url
+  const mainnetResults = await Promise.all(
+    mainnetTokens.map((token) => fetchTokenInfo(mainnetClient, token, address)),
+  )
+  const lines = mainnetResults.map((t) =>
+    fmtBalance(t.balance, t.symbol, t.decimals, {
+      explorerUrl: mainnetExplorerUrl,
+      token: t.token,
+    }),
+  )
 
   if (opts?.includeTestnet !== false) {
     const testnetClient = createClient({ chain: tempoModerato, transport: http() })
+    const testnetExplorerUrl = tempoModerato.blockExplorers?.default?.url
     const testnetResults = await Promise.all(
       testnetTokens.map((token) => fetchTokenInfo(testnetClient, token, address)),
     )
     for (const t of testnetResults) {
       if (t.balance > 0n)
-        lines.push(`${fmtBalance(t.balance, t.symbol, t.decimals)} ${pc.dim('(testnet)')}`)
+        lines.push(
+          `${fmtBalance(t.balance, t.symbol, t.decimals, { explorerUrl: testnetExplorerUrl, token: t.token })} ${pc.dim('(testnet)')}`,
+        )
     }
   }