pion-mcp 0.2.0 → 0.4.0

package/dist/payments.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Arming logic and money-safety helpers for Tier C (A2U payments).
+ *
+ * This is the only part of Pion that can move value, so it is disabled unless
+ * every guard below passes. Possessing credentials is deliberately NOT enough
+ * to arm it: PION_ENABLE_PAYMENTS is a separate, explicit switch, and
+ * PION_MAX_PAYMENT_PI is a required ceiling that bounds worst-case loss no
+ * matter how the agent is steered.
+ *
+ * Neither the server API key nor the wallet secret is ever accepted as a tool
+ * argument, returned in a result, or logged.
+ */
+import { z } from "zod";
+import { type PiNetwork } from "./networks.js";
+export interface PaymentsConfig {
+    serverApiKey: string;
+    walletSecret: string;
+    maxAmountStroops: bigint;
+    maxAmountPi: string;
+}
+export type PaymentsArming = {
+    armed: true;
+    config: PaymentsConfig;
+} | {
+    armed: false;
+    reason: string;
+};
+/**
+ * Converts a decimal Pi amount to stroops exactly. Comparisons against the
+ * spend cap are done in integer stroops rather than floats — this is money,
+ * and 0.1 + 0.2 problems are not acceptable in a ceiling check.
+ */
+export declare function toStroops(amount: string): bigint | null;
+/**
+ * Metadata for a create-payment call, guaranteed non-empty.
+ *
+ * Pi rejects `POST /v2/payments` with `400 invalid_metadata` — "Metadata can't
+ * be empty" — when the field is `{}`. This is undocumented, and it is invisible
+ * in testing if every probe happens to pass something: ours did, so an omitted
+ * metadata argument stayed broken until the first real send (2026-08-01).
+ *
+ * The default carries provenance and nothing about the user.
+ */
+export declare function paymentMetadata(supplied?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Runtime shape check for the create-payment fields `send_payment` depends on.
+ *
+ * Parsed rather than cast, on purpose. An earlier version of this codebase
+ * declared the recipient wallet as `recipient` — a name Pi never returns — and
+ * a cast turned that into `undefined` at runtime instead of a type error. Every
+ * A2U payment would have failed while building the transaction, stranding a
+ * record each time, with nothing in the failure to point at the cause.
+ *
+ * Deliberately narrow: it covers only the fields actually read, so an unrelated
+ * addition to Pi's response never blocks a payment, while a rename of something
+ * load-bearing stops it before anything is signed.
+ *
+ * Field names verified against a live response (`npm run probe:a2u`, 2026-07-31).
+ */
+export declare const createdPaymentSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    to_address: z.ZodString;
+    from_address: z.ZodString;
+    amount: z.ZodNumber;
+    status: z.ZodObject<{
+        developer_approved: z.ZodBoolean;
+        cancelled: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CreatedPayment = z.infer<typeof createdPaymentSchema>;
+export type ParsedCreate = {
+    ok: true;
+    payment: CreatedPayment;
+} | {
+    ok: false;
+    issues: string;
+    identifier: string | undefined;
+};
+/**
+ * Validates a create-payment response.
+ *
+ * On failure it still digs the identifier out of the raw body if one is there:
+ * a record may exist even when the response cannot be understood, and a
+ * stranded payment with no id is far worse than one with an id.
+ */
+export declare function parseCreatedPayment(raw: unknown): ParsedCreate;
+/**
+ * Converts Pi's recorded amount to stroops for comparison against the request.
+ *
+ * Never via `String(amount)`: Pi returns amounts as JSON numbers and small ones
+ * arrive in exponential notation — a real `1e-7` was observed — which does not
+ * match the decimal pattern `toStroops` expects.
+ */
+export declare function recordedAmountToStroops(amount: number): bigint;
+/**
+ * Decides whether payments may run at all. Returns a specific reason on
+ * refusal so an operator can tell a missing switch from a missing credential.
+ */
+export declare function checkPaymentsArming(network: PiNetwork): PaymentsArming;

package/dist/payments.js

@@ -0,0 +1,187 @@
+/**
+ * Arming logic and money-safety helpers for Tier C (A2U payments).
+ *
+ * This is the only part of Pion that can move value, so it is disabled unless
+ * every guard below passes. Possessing credentials is deliberately NOT enough
+ * to arm it: PION_ENABLE_PAYMENTS is a separate, explicit switch, and
+ * PION_MAX_PAYMENT_PI is a required ceiling that bounds worst-case loss no
+ * matter how the agent is steered.
+ *
+ * Neither the server API key nor the wallet secret is ever accepted as a tool
+ * argument, returned in a result, or logged.
+ */
+import { z } from "zod";
+import { PI_TESTNET } from "./networks.js";
+/** Stellar amounts carry 7 decimal places; 1 Pi = 10^7 stroops. */
+const STROOPS_PER_PI = 10000000n;
+const AMOUNT_PATTERN = /^\d+(\.\d{1,7})?$/;
+/** Stellar public key: 56 base32 characters beginning with G. */
+const STELLAR_ADDRESS = /^G[A-Z2-7]{55}$/;
+/** Stellar secret seed: 56 base32 characters beginning with S. */
+const SECRET_PATTERN = /^S[A-Z2-7]{55}$/;
+/**
+ * Converts a decimal Pi amount to stroops exactly. Comparisons against the
+ * spend cap are done in integer stroops rather than floats — this is money,
+ * and 0.1 + 0.2 problems are not acceptable in a ceiling check.
+ */
+export function toStroops(amount) {
+    if (!AMOUNT_PATTERN.test(amount))
+        return null;
+    const dot = amount.indexOf(".");
+    const whole = dot === -1 ? amount : amount.slice(0, dot);
+    const fraction = dot === -1 ? "" : amount.slice(dot + 1);
+    return BigInt(whole) * STROOPS_PER_PI + BigInt(fraction.padEnd(7, "0"));
+}
+/**
+ * Metadata for a create-payment call, guaranteed non-empty.
+ *
+ * Pi rejects `POST /v2/payments` with `400 invalid_metadata` — "Metadata can't
+ * be empty" — when the field is `{}`. This is undocumented, and it is invisible
+ * in testing if every probe happens to pass something: ours did, so an omitted
+ * metadata argument stayed broken until the first real send (2026-08-01).
+ *
+ * The default carries provenance and nothing about the user.
+ */
+export function paymentMetadata(supplied) {
+    if (supplied && Object.keys(supplied).length > 0)
+        return supplied;
+    return { source: "pion-mcp" };
+}
+/**
+ * Runtime shape check for the create-payment fields `send_payment` depends on.
+ *
+ * Parsed rather than cast, on purpose. An earlier version of this codebase
+ * declared the recipient wallet as `recipient` — a name Pi never returns — and
+ * a cast turned that into `undefined` at runtime instead of a type error. Every
+ * A2U payment would have failed while building the transaction, stranding a
+ * record each time, with nothing in the failure to point at the cause.
+ *
+ * Deliberately narrow: it covers only the fields actually read, so an unrelated
+ * addition to Pi's response never blocks a payment, while a rename of something
+ * load-bearing stops it before anything is signed.
+ *
+ * Field names verified against a live response (`npm run probe:a2u`, 2026-07-31).
+ */
+export const createdPaymentSchema = z.object({
+    identifier: z.string().min(1),
+    /** The recipient's wallet. Present on create — no separate lookup needed. */
+    to_address: z.string().regex(STELLAR_ADDRESS, "is not a Stellar public key"),
+    /**
+     * The wallet Pi expects to send from — the app wallet *selected* in the
+     * Developer Portal, which is not necessarily the one `PI_WALLET_SECRET`
+     * unlocks. Observed 2026-08-01: Pi returns the selected wallet here
+     * regardless of what key the app actually holds, so this is the only place
+     * the two can be compared before signing.
+     */
+    from_address: z.string().regex(STELLAR_ADDRESS, "is not a Stellar public key"),
+    /** Pi's record of the amount, to be cross-checked against what was asked. */
+    amount: z.number().finite(),
+    status: z.object({
+        developer_approved: z.boolean(),
+        cancelled: z.boolean(),
+    }),
+});
+/**
+ * Validates a create-payment response.
+ *
+ * On failure it still digs the identifier out of the raw body if one is there:
+ * a record may exist even when the response cannot be understood, and a
+ * stranded payment with no id is far worse than one with an id.
+ */
+export function parseCreatedPayment(raw) {
+    const parsed = createdPaymentSchema.safeParse(raw);
+    if (parsed.success)
+        return { ok: true, payment: parsed.data };
+    const loose = raw?.identifier;
+    return {
+        ok: false,
+        issues: parsed.error.issues
+            .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
+            .join("; "),
+        identifier: typeof loose === "string" && loose.length > 0 ? loose : undefined,
+    };
+}
+/**
+ * Converts Pi's recorded amount to stroops for comparison against the request.
+ *
+ * Never via `String(amount)`: Pi returns amounts as JSON numbers and small ones
+ * arrive in exponential notation — a real `1e-7` was observed — which does not
+ * match the decimal pattern `toStroops` expects.
+ */
+export function recordedAmountToStroops(amount) {
+    return BigInt(Math.round(amount * Number(STROOPS_PER_PI)));
+}
+/**
+ * Decides whether payments may run at all. Returns a specific reason on
+ * refusal so an operator can tell a missing switch from a missing credential.
+ */
+export function checkPaymentsArming(network) {
+    const enable = process.env.PION_ENABLE_PAYMENTS;
+    if (enable !== "1" && enable?.toLowerCase() !== "true") {
+        return {
+            armed: false,
+            reason: "PION_ENABLE_PAYMENTS is not set to 1 — payments are off by default",
+        };
+    }
+    // A2U is testnet-only per Pi's payments_advanced.md. Refuse anything else
+    // rather than discovering the restriction mid-flow with a created payment.
+    //
+    // Two conditions, deliberately. Until v0.4 this was a single substring test
+    // for "testnet" in the Horizon URL, which any string containing that word
+    // satisfied — https://api.mainnet.minepi.com/#testnet included. Arming now
+    // requires the resolved network to *be* Pi Testnet, and a custom endpoint
+    // resolves to `custom` however testnet-ish its URL looks.
+    if (!network.isTestnet) {
+        return {
+            armed: false,
+            reason: `the selected network is ${network.label} (${network.horizonUrl}), not Pi Testnet. ` +
+                "Pi restricts App-to-User payments to testnet, and Pion will not attempt them " +
+                "elsewhere. Payments cannot be armed while PION_NETWORK=mainnet or while " +
+                "PION_HORIZON_URL points at an endpoint Pion cannot identify.",
+        };
+    }
+    // Self-consistency assertion, not a second guess at the network. It cannot
+    // fire from any environment variable — only from someone editing the table in
+    // networks.ts so that `isTestnet` and the URL disagree.
+    if (network.horizonUrl !== PI_TESTNET.horizonUrl) {
+        return {
+            armed: false,
+            reason: `network table inconsistency: a network marked testnet points at ` +
+                `${network.horizonUrl}, not ${PI_TESTNET.horizonUrl}. Refusing to arm.`,
+        };
+    }
+    const serverApiKey = process.env.PI_SERVER_API_KEY;
+    if (!serverApiKey) {
+        return { armed: false, reason: "PI_SERVER_API_KEY is not set" };
+    }
+    const walletSecret = process.env.PI_WALLET_SECRET;
+    if (!walletSecret) {
+        return { armed: false, reason: "PI_WALLET_SECRET is not set" };
+    }
+    if (!SECRET_PATTERN.test(walletSecret)) {
+        // Never echo the value — say only that the shape is wrong.
+        return {
+            armed: false,
+            reason: "PI_WALLET_SECRET is not a valid Stellar secret seed (expected 56 characters starting with S)",
+        };
+    }
+    const rawCap = process.env.PION_MAX_PAYMENT_PI;
+    if (!rawCap) {
+        return {
+            armed: false,
+            reason: "PION_MAX_PAYMENT_PI is not set. A per-payment ceiling is required — " +
+                "it is what bounds the damage if the agent is manipulated.",
+        };
+    }
+    const maxAmountStroops = toStroops(rawCap.trim());
+    if (maxAmountStroops === null || maxAmountStroops <= 0n) {
+        return {
+            armed: false,
+            reason: `PION_MAX_PAYMENT_PI must be a positive decimal amount of Pi, got "${rawCap}"`,
+        };
+    }
+    return {
+        armed: true,
+        config: { serverApiKey, walletSecret, maxAmountStroops, maxAmountPi: rawCap.trim() },
+    };
+}

package/dist/platform.d.ts

@@ -22,4 +22,7 @@ export declare class PlatformAuthError extends Error {
     readonly status: number;
     constructor(message: string, status: number);
 }
+/** Authenticated as a user, via their access token. */
 export declare function platformGet<T>(path: string, accessToken: string): Promise<T>;
+/** Authenticated as the app, via the server API key. Server-side only. */
+export declare function platformPostAsApp<T>(path: string, serverApiKey: string, body?: unknown): Promise<T>;

package/dist/platform.js

@@ -32,16 +32,19 @@ export class PlatformAuthError extends Error {
         this.name = "PlatformAuthError";
     }
 }
-export async function platformGet(path, accessToken) {
+async function platformRequest(method, path, auth, body) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
     let response;
     try {
         response = await fetch(`${PLATFORM_URL}${path}`, {
+            method,
             headers: {
-                authorization: `Bearer ${accessToken}`,
+                authorization: `${auth.scheme} ${auth.credential}`,
                 accept: "application/json",
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
             },
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
             signal: controller.signal,
         });
     }
@@ -56,12 +59,39 @@ export async function platformGet(path, accessToken) {
         clearTimeout(timer);
     }
     if (response.status === 401 || response.status === 403) {
+        // Do NOT assume a 401 means bad credentials. /v2/payments returns 401 with
+        // {"error":"missing_scope"} when the *recipient* has not granted
+        // wallet_address — nothing to do with the caller's key. The body carries
+        // the real reason, so read it before blaming the credential.
+        const raw = (await response.text().catch(() => "")).trim();
+        let apiError;
+        let apiMessage;
+        try {
+            const parsed = JSON.parse(raw);
+            apiError = parsed.error;
+            apiMessage = parsed.error_message;
+        }
+        catch {
+            // Empty or non-JSON body — fall back to the generic wording below.
+        }
+        if (apiError !== undefined) {
+            throw new PlatformAuthError(`Pi rejected the request (${response.status} ${apiError})` +
+                (apiMessage ? `: ${apiMessage}` : "") +
+                (apiError === "missing_scope"
+                    ? "\n\nThis is a consent problem, not a credential problem. Your credentials are " +
+                        "fine: the recipient has not authorized the required scope for your app. For " +
+                        "A2U that is wallet_address, which lets Pi resolve their wallet.\n\n" +
+                        "The verified way to obtain it is a Pi Browser SDK grant — the recipient runs " +
+                        "Pi.authenticate for your app including wallet_address, inside the Pi Browser. " +
+                        "Whether a Pi Sign-in grant also satisfies this is untested."
+                    : ""), response.status);
+        }
+        const subject = auth.scheme === "Bearer" ? "access token" : "server API key";
         throw new PlatformAuthError(response.status === 401
-            ? "The Pi Platform API rejected this access token. It is invalid, expired, or was issued for a different app."
-            : "This access token is valid but lacks the scope required for this call.", response.status);
+            ? `The Pi Platform API rejected this ${subject}. It is invalid, expired, or was issued for a different app.`
+            : `This ${subject} is valid but lacks the permission required for this call.`, response.status);
     }
     if (!response.ok) {
-        // 401 responses come back with an empty body, so never assume JSON here.
         const body = await response.text().catch(() => "");
         const detail = body.trim().slice(0, 300);
         throw new PlatformError(detail.length > 0
@@ -70,4 +100,11 @@ export async function platformGet(path, accessToken) {
     }
     return (await response.json());
 }
-//# sourceMappingURL=platform.js.map
+/** Authenticated as a user, via their access token. */
+export function platformGet(path, accessToken) {
+    return platformRequest("GET", path, { scheme: "Bearer", credential: accessToken });
+}
+/** Authenticated as the app, via the server API key. Server-side only. */
+export function platformPostAsApp(path, serverApiKey, body) {
+    return platformRequest("POST", path, { scheme: "Key", credential: serverApiKey }, body);
+}

package/dist/tools/common.d.ts

@@ -1,5 +1,20 @@
 import { z } from "zod";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { PiNetwork } from "../networks.js";
+/**
+ * The sentence every Tier A tool description ends with.
+ *
+ * Named once so all three read tools say the same thing about the same fact.
+ * An agent that only ever sees a tool description — never the startup banner —
+ * still learns which chain it is reading and why that matters.
+ *
+ * The wording is deliberate about what a wrong-chain read looks like. Measured
+ * 2026-08-14: some Pi addresses hold a balance on *both* chains, with different
+ * amounts (docs/FINDINGS.md, finding 5). So querying the wrong network does not
+ * reliably produce a not-found error — it can produce a well-formed, plausible,
+ * wrong number. That is why the network is stated rather than implied.
+ */
+export declare function networkNote(network: PiNetwork): string;
 /** Stellar/Pi public key: 56 base32 characters beginning with G. */
 export declare const walletAddress: z.ZodString;
 /** Stellar transaction hash: 64 hex characters. */

package/dist/tools/common.js

@@ -1,6 +1,27 @@
 import { z } from "zod";
 import { HorizonError } from "../horizon.js";
 import { PlatformError } from "../platform.js";
+/**
+ * The sentence every Tier A tool description ends with.
+ *
+ * Named once so all three read tools say the same thing about the same fact.
+ * An agent that only ever sees a tool description — never the startup banner —
+ * still learns which chain it is reading and why that matters.
+ *
+ * The wording is deliberate about what a wrong-chain read looks like. Measured
+ * 2026-08-14: some Pi addresses hold a balance on *both* chains, with different
+ * amounts (docs/FINDINGS.md, finding 5). So querying the wrong network does not
+ * reliably produce a not-found error — it can produce a well-formed, plausible,
+ * wrong number. That is why the network is stated rather than implied.
+ */
+export function networkNote(network) {
+    return (`This server reads ${network.label}, and every result repeats that in its ` +
+        '"network" field — always report which chain a figure came from. Pi Mainnet ' +
+        "and Pi Testnet are separate ledgers sharing one address format, and the same " +
+        "address can hold different balances on each, so a result from the wrong chain " +
+        "looks entirely normal. Testnet Pi has no monetary value: never present a " +
+        "testnet balance as real holdings.");
+}
 /** Stellar/Pi public key: 56 base32 characters beginning with G. */
 export const walletAddress = z
     .string()
@@ -43,4 +64,3 @@ export function fail(error) {
         : `Unexpected error: ${error instanceof Error ? error.message : String(error)}`;
     return { content: [{ type: "text", text: message }], isError: true };
 }
-//# sourceMappingURL=common.js.map

package/dist/tools/get-account-payments.d.ts

@@ -1,2 +1,3 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerGetAccountPayments(server: McpServer, network: string): void;
+import type { PiNetwork } from "../networks.js";
+export declare function registerGetAccountPayments(server: McpServer, network: PiNetwork): void;

package/dist/tools/get-account-payments.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { cursorFromLink, formatAsset, horizonGet } from "../horizon.js";
-import { fail, ok, pagingCursor, pagingLimit, pagingOrder, walletAddress } from "./common.js";
+import { fail, networkNote, ok, pagingCursor, pagingLimit, pagingOrder, walletAddress, } from "./common.js";
 const paymentShape = z.object({
     id: z.string(),
     type: z.string(),
@@ -72,7 +72,8 @@ export function registerGetAccountPayments(server, network) {
             "a payment arrived, who funded an account, or what it recently sent. Covers " +
             "payments, account creations, path payments, and account merges. Results are " +
             "paginated: pass the returned `next_cursor` back as `cursor` for the next page. " +
-            "Reads public ledger data only.",
+            "Reads public ledger data only. " +
+            networkNote(network),
         inputSchema: {
             address: walletAddress,
             limit: pagingLimit,
@@ -93,7 +94,7 @@ export function registerGetAccountPayments(server, network) {
             // set. Only surface a cursor when the page came back full.
             const nextCursor = payments.length === limit ? cursorFromLink(page._links?.next?.href) : undefined;
             return ok({
-                network,
+                network: network.label,
                 account_id: address,
                 count: payments.length,
                 ...(nextCursor !== undefined ? { next_cursor: nextCursor } : {}),
@@ -105,4 +106,3 @@ export function registerGetAccountPayments(server, network) {
         }
     });
 }
-//# sourceMappingURL=get-account-payments.js.map

package/dist/tools/get-wallet-balance.d.ts

@@ -1,2 +1,3 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerGetWalletBalance(server: McpServer, network: string): void;
+import type { PiNetwork } from "../networks.js";
+export declare function registerGetWalletBalance(server: McpServer, network: PiNetwork): void;

package/dist/tools/get-wallet-balance.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { formatAsset, horizonGet } from "../horizon.js";
-import { fail, ok, walletAddress } from "./common.js";
+import { fail, networkNote, ok, walletAddress } from "./common.js";
 const outputSchema = {
     network: z.string(),
     account_id: z.string(),
@@ -21,7 +21,8 @@ export function registerGetWalletBalance(server, network) {
         description: "Read the current Pi and custom-token balances of a Pi wallet address. " +
             "Call this whenever you need to know how much Pi an address holds, whether it " +
             "holds a particular token, or whether the account exists on-chain at all. " +
-            "Reads public ledger data only — it cannot move funds and needs no credentials.",
+            "Reads public ledger data only — it cannot move funds and needs no credentials. " +
+            networkNote(network),
         inputSchema: { address: walletAddress },
         outputSchema,
         annotations: { readOnlyHint: true, openWorldHint: true },
@@ -29,7 +30,7 @@ export function registerGetWalletBalance(server, network) {
         try {
             const account = await horizonGet(`/accounts/${address}`);
             return ok({
-                network,
+                network: network.label,
                 account_id: account.account_id,
                 sequence: account.sequence,
                 subentry_count: account.subentry_count,
@@ -51,4 +52,3 @@ export function registerGetWalletBalance(server, network) {
         }
     });
 }
-//# sourceMappingURL=get-wallet-balance.js.map

package/dist/tools/query-transaction.d.ts

@@ -1,2 +1,3 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerQueryTransaction(server: McpServer, network: string): void;
+import type { PiNetwork } from "../networks.js";
+export declare function registerQueryTransaction(server: McpServer, network: PiNetwork): void;

package/dist/tools/query-transaction.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { horizonGet } from "../horizon.js";
-import { fail, ok, transactionHash } from "./common.js";
+import { fail, networkNote, ok, transactionHash } from "./common.js";
 const outputSchema = {
     network: z.string(),
     hash: z.string(),
@@ -23,7 +23,8 @@ export function registerQueryTransaction(server, network) {
             "which ledger it landed in, who submitted it, the fee charged, and its memo. " +
             "Call this to verify that a specific transaction actually went through — a user " +
             "or another service claiming a payment was made is not proof; this is. " +
-            "Reads public ledger data only.",
+            "Reads public ledger data only. " +
+            networkNote(network),
         inputSchema: { hash: transactionHash },
         outputSchema,
         annotations: { readOnlyHint: true, openWorldHint: true },
@@ -31,7 +32,7 @@ export function registerQueryTransaction(server, network) {
         try {
             const tx = await horizonGet(`/transactions/${hash.toLowerCase()}`);
             return ok({
-                network,
+                network: network.label,
                 hash: tx.hash,
                 successful: tx.successful,
                 ledger: tx.ledger,
@@ -51,4 +52,3 @@ export function registerQueryTransaction(server, network) {
         }
     });
 }
-//# sourceMappingURL=query-transaction.js.map

package/dist/tools/send-payment.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type PaymentsConfig } from "../payments.js";
+export declare function registerSendPayment(server: McpServer, config: PaymentsConfig): void;