@aibtc/mcp-server 1.65.0 → 1.66.0

package/dist/tools/endpoint.tools.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { createApiClient, API_URL, probeEndpoint, formatPaymentAmount, checkSufficientBalance, generateDedupKey, checkDedupCache, recordTransaction, NETWORK } from "../services/x402.service.js";
+import { createApiClient, API_URL, probeEndpoint, formatPaymentAmount, checkSufficientBalance, generateDedupKey, checkDedupCache, recordTransaction, X402_DEDUP_TTL_MS, NETWORK } from "../services/x402.service.js";
 import { ALL_ENDPOINTS, searchEndpoints, formatEndpointsTable, getEndpointsBySource, getCategories, } from "../endpoints/registry.js";
 import { createJsonResponse, createErrorResponse } from "../utils/index.js";
 import { X402_HEADERS } from "../utils/x402-protocol.js";
@@ -270,6 +270,9 @@ For aibtc.com inbox messages, use send_inbox_message_direct instead — it signs
         },
     }, async ({ method, url, path, apiUrl, params, data, autoApprove, asset }) => {
         let fullUrl = "";
+        // Hoisted so the catch can record a broadcast payment for dedup — a
+        // failed settlement still spends real funds (#630).
+        let dedupKey = null;
         try {
             const parsed = parseEndpointUrl({ url, path, apiUrl, params });
             fullUrl = parsed.fullUrl;
@@ -281,14 +284,27 @@ For aibtc.com inbox messages, use send_inbox_message_direct instead — it signs
             // autoApprove=true: check dedup cache before any network request, then execute
             // with a single request. Balance validation happens inside the onBeforePayment
             // callback when the interceptor receives the 402, eliminating the separate probe.
-            const dedupKey = generateDedupKey(method, fullUrl, params, data);
-            const existingTxid = checkDedupCache(dedupKey);
+            dedupKey = generateDedupKey(method, fullUrl, params, data);
+            const existingTxid = await checkDedupCache(dedupKey);
             if (existingTxid) {
+                const windowSeconds = Math.round(X402_DEDUP_TTL_MS / 1000);
+                const pending = existingTxid.startsWith("pending:");
                 return createJsonResponse({
                     endpoint: `${method} ${fullUrl}`,
-                    message: 'Request already processed within the last 60 seconds. This prevents accidental duplicate payments.',
-                    txid: existingTxid,
-                    note: 'Wait 60s or use different endpoint/params to force a new transaction.',
+                    // Deliberately says "broadcast", not "paid": the entry is written
+                    // whenever a payment was signed and broadcast, including when
+                    // settlement then reported an error. Claiming it succeeded would
+                    // be wrong in exactly the cases the caller most needs to check.
+                    message: `An identical request already broadcast a payment within the last ${windowSeconds} seconds. This prevents accidental duplicate payments.`,
+                    // A prior attempt whose txid was never observable is recorded with a
+                    // synthetic marker. Report it as null rather than leaking the marker,
+                    // which is not a chain txid and must not be treated as one.
+                    txid: pending ? null : existingTxid,
+                    ...(pending && {
+                        txidNote: "The earlier payment was broadcast but its txid was not observable in the response. " +
+                            "Query get_account_transactions to find the settled txid before paying again.",
+                    }),
+                    note: `The earlier payment may have settled even if it reported an error — verify it before retrying. Wait ${windowSeconds}s or vary the endpoint/params to force a new transaction.`,
                 });
             }
             const api = await createApiClient(parsed.baseUrl, {
@@ -321,7 +337,7 @@ For aibtc.com inbox messages, use send_inbox_message_direct instead — it signs
             // observable, using a synthetic pending marker that cannot be
             // confused for a real chain txid.
             if (paymentAttempted) {
-                recordTransaction(dedupKey, txid ?? `pending:${dedupKey}`);
+                await recordTransaction(dedupKey, txid ?? `pending:${dedupKey}`);
             }
             // Build the txid response fields per the behavior matrix:
             //   payment attempted + observable txid → { txid: "0x..." }
@@ -352,9 +368,20 @@ For aibtc.com inbox messages, use send_inbox_message_direct instead — it signs
             // interceptor in x402.service.ts) and return it so the agent can verify.
             const axiosError = error;
             const canonicalStatus = axiosError.x402PaymentStatus;
+            // The presence of this header means the interceptor signed and
+            // broadcast a payment. That spends real funds whether or not
+            // settlement succeeded, so record it for dedup before returning any
+            // error — otherwise an identical retry passes the dedup guard and pays
+            // a second time for an invoice already settled on chain (#630).
+            // Mirrors the success path, including the synthetic pending marker
+            // used when the txid is not yet observable.
+            const paymentSigHeader = axiosError.config?.headers?.[X402_HEADERS.PAYMENT_SIGNATURE];
+            if (paymentSigHeader && dedupKey) {
+                const broadcastTxid = extractTxidFromPaymentSignature(paymentSigHeader);
+                await recordTransaction(dedupKey, broadcastTxid ?? `pending:${dedupKey}`);
+            }
             if (canonicalStatus) {
                 const baseError = formatEndpointError(error, label);
-                const paymentSigHeader = axiosError.config?.headers?.[X402_HEADERS.PAYMENT_SIGNATURE];
                 const fallbackTxid = paymentSigHeader
                     ? extractTxidFromPaymentSignature(paymentSigHeader)
                     : null;
@@ -382,7 +409,6 @@ For aibtc.com inbox messages, use send_inbox_message_direct instead — it signs
                     content: [{ type: "text", text }],
                 };
             }
-            const paymentSigHeader = axiosError.config?.headers?.[X402_HEADERS.PAYMENT_SIGNATURE];
             if (paymentSigHeader) {
                 const txid = extractTxidFromPaymentSignature(paymentSigHeader);
                 const fallbackPaymentId = extractPaymentIdFromPaymentSignature(paymentSigHeader);

package/dist/tools/index.js

@@ -36,6 +36,7 @@ import { registerJingswapTools } from "./jingswap.tools.js";
 import { registerSigningTools } from "./signing.tools.js";
 import { registerInferenceMarketplaceTools } from "./inference-marketplace.tools.js";
 import { registerNewsTools } from "./news.tools.js";
+import { registerLegionTools } from "./legion.tools.js";
 import { registerIdentityTools } from "./identity.tools.js";
 import { registerCredentialsTools } from "./credentials.tools.js";
 import { registerSouldinalsTools } from "./souldinals.tools.js";
@@ -167,6 +168,8 @@ export function registerAllTools(server) {
     registerInferenceMarketplaceTools(server);
     // AIBTC News (signal feed, leaderboard, file signals)
     registerNewsTools(server);
+    // AIBTC News Legion (news-gov-v5 governance — inscribe, propose, vote, veto, conclude)
+    registerLegionTools(server);
     // Identity (ERC-8004 on-chain agent identity management)
     registerIdentityTools(server);
     // Credentials (encrypted credential store — list, get, set, delete, unlock)

package/dist/tools/legion.tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AIBTC News Legion tools (news-gov-v5).
+ *
+ * Lifecycle: inscribe → reveal → propose → vote → veto → conclude, plus
+ * contribute (buys weight) and sponsor (does not).
+ *
+ * These tools pin their own network: `getLegionAccount()` re-derives the
+ * unlocked wallet for the legion's chain, so a mainnet-configured server signs
+ * against testnet. Inscription is the exception — real BTC on whatever chain
+ * NETWORK names.
+ *
+ * Fund-moving calls sign in DENY mode with an exact post-condition.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerLegionTools(server: McpServer): void;
+//# sourceMappingURL=legion.tools.d.ts.map