@molpha/mcp 0.1.0

package/dist/src/x402.js

@@ -0,0 +1,552 @@
+/**
+ * x402 self-funded pay-per-request client for `POST /v1/agent/execute` and
+ * `GET /v1/agent/{payer}/status`. The SDK has no x402 support (it only
+ * covers the subscription round path), so this talks to the gateway
+ * directly, mirroring the gateway's own Go implementation
+ * (gateway/internal/gateway/features/agentexec).
+ */
+import { createHash } from "node:crypto";
+import { address, getAddressEncoder, getProgramDerivedAddress } from "@solana/kit";
+import { findAssociatedTokenPda, getCreateAssociatedTokenIdempotentInstruction, getTransferInstruction, TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
+import { Transaction } from "@solana/web3.js";
+import { canonicalizeApiConfig, deriveApiConfigHash, deriveFeedIdString } from "./apiconfig.js";
+import { getMolphaProgramId, requireMethod } from "./clients.js";
+import {} from "./config.js";
+import { checkX402DailySpendCap, checkX402PerRoundCap, checkX402SpendCap, recordX402Spend } from "./guardrails.js";
+import { normalizeFeedId } from "./hex.js";
+import { requireSdkExport } from "./sdk.js";
+import { toLegacyInstruction, toLegacyPublicKey } from "./solana-compat.js";
+const AGENT_REQAUTH_PREFIX = "MOLPHA_AGENT_REQAUTH_V1";
+const MAX_ROUND_ATTEMPTS = 5;
+export class X402PaymentRequiredError extends Error {
+    status = 402;
+    x402;
+    constructor(message, x402) {
+        super(message);
+        this.name = "X402PaymentRequiredError";
+        this.x402 = x402;
+    }
+}
+/** In-memory cache of the settling gateway PDA per endpoint — revealed via status or a 402 body. */
+const gatewayPdaCache = new Map();
+/**
+ * Escrow PDA: `["molpha_agent", payer, gateway]`.
+ * Escrows are per (payer, gateway); the gateway seed is the settling gateway PDA.
+ */
+export async function deriveAgentEscrow(payer, gateway, programId) {
+    const encoder = getAddressEncoder();
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: [Buffer.from("molpha_agent"), Buffer.from(encoder.encode(payer)), Buffer.from(encoder.encode(gateway))]
+    });
+    return pda;
+}
+/** Escrow USDC ATA (associated token account owned by the agent escrow PDA). */
+export async function deriveAgentEscrowAta(escrow, usdcMint) {
+    const [ata] = await findAssociatedTokenPda({
+        owner: escrow,
+        mint: usdcMint,
+        tokenProgram: TOKEN_PROGRAM_ADDRESS
+    });
+    return ata;
+}
+/**
+ * Treat a 402 `accepts[0]` as untrusted: derive escrow + USDC ATA, pin the mint
+ * to on-chain protocol config, and cap the transfer amount before signing.
+ */
+export async function verifyX402FundingAccept(accept, ctx) {
+    if (accept.extra.payer !== String(ctx.payer)) {
+        throw new Error(`x402 402 response payer mismatch: expected ${ctx.payer}, got ${accept.extra.payer}`);
+    }
+    const gateway = address(accept.extra.gateway);
+    if (ctx.knownGateway !== undefined && String(ctx.knownGateway) !== String(gateway)) {
+        throw new Error(`x402 402 response gateway mismatch: expected ${ctx.knownGateway}, got ${gateway}`);
+    }
+    const escrow = await deriveAgentEscrow(ctx.payer, gateway, ctx.programId);
+    if (accept.extra.agent !== String(escrow)) {
+        throw new Error(`x402 402 response agent (escrow) mismatch: expected derived ${escrow}, got ${accept.extra.agent}`);
+    }
+    if (accept.asset !== String(ctx.usdcMint)) {
+        throw new Error(`x402 402 response asset mismatch: expected protocol USDC mint ${ctx.usdcMint}, got ${accept.asset}`);
+    }
+    const escrowAta = await deriveAgentEscrowAta(escrow, ctx.usdcMint);
+    if (accept.payTo !== String(escrowAta)) {
+        throw new Error(`x402 402 response payTo mismatch: expected derived escrow ATA ${escrowAta}, got ${accept.payTo}`);
+    }
+    const roundPrice = BigInt(accept.extra.amount);
+    const fundAmount = BigInt(accept.maxAmountRequired);
+    checkX402PerRoundCap(roundPrice, ctx.maxPriceUsdcAtomic);
+    if (fundAmount > 0n) {
+        checkX402DailySpendCap(fundAmount, ctx.maxSpendPerDayUsdcAtomic);
+    }
+    if (fundAmount > roundPrice) {
+        throw new Error(`x402 402 response maxAmountRequired (${fundAmount}) exceeds round price extra.amount (${roundPrice})`);
+    }
+    return {
+        gateway,
+        escrow,
+        escrowAta,
+        usdcMint: ctx.usdcMint,
+        fundAmount,
+        roundPrice
+    };
+}
+/** Advisory status for one payer at this gateway. Escrow is derived server-side. */
+export async function fetchAgentStatus(config, payer, signaturesRequired) {
+    const path = `/v1/agent/${payer}/status?signatures_required=${signaturesRequired}`;
+    return getFirstReachable(config.gatewayEndpoints, path);
+}
+export async function agentFetch(ctx, opts) {
+    const { config, connection, signer, solana } = ctx;
+    const payer = signer.publicKey;
+    const apiConfig = canonicalizeApiConfig(opts.apiConfig);
+    const apiConfigHash = deriveApiConfigHash(apiConfig);
+    const expectedFeedId = deriveFeedIdString(payer, apiConfigHash, opts.signaturesRequired);
+    assertFeedIdMatch(expectedFeedId, opts.feedId);
+    const endpointKey = config.gatewayEndpoints[0] ?? "";
+    const programId = getMolphaProgramId();
+    const { usdcMint: usdcMintRaw } = await requireMethod(solana, "fetchProtocolTokens")();
+    const usdcMint = address(String(usdcMintRaw));
+    const registryVersion = await requireMethod(solana, "getRegistryVersion")();
+    // Status is advisory, so a failure must not abort the round — but it is the
+    // only source of the settling gateway PDA when nothing is pinned or cached,
+    // so keep the reason around for the error message that needs it.
+    let statusError;
+    const status = await fetchAgentStatus(config, payer, opts.signaturesRequired).catch((error) => {
+        statusError = error instanceof Error ? error.message : String(error);
+        return undefined;
+    });
+    let gatewayPda = config.x402.gatewayPda ?? gatewayPdaCache.get(endpointKey) ?? status?.gateway ?? undefined;
+    if (gatewayPda)
+        cacheGatewayPda(endpointKey, gatewayPda);
+    let priceAtomic = status ? BigInt(status.quotedNextPrice) : undefined;
+    let availableAtomic = status
+        ? bigIntMax(0n, BigInt(status.ataBalance) - BigInt(status.committedAmount))
+        : 0n;
+    let escrowStr = gatewayPda !== undefined
+        ? String(await deriveAgentEscrow(payer, address(gatewayPda), programId))
+        : "";
+    const fundingVerifyCtx = (knownGateway) => ({
+        payer,
+        programId,
+        usdcMint,
+        knownGateway,
+        maxPriceUsdcAtomic: config.x402.maxPriceUsdcAtomic,
+        maxSpendPerDayUsdcAtomic: config.x402.maxSpendPerDayUsdcAtomic
+    });
+    if (opts.dryRun) {
+        if (priceAtomic === undefined || gatewayPda === undefined) {
+            const discovery = await discover(config, {
+                payer,
+                apiConfig,
+                signaturesRequired: opts.signaturesRequired,
+                registryVersion,
+                timestamp: Math.floor(Date.now() / 1000)
+            });
+            if (discovery.kind === "already_funded") {
+                // The escrow covers the round; the 400 quote carries no addresses, so
+                // report whatever the pinned/cached gateway PDA can still derive.
+                const escrow = gatewayPda
+                    ? String(await deriveAgentEscrow(payer, address(gatewayPda), programId))
+                    : "unknown";
+                const ata = escrow !== "unknown"
+                    ? String(await deriveAgentEscrowAta(address(escrow), usdcMint))
+                    : "unknown";
+                checkX402PerRoundCap(discovery.roundPrice, config.x402.maxPriceUsdcAtomic);
+                return dryRunPreview(expectedFeedId, escrow, ata, discovery.roundPrice, discovery.roundPrice);
+            }
+            const verified = await verifyX402FundingAccept(discovery.accept, fundingVerifyCtx(gatewayPda));
+            assertFeedIdMatch(expectedFeedId, discovery.accept.extra.feedId);
+            cacheGatewayPda(endpointKey, String(verified.gateway));
+            availableAtomic = bigIntMax(0n, BigInt(discovery.accept.extra.currentAtaBalance) -
+                BigInt(discovery.accept.extra.committedAmount));
+            return dryRunPreview(expectedFeedId, String(verified.escrow), String(verified.escrowAta), verified.roundPrice, availableAtomic);
+        }
+        const escrowAta = escrowStr !== ""
+            ? String(await deriveAgentEscrowAta(address(escrowStr), usdcMint))
+            : (status?.ataAddress ?? "unknown");
+        return dryRunPreview(expectedFeedId, escrowStr || "unknown", escrowAta, priceAtomic, availableAtomic);
+    }
+    let timestamp = Math.floor(Date.now() / 1000);
+    let feedIdHex = expectedFeedId;
+    let lastPaymentRequired;
+    let walletSpendRecordedForRound = false;
+    for (let attempt = 0; attempt < MAX_ROUND_ATTEMPTS; attempt++) {
+        const needsQuoteOrFunding = priceAtomic === undefined || availableAtomic < priceAtomic;
+        const needsGateway = gatewayPda === undefined;
+        if (needsQuoteOrFunding || needsGateway) {
+            // Unsigned discovery (amount: 0) only works while underfunded. If the
+            // escrow already covers the quoted price but we lack the gateway PDA,
+            // refresh status instead — a funded amount:0 request returns 400.
+            if (!needsQuoteOrFunding && needsGateway) {
+                const refreshed = await fetchAgentStatus(config, payer, opts.signaturesRequired).catch(() => undefined);
+                if (!refreshed?.gateway) {
+                    throw new Error(gatewayPdaUnknownMessage(statusError));
+                }
+                gatewayPda = refreshed.gateway;
+                cacheGatewayPda(endpointKey, gatewayPda);
+                escrowStr = String(await deriveAgentEscrow(payer, address(gatewayPda), programId));
+                priceAtomic = BigInt(refreshed.quotedNextPrice);
+                availableAtomic = bigIntMax(0n, BigInt(refreshed.ataBalance) - BigInt(refreshed.committedAmount));
+            }
+            else {
+                timestamp = Math.floor(Date.now() / 1000);
+                const discovery = await discover(config, {
+                    payer,
+                    apiConfig,
+                    signaturesRequired: opts.signaturesRequired,
+                    registryVersion,
+                    timestamp
+                });
+                if (discovery.kind === "already_funded") {
+                    // Status was unavailable so we assumed an empty escrow, but the
+                    // gateway says it is funded. Nothing to fund — take the quote and
+                    // sign, provided the gateway PDA is known from a pin or the cache.
+                    if (!gatewayPda) {
+                        throw new Error(gatewayPdaUnknownMessage(statusError));
+                    }
+                    priceAtomic = discovery.roundPrice;
+                    availableAtomic = discovery.roundPrice;
+                    escrowStr = String(await deriveAgentEscrow(payer, address(gatewayPda), programId));
+                    feedIdHex = expectedFeedId;
+                }
+                else {
+                    const verified = await verifyX402FundingAccept(discovery.accept, fundingVerifyCtx(gatewayPda));
+                    assertFeedIdMatch(expectedFeedId, discovery.accept.extra.feedId);
+                    gatewayPda = String(verified.gateway);
+                    cacheGatewayPda(endpointKey, gatewayPda);
+                    priceAtomic = verified.roundPrice;
+                    if (verified.fundAmount > 0n) {
+                        await fundEscrow(connection, signer, {
+                            mint: verified.usdcMint,
+                            escrow: verified.escrow,
+                            escrowAta: verified.escrowAta,
+                            amountAtomic: verified.fundAmount
+                        });
+                        recordX402Spend(verified.fundAmount);
+                        walletSpendRecordedForRound = true;
+                    }
+                    timestamp = discovery.accept.extra.canonicalTimestamp;
+                    feedIdHex = expectedFeedId;
+                    escrowStr = String(verified.escrow);
+                    availableAtomic = priceAtomic;
+                }
+            }
+        }
+        if (!gatewayPda || !escrowStr || priceAtomic === undefined) {
+            throw new Error("x402 agent execute missing gateway PDA, escrow, or round price after discovery");
+        }
+        if (walletSpendRecordedForRound) {
+            checkX402PerRoundCap(priceAtomic, config.x402.maxPriceUsdcAtomic);
+        }
+        else {
+            checkX402SpendCap(priceAtomic, config.x402.maxPriceUsdcAtomic, config.x402.maxSpendPerDayUsdcAtomic);
+        }
+        const sig = await signAgentRequestAuth(signer, {
+            agent: address(escrowStr),
+            gateway: address(gatewayPda),
+            feedId: hexToBytesLocal(feedIdHex),
+            canonicalTimestamp: timestamp,
+            amount: priceAtomic
+        });
+        const outcome = await postAgentExecute(config.gatewayEndpoints, {
+            payer,
+            canonical_timestamp: timestamp,
+            signatures_required: opts.signaturesRequired,
+            amount: Number(priceAtomic),
+            registry_version: registryVersion,
+            agent_request_auth_sig: bytesToHex0xLocal(sig),
+            apiConfig
+        });
+        if (outcome.kind === "ok") {
+            return mapAgentResponse(outcome.body);
+        }
+        if (outcome.kind === "payment_required") {
+            lastPaymentRequired = outcome.body;
+            const accept = outcome.body.accepts[0];
+            if (accept?.extra.gateway) {
+                if (gatewayPda !== undefined && accept.extra.gateway !== gatewayPda) {
+                    throw new Error(`x402 402 response gateway mismatch: expected ${gatewayPda}, got ${accept.extra.gateway}`);
+                }
+                gatewayPda = accept.extra.gateway;
+                cacheGatewayPda(endpointKey, gatewayPda);
+                escrowStr = String(await deriveAgentEscrow(payer, address(gatewayPda), programId));
+            }
+            priceAtomic = undefined;
+            availableAtomic = 0n;
+            continue;
+        }
+        if (outcome.kind === "amount_mismatch") {
+            // Price moved between the quote and the signed request. The rejection
+            // carries the current price, so re-sign against it directly; only fall
+            // back to status when the gateway did not name one.
+            if (outcome.quotedPrice !== undefined) {
+                priceAtomic = outcome.quotedPrice;
+                availableAtomic = outcome.quotedPrice;
+                timestamp = Math.floor(Date.now() / 1000);
+                continue;
+            }
+            const refreshed = await fetchAgentStatus(config, payer, opts.signaturesRequired).catch(() => undefined);
+            if (refreshed) {
+                priceAtomic = BigInt(refreshed.quotedNextPrice);
+                availableAtomic = bigIntMax(0n, BigInt(refreshed.ataBalance) - BigInt(refreshed.committedAmount));
+                if (refreshed.gateway) {
+                    gatewayPda = refreshed.gateway;
+                    cacheGatewayPda(endpointKey, gatewayPda);
+                }
+                if (gatewayPda) {
+                    escrowStr = String(await deriveAgentEscrow(payer, address(gatewayPda), programId));
+                }
+                timestamp = Math.floor(Date.now() / 1000);
+                continue;
+            }
+            priceAtomic = undefined;
+            availableAtomic = 0n;
+            continue;
+        }
+        if (outcome.kind === "bad_request") {
+            // Stale registry version, clock skew, malformed apiConfig — none of
+            // these are fixed by retrying the same request.
+            throw new Error(`x402 agent execute rejected: ${outcome.message}`);
+        }
+        if (outcome.kind === "conflict") {
+            // canonical_timestamp already reserved — bump and re-sign.
+            timestamp += 1;
+            continue;
+        }
+        if (outcome.kind === "unavailable") {
+            timestamp = Math.floor(Date.now() / 1000);
+            continue;
+        }
+        throw new Error(`x402 agent execute failed: ${outcome.message}`);
+    }
+    if (lastPaymentRequired) {
+        throw new X402PaymentRequiredError(lastPaymentRequired.error || "payment required: escrow ATA underfunded after retries", lastPaymentRequired);
+    }
+    throw new Error("x402 agent round failed after retries (payment/timestamp conflicts did not resolve)");
+}
+function dryRunPreview(feedId, escrow, ata, priceAtomic, availableAtomic) {
+    const shortfall = bigIntMax(0n, priceAtomic - availableAtomic);
+    return {
+        dryRun: true,
+        action: "x402_agent_execute",
+        feedId,
+        escrow,
+        ata,
+        priceAtomicUsdc: priceAtomic.toString(),
+        availableAtomicUsdc: availableAtomic.toString(),
+        shortfallAtomicUsdc: shortfall.toString(),
+        note: shortfall > 0n
+            ? "Escrow is underfunded for this round; a live call would fund the ATA before requesting data."
+            : "Escrow already covers this round's price; a live call would request data immediately."
+    };
+}
+function gatewayPdaUnknownMessage(statusError) {
+    return [
+        "x402 escrow appears funded but the settling gateway PDA is unknown; set MOLPHA_X402_GATEWAY_PDA or ensure GET /v1/agent/{payer}/status returns gateway.",
+        statusError ? ` (status lookup failed: ${statusError})` : ""
+    ].join("");
+}
+function assertFeedIdMatch(expected, provided) {
+    if (provided === undefined)
+        return;
+    if (normalizeFeedId(provided) !== normalizeFeedId(expected)) {
+        throw new Error(`feedId does not match apiConfig + signaturesRequired for this signer: expected ${expected}, got ${provided}`);
+    }
+}
+function hexToBytesLocal(hex) {
+    return requireSdkExport("hexToBytes")(hex);
+}
+function bytesToHex0xLocal(bytes) {
+    return requireSdkExport("bytesToHex0x")(bytes);
+}
+function u64le(value) {
+    return requireSdkExport("u64le")(value);
+}
+/**
+ * `sha256("MOLPHA_AGENT_REQAUTH_V1" || agent(32) || gateway(32) || feedId(32) || canonicalTimestamp_le(8) || amount_le(8))`.
+ * Must stay byte-identical with the gateway's `agentauth.AgentRequestAuth.Hash()`
+ * (tmp/gateway/internal/gateway/features/agentexec/agentauth/agentauth.go) and
+ * the Solana program's `state/receipt.rs::hash_agent_request_auth`.
+ */
+export function agentRequestAuthMessage(params) {
+    const addressEncoder = getAddressEncoder();
+    const borsh = Buffer.concat([
+        Buffer.from(addressEncoder.encode(params.agent)),
+        Buffer.from(addressEncoder.encode(params.gateway)),
+        Buffer.from(params.feedId),
+        Buffer.from(u64le(params.canonicalTimestamp)),
+        Buffer.from(u64le(params.amount))
+    ]);
+    return new Uint8Array(createHash("sha256").update(Buffer.concat([Buffer.from(AGENT_REQAUTH_PREFIX, "utf8"), borsh])).digest());
+}
+async function signAgentRequestAuth(signer, params) {
+    return signer.signMessage(agentRequestAuthMessage(params));
+}
+function addressSigner(addr) {
+    // Only `.address` is read when Codama builds the instruction meta — actual
+    // signing goes through MolphaSigner.signTransaction, never through Kit.
+    return { address: addr };
+}
+/**
+ * Build + send the escrow ATA create/transfer. Callers must pass addresses and
+ * amounts already verified by {@link verifyX402FundingAccept} — never raw 402 fields.
+ */
+async function fundEscrow(connection, signer, args) {
+    const [payerAta] = await findAssociatedTokenPda({
+        owner: signer.publicKey,
+        mint: args.mint,
+        tokenProgram: TOKEN_PROGRAM_ADDRESS
+    });
+    const createAtaIx = getCreateAssociatedTokenIdempotentInstruction({
+        payer: addressSigner(signer.publicKey),
+        ata: args.escrowAta,
+        owner: args.escrow,
+        mint: args.mint
+    });
+    const transferIx = getTransferInstruction({
+        source: payerAta,
+        destination: args.escrowAta,
+        authority: addressSigner(signer.publicKey),
+        amount: args.amountAtomic
+    });
+    const tx = new Transaction().add(toLegacyInstruction(createAtaIx), toLegacyInstruction(transferIx));
+    tx.feePayer = toLegacyPublicKey(signer.publicKey);
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    tx.recentBlockhash = blockhash;
+    const signed = await signer.signTransaction(tx);
+    const signature = await connection.sendRawTransaction(signed.serialize());
+    await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, "confirmed");
+    return signature;
+}
+async function discover(config, args) {
+    const outcome = await postAgentExecute(config.gatewayEndpoints, {
+        payer: args.payer,
+        canonical_timestamp: args.timestamp,
+        signatures_required: args.signaturesRequired,
+        amount: 0,
+        registry_version: args.registryVersion,
+        apiConfig: args.apiConfig
+    });
+    if (outcome.kind === "amount_mismatch" && outcome.quotedPrice !== undefined) {
+        return { kind: "already_funded", roundPrice: outcome.quotedPrice };
+    }
+    if (outcome.kind !== "payment_required") {
+        throw new Error(`unsigned discovery request failed (expected a 402 quote), got ${outcome.kind}: ${"message" in outcome ? outcome.message : ""}`);
+    }
+    const accept = outcome.body.accepts[0];
+    if (!accept) {
+        throw new Error("gateway 402 response is missing accepts[0]");
+    }
+    return { kind: "quote", accept };
+}
+/**
+ * The gateway returns 400 for several unrelated validation failures
+ * (`amount`, `registry_version`, `canonical_timestamp`, …). Only the amount
+ * lock is retryable by re-quoting; treating every 400 as an amount mismatch
+ * hid stale-registry and clock-skew errors behind five pointless retries.
+ */
+function classifyBadRequest(message) {
+    if (!/^amount:/.test(message)) {
+        return { kind: "bad_request", message };
+    }
+    const quoted = /round price (\d+)/.exec(message);
+    return quoted
+        ? { kind: "amount_mismatch", message, quotedPrice: BigInt(quoted[1]) }
+        : { kind: "amount_mismatch", message };
+}
+async function postAgentExecute(endpoints, body) {
+    let lastError = { kind: "error", message: "no reachable gateway endpoint" };
+    for (const endpoint of endpoints) {
+        let res;
+        try {
+            res = await fetch(`${endpoint.replace(/\/$/, "")}/v1/agent/execute`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(body)
+            });
+        }
+        catch (error) {
+            lastError = { kind: "unavailable", message: error instanceof Error ? error.message : String(error) };
+            continue;
+        }
+        if (res.status === 200) {
+            return { kind: "ok", body: (await res.json()) };
+        }
+        if (res.status === 402) {
+            return { kind: "payment_required", body: (await res.json()) };
+        }
+        if (res.status === 400) {
+            return classifyBadRequest(await readErrorMessage(res));
+        }
+        if (res.status === 401) {
+            return { kind: "unauthorized", message: await readErrorMessage(res) };
+        }
+        if (res.status === 409) {
+            return { kind: "conflict", message: await readErrorMessage(res) };
+        }
+        if (res.status === 503) {
+            lastError = { kind: "unavailable", message: await readErrorMessage(res) };
+            continue;
+        }
+        return { kind: "error", message: await readErrorMessage(res) };
+    }
+    return lastError;
+}
+async function getFirstReachable(endpoints, path) {
+    let lastError;
+    for (const endpoint of endpoints) {
+        try {
+            const res = await fetch(`${endpoint.replace(/\/$/, "")}${path}`, { method: "GET" });
+            if (res.ok) {
+                return (await res.json());
+            }
+            lastError = new Error(`GET ${path} failed (${res.status})`);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`GET ${path} failed`);
+}
+async function readErrorMessage(res) {
+    try {
+        const text = (await res.text()).trim();
+        if (!text)
+            return `HTTP ${res.status}`;
+        try {
+            const parsed = JSON.parse(text);
+            const message = parsed.error ?? parsed.message ?? parsed.detail;
+            if (typeof message === "string" && message.trim())
+                return message.trim();
+        }
+        catch {
+            // fall back to raw body
+        }
+        return text;
+    }
+    catch {
+        return `HTTP ${res.status}`;
+    }
+}
+function mapAgentResponse(body) {
+    const data = (body.data ?? {});
+    return {
+        feedId: data.feedId,
+        value: data.value,
+        valuePacked: data.valuePacked,
+        timestamp: data.timestamp,
+        registryVersion: data.registryVersion,
+        signaturesRequired: data.signaturesRequired,
+        signersBitmap: data.signersBitmap,
+        s: data.s,
+        commitmentAddr: data.commitmentAddr,
+        fresh: data.fresh ?? true
+    };
+}
+function cacheGatewayPda(endpointKey, gatewayPda) {
+    gatewayPdaCache.set(endpointKey, gatewayPda);
+}
+function bigIntMax(a, b) {
+    return a > b ? a : b;
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@molpha/mcp",
+  "version": "0.1.0",
+  "mcpName": "io.github.molpha/mcp",
+  "description": "MCP server exposing Molpha oracle runtime tools over the Molpha SDK.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Molpha/mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Molpha/mcp/issues"
+  },
+  "homepage": "https://docs.molpha.io/",
+  "keywords": [
+    "mcp",
+    "ai",
+    "agents",
+    "llm",
+    "cursor",
+    "claude",
+    "codex",
+    "x402",
+    "web3",
+    "model-context-protocol",
+    "oracle",
+    "solana"
+  ],
+  "type": "module",
+  "bin": {
+    "molpha-mcp": "dist/src/server.js",
+    "molpha-provision": "dist/cli/provision.js",
+    "molpha-doctor": "dist/cli/doctor.js"
+  },
+  "files": [
+    "dist/src",
+    "dist/cli",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "node --import tsx src/server.ts",
+    "doctor": "node --import tsx cli/doctor.ts",
+    "provision": "node --import tsx cli/provision.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "sync-version": "node scripts/sync-version.mjs",
+    "version": "node scripts/sync-version.mjs && git add manifest.json server.json"
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "dependencies": {
+    "@anchor-lang/core": "^1.1.2",
+    "@coral-xyz/anchor": "^0.30.1",
+    "@modelcontextprotocol/sdk": "^1.13.0",
+    "@molpha-oracle/sdk": "0.5.0",
+    "@privy-io/node": "^0.26.0",
+    "@solana-program/token": "^0.15.0",
+    "@solana/kit": "^7.0.0",
+    "@solana/spl-token": "0.4.15",
+    "@solana/web3.js": "^1.98.4",
+    "@turnkey/sdk-server": "7.0.0",
+    "@turnkey/solana": "^1.1.31",
+    "bn.js": "^5.2.2",
+    "dotenv": "^16.6.1",
+    "zod": "^3.25.0"
+  },
+  "overrides": {
+    "@privy-io/node": {
+      "@solana/kit": "$@solana/kit"
+    }
+  },
+  "devDependencies": {
+    "@types/bn.js": "^5.1.6",
+    "@types/node": "^22.15.29",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.1"
+  }
+}