thaifi-wallet-cli 0.3.6 → 0.5.0

package/README.md

@@ -44,6 +44,8 @@ Set `THAIFI_WALLET_URL` / `THAIFI_RPC_URL` to target other deployments.
 | `tokens` | List supported TIP-20 tokens (symbol, decimals, address) |
 | `balance [--token <symbol\|addr>]` | Balances (default: all supported tokens) |
 | `transfer <to> <amount> [--token <symbol\|addr>]` | Send tokens (default: pathUSD; limit enforced on-chain) |
+| `fund [--no-browser]` | Show the deposit address and open the web Deposit page |
+| `deposit --amount <THB> [--token THCFI\|THCOC] [--ref <id>] [--no-open] [--json]` | **PromptPay QR top-up (1 THB = 1 token)**: order a QR, show it for a human to scan, poll until the tokens are minted |
 | `request <url> [-X -H -d --json --dry-run --max-spend]` | HTTP with automatic x402/MPP payment **and ThaiFiAgent identity auth (401/403 answered by signing the challenge)** |
 | `services [--search q]` | Discover services from the MPP registry (`THAIFI_MPP_REGISTRY`) |
 | `logout` | Remove the local key (revoke on-chain from the web wallet) |
@@ -51,6 +53,38 @@ Set `THAIFI_WALLET_URL` / `THAIFI_RPC_URL` to target other deployments.
 `--token` accepts a symbol (case-insensitive) or a contract address; unknown
 addresses are treated as custom TIP-20s (6 decimals).
 
+## Deposit (PromptPay top-up)
+
+`thaifi deposit --amount 50` orders a PromptPay QR for the paired wallet and
+waits until the tokens are minted (1 THB = 1 token). There is **no API key**:
+the backend verifies on-chain (AccountKeychain precompile, TIP-1011) that the
+agent's access key belongs to a wallet and credits THAT wallet — the recipient
+never comes from the CLI.
+
+```
+$ thaifi deposit --amount 50
+PromptPay deposit — 50.00 THB -> THCFI (1 THB = 1 token)
+Credited wallet: 0x…
+<terminal QR block>
+QR_FILE=~/.thaifi/qr-<referenceNo>.png
+REFERENCE=<referenceNo>
+AMOUNT=50.00 THB -> THCFI
+RESUME=thaifi deposit --ref <referenceNo>
+STATUS=pending  (scan the QR to pay)
+STATUS=delivered
+TX=0x…  Explorer: https://exp.thaifi.com/tx/0x…
+```
+
+- The QR is saved to `~/.thaifi/qr-<referenceNo>.png` (chmod 600), rendered as
+  terminal blocks, and opened in the default viewer (disable with `--no-open`).
+- Orders expire after 15 minutes; paying late still delivers. Resume watching
+  any order with `--ref <referenceNo>` — the status response includes the QR
+  again, so a restarted CLI can re-display it.
+- Limits: 6–10,000 THB per order, 50,000 THB per wallet per 24h, 5 pending
+  orders per wallet. `--json` prints machine-readable output.
+- Requires an approved pairing (`thaifi login`); a revoked/expired key fails
+  with 401 on-chain verification.
+
 ## Security notes
 
 - The recovery password / passphrase is never involved here — the agent key is

package/dist/agentAuth.js

@@ -18,6 +18,31 @@ const ZERO_BODY_HASH = `0x${"00".repeat(32)}`;
 function b64uDecodeBytes(value) {
     return new Uint8Array(Buffer.from(value.replace(/-/g, "+").replace(/_/g, "/"), "base64"));
 }
