mppx 0.3.3 → 0.3.5

package/dist/cli.js

@@ -14,8 +14,9 @@ import { 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 { signVoucher } from './tempo/stream/Voucher.js';
+import { signVoucher } from './tempo/session/Voucher.js';
 const require = createRequire(import.meta.url);
 const { name, version } = require('../package.json');
 const cli = cac(name);
@@ -33,19 +34,16 @@ 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"}'`)
     .action(async (rawUrl, rawOptions) => {
     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()),
@@ -53,11 +51,13 @@ 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()),
         verbose: z.optional(z.boolean()),
     }), rawOptions);
+    const methodOpts = parseMethodOpts(options.methodOpt);
     if (!rawUrl) {
         cli.outputHelp();
         return;
@@ -67,14 +67,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 = {};
     if (options.header) {
         const headerList = Array.isArray(options.header) ? options.header : [options.header];
@@ -148,22 +140,39 @@ cli
             console.log((await challengeResponse.text()).replace(/\n+$/, ''));
             return;
         }
-        const account = privateKeyToAccount(privateKey);
-        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();
         const challengeRequest = challenge.request;
         const currency = challengeRequest.currency;
-        const tokenInfo = currency
-            ? await fetchTokenInfo(client, currency, account.address).catch(() => undefined)
-            : undefined;
-        const tokenSymbol = tokenInfo?.symbol ?? currency ?? '';
-        const tokenDecimals = tokenInfo?.decimals ?? challengeRequest.decimals ?? 6;
+        const shownKeys = new Set();
+        let tokenSymbol = challenge.method === 'stripe' ? (currency?.toUpperCase() ?? '') : (currency ?? '');
+        let tokenDecimals = challengeRequest.decimals ?? (challenge.method === 'stripe' ? 2 : 6);
+        let explorerUrl;
+        // Tempo-specific setup (private key, viem account/client, token info)
+        let account;
+        let client;
+        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);
+            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, account.address).catch(() => undefined)
+                : undefined;
+            tokenSymbol = tokenInfo?.symbol ?? currency ?? '';
+            tokenDecimals =
+                tokenInfo?.decimals ?? challengeRequest.decimals ?? 6;
+        }
         {
             printResponseHeaders(challengeResponse);
             const request = challengeRequest;
@@ -266,55 +275,149 @@ cli
                 }
             }
         }
