createClient କୁ @blockchain0x/node (କିମ୍ବା Python client)ରୁ ଏକ ଏଜେଣ୍ଟ ସୃଷ୍ଟି କର, payments.create ସହିତ USDC ଦେୟ ପଠାଇ, ଏବଂ webhooks.verify ସହିତ ସାଇନ୍ କରାଯାଇଥିବା ଓବ୍‌ହେକ୍ କୁ ନିଶ୍ଚୟ କର। ବ୍ୟୟ ନିୟନ୍ତ୍ରଣଗୁଡିକ ଡ୍ୟାସ୍ବୋର୍ଡ୍ରେ ସେଟ୍ କରାଯାଇଛି ଏବଂ API ଉପରେ ପଢ଼ିବାକୁ ମାତ୍ର। ଏଜେଣ୍ଟ କେବଳ ଗୋପନ କୀଗୁଡିକୁ ସିଧାସଳକ ଚୁଇଁନାହିଁ। ସାଇନ୍-ଅପ୍ କରିବାରୁ ଦଶ ମିନିଟ୍ ମଧ୍ୟରେ Base ଉପରେ ତୁମର ପ୍ରଥମ USDC ଦେୟ, TypeScript କିମ୍ବା Python ରେ।

ଏଜେଣ୍ଟ ପ୍ରୋଫାଇଲ୍ ସୃଷ୍ଟି କରନ୍ତୁ।

agent profile ହେଉଛି ଆପଣଙ୍କ agent ଯେ ପ୍ରତ୍ୟେକ payment ପଠାଏ କିମ୍ବା ଗ୍ରହଣ କରେ, ସେହାର ପଛରେ ଥିବା addressable identity। ଏଥିରେ wallet address, public page, verification badges, ଏବଂ (ପରେ) spend policy ଅଛି। ପ୍ରତ୍ୟେକ logical agent ପାଇଁ ଗୋଟିଏ create କରନ୍ତୁ।

import { createClient } from "@blockchain0x/node";

const client = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! }); // sk_test_ / sk_live_

const agent = await client.agents.create({ name: "research-bot" });

console.log(agent.id); // "agt_..."
// Public page: https://wallet.blockchain0x.com/a/{slug}

from blockchain0x import Client

client = Client()  # reads BLOCKCHAIN0X_API_KEY from the environment

agent = client.agents.create(body={"name": "research-bot"})

print(agent["id"])  # "agt_..."
# Public page: https://wallet.blockchain0x.com/a/{slug}

After this call, the agent has a public page at https://wallet.blockchain0x.com/a/<slug> that any counterparty (human or agent) can hover for verification info. See the agent payment identity glossary entry for what that page exposes.

ୱେବହୁକ୍ କୁ ହ୍ୟାଣ୍ଡଲ୍ କରନ୍ତୁ।

ଓେଭୁକ୍‌ଗୁଡିକ ହେଉଛି କିପରି ଆପଣ ଜାଣିବେ ଯେ ଏକ ଦେୟ ସମାଧାନ ହୋଇଛି। Node ରେ, @blockchain0x/node ରୁ webhooks.verify HMAC ଚେକ୍ କରେ ଏବଂ ଏକ ଭିନ୍ନ ଯୁଗ୍ମକୁ ଫେରାଇବା; ଅନ୍ୟ ଭାଷାରେ, କଚା ଦେହରେ ସେହି HMAC କୁ ଗଣନା କରନ୍ତୁ। ଘଟଣା ପ୍ରକାର (inbound ପାଇଁ payment.received) ଉପରେ ଶାଖା କରନ୍ତୁ, 2xx ଦ୍ରୁତ ଭାବେ ପ୍ରତିକ୍ରିୟା କରନ୍ତୁ, ଏବଂ 2xx ର ପଛରେ କିଛି ଭାରୀ କୁ କ୍ୟୁ କରନ୍ତୁ ଯାହା ଡିଲିଭରୀ ସମୟ ସମାପ୍ତ ହେବାକୁ ନାହିଁ।

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") {
    // USDC landed - deliver the work, fulfil the order, etc.
    void deliver(result.eventId);
  }
  res.status(200).send("ok");
});

