createClient ಅನ್ನು @blockchain0x/node (ಅಥವಾ Python ಕ್ಲೈಂಟ್) ನಿಂದ ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ, payments.create ನೊಂದಿಗೆ USDC ಪಾವತಿಯನ್ನು ಕಳುಹಿಸಿ ಮತ್ತು webhooks.verify ನೊಂದಿಗೆ ಒಪ್ಪಿಗೆಯ ವೆಬ್‌ಹುಕ್ ಅನ್ನು ದೃಢೀಕರಿಸಿ. ಖರ್ಚು ನಿಯಂತ್ರಣಗಳು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ ಮತ್ತು API ಮೂಲಕ ಓದಲು ಮಾತ್ರ. ಏಜೆಂಟ್ ಎಂದಿಗೂ ಖಾಸಗಿ ಕೀಗಳನ್ನು ನೇರವಾಗಿ ತಲುಪುವುದಿಲ್ಲ. TypeScript ಅಥವಾ Python ನಲ್ಲಿ Base ನಲ್ಲಿ ನಿಮ್ಮ ಮೊದಲ USDC ಪಾವತಿಗೆ ನೋಂದಾಯಿಸುವುದರಿಂದ ಹತ್ತು ನಿಮಿಷಗಳ ಒಳಗೆ.

ಏಜೆಂಟ್ ಪ್ರೊಫೈಲ್ ಅನ್ನು ರಚಿಸಿ.

ಏಜೆಂಟ್ ಪ್ರೊಫೈಲ್ ನಿಮ್ಮ ಏಜೆಂಟ್ ಕಳುಹಿಸುವ ಅಥವಾ ಸ್ವೀಕರಿಸುವ ಪ್ರತಿಯೊಂದು ಪಾವತಿಯ ಹಿಂದೆ ಇರುವ ವಿಳಾಸದ ಗುರುತಾಗಿದೆ. ಇದು ವಾಲೆಟ್ ವಿಳಾಸ, ಸಾರ್ವಜನಿಕ ಪುಟ, ಪರಿಶೀಲನಾ ಬ್ಯಾಡ್ಜ್‌ಗಳು ಮತ್ತು (ಮರು) ಖರ್ಚು ನೀತಿಯನ್ನು ಹೊಂದಿದೆ. ಲಾಜಿಕ್ ಏಜೆಂಟ್‌ಗೆ ಒಂದನ್ನು ರಚಿಸಿ.

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.

ವೆಬ್‌ಹುಕ್ ಅನ್ನು ನಿರ್ವಹಿಸಿ.

