LangChain ಪಾವತಿ ಒಕ್ಕೂಟ.
ಯಾವುದೇ LangChain ಏಜೆಂಟ್ಗೆ USDC ಪಾವತಿಗಳನ್ನು ಸೇರಿಸಿ. ವಾಸ್ತವ Python ಪ್ಯಾಕೇಜ್ ಇದಕ್ಕೆ ವಾಲೆಟ್ ಸಾಧನಗಳನ್ನು ನೀಡುತ್ತದೆ - ಕಳುಹಿಸಲು, ನೆನೆಸಲು ಮತ್ತು ಓದಲು - ಕೆಲವು ಸಾಲುಗಳಲ್ಲಿ.
Blockchain0x ನಿಜವಾದ Python package, , ಅನ್ನು ship ಮಾಡುತ್ತದೆ, ಇದು LangChain agent ಗೆ native wallet tools ನೀಡುತ್ತದೆ: Base ನಲ್ಲಿ USDC ಕಳುಹಿಸಿ, on-chain proof ಜೊತೆಗೆ invoice settle ಮಾಡಿ, ಮತ್ತು wallets ಹಾಗೂ transactions ಅನ್ನು ಓದಿ. ಅದನ್ನು install ಮಾಡಿ, set ಮಾಡಿ, call ಮಾಡಿ, ಮತ್ತು tools ಅನ್ನು ನಿಮ್ಮ agent ಗೆ ನೀಡಿ. TypeScript ನಲ್ಲಿ? ಯಾವುದೇ npm adapter ಇಲ್ಲ - x402 client ಅನ್ನು LangChain.js tool ಒಳಗೆ wrap ಮಾಡಿ.
Blockchain0x HTTP API ಮೇಲೆ ಒಂದು ಬಡ ಹಂತ.
blockchain0x-langchain ನಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಸಾಧನವು ಅಧಿಕೃತ blockchain0x ಕೋರ್ SDK ಯ ಮೇಲೆ ಹಸಿರು ರಾಪ್ಪರ್ ಆಗಿದೆ. ಪುನಃ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ REST ಅಥವಾ x402 ಲಾಜಿಕ್ ಇಲ್ಲ, ಯಾವುದೇ ಕೀ ಕಸ್ಟೋಡಿ ಇಲ್ಲ: ಅಡಾಪ್ಟರ್ ನಿಮ್ಮ API ಕೀ ಅನ್ನು ಬ್ಯಾಕ್ಎಂಡ್ಗೆ ಮುನ್ನಡೆಸುತ್ತದೆ ಮತ್ತು ತನ್ನದೇ ಆದ ಯಾವುದೇ ರಹಸ್ಯವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದಿಲ್ಲ. create_blockchain0x_toolset(client) LangChain ಗೆ ಐದು ಸಾಧನಗಳನ್ನು ನೀಡುತ್ತದೆ - ಪಾವತಿಯನ್ನು ಕಳುಹಿಸಲು, ರಸೀದಿ ನಿಗಮಿಸಲು, ವಾಲೆಟ್ ಓದಲು, ವಾಲೆಟ್ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಲು, ವ್ಯವಹಾರವನ್ನು ಓದಲು - ಪ್ರತಿಯೊಂದು ಈಗಾಗಲೇ ಟೈಪ್ಡ್ ಮತ್ತು ಶ್ರೇಣೀಬದ್ಧವಾಗಿದೆ.
ನೀವು ಇಷ್ಟವಾದರೆ ಕಚ್ಚಾ API ಅಥವಾ ಕೋರ್ SDK ಅನ್ನು ನೇರವಾಗಿ ಕರೆ ಮಾಡಬಹುದು. ಅಡಾಪ್ಟರ್ ಕಡಿಮೆ ಪ್ರತಿರೋಧದ ಮಾರ್ಗವಾಗಿದೆ; API ಒಪ್ಪಂದವಾಗಿದೆ. blockchain0x-langchain ಅನ್ನು ಇದು ಬೆಂಬಲಿಸುವ langchain-core ಶ್ರೇಣಿಗೆ ಪಿನ್ ಮಾಡಿ, ಎರಡರಲ್ಲಿಯೂ ಇತ್ತೀಚಿನದನ್ನು ಹಿಂಡಬೇಡಿ.
ಒಂದು ಸ್ಥಾಪನೆ. ಒಂದು ಪರಿಸರ ಚರ. ಸಿದ್ಧ.
ಈ ಪ್ಯಾಕೇಜ್ಗೆ Python 3.9 ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೊಸದು ಬೇಕು. ಇದು core blockchain0x SDK ಮತ್ತು langchain-core ಅನ್ನು dependencies ಆಗಿ pull ಮಾಡುತ್ತದೆ; ಮತ್ತೇನನ್ನೂ ಸೇರಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
pip install blockchain0x-langchainexport BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
BLOCKCHAIN0X_API_KEY ನಿಮ್ಮ Blockchain0x dashboard ನಿಂದ ಬಂದಿರುವ sk_test_ testnet ಅಥವಾ sk_live_ mainnet key ಆಗಿದೆ. adapter ಗೆ ಬೇಕಾಗುವ ಏಕೈಕ variable ಅದೇ; ಅದು key ಅನ್ನು backend ಗೆ forward ಮಾಡುತ್ತದೆ ಮತ್ತು ತನ್ನದೇ secret ಅನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ. ಕೆಳಗೆ ತೋರಿಸಿರುವ webhook handler ಗಾಗಿ ನೀವು BLOCKCHAIN0X_WEBHOOK_SECRET ಅನ್ನು ಕೂಡ ಹೊಂದಿಸಬೇಕು, webhook ಅನ್ನು create ಅಥವಾ rotate ಮಾಡುವಾಗ dashboard ಅದನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ನೀಡುತ್ತದೆ.
ಪಾವತಿ ಬೆಂಬಲವಿರುವ ಕಾರ್ಯನಿರ್ವಹಣೆಯ ಲಾಂಗ್ಚೈನ್ ಏಜೆಂಟ್.
ಕೆಳಗೆ Python ನಲ್ಲಿ ಸಂಪೂರ್ಣ LangChain ಏಜೆಂಟ್ ಇದೆ. create_blockchain0x_toolset ವಾಲೆಟ್ ಸಾಧನಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, create_react_agent ಅವರನ್ನು ReAct ಲೂಪ್ನಲ್ಲಿ ಸಂಪರ್ಕಿಸುತ್ತದೆ, ಮತ್ತು ಮಾದರಿ ಪ್ರಾಂಪ್ಟ್ನಿಂದ ಸರಿಯಾದ ಸಾಧನವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. BLOCKCHAIN0X_API_KEY ಅನ್ನು ಹೊಂದಿಸಿ, ಅದನ್ನು ಓಡಿಸಿ, ಏಜೆಂಟ್ USDC ಅನ್ನು ಬೇಸ್ನಲ್ಲಿ ಚಲಾಯಿಸಲು ಮತ್ತು ಓದಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
from blockchain0x import Client from blockchain0x_langchain import create_blockchain0x_toolset from langchain_openai import ChatOpenAI from langgraph.prebuilt import create_react_agent client = Client() # reads BLOCKCHAIN0X_API_KEY from the environment tools = create_blockchain0x_toolset(client) llm = ChatOpenAI(model="gpt-4o") agent = create_react_agent(llm, tools) result = agent.invoke({ "messages": [{ "role": "user", "content": "Pay 0.01 USDC from my agent to 0xRecipient for the dataset.", }], })
Run it with the prompt above and the model picks the send-payment tool, the SDK submits the transfer on Base, and you get a transaction hash back. amount_wei is USDC base units (6 decimals), so 0.01 USDC is the string "10000". A sk_test_ key keeps you on Base Sepolia until you switch to sk_live_. Heads up: payments.create can answer 503 until the chain adapter is wired for your network.
ಬಳಕೆದಾರನು ಹಣ ನೀಡಿದ ನಂತರ ಏನಾಗುತ್ತದೆ.
ನಿಮ್ಮ ಏಜೆಂಟ್ನ ವೆಬ್ಹುಕ್ URL (Blockchain0x ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ) ಪಾವತಿ ನಿಗಮವಾಗುವಾಗ POST ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ವೆಬ್ಹುಕ್ ಪರಿಶೀಲನೆ ಸಹಾಯಕವು Node SDK ನಲ್ಲಿ ಇದೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಏಜೆಂಟ್ Python ಆದರೂ ಈ ಹ್ಯಾಂಡ್ಲರ್ TypeScript ಆಗಿದೆ. ಕೆಳಗಿನದು ಸಹಿ ಪರಿಶೀಲಿಸುವ ಮತ್ತು ಪಾವತಿಯಾದ ಕೆಲಸವನ್ನು ನಿರ್ವಹಿಸುವ ಎಕ್ಸ್ಪ್ರೆಸ್ ಹ್ಯಾಂಡ್ಲರ್ ಆಗಿದೆ. ಯಾವುದೇ HTTP ಫ್ರೇಮ್ವರ್ಕ್ನಲ್ಲಿ ಒಂದೇ ಮಾದರಿಯನ್ನು ಬಳಸಿರಿ.
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 in your agent wallet - do the paid work } res.status(200).send("ok"); });
webhooks.verify HMAC-SHA256 ಅನ್ನು ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ವಿಭಜಿತ ಒಕ್ಕೂಟವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಪ್ರಯತ್ನ/ಪತ್ತೆ ಇಲ್ಲದೆ result.ok ನಲ್ಲಿ ಶಾಖೆ ಮಾಡುತ್ತೀರಿ ಮತ್ತು result.eventType ಅನ್ನು ಓಡಿಸುತ್ತೀರಿ. ಕಚ್ಚಾ ಶರೀರವನ್ನು ಓದಿ, ವಿಶ್ಲೇಷಿತ ನಕಲನ್ನು ಅಲ್ಲ: ವಿಶ್ಲೇಷಣೆ ನಂತರ ಪುನಃ-ಅನ್ವಯಿಸುವುದು ಸಹಿ ಅನ್ನು ಮುರಿಯುತ್ತದೆ. ಸಾಗಿಸಲಾದ ಘಟನೆಗಳು payment.received, payment.sent, wallet.deployed, ಮತ್ತು webhook.test; ನಿಮ್ಮ ಏಜೆಂಟ್ಗೆ ಒಳನೋಡುವ ಶುಲ್ಕವು payment.received.
ಯಾವುದೇ npm LangChain ಅಡಾಪ್ಟರ್ ಇಲ್ಲ. ಇಲ್ಲಿ ಸತ್ಯವಾದ ಪಾಕವಿಧಾನವಿದೆ.
ಕಳುಹಿಸಲಾದ LangChain ಅಡಾಪ್ಟರ್ ಕೇವಲ ಪೈಥಾನ್ ಮಾತ್ರ. npm ನಲ್ಲಿ LangChain ಅಡಾಪ್ಟರ್ ಇಲ್ಲ. TypeScript LangChain ಅಥವಾ LangGraph ಏಜೆಂಟ್ಗಾಗಿ, ನೀವು LangChain.js ಉಪಕರಣದಲ್ಲಿ ವಾಸ್ತವ x402 ಕ್ಲೈಂಟ್ ಅನ್ನು ನೀವು ಸ್ವತಃ ಲುಪ್ತಗೊಳಿಸುತ್ತೀರಿ. ಇದು ಕೆಲವು ಸಾಲುಗಳು ಮತ್ತು ಇದು ನಿಖರವಾಗಿ ಸಮರ್ಪಿತ ಅಡಾಪ್ಟರ್ ಅಡಿಯಲ್ಲಿ ಏನು ಮಾಡುತ್ತದೆ.
import { createClient } from "@blockchain0x/node"; import { createX402Client } from "@blockchain0x/x402/client"; import { tool } from "@langchain/core/tools"; import { z } from "zod"; const sdk = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! }); const fetchWithPay = createX402Client({ sdk }); // There is no npm LangChain adapter. Wrap the x402 client in a LangChain.js tool. export const payAndFetch = tool( async ({ url }) => (await fetchWithPay(url)).text(), { name: "pay_and_fetch", description: "Fetch a URL, answering any x402 payment challenge automatically", schema: z.object({ url: z.string().url() }), }, );
Source ಮತ್ತು testnet examples the Python SDK repo ನಲ್ಲಿ ಇವೆ; SDK support matrix the docs ನಲ್ಲಿ ಇದೆ. Python smoke example, LangChain tool wrap ಮಾಡುವ ಅದೇ send-payment action ಮೂಲಕ Base Sepolia ನಲ್ಲಿ ನಿಜವಾದ $0.01 USDC transfer ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ.
ಮೊದಲ ಏಕೀಕರಣದಲ್ಲಿ ಕಚ್ಚುವ ಐದು ವಿಷಯಗಳು.
ಇವು ನಮ್ಮ ಬೆಂಬಲ ಇನ್ಬಾಕ್ಸ್ನಿಂದ ಬರುತ್ತವೆ. ಇವುಗಳಲ್ಲಿ ಯಾವುದೇ ಒಪ್ಪಂದ-ಬ್ರೇಕರ್ಗಳಲ್ಲ, ಆದರೆ ಅವುಗಳ ಬಗ್ಗೆ ಮುಂಚೆ ತಿಳಿಯುವುದು ಪ್ರತಿ ಒಂದು ಗಂಟೆ ತಲೆಚುಚ್ಚುವಿಕೆ ಉಳಿಸುತ್ತದೆ.
ಮೌಲ್ಯಗಳು USDC ಆಧಾರ ಘಟಕಗಳಾಗಿವೆ, ಸ್ಟ್ರಿಂಗ್ಗಳಂತೆ
The payment tools take amount_wei: a string of USDC base units, not a float and not a dollar figure. USDC has 6 decimals, so 0.01 USDC is "10000" and 5 USDC is "5000000". Always pass a string; large integers lose precision as JSON numbers. Send "5.00" and you will either get a validation error or move a millionth of what you meant.
invoice tool settle ಮಾಡುತ್ತದೆ, create ಮಾಡುವುದಿಲ್ಲ
blockchain0x_settle_invoice ಒಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪಾವತಿ ವಿನಂತಿಯನ್ನು ಆನ್-ಚೈನ್ ಸಾಕ್ಷಿಯೊಂದಿಗೆ ನಿಗಮಿಸುತ್ತದೆ. ಹೊಸ ಇನ್ವಾಯ್ಸ್ ಅಥವಾ ಹೋಸ್ಟೆಡ್ ಚೆಕ್ಔಟ್ ಲಿಂಕ್ ಅನ್ನು ಮಿಂಟ್ಸ್ ಮಾಡುವ ಯಾವುದೇ ಸಾಧನವಿಲ್ಲ: ಪಾವತಿ ವಿನಂತಿಗಳನ್ನು ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿ ರಚಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಕೋರ್ SDK ನಿಗಮವನ್ನು ಮಾತ್ರ ಹೊರಹಾಕುತ್ತದೆ. ನೀವು ಏಜೆಂಟ್ ಅನ್ನು ತಕ್ಷಣವೇ ಪಾವತಿಸಬಹುದಾದ ಲಿಂಕ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ನಿರೀಕ್ಷಿಸಿದರೆ, ಅದು ಆ ಆಕೃತಿಯಲ್ಲಿಲ್ಲ. ಬ್ಯಾಂಡ್ ಹೊರಗೊಮ್ಮಲು ವಿನಂತಿಯನ್ನು ರಚಿಸಿ, ನಂತರ ಏಜೆಂಟ್ ಅನ್ನು ಅದನ್ನು ನಿಗಮಿಸಲು ಬಿಡಿ.
Webhooks ಅನ್ನು raw body ವಿರುದ್ಧ verify ಮಾಡಿ
Webhooks ನಿಮ್ಮ URL ಗೆ POST ಮಾಡುತ್ತವೆ, ಮತ್ತು ಆ URL ತಿಳಿದುಕೊಳ್ಳುವ ಯಾರಾದರೂ junk ಅನ್ನು POST ಮಾಡಬಹುದು. ಯಾವುದೇ event ಅನ್ನು ನಂಬುವ ಮೊದಲು RAW request bytes ಮೇಲೆ @blockchain0x/node ನಿಂದ webhooks.verify ಅನ್ನು ಚಲಾಯಿಸಿ. ಮೊದಲು JSON ಅನ್ನು parse ಮಾಡಿದರೆ HMAC ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ, ಏಕೆಂದರೆ signature ಬಂದ ನಿಖರ bytes ಗಳನ್ನೇ ಒಳಗೊಂಡಿರುತ್ತದೆ. ಇದು 300-second replay window ಹೊಂದಿರುವ HMAC-SHA256. ಇದನ್ನು ಬಿಟ್ಟುಬಿಡುವುದೇ production ನಲ್ಲಿ ಅತಿ ಸಾಮಾನ್ಯವಾದ ತಪ್ಪು.
send_payment ಆರಂಭದಲ್ಲಿ 503 ಅನ್ನು ಉತ್ತರಿಸಬಹುದು
blockchain0x_send_payment wrap ಮಾಡುವ payments.create default ಆಗಿ retry ಮಾಡುವುದಿಲ್ಲ ಮತ್ತು ನಿಮ್ಮ network ಗೆ chain adapter wired ಆಗುವವರೆಗೆ 503 ಮರಳಿಸಬಹುದು. error ಬಂದಾಗ LLM tool ಅನ್ನು retry loop ನಲ್ಲಿ repeatedly hammer ಮಾಡಲು ಬಿಡಬೇಡಿ: ಅದು tokens ಖರ್ಚುಮಾಡುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ intent log ಅನ್ನು ಗೊಂದಲಗೊಳಿಸುತ್ತದೆ. built-in idempotency key ಮೇಲೆ ನಂಬಿಕೆ ಇಡಿ, failure ಅನ್ನು ತೋರಿಸಿ, ಮುಂದಕ್ಕೆ ಸಾಗಿರಿ.
langchain-core ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿಸಿ
blockchain0x-langchain 0.1.x, langchain-core >=0.2,<0.4 ಅನ್ನು target ಮಾಡುತ್ತದೆ. adapter ಬೆಂಬಲಿಸುವುದಕ್ಕಿಂತ ಹೊಸ core ನಲ್ಲಿ ನೀವು ಇದ್ದರೆ, ಎರಡರಲ್ಲೂ latest ಅನ್ನು ಹಿಂಬಾಲಿಸುವ ಬದಲು ಹೊಂದಿಕೊಳ್ಳುವ pair ಅನ್ನು pin ಮಾಡಿ. support matrix docs ನಲ್ಲಿ ಇದೆ.