-        const mppx = Mppx.create({
-            methods: tempo({
-                account,
-                getClient: () => client,
-                deposit: (() => {
-                    if (challenge.intent !== 'session')
-                        return undefined;
-                    const suggestedDeposit = challenge.request
-                        .suggestedDeposit;
-                    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);
-                    }
-                    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() }),
-            };
-        })());
-        const streamMd = challenge.request.methodDetails;
-        let streamChannelId;
-        let streamEscrowContract;
-        let streamChainId = 0;
-        let streamCumulativeAmount = 0n;
+        let credential;
+        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
+                            .suggestedDeposit;
+                        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() }),
+                };
+            })());
+        }
+        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());
+                                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());
+                                        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());
+                            return id;
+                        },
+                    }),
+                ],
+                polyfill: false,
+            });
+            credential = await mppx.createCredential(challengeResponse);
+        }
+        else {
+            console.error(`Unsupported payment method: ${challenge.method}`);
+            process.exit(1);
+        }
+        const sessionMd = challenge.request.methodDetails;
+        let sessionChannelId;
+        let sessionEscrowContract;
+        let sessionChainId = 0;
+        let sessionCumulativeAmount = 0n;
         if (challenge.intent === 'session') {
             const parsed = Credential.deserialize(credential);
-            streamChannelId = parsed.payload.channelId;
-            streamChainId = streamMd?.chainId ?? client.chain?.id ?? 0;
-            streamEscrowContract = streamMd?.escrowContract;
+            sessionChannelId = parsed.payload.channelId;
+            sessionChainId = sessionMd?.chainId ?? client?.chain?.id ?? 0;
+            sessionEscrowContract = sessionMd?.escrowContract;
             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 ?? options.deposit;
+                const depositRaw = challengeRequest.suggestedDeposit;
                 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`);
             }
         }
         const credentialFetchInit = {
@@ -355,9 +458,9 @@ cli
                     const receiptJson = JSON.parse(Base64.toString(receiptHeader));
                     if (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 = [];
@@ -381,6 +484,14 @@ 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)]);
                     }
@@ -402,17 +513,17 @@ cli
                 const decoder = new TextDecoder();
                 let buffer = '';
                 let currentEvent = '';
-                const streamCred = challenge.intent === 'session'
+                const sessionCred = challenge.intent === 'session'
                     ? Credential.deserialize(credential)
                     : undefined;
-                const channelId = streamCred?.payload.channelId;
+                const channelId = sessionCred?.payload.channelId;
                 const md = challenge.request.methodDetails;
-                const streamChainId = md?.chainId ?? client.chain?.id ?? 0;
+                const sessionChainId = md?.chainId ?? client?.chain?.id ?? 0;
                 const escrowContract = md?.escrowContract;
-                let cumulativeAmount = streamCred?.payload &&
-                    'cumulativeAmount' in streamCred.payload &&
-                    streamCred.payload.cumulativeAmount
-                    ? BigInt(streamCred.payload.cumulativeAmount)
+                let cumulativeAmount = sessionCred?.payload &&
+                    'cumulativeAmount' in sessionCred.payload &&
+                    sessionCred.payload.cumulativeAmount
+                    ? BigInt(sessionCred.payload.cumulativeAmount)
                     : 0n;
                 let _voucherSeq = 0;
                 const termBg = verbose ? await detectTerminalBg() : undefined;
@@ -458,12 +569,12 @@ cli
                         if (currentEvent === 'payment-need-voucher' &&
                             channelId &&
                             escrowContract &&
-                            streamChainId) {
+                            sessionChainId) {
                             try {
                                 const event = JSON.parse(data);
                                 const required = BigInt(event.requiredCumulative);
                                 cumulativeAmount = cumulativeAmount > required ? cumulativeAmount : required;
-                                const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, streamChainId);
+                                const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, sessionChainId);
                                 const voucherCred = Credential.serialize({
                                     challenge,
                                     payload: {
@@ -472,7 +583,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',
@@ -549,8 +660,8 @@ cli
                 }
                 if (buffer.trim())
                     await processLines([buffer]);
-                if (channelId && escrowContract && streamChainId) {
-                    const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, streamChainId);
+                if (channelId && escrowContract && sessionChainId) {
+                    const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, sessionChainId);
                     const closePayload = {
                         action: 'close',
                         channelId,
@@ -560,7 +671,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',
@@ -592,9 +703,9 @@ cli
                 console.log(body);
                 const shouldClose = challenge.intent === 'session' &&
                     credentialResponse.ok &&
-                    streamChannelId &&
-                    streamEscrowContract &&
-                    streamChainId;
+                    sessionChannelId &&
+                    sessionEscrowContract &&
+                    sessionChainId;
                 if (shouldClose && options.confirm) {
                     info('\n');
                 }
@@ -602,17 +713,17 @@ cli
                     info(`${pc.dim('Kept channel open.')}\n`);
                 }
                 else if (shouldClose) {
-                    const signature = await signVoucher(client, account, { channelId: streamChannelId, cumulativeAmount: streamCumulativeAmount }, streamEscrowContract, streamChainId);
+                    const signature = await signVoucher(client, account, { channelId: sessionChannelId, cumulativeAmount: sessionCumulativeAmount }, sessionEscrowContract, sessionChainId);
                     const closePayload = {
                         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,
@@ -622,7 +733,7 @@ cli
                         },
                     });
                     if (closeRes.ok) {
-                        deleteChannelState(streamChannelId);
+                        deleteChannelState(sessionChannelId);
                         const closeReceiptHeader = closeRes.headers.get('Payment-Receipt');
                         let closeTxHash;
                         if (closeReceiptHeader) {
@@ -636,16 +747,17 @@ cli
                         const txInfo = closeTxHash && explorerUrl
                             ? ` ${pc.dim(pc.link(`${explorerUrl}/tx/${closeTxHash}`, closeTxHash))}`
                             : '';
-                        info(`\n${pc.dim('Channel closed.')} ${pc.dim(`Spent ${fmtBalance(streamCumulativeAmount, tokenSymbol, tokenDecimals)}.`)}${txInfo}\n`);
+                        const closePrefix = options.confirm ? '' : '\n';
+                        info(`${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`);
-                        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` +
+                        info(`\n${pc.dim(pc.yellow('Channel close failed'))} ${pc.dim(`(${closeRes.status})`)}\n`);
+                        info(`${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`);
                     }
                 }