+/** base64url-encode (utf8) — used for the ThaiFiAgent credential header. */
+export function b64uEncode(s) {
+    return Buffer.from(s, "utf8")
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+/** Parse a `WWW-Authenticate: ThaiFiAgent realm="…", challenge="<b64u>"`
+ *  header — ThaiFi Agent Auth (identity proof, no payment). */
+export function parseAgentChallenge(header) {
+    const m = /^ThaiFiAgent\s+(.+)$/i.exec(header.trim());
+    if (!m)
+        return null;
+    const params = {};
+    const re = /([a-zA-Z]+)=((?:"((?:[^"\\]|\\.)*)")|[^\s,]+)/g;
+    let pm;
+    while ((pm = re.exec(m[1]))) {
+        const value = pm[3] !== undefined ? pm[3].replace(/\\(.)/g, "$1") : pm[2];
+        params[pm[1].toLowerCase()] = value;
+    }
+    if (!params.realm || !params.challenge)
+        return null;
+    return { realm: params.realm, nonce: params.challenge };
+}
 export function agentAuthHash(params) {
     const bodyHash = params.body && params.body.length > 0 ? sha256(stringToBytes(params.body)) : ZERO_BODY_HASH;
     return keccak256(concatHex([

package/dist/chain.js

@@ -3,14 +3,14 @@ import { http, defineChain } from "viem";
 import { createClient, tempoActions } from "viem/tempo";
 import { Actions, Account, Addresses, Chain as TempoChains } from "viem/tempo";
 import { CONFIG } from "./config.js";
-import { PATHUSD, TOKENS } from "./tokens.js";
+import { PATHTHB, TOKENS } from "./tokens.js";
 /** ThaiFi chain 17 — clone of the tempo chain definition (formatters/serializers) with our ids. */
 export const thaiFi = defineChain({
     ...TempoChains.mainnet,
     id: CONFIG.chainId,
     name: "ThaiFi",
     network: "thaifi",
-    nativeCurrency: { name: "pathUSD", symbol: "pathUSD", decimals: 6 },
+    nativeCurrency: { name: "pathTHB", symbol: "pathTHB", decimals: 6 },
     rpcUrls: { default: { http: [CONFIG.rpcUrl] } },
     blockExplorers: {
         default: { name: "ThaiFi Explorer", url: "https://exp.thaifi.com" },
@@ -34,8 +34,8 @@ export function createAgentClient(store, feeToken) {
 /** Min balance that makes a token usable as gas (~0.01; gas ≈ 0.003/tx). */
 const GAS_MIN_UNITS = 10000n;
 /**
- * Pick the gas token by balance: pathUSD → THCFI → THCOC. The chain swaps the
- * chosen token to the validator's pathUSD through the protocol FeeAMM.
+ * Pick the gas token by balance: pathTHB → THCFI → THCOC. The chain swaps the
+ * chosen token to the validator's pathTHB through the protocol FeeAMM.
  */
 export async function pickFeeToken(client, userAddress) {
     for (const t of TOKENS) {
@@ -43,7 +43,7 @@ export async function pickFeeToken(client, userAddress) {
         if (bal >= GAS_MIN_UNITS)
             return t;
     }
-    return PATHUSD;
+    return PATHTHB;
 }
 export async function tokenBalance(client, token, address) {
     return client.readContract({

package/dist/commands/deposit.js

@@ -0,0 +1,213 @@
+/** `thaifi deposit` — PromptPay QR top-up (1 THB = 1 token).
+ *
+ * Creates a QR order on wallet.thaifi.com and waits until the tokens are
+ * minted. Auth is ThaiFi Agent Auth (no API key): the backend verifies
+ * on-chain (AccountKeychain precompile) that this agent's access key belongs
+ * to a wallet and credits THAT wallet — the CLI never sends a recipient.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import png from "pngjs";
+import * as jsqrModule from "jsqr";
+import qrcodeTerminal from "qrcode-terminal";
+import { loadStore, storePath } from "../store.js";
+import { CONFIG } from "../config.js";
+import { b64uEncode, buildAgentAuthCredential, parseAgentChallenge, } from "../agentAuth.js";
+import { openBrowser } from "./fund.js";
+const ORDER_PATH = "/api/agent/deposit/qr";
+const MIN_THB = 6;
+const MAX_THB = 10000;
+/** Orders expire after 15 min, but a late payment still delivers — keep
+ *  watching that long past expiry. */
+const LATE_GRACE_MS = 15 * 60 * 1000;
+const TERMINAL_STATUSES = new Set(["delivered", "cancelled", "capped", "qr_error"]);
+const { PNG } = png;
+// NodeNext misbinds jsqr's CJS `export default` to the whole module namespace
+// when importing from ESM; at runtime the namespace's `.default` IS the
+// function (verified) — pick it with an explicit cast.
+const jsQR = jsqrModule.default;
+const STATUS_HINTS = {
+    pending: "scan the QR to pay",
+    paid: "payment received — minting",
+    delivering: "minting tokens",
+    delivered: "tokens are in the wallet",
+    cancelled: "order was cancelled",
+    capped: "over the daily cap — needs operator review",
+    qr_error: "QR creation failed",
+};
+// ---------------------------------------------------------------- HTTP + TAA
+/** fetch with automatic ThaiFi Agent Auth: on a 401/403 challenge, sign with
+ *  the agent access key (identity proof, no payment) and retry once. The
+ *  server verifies the key against the AccountKeychain precompile. */
+async function agentFetch(store, url, init) {
+    const headers = {};
+    if (init.body !== undefined)
+        headers["Content-Type"] = "application/json";
+    let res = await fetch(url, { method: init.method, headers, body: init.body });
+    if (res.status === 401 || res.status === 403) {
+        const challenge = parseAgentChallenge(res.headers.get("www-authenticate") ?? "");
+        if (challenge) {
+            const credential = await buildAgentAuthCredential(store, challenge, {
+                method: init.method,
+                url,
+                body: init.body,
+            });
+            res = await fetch(url, {
+                method: init.method,
+                headers: {
+                    ...headers,
+                    Authorization: "ThaiFiAgent " + b64uEncode(JSON.stringify(credential)),
+                },
+                body: init.body,
+            });
+        }
+    }
+    return res;
+}
+// ------------------------------------------------------------------ QR output
+/** Decode the payso QR PNG and re-render it as terminal blocks so a human
+ *  watching the session can scan straight off the screen. Best-effort. */
+function renderTerminalQr(dataUrl) {
+    try {
+        const b64 = dataUrl.slice(dataUrl.indexOf(",") + 1);
+        const img = PNG.sync.read(Buffer.from(b64, "base64"));
+        const decoded = jsQR(new Uint8ClampedArray(img.data), img.width, img.height);
+        if (!decoded?.data)
+            return;
+        console.log("");
+        qrcodeTerminal.generate(decoded.data, { small: true });
+        console.log("");
+    }
+    catch {
+        // terminal rendering is a convenience — the saved PNG always works
+    }
+}
+/** Save the QR image to ~/.thaifi/qr-<referenceNo>.<ext> (chmod 600) so the
+ *  agent has a durable path to show the user. Returns the path or null. */
+function saveQrImage(dataUrl, referenceNo) {
+    try {
+        const m = /^data:image\/(png|jpe?g|webp);base64,(.+)$/s.exec(dataUrl);
+        if (!m)
+            return null;
+        const ext = m[1] === "jpeg" ? "jpg" : m[1];
+        const dir = dirname(storePath);
+        const file = join(dir, `qr-${referenceNo}.${ext}`);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(file, Buffer.from(m[2], "base64"), { mode: 0o600 });
+        return file;
+    }
+    catch {
+        return null;
+    }
+}
+// --------------------------------------------------------------------- polling
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Poll the order until a terminal status (or the late-payment grace runs
+ *  out). Prints STATUS=/TX= lines — machine-parsable like `PAIR_URL=`. */
+async function watchOrder(store, orderUrl, order, options) {
+    const statusUrl = `${orderUrl}/${order.referenceNo}`;
+    const deadline = (order.expiresAt || Date.now()) + LATE_GRACE_MS;
+    let last = "";
+    while (Date.now() < deadline) {
+        const res = await agentFetch(store, statusUrl, { method: "GET" });
+        const data = (await res.json().catch(() => null));
+        if (res.ok && data?.status && data.status !== last) {
+            last = data.status;
+            if (options.json) {
+                const { image, ...rest } = data;
+                console.log(JSON.stringify(rest, null, 2));
+            }
+            else {
+                const hint = STATUS_HINTS[data.status];
+                console.log(`STATUS=${data.status}${hint ? `  (${hint})` : ""}`);
+            }
+            if (data.status === "delivered" && data.txHash && !options.json) {
+                console.log(`TX=${data.txHash}`);
+                console.log(`Explorer: https://exp.thaifi.com/tx/${data.txHash}`);
+            }
+            if (TERMINAL_STATUSES.has(data.status)) {
+                if (data.status !== "delivered")
+                    process.exitCode = 1;
+                return;
+            }
+        }
+        await sleep(CONFIG.pollIntervalMs);
+    }
+    console.error("Timed out waiting for payment. Payment after expiry still delivers — resume later with:");
+    console.error(`  thaifi deposit --ref ${order.referenceNo}`);
+    process.exitCode = 1;
+}
+export async function deposit(options = {}) {
+    const store = loadStore();
+    if (!store?.userAddress) {
+        console.error("Not paired. Run `thaifi login` first.");
+        process.exitCode = 1;
+        return;
+    }
+    // CONFIG (env THAIFI_WALLET_URL > default) — same precedence as `login`,
+    // NOT store.walletUrl: a stale value would silently hit the wrong host.
+    const base = (process.env.THAIFI_WALLET_URL || CONFIG.walletUrl).replace(/\/+$/, "");
+    const orderUrl = base + ORDER_PATH;
+    // --ref: watch an existing order (e.g. after a restart) instead of creating one.
+    if (options.ref) {
+        const res = await agentFetch(store, `${orderUrl}/${options.ref.trim()}`, { method: "GET" });
+        const data = (await res.json().catch(() => null));
+        if (!res.ok || !data?.referenceNo) {
+            console.error(`${res.status}: ${data?.error ?? res.statusText}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!options.json) {
+            console.log(`REFERENCE=${data.referenceNo}`);
+            console.log(`AMOUNT=${data.total} THB -> ${data.token ?? "?"}`);
+        }
+        await watchOrder(store, orderUrl, data, options);
+        return;
+    }
+    const token = (options.token ?? "THCFI").toUpperCase();
+    if (token !== "THCFI" && token !== "THCOC") {
+        console.error("--token must be THCFI or THCOC");
+        process.exitCode = 1;
+        return;
+    }
+    const amount = Number(options.amount);
+    if (!options.amount || !Number.isFinite(amount) || amount < MIN_THB || amount > MAX_THB) {
+        console.error(`--amount must be ${MIN_THB}-${MAX_THB} THB`);
+        process.exitCode = 1;
+        return;
+    }
+    const body = JSON.stringify({ amount, token });
+    const res = await agentFetch(store, orderUrl, { method: "POST", body });
+    const data = (await res.json().catch(() => null));
+    if (!res.ok || !data?.referenceNo) {
+        console.error(`${res.status}: ${data?.error ?? res.statusText}`);
+        if (data?.detail && typeof data.detail === "object") {
+            console.error(JSON.stringify(data.detail).slice(0, 400));
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const file = data.image ? saveQrImage(data.image, data.referenceNo) : null;
+    if (options.json) {
+        const { image, ...rest } = data;
+        console.log(JSON.stringify({ ...rest, qrFile: file }, null, 2));
+    }
+    else {
+        console.log(`PromptPay deposit — ${data.total} THB -> ${token} (1 THB = 1 token)`);
+        console.log(`Credited wallet: ${store.userAddress}`);
+        if (data.image)
+            renderTerminalQr(data.image);
+        if (file)
+            console.log(`QR_FILE=${file}`);
+        console.log(`REFERENCE=${data.referenceNo}`);
+        console.log(`AMOUNT=${data.total} THB -> ${token}`);
+        console.log(`RESUME=thaifi deposit --ref ${data.referenceNo}`);
+        console.log("");
+        console.log("Scan the QR with any banking app — polling until the tokens are minted");
+        console.log("(Ctrl-C to stop; resume with the RESUME command above).");
+    }
+    if (file && options.open !== false) {
+        await openBrowser("file://" + file);
+    }
+    await watchOrder(store, orderUrl, data, options);
+}

package/dist/commands/fund.js

@@ -1,6 +1,6 @@
 /** `thaifi fund` — show the deposit address and open the web Deposit page. */
 import { loadStore } from "../store.js";
-async function openBrowser(url) {
+export async function openBrowser(url) {
     const { exec } = await import("node:child_process");
     const cmd = process.platform === "darwin"
         ? `open "${url}"`

package/dist/commands/login.js

@@ -161,7 +161,7 @@ export async function login(options = {}) {
     console.log("  Wallet account: " + status.userAddress);
     console.log("  Spend limit:    " +
         Number(status.limitAmount ?? 0) / 10 ** 6 +
-        " pathUSD / " +
+        " pathTHB / " +
         Math.round((status.limitPeriod ?? 0) / 86400) +
         " days (THCFI/THCOC limits set at approval)");
     console.log("  Key expires:    " + (status.expiry ? new Date(status.expiry * 1000).toISOString() : "never"));

package/dist/commands/mcp.js

@@ -0,0 +1,161 @@
+/**
+ * `thaifi mcp` — stdio MCP server that exposes every paid service in the
+ * ThaiFi MPP catalog (mpp.thaifi.com /services) as MCP tools, paying per call
+ * with the agent access key already paired on this machine.
+ *
+ * Tools are generated from the live registry: `POST` services get an
+ * inputSchema from the catalog's `requestBody`; tool calls go through
+ * paidFetch, which pays 402 challenges automatically (the on-chain access-key
+ * spending limit still applies). THAIFI_MCP_MAX_SPEND (USD, default 5) caps
+ * every call on top.
+ *
+ * stdout carries only JSON-RPC — everything else goes to stderr.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { paidFetch, fmtAmount } from "../paidFetch.js";
+import { loadStore } from "../store.js";
+const err = (msg) => {
+    console.error(msg);
+};
+function registryUrl() {
+    return (process.env.THAIFI_MPP_REGISTRY ?? "https://mpp.thaifi.com").replace(/\/+$/, "");
+}
+async function fetchCatalog() {
+    const res = await fetch(registryUrl() + "/services", {
+        headers: { "user-agent": "thaifi-wallet-cli-mcp" },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok)
+        throw new Error(`Registry returned HTTP ${res.status} for GET ${registryUrl()}/services`);
+    const body = (await res.json());
+    return (body.services ?? []).filter((s) => s.auth === "mpp");
+}
+/** Convert a JSON-schema property to a zod shape (registerTool takes zod). */
+function propToZod(prop) {
+    const desc = typeof prop.description === "string" ? prop.description : undefined;
+    switch (prop.type) {
+        case "string": {
+            let s = z.string();
+            if (desc)
+                s = s.describe(desc);
+            return s;
+        }
+        case "number":
+        case "integer": {
+            let n = z.number();
+            if (desc)
+                n = n.describe(desc);
+            return n;
+        }
+        case "boolean":
+            return z.boolean();
+        case "array":
+            return z.array(z.any());
+        default:
+            return z.any();
+    }
+}
+/** Build a zod shape from the catalog's requestBody JSON schema. */
+function zodFromSchema(schema) {
+    if (!schema || schema.type !== "object" || typeof schema.properties !== "object")
+        return {};
+    const shape = {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    for (const [key, rawProp] of Object.entries(schema.properties)) {
+        const zt = propToZod(rawProp);
+        shape[key] = required.includes(key) ? zt : zt.optional();
+    }
+    return shape;
+}
+/** Translate a tool call into the registry request. GET tools accept no args. */
+function requestFor(svc, input) {
+    const url = registryUrl() + svc.path;
+    if (svc.method === "GET")
+        return { url, method: "GET" };
+    const bodyObj = svc.requestBody
+        ? input
+        : Object.keys(input).length === 0
+            ? undefined
+            : { body: input };
+    return { url, method: "POST", body: bodyObj ? JSON.stringify(bodyObj) : undefined };
+}
+export async function mcp() {
+    const store = loadStore();
+    if (!store?.userAddress || !store?.privateKey) {
+        // Not fatal for list-tools — but tell the operator loudly on stderr.
+        err("thaifi mcp: not paired — tools will refuse to pay until `thaifi login` completes.");
+    }
+    const maxSpend = BigInt(Math.max(1, Math.round(Number(process.env.THAIFI_MCP_MAX_SPEND || 5))) * 1_000_000);
+    const server = new McpServer({ name: "thaifi", version: "0.5.0" }, { capabilities: { tools: {} } });
+    let catalog = [];
+    try {
+        catalog = await fetchCatalog();
+    }
+    catch (e) {
+        err(`thaifi mcp: could not load service catalog (${e instanceof Error ? e.message : String(e)}).`);
+        err("Tools will be registered once the catalog is reachable — restarting the MCP server retries it.");
+    }
+    for (const svc of catalog) {
+        const toolName = `thaifi_${svc.id}`.replace(/[^a-zA-Z0-9_]/g, "_");
+        const shape = svc.method === "GET" ? {} : zodFromSchema(svc.requestBody);
+        server.tool(toolName, `${svc.title} — ${svc.description} [price: ${svc.price}]`, shape, async (input) => {
+            const req = requestFor(svc, input);
+            const result = await paidFetch(req.url, {
+                method: req.method,
+                body: req.body,
+                maxSpend,
+                log: (m) => err(`thaifi mcp [${toolName}]: ${m}`),
+            });
+            const content = [];
+            let parsed = null;
+            try {
+                parsed = JSON.parse(result.text);
+            }
+            catch { /* not JSON */ }
+            const b64 = parsed?.image_base64 ?? parsed?.data?.image_base64;
+            if (typeof b64 === "string" && b64.length > 1000) {
+                const mime = String(parsed?.mime_type ?? parsed?.data?.mime_type ?? "image/png");
+                content.push({ type: "image", data: b64, mimeType: mime });
+                try {
+                    const { writeFileSync } = await import("node:fs");
+                    const id = String(parsed?.id ?? parsed?.data?.id ?? Date.now()).toString().replace(/[^\w-]/g, "");
+                    const ext = mime.includes("webp") ? "webp" : mime.includes("jpeg") ? "jpg" : "png";
+                    writeFileSync(`image-${id}.${ext}`, Buffer.from(b64, "base64"));
+                }
+                catch { /* saving is best-effort */ }
+            }
+            if (result.unpaid402) {
+                return { isError: true, content: [{ type: "text", text: `Unpaid (402): ${result.unpaid402}\nPair this machine with \`thaifi login\` and raise THAIFI_MCP_MAX_SPEND if needed.` }] };
+            }
+            if (result.status >= 400) {
+                content.push({ type: "text", text: `HTTP ${result.status}: ${result.text.slice(0, 2000)}` });
+                if (result.payment) {
+                    content.push({ type: "text", text: `Note: payment of ${fmtAmount(result.payment.amount, 6)} was already broadcast (tx ${result.payment.hash}) — the operator may refund.` });
+                }
+                return { isError: true, content };
+            }
+            content.push({ type: "text", text: result.text.slice(0, 200_000) });
+            return { content };
+        });
+    }
+    server.tool("thaifi_spend_cap", "Show the current per-call spend cap (THAIFI_MCP_MAX_SPEND) and whether this machine is paired.", {}, async () => ({
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    paired: Boolean(loadStore()?.userAddress),
+                    wallet: loadStore()?.userAddress ?? null,
+                    registry: registryUrl(),
+                    max_spend_per_call: `${fmtAmount(maxSpend, 6)} THCFI`,
+                    env: "THAIFI_MCP_MAX_SPEND (USD)",
+                }, null, 2),
+            },
+        ],
+    }));
+    err(`thaifi mcp: ${catalog.length} tools from ${registryUrl()} (max spend ${fmtAmount(maxSpend, 6)}/call, wallet ${store?.userAddress ?? "not paired"})`);
+    await server.connect(new StdioServerTransport());
+    // Keep the process alive while the transport is open.
+    await new Promise(() => { });
+}

package/dist/commands/request.js

@@ -2,23 +2,16 @@
 import { concatHex, keccak256, slice, stringToBytes } from "viem";
 import { loadStore } from "../store.js";
 import { createAgentClient, pickFeeToken } from "../chain.js";
-import { buildAgentAuthCredential } from "../agentAuth.js";
+import { b64uEncode, buildAgentAuthCredential, parseAgentChallenge, } from "../agentAuth.js";
 import { CONFIG, PATHUSD_DECIMALS } from "../config.js";
 import { PATHUSD, resolveToken } from "../tokens.js";
-function b64uDecode(s) {
-    return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
-}
-function b64uEncode(s) {
-    return Buffer.from(s, "utf8")
-        .toString("base64")
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=+$/, "");
-}
 /**
  * Parse an MPP `WWW-Authenticate: Payment id="…", request="<b64u json>"` header.
  * See https://mpp.dev — Machine Payments Protocol.
  */
+function b64uDecode(s) {
+    return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+}
 export function parseMppChallenge(header) {
     const m = /^Payment\s+(.+)$/i.exec(header.trim());
     if (!m)
@@ -53,26 +46,6 @@ export function parseMppChallenge(header) {
         challenge.expires = params.expires;
     return challenge;
 }
-/**
- * Parse a `WWW-Authenticate: ThaiFiAgent realm="…", challenge="<b64u>"`
- * header — ThaiFi Agent Auth (identity proof, no payment). The server
- * verifies our signature against the AccountKeychain precompile.
- */
-function parseAgentChallenge(header) {
-    const m = /^ThaiFiAgent\s+(.+)$/i.exec(header.trim());
-    if (!m)
-        return null;
-    const params = {};
-    const re = /([a-zA-Z]+)=((?:"((?:[^"\\]|\\.)*)")|[^\s,]+)/g;
-    let pm;
-    while ((pm = re.exec(m[1]))) {
-        const value = pm[3] !== undefined ? pm[3].replace(/\\(.)/g, "$1") : pm[2];
-        params[pm[1].toLowerCase()] = value;
-    }
-    if (!params.realm || !params.challenge)
-        return null;
-    return { realm: params.realm, nonce: params.challenge };
-}
 /** MPP tempo charge → on-chain TIP-20 transfer (push mode: we broadcast, then send the hash). */
 function mppTempoChallenge(challenge) {
     const req = challenge.request;

package/dist/config.js

@@ -3,10 +3,10 @@ export const CONFIG = {
     rpcUrl: process.env.THAIFI_RPC_URL ?? "https://rpc.thaifi.com",
     walletUrl: process.env.THAIFI_WALLET_URL ?? "https://wallet.thaifi.com",
     chainId: Number(process.env.THAIFI_CHAIN_ID ?? 17),
-    /** pathUSD — ThaiFi fee/stable token (TIP-20, 6 decimals). */
+    /** pathTHB — ThaiFi fee/stable token (TIP-20, 6 decimals). */
     pathUsd: (process.env.THAIFI_PATHUSD ??
         "0x20c0000000000000000000000000000000000000"),
-    /** Default spending limit: 100 pathUSD. */
+    /** Default spending limit: 100 pathTHB. */
     defaultLimit: 100n * 10n ** 6n,
     /** Default limit period: 30 days (seconds). */
     defaultPeriod: 60 * 60 * 24 * 30,

package/dist/index.js

@@ -9,7 +9,9 @@ import { balance } from "./commands/balance.js";
 import { transfer } from "./commands/transfer.js";
 import { request } from "./commands/request.js";
 import { services } from "./commands/services.js";
+import { mcp } from "./commands/mcp.js";
 import { fund } from "./commands/fund.js";
+import { deposit } from "./commands/deposit.js";
 import { tokens } from "./commands/tokens.js";
 // Resolve ../package.json at runtime (works from src/ via tsx and from dist/ when installed) — never hardcode the version here again.
 const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -38,21 +40,30 @@ program
 program
     .command("balance")
     .description("Show TIP-20 token balances of the paired account")
-    .option("--token <symbol|address>", "Token symbol (pathUSD, THCFI, THCOC) or contract address (default: all)")
+    .option("--token <symbol|address>", "Token symbol (pathTHB, THCFI, THCOC) or contract address (default: all)")
     .action(balance);
 program
     .command("transfer")
     .description("Transfer tokens signed by the agent access key (spend limit enforced on-chain)")
     .argument("<to>", "Recipient address (0x…)")
     .argument("<amount>", "Amount in human units (e.g. 1.5)")
-    .option("--token <symbol|address>", "Token symbol or contract address (default: pathUSD)")
-    .option("--fee-token <symbol|address>", "Gas token (default: auto — pathUSD, else THCFI/THCOC by balance)")
+    .option("--token <symbol|address>", "Token symbol or contract address (default: pathTHB)")
+    .option("--fee-token <symbol|address>", "Gas token (default: auto — pathTHB, else THCFI/THCOC by balance)")
     .action(transfer);
 program
     .command("fund")
     .description("Show your deposit address and open the web Deposit page")
     .option("--no-browser", "Print the address without opening a browser")
     .action(fund);
+program
+    .command("deposit")
+    .description("PromptPay QR top-up (1 THB = 1 token): create a QR order, show it for the user to scan, and wait until the tokens are minted")
+    .option("--amount <thb>", "Amount in THB (6-10000)")
+    .option("--token <symbol>", "Payout token: THCFI (default) or THCOC")
+    .option("--ref <referenceNo>", "Watch an existing order instead of creating a new one")
+    .option("--no-open", "Do not open the saved QR image in a viewer")
+    .option("--json", "Machine-readable output (JSON)")
+    .action(deposit);
 program
     .command("request")
     .description("HTTP request with automatic x402/MPP payments (curl-like)")
@@ -63,7 +74,7 @@ program
     .option("--json <json>", "JSON body shorthand (sets method POST + content-type)")
     .option("--dry-run", "Print the request without sending")
     .option("--max-spend <usd>", "Maximum automatic payment (USD)", Number)
-    .option("--fee-token <symbol|address>", "Gas token for the payment tx (default: auto — pathUSD, else THCFI/THCOC by balance)")
+    .option("--fee-token <symbol|address>", "Gas token for the payment tx (default: auto — pathTHB, else THCFI/THCOC by balance)")
     .action(async (url, opts) => {
     const headers = {};
     for (const h of opts.header ?? []) {
@@ -91,4 +102,8 @@ program
     .description("Discover paid services from the MPP/x402 registry")
     .option("--search <query>", "Search services")
     .action(services);
+program
+    .command("mcp")
+    .description("Run a stdio MCP server exposing all MPP catalog services as tools (pays with the paired access key)")
+    .action(mcp);
 program.parseAsync();

package/dist/paidFetch.js

@@ -0,0 +1,256 @@
+/**
+ * HTTP fetch that pays MPP challenges with the paired agent access key.
+ *
+ * Same wire logic as `thaifi request` (src/commands/request.ts is the
+ * reference implementation, kept untouched) but as a quiet, programmable
+ * function used by `thaifi mcp` — no stdout logging, returns a result object.
+ *
+ * Flow (MPP tempo charge, push mode):
+ *   1. normal fetch; if not 402 → return as-is
+ *   2. parse the `WWW-Authenticate: Payment …` challenge (x402 legacy fallback)
+ *   3. broadcast the TIP-20 transfer ourselves (memo-bound to the challenge)
+ *   4. retry with `Authorization: Payment <base64url credential>`
+ */
+import { keccak256, slice, stringToBytes, concatHex } from "viem";
+import { loadStore } from "./store.js";
+import { CONFIG, PATHUSD_DECIMALS } from "./config.js";
+import { createAgentClient, pickFeeToken } from "./chain.js";
+import { b64uEncode } from "./agentAuth.js";
+/** b64url → bytes (mirrors agentAuth's internal helper, which is not exported). */
+function b64uDecodeBytes(value) {
+    return new Uint8Array(Buffer.from(value.replace(/-/g, "+").replace(/_/g, "/"), "base64"));
+}
+// ── MPP attribution memo (32 bytes) per mppx Attribution encoding ─────────
+// tag = keccak256("mpp") [0..4 bytes], MPP protocol version 0x10,
+// serverId = realm fingerprint, clientId = "thaifi-wallet-cli" fingerprint,
+// nonce = keccak256(challengeId) [0..7 bytes].
+// Required by servers that don't pre-assign a memo to the challenge.
+const MPP_TAG = slice(keccak256(stringToBytes("mpp")), 0, 4);
+const fingerprint = (value) => slice(keccak256(stringToBytes(value)), 0, 10);
+function attributionMemo(realm, challengeId) {
+    return concatHex([
+        MPP_TAG,
+        "0x10",
+        fingerprint(realm),
+        fingerprint("thaifi-wallet-cli"),
+        slice(keccak256(stringToBytes(challengeId)), 0, 7),
+    ]);
+}
+function storeAddress() {
+    const store = loadStore();
+    return store?.userAddress ?? "0x0";
+}
+function parseMppChallenge(header) {
+    // mppx emits scheme "Payment" (some servers use "MPP") — both are the same param set.
+    const m = /^(?:Payment|MPP)\s+(.+)$/i.exec(header.trim());
+    if (!m)
+        return null;
+    const params = {};
+    const re = /([a-zA-Z]+)=(?:"((?:[^"\\]|\\.)*)"|([^\s,]+))/g;
+    let pm;
+    while ((pm = re.exec(m[1]))) {
+        const value = pm[3] !== undefined ? pm[3] : pm[2] !== undefined ? pm[2].replace(/\\(.)/g, "$1") : "";
+        params[pm[1].toLowerCase()] = value;
+    }
+    if (!params.request || !params.realm)
+        return null;
+    let request;
+    try {
+        request = JSON.parse(Buffer.from(b64uDecodeBytes(params.request)).toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+    const challenge = {
+        id: params.id,
+        realm: params.realm ?? "",
+        method: params.method ?? "tempo",
+        intent: params.intent ?? "charge",
+        request,
+        requestRaw: params.request,
+    };
+    if (params.expires !== undefined)
+        challenge.expires = params.expires;
+    if (params.opaque !== undefined)
+        challenge.opaque = params.opaque;
+    return challenge;
+}
+/** MPP tempo charge → on-chain TIP-20 transfer (push mode: we broadcast, then send the hash). */
+function mppTempoChallenge(challenge) {
+    const req = challenge.request;
+    if (!req?.amount || !req?.recipient)
+        return null;
+    const amount = BigInt(req.amount);
+    // mppx omits `decimals` for pathTHB-denominated challenges.
+    const decimals = req.decimals ?? 6;
+    return {
+        payTo: req.recipient,
+        amount,
+        token: req.currency,
+        memo: req.memo ?? attributionMemo(challenge.realm, challenge.id),
+        decimals,
+        proofHeader: (txHash) => {
+            // Write format: challenge.request is the base64url string, not a re-sent object.
+            const credential = {
+                challenge: {
+                    id: challenge.id,
+                    realm: challenge.realm,
+                    method: challenge.method,
+                    intent: challenge.intent,
+                    request: challenge.requestRaw,
+                    ...(challenge.opaque !== undefined && { opaque: challenge.opaque }),
+                    ...(challenge.expires !== undefined && { expires: challenge.expires }),
+                },
+                payload: { type: "hash", hash: txHash },
+                source: `did:pkh:eip155:${CONFIG.chainId}:${storeAddress()}`,
+            };
+            return "Payment " + b64uEncode(JSON.stringify(credential));
+        },
+    };
+}
+/**
+ * Extract a payment challenge from a 402 response.
+ * MPP first (`WWW-Authenticate: Payment …`), legacy x402 JSON body as fallback.
+ */
+export async function parseChallenge(res, defaultToken) {
+    const wwwAuth = res.headers.get("www-authenticate");
+    if (wwwAuth) {
+        const mpp = parseMppChallenge(wwwAuth);
+        if (mpp && mpp.method === "tempo" && mpp.intent === "charge") {
+            const parsed = mppTempoChallenge(mpp);
+            if (parsed)
+                return parsed;
+        }
+        let body = null;
+        try {
+            body = await res.json();
+        }
+        catch {
+            body = null;
+        }
+        const accept = body?.payments?.[0] ?? body?.accepts?.[0] ?? body;
+        const payTo = accept?.payTo ?? accept?.payToAddress ?? accept?.recipient;
+        const maxAmount = accept?.maxAmountRequired ?? accept?.amount ?? accept?.price;
+        if (!payTo || maxAmount === undefined)
+            return null;
+        const amount = typeof maxAmount === "string" && /^\d+$/.test(maxAmount)
+            ? BigInt(maxAmount)
+            : BigInt(Math.round(Number(maxAmount) * 10 ** PATHUSD_DECIMALS));
+        return {
+            payTo,
+            amount,
+            token: accept?.asset ?? accept?.token ?? defaultToken,
+            decimals: PATHUSD_DECIMALS,
+            proofHeader: (txHash) => Buffer.from(JSON.stringify({
+                scheme: "exact",
+                txHash,
+                from: storeAddress(),
+                to: payTo,
+                amount: "0x" + amount.toString(16),
+                token: accept?.asset ?? accept?.token ?? defaultToken,
+            })).toString("base64"),
+        };
+    }
+    return null;
+}
+/** Format the challenge amount for humans (uses the challenge's own decimals). */
+export function fmtAmount(amount, decimals) {
+    const base = 10n ** BigInt(decimals);
+    const whole = amount / base;
+    const frac = amount % base;
+    return frac === 0n ? whole.toString() : `${whole}.${frac.toString().padStart(decimals, "0")}`.replace(/0+$/, "").replace(/\.$/, "");
+}
+/**
+ * Fetch with automatic MPP payment. Payment is signed locally by the agent
+ * access key and enforced on-chain by the AccountKeychain precompile.
+ */
+export async function paidFetch(url, opts = {}) {
+    const log = opts.log ?? (() => { });
+    const store = loadStore();
+    if (!store?.userAddress || !store?.privateKey) {
+        return unpaid402(url, "Not paired — run `thaifi login` first.", opts.log);
+    }
+    const method = opts.method ?? "GET";
+    const res = await fetch(url, {
+        method,
+        headers: {
+            "user-agent": "thaifi-wallet-cli",
+            ...(opts.body !== undefined ? { "content-type": "application/json" } : {}),
+            ...opts.headers,
+        },
+        body: opts.body,
+    });
+    const contentType = res.headers.get("content-type");
+    if (res.status !== 402) {
+        return { status: res.status, contentType, text: await res.text() };
+    }
+    // 402 Payment Required — parse the challenge and pay it.
+    const challenge = await parseChallenge(res.clone(), CONFIG.pathUsd);
+    if (!challenge) {
+        const snippet = (await res.text()).slice(0, 400);
+        return unpaid402(url, `402 Payment Required — could not parse the challenge. ${snippet}`, opts.log);
+    }
+    if (opts.maxSpend !== undefined && challenge.amount > opts.maxSpend) {
+        return unpaid402(url, `Quote ${fmtAmount(challenge.amount, challenge.decimals ?? 6)} exceeds this session's max spend (${fmtAmount(opts.maxSpend, 6)}) — refusing to pay.`, opts.log);
+    }
+    const token = (challenge.token ?? CONFIG.pathUsd);
+    log(`Paying ${fmtAmount(challenge.amount, challenge.decimals ?? 6)} (base ${challenge.amount}) to ${challenge.payTo}…`);
+    // pickFeeToken needs a client; probe with the pathTHB default, then re-create
+    // the agent client with the chosen fee token (chain FeeAMM swaps it to the
+    // validator's pathTHB).
+    let feeToken;
+    try {
+        if (opts.feeToken) {
+            feeToken = opts.feeToken;
+        }
+        else {
+            const probe = createAgentClient(store, CONFIG.pathUsd);
+            const info = await pickFeeToken(probe, store.userAddress);
+            feeToken = info.address;
+        }
+    }
+    catch (err) {
+        return unpaid402(url, `Could not pick a gas token: ${err instanceof Error ? err.message : String(err)}`, opts.log);
+    }
+    const client = createAgentClient(store, feeToken);
+    let hash;
+    try {
+        hash = await client.token.transfer({
+            to: challenge.payTo,
+            amount: challenge.amount,
+            token,
+            memo: challenge.memo,
+        });
+    }
+    catch (err) {
+        return unpaid402(url, `Payment transaction failed: ${err instanceof Error ? err.message : String(err)}`, opts.log);
+    }
+    log(`Payment tx ${hash} — waiting for receipt…`);
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success") {
+        log(`⚠️ Payment transaction reverted: ${hash}`);
+        return { status: res.status, contentType, text: "Payment transaction reverted — no charge applied.", payment: undefined, unpaid402: `reverted: ${hash}` };
+    }
+    const retry = await fetch(url, {
+        method,
+        headers: {
+            "user-agent": "thaifi-wallet-cli",
+            ...(opts.body !== undefined ? { "content-type": "application/json" } : {}),
+            ...opts.headers,
+            authorization: challenge.proofHeader(hash),
+        },
+        body: opts.body,
+    });
+    const retryText = await retry.text();
+    log(`Paid. Retry → HTTP ${retry.status}`);
+    return {
+        status: retry.status,
+        contentType: retry.headers.get("content-type"),
+        text: retryText,
+        payment: { token, amount: challenge.amount, hash },
+    };
+}
+function unpaid402(url, message, log) {
+    log?.(message);
+    return { status: 402, contentType: null, text: JSON.stringify({ error: "unpaid", detail: message }), unpaid402: message };
+}

package/dist/tokens.js

@@ -1,9 +1,9 @@
 /** TIP-20 tokens surfaced by the CLI — all ThaiFi TIP-20s use 6 decimals. */
 import { CONFIG } from "./config.js";
-export const PATHUSD = {
+export const PATHTHB = {
     address: CONFIG.pathUsd,
-    symbol: "pathUSD",
-    name: "pathUSD",
+    symbol: "pathTHB",
+    name: "pathTHB",
     decimals: 6,
 };
 // System TIP-20 tokens (native factory, 2026-09-24) — can pay gas fees via
@@ -21,13 +21,17 @@ export const THCOC = {
     decimals: 6,
 };
 /** Tokens listed by `thaifi tokens` / shown by default in `thaifi balance`. */
-export const TOKENS = [PATHUSD, THCFI, THCOC];
+export const TOKENS = [PATHTHB, THCFI, THCOC];
+/** Pre-rename alias — old scripts using `pathUSD` still resolve. */
+export const PATHUSD = PATHTHB;
 /**
  * Resolve a token by symbol (case-insensitive) or 0x address. Addresses
  * outside the registry are treated as custom TIP-20s (6 decimals); the
  * symbol is read from the chain by the caller.
  */
 export function resolveToken(arg) {
+    if (arg.toLowerCase() === "pathusd")
+        return PATHTHB; // pre-rename alias
     const bySymbol = TOKENS.find((t) => t.symbol.toLowerCase() === arg.toLowerCase());
     if (bySymbol)
         return bySymbol;
@@ -37,5 +41,5 @@ export function resolveToken(arg) {
             return known;
         return { address: arg, symbol: "TOKEN", name: "Custom TIP-20", decimals: 6 };
     }
-    throw new Error(`Unknown token "${arg}" — use a symbol (pathUSD, THCFI, THCOC) or a 0x contract address.`);
+    throw new Error(`Unknown token "${arg}" — use a symbol (pathTHB, THCFI, THCOC) or a 0x contract address.`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thaifi-wallet-cli",
-  "version": "0.3.6",
+  "version": "0.5.0",
   "description": "ThaiFi Wallet CLI for AI agents — pair with wallet.thaifi.com, sign with on-chain access keys (spending limits enforced on-chain), x402/MPP payments",
   "type": "module",
   "bin": {
@@ -24,6 +24,7 @@
     "ai",
     "x402",
     "mpp",
+    "mcp",
     "tempo",
     "cli",
     "payments"
@@ -33,11 +34,17 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
     "commander": "^14.0.0",
-    "viem": "^2.56.0"
+    "jsqr": "^1.4.0",
+    "pngjs": "^7.0.0",
+    "qrcode-terminal": "^0.12.0",
+    "viem": "^2.56.0",
+    "zod": "^3.25.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.2",
+    "@types/pngjs": "^6.0.5",
     "tsx": "^4.19.0",
     "typescript": "^5.9.0"
   }