agenticbtc-mcp 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenticbtc-mcp",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Privacy-intelligent payments for AI agents — your privacy, your choice. Universal payment router with Lightning, Strike, Coinbase, PayPal, Venmo support.",
   "keywords": [
     "bitcoin",

package/src/server.js

@@ -11,8 +11,8 @@ import crypto from "crypto";
 
 const API_URL = process.env.AGENTICBTC_API_URL || process.env.AGENTBTC_API_URL || "http://localhost:8000";
 const API_KEY = process.env.AGENTICBTC_API_KEY || process.env.AGENTBTC_API_KEY || "";
-const LND_HOST = process.env.AGENTBTC_LND_HOST || "";
-const LND_MACAROON = process.env.AGENTBTC_LND_MACAROON || "";
+const LND_HOST = process.env.AGENTICBTC_LND_HOST || process.env.AGENTBTC_LND_HOST || "";
+const LND_MACAROON = process.env.AGENTICBTC_LND_MACAROON || process.env.AGENTBTC_LND_MACAROON || "";
 
 // X (Twitter) credentials — optional, enables social posting tools
 const X_CONSUMER_KEY = process.env.TWITTER_CONSUMER_KEY || "";
@@ -771,6 +771,145 @@ server.tool(
   }
 );
 
+// Tool: Universal send_payment — auto-detects recipient type
+server.tool(
+  "send_payment",
+  "Send a payment to any recipient. Automatically detects recipient type: BOLT11 Lightning invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username). Routes through the optimal payment rail.",
+  {
+    recipient: z.string().describe("Where to send: Lightning invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username)"),
+    amount_sats: z.number().optional().describe("Amount in satoshis (required for Lightning address and Strike handle; optional for BOLT11 invoices which encode the amount)"),
+    amount_usd: z.number().optional().describe("Amount in USD (for Strike handle payments; alternative to amount_sats)"),
+    memo: z.string().optional().default("").describe("Optional payment memo or comment"),
+    agent: z.string().optional().describe("Agent wallet name or ID for spending policy enforcement"),
+  },
+  async ({ recipient, amount_sats, amount_usd, memo, agent }) => {
+    // Detect recipient type
+    const isBolt11 = /^lnbc|^lntb|^lnbcrt/i.test(recipient);
+    const isStrikeHandle = recipient.startsWith("$");
+    const isLightningAddress = !isBolt11 && !isStrikeHandle && recipient.includes("@");
+
+    // Resolve agent for spending policy
+    let resolvedAgent = null;
+    if (agent) {
+      resolvedAgent = await resolveAgent(agent);
+      if (!resolvedAgent) return { content: [{ type: "text", text: `Error: Agent '${agent}' not found` }] };
+      if (!resolvedAgent.enabled) return { content: [{ type: "text", text: `Error: Agent '${resolvedAgent.name}' is disabled` }] };
+    }
+    if (!resolvedAgent) {
+      const auth = await getAuthLevel();
+      if (auth.agent_id) resolvedAgent = { id: auth.agent_id, name: auth.agent_name || auth.agent_id };
+    }
+
+    if (isBolt11) {
+      // Delegate to router via pay_lightning_invoice logic
+      if (resolvedAgent) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats || 0);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      const { status, data } = await apiCall("/api/v1/payments", {
+        method: "POST",
+        body: JSON.stringify({ invoice: recipient, fee_limit_sats: 100 }),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "lightning_invoice", amount_sats: data.amount_sats, fee_sats: data.fee_sats || 0, rail: data.rail, payment_hash: data.payment_hash }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else if (isLightningAddress) {
+      if (!amount_sats) return { content: [{ type: "text", text: "Error: amount_sats required for Lightning address payments" }] };
+      if (resolvedAgent) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      // LNURL resolve → pay via router
+      const [user, domain] = recipient.split("@");
+      const lnurlRes = await fetch(`https://${domain}/.well-known/lnurlp/${user}`);
+      if (!lnurlRes.ok) return { content: [{ type: "text", text: `Error: Could not resolve Lightning address ${recipient}` }] };
+      const lnurlData = await lnurlRes.json();
+      const minSats = Math.ceil((lnurlData.minSendable || 1000) / 1000);
+      const maxSats = Math.floor((lnurlData.maxSendable || 100000000000) / 1000);
+      if (amount_sats < minSats || amount_sats > maxSats) {
+        return { content: [{ type: "text", text: `Error: Amount must be between ${minSats} and ${maxSats} sats for this address` }] };
+      }
+      let callbackUrl = `${lnurlData.callback}${lnurlData.callback.includes("?") ? "&" : "?"}amount=${amount_sats * 1000}`;
+      if (memo && lnurlData.commentAllowed) callbackUrl += `&comment=${encodeURIComponent(memo)}`;
+      const invoiceRes = await fetch(callbackUrl);
+      if (!invoiceRes.ok) return { content: [{ type: "text", text: `Error: Failed to get invoice from ${domain}` }] };
+      const invoiceData = await invoiceRes.json();
+      if (!invoiceData.pr) return { content: [{ type: "text", text: `Error: No invoice returned from ${domain}` }] };
+      const { status, data } = await apiCall("/api/v1/payments", {
+        method: "POST",
+        body: JSON.stringify({ invoice: invoiceData.pr, fee_limit_sats: Math.max(100, Math.floor(amount_sats * 0.01)) }),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "lightning_address", recipient, amount_sats, fee_sats: data.fee_sats || 0, payment_hash: data.payment_hash, message: `Sent ${amount_sats} sats to ${recipient} ⚡` }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else if (isStrikeHandle) {
+      const handle = recipient.slice(1); // strip "$"
+      if (!amount_usd && !amount_sats) return { content: [{ type: "text", text: "Error: amount_usd or amount_sats required for Strike payments" }] };
+      const satsToSend = amount_sats || 0;
+      if (resolvedAgent && satsToSend) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, satsToSend);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+
+      // Try Lightning-first: resolve handle@strike.me via LNURL
+      if (satsToSend > 0) {
+        try {
+          const lightningAddr = `${handle}@strike.me`;
+          const lnurlRes = await fetch(`https://strike.me/.well-known/lnurlp/${handle}`, { signal: AbortSignal.timeout(5000) });
+          if (lnurlRes.ok) {
+            const lnurlData = await lnurlRes.json();
+            if (lnurlData.status !== "ERROR") {
+              const minSats = Math.ceil((lnurlData.minSendable || 1000) / 1000);
+              const maxSats = Math.floor((lnurlData.maxSendable || 100000000000) / 1000);
+              if (satsToSend >= minSats && satsToSend <= maxSats) {
+                let callbackUrl = `${lnurlData.callback}${lnurlData.callback.includes("?") ? "&" : "?"}amount=${satsToSend * 1000}`;
+                if (memo && lnurlData.commentAllowed) callbackUrl += `&comment=${encodeURIComponent(memo)}`;
+                const invoiceRes = await fetch(callbackUrl, { signal: AbortSignal.timeout(5000) });
+                if (invoiceRes.ok) {
+                  const invoiceData = await invoiceRes.json();
+                  if (invoiceData.pr) {
+                    const { status: payStatus, data: payData } = await apiCall("/api/v1/payments", {
+                      method: "POST",
+                      body: JSON.stringify({ invoice: invoiceData.pr, fee_limit_sats: Math.max(100, Math.floor(satsToSend * 0.01)) }),
+                    });
+                    if (payStatus === 200 && payData.success) {
+                      return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "strike_handle_via_lightning", recipient, lightning_address: lightningAddr, amount_sats: satsToSend, fee_sats: payData.fee_sats || 0, payment_hash: payData.payment_hash, message: `Sent ${satsToSend} sats to ${recipient} via Lightning (${lightningAddr}) ⚡ — cheaper than Strike API` }) }] };
+                    }
+                    // Lightning failed — fall through to Strike API
+                  }
+                }
+              }
+            }
+          }
+        } catch (_) {
+          // LNURL resolution failed — fall through to Strike API
+        }
+      }
+
+      // Fall back to Strike API
+      const body = { handle, description: memo || `Payment to $${handle}` };
+      if (amount_usd) body.amount_usd = amount_usd;
+      if (satsToSend) body.amount_sats = satsToSend;
+      if (resolvedAgent) body.agent_id = resolvedAgent.id;
+      const { status, data } = await apiCall("/api/v1/strike/pay", {
+        method: "POST",
+        body: JSON.stringify(body),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "strike_handle_via_api", recipient, amount_usd: data.amount_usd, fee_usd: data.fee_usd || 0, payment_id: data.payment_id, message: `Sent to ${recipient} via Strike API 💸 (Lightning not available for this recipient)` }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else {
+      return { content: [{ type: "text", text: `Error: Unrecognized recipient format. Use a BOLT11 invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username).` }] };
+    }
+  }
+);
+
 // Tool: Decode Lightning invoice
 server.tool(
   "decode_invoice",