ಪಾವತಿ settle ಆಗಿದೆ ಎಂಬುದನ್ನು ತಿಳಿಯುವ ವಿಧಾನವೆಂದರೆ webhooks. Node ನಲ್ಲಿ, @blockchain0x/node ನ webhooks.verify HMAC check ಅನ್ನು ಮಾಡುತ್ತದೆ ಮತ್ತು discriminated union ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಇತರ ಭಾಷೆಗಳಲ್ಲಿ, raw body ಮೇಲೆ ಅದೇ HMAC ಅನ್ನು ಗಣನೆ ಮಾಡಿ. event type ಆಧರಿಸಿ branch ಮಾಡಿ (inbound ಗಾಗಿ payment.received), ತ್ವರಿತವಾಗಿ 2xx ನೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಿ, ಮತ್ತು delivery time out ಆಗದಂತೆ ಯಾವುದೇ ಭಾರವಾದ ಕೆಲಸವನ್ನು 2xx ನಂತರ queue ಮಾಡಿ.

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_ ಕೀಗಳಿಗೆ ತಿರುಗಿಸುವ ಮೊದಲು, sk_test_ ಮೂಲಕ ಸಂಪೂರ್ಣ ಮಾರ್ಗವನ್ನು ಕೊನೆಗೆ ಓಡಿಸಿ. ಒಂದು ಪರೀಕ್ಷಾ ಕೀ ಬೇಸ್ ಸೆಪೋಲಿಯಾದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಇಟ್ಟುಕೊಳ್ಳುತ್ತದೆ, ಅಲ್ಲಿ ನೀವು ಸಾರ್ವಜನಿಕ ನದಿಯಿಂದ ವಾಲೆಟ್ ಅನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತೀರಿ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ರೂಪಗಳು ಜೀವಂತವಾಗಿ ಹೊಂದಿಸುತ್ತವೆ. ಕೀ ಪ್ರೀಫಿಕ್ಸ್ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಪರೀಕ್ಷಾ ಕೀ ಮುಖ್ಯ ನೆಟ್‌ವರ್ಕ್ ನಿಧಿಗಳನ್ನು ಚಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಮೂವರು ದೃಶ್ಯಗಳನ್ನು ಅಭ್ಯಾಸ ಮಾಡಿ: payment.received ಅನ್ನು ಉಲ್ಲೇಖಿಸುವ ಸಂತೋಷದ ಮಾರ್ಗದ ಪಾವತಿ, ತಪ್ಪಿದ ಡೆಲಿವರಿ (ವೆಬ್‌ಹುಕ್ ಅನ್ನು ಮೃತ URL ಗೆ ಸೂಚಿಸಿ, ನಂತರ transactions.get ಮೂಲಕ ವ್ಯವಹಾರವನ್ನು ಪಡೆಯುವ ಮೂಲಕ ಪುನಃ ಸಮಾನೀಕರಣ ಮಾಡಿ), ಮತ್ತು ವೆಬ್‌ಹುಕ್ ಪುನರಾವೃತ್ತ (ಮೊದಲ ಬಾರಿಗೆ 500 ಅನ್ನು ಹಿಂದಿರುಗಿಸಿ, ಎರಡನೆಯದಾಗಿ 200 ಅನ್ನು ಹಿಂದಿರುಗಿಸಿ, ಮತ್ತು ನಿಮ್ಮ ಹ್ಯಾಂಡ್ಲರ್ ಐಡಂಪೊಟೆಂಟ್ ಎಂದು ದೃಢೀಕರಿಸಿ). ಎಲ್ಲಾ ಮೂರು ಪರೀಕ್ಷೆಯಲ್ಲಿ ಪಾಸ್ ಆದಾಗ, ಕೀ ಅನ್ನು ಬದಲಾಯಿಸಿ ಮತ್ತು ಕಳುಹಿಸಿ.

ಒಂದು ಬಾರಿ ನೀವು ನಿಮ್ಮ ಮೊದಲ ಪಾವತಿ ಹೊಂದಿದಾಗ.

ಮೂಲಭೂತ ಪಾವತಿಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವಾಗ, ಹೆಚ್ಚು ಲಾಭ ನೀಡುವ ಮುಂದಿನ ಕ್ರಮಗಳು ಖರ್ಚು ನಿಯಂತ್ರಣಗಳು (ಹೀಗಾಗಿ ಏಜೆಂಟ್ ಬಜೆಟ್‌ನೊಂದಿಗೆ ಓಡಿಹೋಗದಂತೆ), webhook robustness (ಹೀಗಾಗಿ ಹೆಚ್ಚಿನ ಲೋಡ್‌ನಲ್ಲೂ ಪಾವತಿಗಳು ಮೌನವಾಗಿ ಕಳೆದುಹೋಗದಂತೆ), ಮತ್ತು identity verification (ಹೀಗಾಗಿ counterpartyಗಳು ಏಜೆಂಟ್‌ನ public page ಅನ್ನು ನಂಬುವಂತೆ) ಆಗಿವೆ.

docs.blockchain0x.com ನಲ್ಲಿ ಸಂಪೂರ್ಣ API ಉಲ್ಲೇಖವಿದೆ. ಒಂದೇ API ಗಾಗಿ ಉತ್ಪನ್ನ ಮೇಲ್ಮಟ್ಟ: ಪಾವತಿ API.