@@ -726,7 +838,11 @@ cli
             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) => import('viem/tempo').then(({ Actions }) => Actions.faucet.fund(client, { account }).catch(() => { })));
@@ -761,8 +877,12 @@ cli
             const account = privateKeyToAccount(key);
             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`));
                 process.stderr.write(pc.dim('This action cannot be undone\n\n'));
@@ -836,12 +956,16 @@ 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)));
             for (const entry of resolved) {
                 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;
         }
@@ -857,9 +981,13 @@ cli
                 process.exit(1);
             }
             const account = privateKeyToAccount(key);
-            console.log(`${pc.dim('Address')}  ${account.address}`);
-            const rpcUrl = options.rpcUrl ?? process.env.MPPX_RPC_URL;
-            const chain = rpcUrl ? await resolveChain({ rpcUrl }) : undefined;
+            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 balanceLines = await fetchBalanceLines(account.address, chain && rpcUrl ? { chain, rpcUrl } : undefined);
             for (let i = 0; i < balanceLines.length; i++)
                 console.log(`${pc.dim(i === 0 ? 'Balance' : '       ')}  ${balanceLines[i]}`);
@@ -903,6 +1031,21 @@ catch (err) {
     process.exit(1);
 }
 /////////////////////////////////////////////////////////////////////////////////////////////////
+function parseMethodOpts(raw) {
+    if (!raw)
+        return {};
+    const list = Array.isArray(raw) ? raw : [raw];
+    const result = {};
+    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(schema, rawOptions) {
     const result = schema.safeParse(rawOptions ?? {});
     if (result.success)
@@ -971,7 +1114,7 @@ function createDefaultStore() {
 function resolveAccountName(explicit) {
     if (explicit)
         return explicit;
-    if (process.env.MPPX_ACCOUNT)
+    if (process.env.MPPX_ACCOUNT?.trim())
         return process.env.MPPX_ACCOUNT;
     return createDefaultStore().get();
 }
@@ -1154,10 +1297,10 @@ const pc = (() => {
         bgMagentaBright: f('\x1b[105m', '\x1b[49m'),
         bgCyanBright: f('\x1b[106m', '\x1b[49m'),
         bgWhiteBright: f('\x1b[107m', '\x1b[49m'),
-        link(url, text) {
+        link(url, text, noUnderline) {
             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`;
         },
     };
 })();
@@ -1181,17 +1324,22 @@ function chainName(chain) {
     return chainNames[chain.id] ?? chain.name;
 }
 const pathUsd = '0x20c0000000000000000000000000000000000000';
+const usdc = '0x20C000000000000000000000b9537d11c60E8b50';
+const mainnetTokens = [pathUsd, usdc];
 const testnetTokens = [
     '0x20c0000000000000000000000000000000000000',
     '0x20c0000000000000000000000000000000000001',
     '0x20c0000000000000000000000000000000000002',
     '0x20c0000000000000000000000000000000000003',
 ];
-function fmtBalance(b, symbol, decimals = 6) {
+function fmtBalance(b, symbol, decimals = 6, opts) {
     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) {
     return chain.id !== tempoMainnet.id;
@@ -1202,9 +1350,13 @@ async function fetchTokenInfo(client, token, account) {
         Actions.token.getBalance(client, { account, token }).catch(() => 0n),
         Actions.token.getMetadata(client, { token }).catch(() => ({ symbol: token })),
     ]);
-    const symbol = token === pathUsd ? 'PathUSD' : metadata.symbol;
+    const knownSymbols = {
+        [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(timeoutMs = 100) {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
@@ -1242,25 +1394,34 @@ function detectTerminalBg(timeoutMs = 100) {
 async function fetchBalanceLines(address, opts) {
     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(testnetTokens.map((token) => fetchTokenInfo(client, token, address)));
             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)')}`);
         }
     }
     return lines;