import hmac, hashlib, os, time
from flask import Flask, request, abort

app = Flask(__name__)
SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode()

@app.post("/webhooks/payment")
def webhook():
    raw = request.get_data()  # RAW bytes - do not parse first
    sig = request.headers.get("X-Blockchain0x-Signature", "")
    ts = request.headers.get("X-Blockchain0x-Timestamp", "")
    parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p)
    t, v1 = parts.get("t", ts), parts.get("v1", sig)
    want = hmac.new(SECRET, t.encode() + b"." + raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(want, v1) or abs(time.time() - int(t)) > 300:
        abort(401)
    if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received":
        deliver(request.get_json())  # USDC landed
    return ("ok", 200)

Base Sepolia ରେ ସମସ୍ତ ପ୍ରବାହକୁ ପରୀକ୍ଷା କରନ୍ତୁ।

sk_live_ keys କୁ flip କରିବା ପୂର୍ବରୁ, sk_test_ ସହିତ ସମ୍ପୂର୍ଣ୍ଣ path କୁ end-to-end ଚଳାନ୍ତୁ। test key ସବୁକିଛିକୁ Base Sepolia ରେ ରଖେ, ଯେଉଁଠାରେ ଆପଣ public faucet ରୁ wallet କୁ fund କରନ୍ତି ଏବଂ response shapes live ସହିତ ମେଳ ଖାଏ। key prefix network ଚୟନ କରେ, ସେଥିପାଇଁ test key କୌଣସି mainnet funds move କରିପାରେ ନାହିଁ।

ତିନୋଟି ପରିସ୍ଥିତିରେ ଅଭ୍ୟାସ କରନ୍ତୁ: ଏକ ସୁଖଦ-ପଥ ଭୁଗତାନ ଯାହା payment.received କୁ ଅନ୍ୟାନ୍ୟ କରେ, ଏକ ମିସ୍ ଡେଲିଭରୀ (ୱେବହୁକ୍କୁ ଏକ ମୃତ URL ଦିଆଯାଉ, ପରେ transactions.get ସହିତ ଲେନଦେନ ଆଣିବା ଦ୍ୱାରା ସମ୍ପର୍କ କରନ୍ତୁ), ଏବଂ ଏକ ୱେବହୁକ୍ ପୁନର୍ପ୍ରୟାସ (ପ୍ରଥମ ବେଳେ 500 ଫେରାଇବେ, ଦ୍ୱିତୀୟ ବେଳେ 200, ଏବଂ ଆପଣଙ୍କର ହ୍ୟାଣ୍ଡଲର୍ idempotent ହେବାକୁ ନିଶ୍ଚିତ କରନ୍ତୁ)। ଯେତେବେଳେ ତିନୋଟି ପରୀକ୍ଷାରେ ପାସ୍ ହୁଏ, କୀ ବଦଳାନ୍ତୁ ଏବଂ ଜାହାଜ କରନ୍ତୁ।

ଯେତେବେଳେ ତୁମର ପ୍ରଥମ ପେମେଣ୍ଟ ହେବ।

ମୌଳିକ payments କାମ କରୁଥିବାବେଳେ, ସବୁଠୁ ଅଧିକ ଲାଭଦାୟକ follow-up ଗୁଡ଼ିକ ହେଲା spend controls (ଯାହାଦ୍ୱାରା agent budget ସହିତ ପଳାଇ ନପାରେ), webhook robustness (ଯାହାଦ୍ୱାରା load ତଳେ payments ଚୁପଚାପ ହରାଇ ନଯାଏ), ଏବଂ identity verification (ଯାହାଦ୍ୱାରା counterparties agent ର public page ଉପରେ trust କରନ୍ତି)।

docs.blockchain0x.com ରେ ପୂର୍ଣ୍ଣ API ସନ୍ଦର୍ଭ ଅଛି। ସେହି APIs ପାଇଁ ଉତ୍ପାଦ ସତହ: Payment API.