MCP ಮೂಲಕ Blockchain0x.
ಯಾವುದೇ MCP ಹೋಸ್ಟ್ - ಕ್ಲೋಡ್ ಡೆಸ್ಕ್ಟಾಪ್, ಕರ್ಸರ್, VS ಕೋಡ್ - ಏಜೆಂಟ್ ವಾಲೆಟ್ ಸಾಧನಗಳನ್ನು ಒಂದೇ ಕಾನ್ಫಿಗ್ ಬ್ಲಾಕ್ೊಂದಿಗೆ ನೀಡಿ. ಮತ್ತು ನೀವು ನಿಮ್ಮದೇ ಸಾಧನಗಳಿಗೆ ಶುಲ್ಕ ವಿಧಿಸಲು ಬಯಸಿದಾಗ, ನಿಜವಾದ requirePayment x402 ನಿರ್ಮಾಪಕವನ್ನು ಬಳಸಿರಿ.
@blockchain0x/mcp server MCP host ಗೆ ಐದು agent-wallet tools ನೀಡುತ್ತದೆ: wallet read ಮಾಡಿ, wallets list ಮಾಡಿ, transaction check ಮಾಡಿ, USDC payment send ಮಾಡಿ, ಮತ್ತು x402 invoice ಅನ್ನು settle ಮಾಡಿ. ಇದನ್ನು npx @blockchain0x/mcp ಮೂಲಕ run ಮಾಡಿ (ನಿಮ್ಮ key ನಿಮ್ಮ machine ನಲ್ಲಿಯೇ ಇರುತ್ತದೆ) ಅಥವಾ hosted URL ಅನ್ನು point ಮಾಡಿ. Separately, package requirePayment ಅನ್ನು export ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು x402 402 challenge ಮೂಲಕ ನಿಮ್ಮದೇ MCP tools ಗೆ price ಹಾಕಬಹುದು.
MCP ಮೂಲಕ spend ಮಾಡಿ. MCP ಮೂಲಕ charge ಮಾಡಿ.
ಕೆಲಸದ ಒಂದನೇ ಹಂತ: ಏಜೆಂಟ್ ಅನ್ನು ತನ್ನ ಹೋಸ್ಟ್ನ ಒಳಗೆ ವಾಲೆಟ್ ಬಳಸಲು ಅನುಮತಿಸಿ. @blockchain0x/mcp ಸರ್ವರ್ @blockchain0x/node SDK ಗೆ ಮೇಲೆ ಹೋಲಿಸುವ ಹಸಿರು, ರಾಜ್ಯರಹಿತ ಪ್ರಾಕ್ಸಿ. ಇದು ಕ್ಲೋಡ್ ಡೆಸ್ಕ್ಟಾಪ್, ಕರ್ಸರ್ ಅಥವಾ VS ಕೋಡ್ ಗೆ ಐದು ವಾಲೆಟ್ ಸಾಧನಗಳನ್ನು ಬಹಿರಂಗಗೊಳಿಸುತ್ತದೆ, ಮತ್ತು ನಿಮ್ಮ API ಕೀ ವ್ಯಾಪ್ತಿ, ಅನುಮತಿ ಮತ್ತು ಅವಧಿಯ ಮಿತಿಗಳನ್ನು ಬೆಂಬಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ. ಸರ್ವರ್ ಯಾವುದೇ ಕೀ ಹೊಂದಿಲ್ಲ ಮತ್ತು ಏನೂ ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ.
ಕೆಲಸದ ಎರಡನೇ ಹಂತ: ನಿಮ್ಮ ಸಾಧನಗಳನ್ನು ಕರೆ ಮಾಡಲು ಏಜೆಂಟ್ಗಳಿಗೆ ಶುಲ್ಕ ವಿಧಿಸಿ. MCP ಸಾಧನವನ್ನು ಕರೆ ಮಾಡುವುದನ್ನು ಸುಲಭಗೊಳಿಸಿದೆ, ಇದು ನಿಮ್ಮ ಸರ್ವರ್ ಉಚಿತವಾಗಿ ಹೊರಹೋಗುವ, ಟೋಕನ್ಗಳನ್ನು ಮತ್ತು ತೃತೀಯ ಪಕ್ಷದ API ವೆಚ್ಚಗಳನ್ನು ತಿನ್ನುವವರೆಗೆ ಉತ್ತಮವಾಗಿದೆ. 402 ಪಾವತಿ ಅಗತ್ಯವಿದೆ ಮಾದರಿ ಇಲ್ಲಿ ಸರಿಯಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. requirePayment ಒಂದು ಹೋಸ್ಟೆಡ್ ಚೆಕ್ಔಟ್ URL ಹೊಂದಿರುವ ಸಂರಚಿತ x402 ಸವಾಲುಗಳನ್ನು ಮಿಂಟ್ ಮಾಡುತ್ತದೆ; ನೀವು ಒಂದು ಸಾಧನವನ್ನು ಪಾವತಿಸದಾಗ ಅದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೀರಿ ಮತ್ತು ಪಾವತಿ ನಿಗಮಿಸಿದಾಗ ಕರೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತೀರಿ. x402 ಅನ್ನು ಮಾತನಾಡುವ ಕ್ಲೈಂಟ್ಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪಾವತಿಸುತ್ತವೆ; ಉಳಿದವು URL ಅನ್ನು ಮಾನವರಿಗೆ ತೋರಿಸುತ್ತವೆ.
ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಎರಡು ಮಾರ್ಗಗಳು. ಹೋಸ್ಟೆಡ್ ಒಂದಕ್ಕೆ ಯಾವುದೇ ಸ್ಥಾಪನೆ ಇಲ್ಲ.
ನಿಮ್ಮ ಯಂತ್ರದಲ್ಲಿ ಕೀ ಉಳಿಯುತ್ತದೆ, ಅಥವಾ ಯಾವುದೇ MCP ಹೋಸ್ಟ್ ಅನ್ನು ಹೋಸ್ಟ್ ಮಾಡಿದ Streamable HTTP URL ಗೆ ಸೂಚಿಸಿ ಮತ್ತು ಕೀ ಅನ್ನು Bearer ಟೋಕನ್ ಎಂದು ಒಯ್ಯಿರಿ. ಎರಡೂ ಹೋಸ್ಟ್ನ MCP ಕಾನ್ಫಿಗ್ ಗೆ ನೇರವಾಗಿ ಬಡುತ್ತದೆ. ಸ್ಥಳೀಯ ಮಾರ್ಗಕ್ಕಾಗಿ Node 20+.
{ "mcpServers": { "blockchain0x": { "command": "npx", "args": ["-y", "@blockchain0x/mcp"], "env": { "BLOCKCHAIN0X_API_KEY": "sk_live_...", "BLOCKCHAIN0X_API_BASE_URL": "https://api.blockchain0x.com" } } } }
{ "mcpServers": { "blockchain0x": { "url": "https://mcp.blockchain0x.com/mcp", "headers": { "Authorization": "Bearer sk_live_..." } } } }
BLOCKCHAIN0X_API_KEY ನಿಮ್ಮ ಡ್ಯಾಶ್ಬೋರ್ಡ್ನ sk_test_ testnet ಅಥವಾ sk_live_ mainnet ಕೀ; BLOCKCHAIN0X_API_BASE_URL https://api.blockchain0x.com ಗೆ ಡೀಫಾಲ್ಟ್ ಆಗಿದೆ. ಸರ್ವರ್ ನಿಮ್ಮ ಕೀ ಅನ್ನು ಬೆನ್ನುಹತ್ತಿದ ಕಡೆಗೆ ಮುಂದುವರಿಸುತ್ತದೆ ಮತ್ತು ಏನೂ ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಆ ಕೀ ಮೇಲೆ ವ್ಯಾಪ್ತಿ ಮತ್ತು ಮಿತಿಗಳು ಏಜೆಂಟ್ ಮಾಡಬಹುದಾದದ್ದೇ ಆಗಿವೆ. ಇದು ಹೊರಹಾಕುವ ಐದು ಸಾಧನಗಳು: get_wallet, list_wallets, get_transaction, send_payment, ಮತ್ತು settle_payment_request.
ನಿಜವಾದ requirePayment ನಿರ್ಮಾಪಕದೊಂದಿಗೆ ಸಾಧನವನ್ನು ನಿರ್ವಹಿಸಿ.
requirePayment @blockchain0x/mcp ನಿಂದ ಶುದ್ಧ ಕಾರ್ಯವಾಗಿದೆ. ನೀವು ಒಂದು ಸಾಧನವನ್ನು ಪಾವತಿಸದಾಗ ಇದನ್ನು ಕರೆ ಮಾಡುತ್ತೀರಿ, ಇದು x402 402 ಸವಾಲನ್ನು (ಬೆಲೆ, ನಿಮ್ಮ ವಾಲೆಟ್, ಹೋಸ್ಟೆಡ್ ಚೆಕ್ಔಟ್ URL) ಮಿಂಟ್ಸ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ನೀವು ಆ ಶರೀರವನ್ನು ಮಾನಕ MCP ದೋಷ ರೂಪದಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತೀರಿ. ಇದು ನಿಮ್ಮ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಮಡಿಸುತ್ತಿಲ್ಲ ಮತ್ತು ಯಾರಿಗೆ ಪಾವತಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಹಿಂಡುತ್ತಿಲ್ಲ - ಆ ಭಾಗವು ನಿಮ್ಮದು, ಇದು ಸಹಾಯಕರನ್ನು ಸಣ್ಣ ಮತ್ತು ಸತ್ಯವಾಗಿರಿಸುತ್ತದೆ.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { requirePayment } from "@blockchain0x/mcp"; import { z } from "zod"; const server = new McpServer({ name: "docs-search-mcp", version: "1.0.0" }); server.tool( "search_docs", "Semantic search across our private docs", { query: z.string() }, async ({ query }, extra) => { if (!hasPaid(extra)) { // Mint an x402 402 challenge and hand it back to the caller. const { body } = requirePayment({ amountUsdc: "0.10", payTo: "0xYourWallet", hostedUrl: "https://pay.blockchain0x.com/checkout/abc", }); return { content: [{ type: "text", text: JSON.stringify(body) }], isError: true }; } const results = await runVectorSearch(query); return { content: [{ type: "text", text: JSON.stringify(results) }] }; }, );
agent search_docs unpaid ಅನ್ನು ಕರೆ ಮಾಡಿದಾಗ, ಅದಕ್ಕೆ 402 body ಸಿಗುತ್ತದೆ. x402 ಮಾತನಾಡುವ clients ಗಳು ಅದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪಾವತಿಸುತ್ತವೆ; Claude Desktop ಮತ್ತು Cursor ಮಾನವನಿಗೆ checkout URL ಅನ್ನು ತೋರಿಸುತ್ತವೆ. ಪಾವತಿ settle ಆದ ನಂತರ ನೀವು ಆ ಕರೆ ಮಾಡಿದವರನ್ನು paid ಎಂದು ಗುರುತಿಸಿ (ಮುಂದಿನ ವಿಭಾಗ) ಮತ್ತು call ಮುಂದಕ್ಕೆ ಹೋಗುತ್ತದೆ. MCP ಒಂದಕ್ಕಿಂತ plain HTTP server ಅನ್ನು ಇಷ್ಟಪಡುತ್ತೀರಾ? receive-side x402 adapter - Express ಗಾಗಿ createX402Middleware, Fastify ಗಾಗಿ createX402Plugin - framework layer ನಲ್ಲಿ ಅದೇ gating ಅನ್ನು ಮಾಡುತ್ತದೆ.
ವೆಬ್ಹುಕ್ ಲ್ಯಾಂಡ್ ಆದಾಗ ಕರೆ ಮಾಡುವವರನ್ನು ಪಾವತಿಸಿದಂತೆ ಗುರುತಿಸಿ.
ಪಾವತಿ settle ಆದಾಗ, Blockchain0x ನಿಮ್ಮ webhook URL ಗೆ signed payment.received event ಅನ್ನು POST ಮಾಡುತ್ತದೆ. ಅದನ್ನು Node SDK ನ webhooks.verify ಮೂಲಕ verify ಮಾಡಿ, ನಂತರ ಕರೆ ಮಾಡಿದವರು ಪಾವತಿಸಿದ್ದಾರೆ ಎಂಬುದನ್ನು ನೀವು ಈಗಾಗಲೇ ಬಳಸುತ್ತಿರುವ ಯಾವುದೇ store ನಲ್ಲಿ ದಾಖಲಿಸಿ. configure ಮಾಡಲು shipped receipt cache ಇಲ್ಲ - ಆ ಭಾಗ ನಿಮ್ಮದೇ, ಆದ್ದರಿಂದ ಅಚ್ಚರಿ infrastructure ಏನೂ ಇಲ್ಲ.
import express from "express"; import { webhooks } from "@blockchain0x/node"; const app = express(); // Capture the RAW body. The HMAC is over the exact bytes on the wire. app.use(express.raw({ type: "application/json" })); app.post("/webhooks/payment", (req, res) => { const result = webhooks.verify({ headers: req.headers, rawBody: req.body, // Buffer, raw bytes secret: process.env.BLOCKCHAIN0X_WEBHOOK_SECRET!, }); if (!result.ok) return res.status(400).json({ code: result.code }); if (result.eventType === "payment.received") { // Mark this payer paid however you like - a DB row, a Redis key, your call. markPaid(result.eventId); } res.status(200).send("ok"); });
webhooks.verify HMAC-SHA256 ಅನ್ನು ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ವಿಭಜಿತ ಒಕ್ಕೂಟವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಪ್ರಯತ್ನ/ಪತ್ತೆ ಇಲ್ಲದೆ result.ok ನಲ್ಲಿ ಶಾಖೆ ಮಾಡುತ್ತೀರಿ. ಕಚ್ಚಾ ಶರೀರವನ್ನು ಓದಿ, ವಿಶ್ಲೇಷಿತ ನಕಲನ್ನು ಅಲ್ಲ, ಏಕೆಂದರೆ ಸಹಿ ನಿಖರವಾದ ಬೈಟ್ಗಳನ್ನು ಆವರಿಸುತ್ತದೆ. ಸಾಗಿಸಲಾದ ಘಟನೆಗಳು payment.received, payment.sent, wallet.deployed, ಮತ್ತು webhook.test; ನಿಮ್ಮ ವಾಲೆಟ್ಗೆ ಪಾವತಿ payment.received. 'ಈ ಕರೆ ಮಾಡಿದವರು ಪಾವತಿಸಿದ' ಅನ್ನು ನೀವು ಉಳಿಸುವ ಸ್ಥಳ - ಡೇಟಾಬೇಸ್ ಸಾಲು, Redis ಕೀ, ಒಬ್ಬ ಪ್ರಕ್ರಿಯೆಗೆ ನೆನಪಿನ ನಕ್ಷೆ - ನಿಮ್ಮ ಕರೆ.
ಸರ್ವರ್ ತೆರೆದ ಮತ್ತು ರಾಜ್ಯರಹಿತವಾಗಿದೆ. ಇದನ್ನು ಓದಿ.
MCP server ಮತ್ತು requirePayment builder Node SDK ಮೇಲೆ ಇರುವ thin pass-through ಆಗಿವೆ, ಯಾವುದೇ database ಅಥವಾ volumes ಇಲ್ಲ, ಆದ್ದರಿಂದ audit ಮಾಡಲು ಹೆಚ್ಚು ಏನೂ ಇಲ್ಲ - ಅದು ಉದ್ದೇಶವೇ. Native MCP OAuth 2.1 ಮುಂದಿನ planned follow-up ಆಗಿದೆ; pasted-key path ಮೊದಲು ship ಆಗುತ್ತದೆ, ಏಕೆಂದರೆ ಅದು ಈಗಿರುವ API-key trust model ಅನ್ನು reuse ಮಾಡುತ್ತದೆ.
github.com/tosh-labs/blockchain0x-nodeಪೂರ್ಣ tool list, scopes, ಮತ್ತು hosted environment URLs ಗಳನ್ನು the docs ನಲ್ಲಿ document ಮಾಡಲಾಗಿದೆ. real key ಅನ್ನು point ಮಾಡುವ ಮೊದಲು ಪರೀಕ್ಷಿಸಲು production ಜೊತೆಗೆ staging ಮತ್ತು dev hosted endpoints ಲಭ್ಯವಿವೆ.
ಐದು MCP-ನಿರ್ದಿಷ್ಟ ಬಲೆಗೆಗಳನ್ನು ತಪ್ಪಿಸಲು.
ಇವು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಪಾವತಿತ MCP ಸರ್ವರ್ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರುವ ಕಾರ್ಯನಿರ್ವಹಕರಿಂದ ಬರುತ್ತವೆ. ಬಹಳಷ್ಟು ಕ್ಯಾಶ್ ವಾಸ್ತುಶಿಲ್ಪ ಮತ್ತು MCP ಪ್ರೋಟೋಕಾಲ್ನ ನಿರ್ದಿಷ್ಟ ದೋಷ ರೂಪಕ್ಕೆ ಸಂಬಂಧಿಸುತ್ತವೆ.
requirePayment ಒಂದು ನಿರ್ಮಾಪಕ, ಮಧ್ಯಮವಿಲ್ಲ
requirePayment ಒಂದು ಶುದ್ಧ ಕಾರ್ಯವಾಗಿದೆ: ನೀವು ಇದನ್ನು ಕರೆ ಮಾಡುತ್ತೀರಿ, ಇದು { status: 402, body } ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಮತ್ತು ನೀವು ಒಂದು ಸಾಧನವನ್ನು ಪಾವತಿಸದಾಗ ಆ ಶರೀರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೀರಿ. ಇದು ನಿಮ್ಮ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಮಡಿಸುತ್ತಿಲ್ಲ, ಇದು ಯಾರಿಗೆ ಪಾವತಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಹಿಂಡುತ್ತಿಲ್ಲ, ಮತ್ತು ಇದು ಯಾವುದೇ ಕಾರಣ ಅಥವಾ ಕ್ಯಾಶ್-ವಿಂಡೋ ಆಯ್ಕೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ - ಕೇವಲ amountUsdc, payTo, hostedUrl, ಮತ್ತು ಆಯ್ಕೆಯ ನೆಟ್ವರ್ಕ್ ಮತ್ತು ವಿವರಣೆಯನ್ನು ಮಾತ್ರ. ಪಾವತಿ ರಾಜ್ಯವನ್ನು ಹಿಂಡುವುದು ನಿಮ್ಮ ಕೆಲಸ: ನಿಮ್ಮ ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ಒಂದು ಸಾಲು, ನಿಮ್ಮದೇ Redis ನಲ್ಲಿ ಒಂದು ಕೀ, ಏನಾದರೂ ಹೊಂದಿಸುತ್ತದೆ. Blockchain0x ಸವಾಲು ನಿರ್ಮಾಪಕ ಮತ್ತು ನಿಗಮ ವೆಬ್ಹುಕ್ ಅನ್ನು ಸಾಗಿಸುತ್ತದೆ, ಬಿಲ್ ಕ್ಯಾಶ್ ಅನ್ನು ಅಲ್ಲ.
stdio ನಿಮ್ಮ ಕೀ ಅನ್ನು ನಿಮ್ಮ ಯಂತ್ರದಲ್ಲಿ ಇಡುತ್ತದೆ
npx ಮತ್ತು ಪರಿಸರದಲ್ಲಿ BLOCKCHAIN0X_API_KEY ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸರ್ವರ್ ಅನ್ನು ಚಾಲನೆ ನೀಡಿ, ಮತ್ತು ಕೀ ನಿಮ್ಮ ಬಾಕ್ಸ್ ಅನ್ನು ಬಿಟ್ಟು ಹೋಗುವುದಿಲ್ಲ - ಇದು ಸ್ಥಳೀಯವಾಗಿ ಓದಲಾಗುತ್ತದೆ, ನೆಟ್ವರ್ಕ್ ಹೆಡರ್ನಂತೆ ಕಳುಹಿಸಲಾಗುವುದಿಲ್ಲ. ಹೋಸ್ಟ್ ಮಾಡಿದ URL ವಿರುದ್ಧ ವ್ಯಾಪಾರವಾಗಿದೆ: ಶೂನ್ಯ ಸ್ಥಾಪನೆ, ಆದರೆ ನೀವು mcp.blockchain0x.com ಗೆ Bearer ಟೋಕನ್ ಎಂದು ಕೀ ಅನ್ನು ಪೇಸ್ಟ್ ಮಾಡುತ್ತೀರಿ. ಡೆವೆಲಪರ್ನ ಸ್ವಂತ ಯಂತ್ರಕ್ಕಾಗಿ stdio ಆಯ್ಕೆ ಮಾಡಿ, ಹಂಚಿದ ನಿಯೋಜನೆಯಿಗಾಗಿ ಹೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ.
ಡ್ಯಾಶ್ಬೋರ್ಡ್-ಮಾತ್ರ ಮೇಲ್ಮಟ್ಟಗಳನ್ನು ಬಹಿರಂಗಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ
ಸರ್ವರ್ @blockchain0x/node ಮೇಲೆ ಒಂದು ಬಡ, ರಾಜ್ಯರಹಿತ ಪ್ರಾಕ್ಸಿ ಆಗಿದೆ. ಇದು ನಿಖರವಾಗಿ ಐದು ಉಪಕರಣಗಳನ್ನು ಮೇಲ್ಮಟ್ಟಕ್ಕೆ ತರುತ್ತದೆ: get_wallet, list_wallets, get_transaction, send_payment, settle_payment_request. ಗುರುತಿನ ಬದಲಾವಣೆಗಳು, API-ಕೀ ಮತ್ತು ವೆಬ್ಹುಕ್ CRUD, ಹಿಂಪಡೆಯುವಿಕೆಗಳು ಮತ್ತು ಬಿಲ್ಲಿಂಗ್ API-ಕೀ ಪ್ರಮಾಣೀಕರಣದ ಅಡಿಯಲ್ಲಿ ಕಠಿಣವಾಗಿ ತಡೆಹಿಡಿಯಲ್ಪಟ್ಟಿವೆ ಮತ್ತು ಸರ್ವರ್ ಎಂದಿಗೂ SDK ಗೆ ತಲುಪುವುದಿಲ್ಲ. ಅವುಗಳಿಗೆ ಒಂದು ಉಪಕರಣವನ್ನು ನಿರೀಕ್ಷಿಸಬೇಡಿ - ಅವು ವಿನ್ಯಾಸದ ಪ್ರಕಾರ ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿ ಜೀವಿಸುತ್ತವೆ.
send_payment idempotent ಆಗಿದೆ ಮತ್ತು ಪುನರಾವೃತ್ತವಾಗುವುದಿಲ್ಲ
The send_payment tool wraps payments.create: it auto-mints an Idempotency-Key so a retried call collapses to one transfer, and it does not retry on its own. It can also answer 503 until the chain adapter is wired for your network. If the model gets a 503, do not let it hammer the tool - surface the state and move on. amountWei is USDC base units (6 decimals), so 0.01 USDC is the string "10000".
requirePayment ನಲ್ಲಿ amountUsdc 6-ದಶಮಾಂಶದ ಸ್ಟ್ರಿಂಗ್
requirePayment validates amountUsdc as a USDC decimal with at most six fractional digits, so "0.10" is fine and "0.1234567" throws. payTo and hostedUrl are required; network defaults to mainnet. Keep the hostedUrl pointing at a real checkout you control (the pattern is https://pay.blockchain0x.com/checkout/<id>). A malformed amount fails fast rather than minting a broken challenge.