@blockchain0x/mcp સર્વર એક MCP હોસ્ટને પાંચ એજન્ટ-વોલેટ ટૂલ્સ આપે છે: એક વોલેટ વાંચો, વોલેટની યાદી બનાવો, એક ટ્રાન્ઝેક્શન ચકાસો, USDC પેમેન્ટ મોકલો, અને એક x402 ઇન્વોઇસ સમાધાન કરો. તેને npx @blockchain0x/mcp સાથે ચલાવો (તમારી કી તમારા મશીન પર રહે છે) અથવા હોસ્ટેડ URL પર નિશાન બનાવો. અલગથી, પેકેજ requirePayment ને નિકાસ કરે છે જેથી તમે તમારા પોતાના MCP ટૂલ્સ પર x402 402 પડકાર સાથે કિંમત મૂકી શકો.

તે ચલાવવા માટે બે રીતો. હોસ્ટેડ માટે કોઈ સ્થાપન નથી.

તેને stdio પર npx સાથે સ્થાનિક રીતે ચલાવો (તમારી કી તમારા મશીન પર રહે છે), અથવા કોઈપણ MCP હોસ્ટને હોસ્ટેડ Streamable HTTP URL પર સેટ કરો અને કી ને Bearer ટોકન તરીકે પસાર કરો. બંને સીધા હોસ્ટના MCP કન્ફિગમાં જડપાય છે. સ્થાનિક માર્ગ માટે નોડ 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.

જ્યારે વેબહૂક લેન્ડ થાય ત્યારે કૉલરને ચૂકવેલ તરીકે માર્ક કરો.

જ્યારે ચુકવણી સેટલ થાય છે, Blockchain0x તમારા વેબહુક URL પર સહી કરેલ payment.received ઇવેન્ટ પોસ્ટ કરે છે. તેને Node SDK માંથી webhooks.verify સાથે માન્ય કરો, પછી નોંધો કે કોલર જે પણ સ્ટોર તમે પહેલેથી ચલાવો છો તેમાં ચૂકવેલ છે. કન્ફિગર કરવા માટે કોઈ શિપ કરેલ રસીદ કેશ નથી - તમે તે ભાગના માલિક છો, જેનો અર્થ છે કે કોઈ આશ્ચર્ય ઇન્ફ્રાસ્ટ્રક્ચર નથી.

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 છે. જ્યાં તમે 'આ કોલર ચૂકવ્યું' જાળવી રાખો છો - ડેટાબેસની પંક્તિ, રેડિસ કી, એક જ પ્રક્રિયા માટે એક મેમરીમાં નકશો - તે તમારી કૉલ છે.

પાંચ MCP-વિશિષ્ટ જાળાઓથી બચવું.

આ પેઇડ MCP સર્વરો ચલાવતા ઓપરેટર્સ પાસેથી આવે છે. મોટાભાગે કેશ આર્કિટેક્ચર અને MCP પ્રોટોકોલના વિશિષ્ટ ભૂલ ફોર્મેટ સાથે સંબંધિત છે.