Blockchain0x MCP ਦੇ ਉੱਪਰ।
ਕਿਸੇ ਵੀ MCP ਹੋਸਟ - Claude Desktop, Cursor, VS Code - ਏਜੰਟ ਵੈਲਟ ਟੂਲ ਇੱਕ ਸੰਰਚਨਾ ਬਲਾਕ ਨਾਲ ਦਿਓ। ਅਤੇ ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੇ ਟੂਲਾਂ ਲਈ ਚਾਰਜ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਅਸਲੀ 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 ਨਾਲ ਚਲਾਓ (ਤੁਹਾਡੀ key ਤੁਹਾਡੀ machine 'ਤੇ ਹੀ ਰਹਿੰਦੀ ਹੈ) ਜਾਂ hosted URL ਵੱਲ point ਕਰੋ। ਵੱਖਰੇ ਤੌਰ 'ਤੇ, package requirePayment export ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਆਪਣੇ MCP tools ਲਈ x402 402 challenge ਨਾਲ price set ਕਰ ਸਕੋ।
MCP ਰਾਹੀਂ spend ਕਰੋ। MCP ਰਾਹੀਂ charge ਕਰੋ।
ਕਾਮ ਇੱਕ: ਇੱਕ ਏਜੰਟ ਨੂੰ ਆਪਣੇ ਹੋਸਟ ਦੇ ਅੰਦਰੋਂ ਇੱਕ ਵੈਲਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਿਓ। @blockchain0x/mcp ਸਰਵਰ @blockchain0x/node SDK 'ਤੇ ਇੱਕ ਪਤਲਾ, ਬਿਨਾਂ ਰਾਜ ਵਾਲਾ ਪ੍ਰਾਕਸੀ ਹੈ। ਇਹ Claude Desktop, Cursor, ਜਾਂ VS Code ਨੂੰ ਪੰਜ ਵੈਲਟ ਟੂਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਡੇ API ਕੁੰਜੀ ਦਾ ਸਕੋਪ, ਆਲਾਊਂਸ, ਅਤੇ ਪ੍ਰਤੀ-ਪੀਰੀਅਡ ਸੀਮਾਵਾਂ ਬੈਕਐਂਡ ਦੁਆਰਾ ਕਿਸੇ ਹੋਰ API ਕਾਲ ਦੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਸਰਵਰ ਕਿਸੇ ਵੀ ਕੁੰਜੀ ਨੂੰ ਰੱਖਦਾ ਨਹੀਂ ਹੈ ਅਤੇ ਕੁਝ ਵੀ ਸਟੋਰ ਨਹੀਂ ਕਰਦਾ।
ਕਾਮ ਦੋ: ਏਜੰਟਾਂ ਨੂੰ ਆਪਣੇ ਟੂਲਾਂ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਚਾਰਜ ਕਰੋ। MCP ਨੇ ਟੂਲ ਆਗਿਆ ਨੂੰ ਬਿਨਾ ਰੁਕਾਵਟ ਬਣਾਇਆ, ਜੋ ਸ਼ਾਨਦਾਰ ਹੈ ਜਦ ਤੱਕ ਤੁਹਾਡਾ ਸਰਵਰ ਮੁਫਤ ਵਿੱਚ ਬਾਹਰ ਜਾਣ, ਟੋਕਨ, ਅਤੇ ਤੀਜੀ ਪਾਰਟੀ API ਖਰਚ ਕਰ ਰਿਹਾ ਹੈ। 402 ਭੁਗਤਾਨ ਦੀ ਲੋੜ ਪੈਟਰਨ ਇੱਥੇ ਬਿਲਕੁਲ ਫਿੱਟ ਹੁੰਦਾ ਹੈ। requirePayment ਇੱਕ ਹੋਸਟ ਕੀਤੀ ਚੈਕਆਉਟ URL ਨਾਲ ਇੱਕ ਸੰਰਚਿਤ x402 ਚੈਲੰਜ ਬਣਾਉਂਦਾ ਹੈ; ਤੁਸੀਂ ਇਸਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹੋ ਜਦੋਂ ਇੱਕ ਟੂਲ ਭੁਗਤਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੁੰਦਾ ਅਤੇ ਭੁਗਤਾਨ ਨਿਪਟਾਰਾ ਹੋਣ 'ਤੇ ਕਾਲ ਨੂੰ ਆਗੇ ਜਾਣ ਦਿੰਦੇ ਹੋ। ਜੋ ਕਲਾਇੰਟ x402 ਬੋਲਦੇ ਹਨ ਉਹ ਆਪਣੇ ਆਪ ਭੁਗਤਾਨ ਕਰਦੇ ਹਨ; ਬਾਕੀ ਮਨੁੱਖ ਨੂੰ URL ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਨ।
ਇਸਨੂੰ ਚਲਾਉਣ ਦੇ ਦੋ ਤਰੀਕੇ। ਹੋਸਟ ਕੀਤੇ ਗਏ ਲਈ ਕੋਈ ਇੰਸਟਾਲ ਨਹੀਂ।
ਇਸਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ stdio ਰਾਹੀਂ npx ਨਾਲ ਚਲਾਓ (ਤੁਹਾਡੀ ਕੁੰਜੀ ਤੁਹਾਡੇ ਮਸ਼ੀਨ 'ਤੇ ਰਹਿੰਦੀ ਹੈ), ਜਾਂ ਕਿਸੇ ਵੀ 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_ ਟੈਸਟਨੈੱਟ ਜਾਂ sk_live_ ਮੈਨੇਟ ਕੁੰਜੀ ਹੈ; 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 call ਕਰਦਾ ਹੈ, ਉਸਨੂੰ 402 body ਮਿਲਦੀ ਹੈ। x402 ਸਮਝਣ ਵਾਲੇ clients ਇਸਨੂੰ ਆਪਣੇ ਆਪ pay ਕਰ ਦਿੰਦੇ ਹਨ; Claude Desktop ਅਤੇ Cursor human ਲਈ checkout URL ਦਿਖਾਉਂਦੇ ਹਨ। ਜਦੋਂ payment settle ਹੋ ਜਾਵੇ, ਤੁਸੀਂ ਉਸ caller ਨੂੰ paid mark ਕਰਦੇ ਹੋ (ਅਗਲਾ section) ਅਤੇ call pass ਹੋ ਜਾਂਦੀ ਹੈ। MCP ਦੀ ਥਾਂ plain HTTP server ਪਸੰਦ ਹੈ? Receive-side x402 adapter - Express ਲਈ createX402Middleware, Fastify ਲਈ createX402Plugin - framework layer 'ਤੇ ਉਹੀ gating ਕਰਦਾ ਹੈ।
ਜਦੋਂ webhook ਲੈਂਡ ਕਰਦਾ ਹੈ, ਕਾਲਰ ਨੂੰ ਭੁਗਤਾਨ ਕੀਤਾ ਮਾਰਕ ਕਰੋ।
ਜਦੋਂ payment settle ਹੁੰਦੀ ਹੈ, Blockchain0x ਤੁਹਾਡੇ webhook URL 'ਤੇ ਇੱਕ signed payment.received event POST ਕਰਦਾ ਹੈ। ਇਸਨੂੰ Node SDK ਤੋਂ webhooks.verify ਨਾਲ verify ਕਰੋ, ਫਿਰ ਇਹ ਦਰਜ ਕਰੋ ਕਿ caller ਨੇ ਭੁਗਤਾਨ ਕੀਤਾ ਹੈ ਉਸ store ਵਿੱਚ ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਚਲਾ ਰਹੇ ਹੋ। Configure ਕਰਨ ਲਈ ਕੋਈ shipped receipt cache ਨਹੀਂ ਹੈ - ਉਹ ਹਿੱਸਾ ਤੁਹਾਡਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕੋਈ surprise 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 ਕੁੰਜੀ, ਇੱਕ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਲਈ ਮੈਮੋਰੀ ਵਿੱਚ ਨਕਸ਼ਾ - ਇਹ ਤੁਹਾਡਾ ਫੈਸਲਾ ਹੈ।
Server open ਅਤੇ stateless ਹੈ। ਇਸਨੂੰ ਪੜ੍ਹੋ।
MCP server ਅਤੇ requirePayment builder Node SDK ਉੱਤੇ ਇੱਕ thin pass-through ਹਨ, ਬਿਨਾਂ database ਅਤੇ ਬਿਨਾਂ volumes ਦੇ, ਇਸ ਲਈ audit ਕਰਨ ਲਈ ਬਹੁਤ ਕੁਝ ਨਹੀਂ - ਅਤੇ ਇਹੀ point ਹੈ। Native MCP OAuth 2.1 ਇੱਕ planned follow-up ਹੈ; pasted-key path ਪਹਿਲਾਂ ship ਹੁੰਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ existing API-key trust model ਨੂੰ reuse ਕਰਦੀ ਹੈ।
github.com/tosh-labs/blockchain0x-nodeਪੂਰੀ tool list, scopes, ਅਤੇ hosted environment URLs the docs 'ਤੇ documented ਹਨ। Production ਦੇ ਨਾਲ staging ਅਤੇ dev hosted endpoints ਵੀ ਮੌਜੂਦ ਹਨ ਤਾਂ ਜੋ ਤੁਸੀਂ real key ਲਗਾਉਣ ਤੋਂ ਪਹਿਲਾਂ test ਕਰ ਸਕੋ।
ਪੰਜ MCP-ਵਿਸ਼ੇਸ਼ ਜਾਲਾਂ ਤੋਂ ਬਚਣ ਲਈ।
ਇਹ ਉਨ੍ਹਾਂ ਓਪਰੇਟਰਾਂ ਤੋਂ ਆਉਂਦੇ ਹਨ ਜੋ ਉਤਪਾਦਨ ਵਿੱਚ ਭੁਗਤਾਨ ਕੀਤੇ MCP ਸਰਵਰ ਚਲਾਉਂਦੇ ਹਨ। ਜ਼ਿਆਦਾਤਰ ਕੈਸ਼ ਆਰਕੀਟੈਕਚਰ ਅਤੇ MCP ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਵਿਸ਼ੇਸ਼ ਗਲਤੀ ਫਾਰਮੈਟ ਨਾਲ ਸੰਬੰਧਿਤ ਹੁੰਦੇ ਹਨ।
requirePayment ਇੱਕ ਬਿਲਡਰ ਹੈ, ਮਿਡਲਵੇਅਰ ਨਹੀਂ
requirePayment ਇੱਕ ਸ਼ੁੱਧ ਫੰਕਸ਼ਨ ਹੈ: ਤੁਸੀਂ ਇਸਨੂੰ ਕਾਲ ਕਰਦੇ ਹੋ, ਇਹ { status: 402, body } ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਉਸ ਸਰੀਰ ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹੋ ਜਦੋਂ ਇੱਕ ਸੰਦ ਅਣਭੁਗਤਾਨ ਹੁੰਦਾ ਹੈ। ਇਹ ਤੁਹਾਡੇ ਹੈਂਡਲਰ ਨੂੰ ਲਪੇਟਦਾ ਨਹੀਂ ਹੈ, ਇਹ ਨਹੀਂ ਟ੍ਰੈਕ ਕਰਦਾ ਕਿ ਕਿਸਨੇ ਭੁਗਤਾਨ ਕੀਤਾ, ਅਤੇ ਇਹ ਕੋਈ ਕਾਰਨ ਜਾਂ ਕੈਸ਼-ਵਿੰਡੋ ਵਿਕਲਪ ਨਹੀਂ ਲੈਂਦਾ - ਸਿਰਫ amountUsdc, payTo, hostedUrl, ਅਤੇ ਇੱਕ ਵਿਕਲਪੀ ਨੈੱਟਵਰਕ ਅਤੇ ਵੇਰਵਾ। ਭੁਗਤਾਨ ਦੀ ਸਥਿਤੀ ਨੂੰ ਟ੍ਰੈਕ ਕਰਨਾ ਤੁਹਾਡਾ ਕੰਮ ਹੈ: ਤੁਹਾਡੇ ਡਾਟਾਬੇਸ ਵਿੱਚ ਇੱਕ ਪੰਨਾ, ਆਪਣੇ Redis ਵਿੱਚ ਇੱਕ ਕੁੰਜੀ, ਜੋ ਕੁਝ ਵੀ ਫਿੱਟ ਕਰਦਾ ਹੈ। Blockchain0x ਚੁਣੌਤੀ ਬਿਲਡਰ ਅਤੇ ਸੈਟਲਮੈਂਟ webhook ਭੇਜਦਾ ਹੈ, ਨਾ ਕਿ ਇੱਕ ਰਸੀਦ ਕੈਸ਼।
stdio ਤੁਹ Keys ਨੂੰ ਤੁਹਾਡੇ ਮਸ਼ੀਨ 'ਤੇ ਰੱਖਦਾ ਹੈ
npx ਨਾਲ ਸਰਵਰ ਚਲਾਓ ਅਤੇ BLOCKCHAIN0X_API_KEY ਨੂੰ ਵਾਤਾਵਰਣ ਵਿੱਚ ਰੱਖੋ, ਅਤੇ ਕੁੰਜੀ ਕਦੇ ਵੀ ਤੁਹਾਡੇ ਬਾਕਸ ਤੋਂ ਨਹੀਂ ਨਿਕਲਦੀ - ਇਹ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਪੜ੍ਹੀ ਜਾਂਦੀ ਹੈ, ਨੈੱਟਵਰਕ ਹੈਡਰ ਦੇ ਤੌਰ 'ਤੇ ਨਹੀਂ ਭੇਜੀ ਜਾਂਦੀ। ਹੋਸਟ ਕੀਤਾ ਗਿਆ URL ਵਿਰੋਧੀ ਵਪਾਰ ਹੈ: ਜ਼ੀਰੋ ਇੰਸਟਾਲ, ਪਰ ਤੁਸੀਂ ਕੁੰਜੀ ਨੂੰ mcp.blockchain0x.com 'ਤੇ Bearer ਟੋਕਨ ਦੇ ਤੌਰ 'ਤੇ ਪੇਸਟ ਕਰਦੇ ਹੋ। ਵਿਕਾਸਕ ਦੀ ਆਪਣੀ ਮਸ਼ੀਨ ਲਈ stdio ਚੁਣੋ, ਸਾਂਝੇ ਡਿਪਲੋਇਮੈਂਟ ਲਈ ਹੋਸਟ ਕੀਤਾ ਗਿਆ।
ਡੈਸ਼ਬੋਰਡ-ਸਿਰਫ ਸਤਹਾਂ ਨੂੰ ਪ੍ਰਗਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ
Server @blockchain0x/node ਉੱਤੇ ਇੱਕ ਪਤਲਾ, stateless proxy ਹੈ। ਇਹ ਬਿਲਕੁਲ ਪੰਜ tools ਦਿਖਾਉਂਦਾ ਹੈ: get_wallet, list_wallets, get_transaction, send_payment, settle_payment_request. Identity changes, API-key ਅਤੇ webhook CRUD, withdrawals, ਅਤੇ billing ਨੂੰ API-key auth ਹੇਠ hard-block ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ server ਕਦੇ ਵੀ SDK ਤੋਂ ਅੱਗੇ ਨਹੀਂ ਜਾਂਦਾ। ਇਨ੍ਹਾਂ ਲਈ ਕਿਸੇ tool ਦੀ ਉਮੀਦ ਨਾ ਕਰੋ - ਇਹ design ਮੁਤਾਬਕ dashboard ਵਿੱਚ ਹੀ ਹਨ।
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.