thaifi-wallet-cli 0.4.0 → 0.5.0

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/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/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,6 +9,7 @@ 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";
@@ -39,15 +40,15 @@ 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")
@@ -73,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 ?? []) {
@@ -101,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.4.0",
+  "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,13 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
     "commander": "^14.0.0",
     "jsqr": "^1.4.0",
     "pngjs": "^7.0.0",
     "qrcode-terminal": "^0.12.0",
-    "viem": "^2.56.0"
+    "viem": "^2.56.0",
+    "zod": "^3.25.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.2",