LangChain ચુકવણી ઇન્ટિગ્રેશન.
કોઈપણ LangChain એજન્ટને USDC ચુકવણીઓ ઉમેરો. વાસ્તવિક Python પેકેજ તેને વોલેટ ટૂલ્સ આપે છે - મોકલો, સમાપ્ત કરો, અને વાંચો - થોડા લાઇનમાં.
Blockchain0x એક વાસ્તવિક Python package, , શિપ કરે છે, જે 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 શ્રેણીમાં પિન કરો જે તે સમર્થન આપે છે, બંનેના નવા પીછો કરવા બદલે.
એક ઇન્સ્ટોલ. એક પર્યાવરણ ચલ. તૈયાર.
પેકેજને પાયથન 3.9 અથવા નવા આવશ્યક છે. તે મુખ્ય blockchain0x SDK અને langchain-core ને નિર્ભરતા તરીકે ખેંચે છે; વધુ કંઈ ઉમેરવાની જરૂર નથી.
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 તરફ ફોરવર્ડ કરે છે અને પોતાનું કોઈ secret રાખતું નથી. નીચે બતાવેલા webhook handler માટે તમારે BLOCKCHAIN0X_WEBHOOK_SECRET પણ સેટ કરવું પડશે, જે webhook create અથવા rotate કરતાં dashboard એકવાર આપે છે.
ચલતું LangChain એજન્ટ જે ચુકવણી સપોર્ટ કરે છે.
નીચે એક સંપૂર્ણ LangChain એજન્ટ છે Pythonમાં. create_blockchain0x_toolset વોલેટ સાધનો પરત આપે છે, create_react_agent તેમને ReAct લૂપમાં જોડે છે, અને મોડલ પ્રોમ્પ્ટમાંથી યોગ્ય સાધન પસંદ કરે છે. BLOCKCHAIN0X_API_KEY સેટ કરો, તેને ચલાવો, અને એજન્ટ Base પર 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 પ્રાપ્ત કરે છે. વેબહુક ચકાસણી સહાયક નોડ SDKમાં છે, તેથી આ હેન્ડલર 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 એજન્ટ માટે, તમે વાસ્તવિક x402 ક્લાયન્ટને LangChain.js ટૂલમાં તમારી જાતે લપેટો છો. તે થોડા પંક્તિઓ છે, અને તે ચોક્કસપણે તે છે જે એક સમર્પિત એડેપ્ટર હેન્ડલ હેઠળ કરશે.
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 Base Sepolia પર વાસ્તવિક $0.01 USDC transfer એ જ send-payment action મારફતે મોકલે છે, જેને LangChain tool wrap કરે છે.
પાંચ વસ્તુઓ જે પ્રથમ એકીકરણ પર કટે છે.
આ અમારા સપોર્ટ ઇનબોક્સમાંથી આવે છે. તેમાંના કોઈપણ ડીલ-બ્રેકર્સ નથી, પરંતુ તેમને અગાઉથી જાણવાથી દરેકમાં એક કલાકના વિચારમાં બચત થાય છે.
રકમ 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.
ઇન્વોઇસ ટૂલ સેટલ કરે છે, તે બનાવતું નથી
blockchain0x_settle_invoice EXISTING payment request ને on-chain proof સાથે settle કરે છે. નવો invoice mint કરનાર અથવા hosted checkout link આપનાર કોઈ tool નથી: payment requests dashboard માં બનાવવામાં આવે છે, અને core SDK ફક્ત settlement જ આપે છે. જો તમે આશા રાખતા હતા કે agent તરત payable link બનાવી દેશે, તો એ રચના નથી. Request ને out of band બનાવો, પછી agent ને તેને settle કરવા દો.
કાચા બોડી સામે વેબહુક્સની પુષ્ટિ કરો
વેબહુક્સ તમારા URL પર પોસ્ટ કરે છે, અને કોઈપણ વ્યક્તિ જે તે URL શીખે છે તે જંક પોસ્ટ કરી શકે છે. તમે એક ઇવેન્ટ પર વિશ્વાસ કરતા પહેલા RAW વિનંતી બાઇટ્સ પર @blockchain0x/node થી webhooks.verify ચલાવો. પ્રથમ JSONને પાર્સ કરો અને HMAC મેળ ખાતું નથી, કારણ કે સહી તે ચોક્કસ બાઇટ્સને આવરી લે છે જે આવી હતી. તે 300-સેકન્ડની પુનરાવર્તન વિન્ડો સાથે HMAC-SHA256 છે. તેને છોડી દેવું સૌથી સામાન્ય ઉત્પાદન ચૂકી જવું છે.
send_payment વહેલા 503 જવાબ આપી શકે છે
payments.create, જેને blockchain0x_send_payment wrap કરે છે, તે default રૂપે retry કરતું નથી અને chain adapter તમારા network માટે wired ન થાય ત્યાં સુધી 503 પાછું આપી શકે છે. error પર LLM ને retry loop માં tool પર વારંવાર મારવા ન દો: એ tokens બળાવે છે અને તમારો intent log ગૂંચવે છે. built-in idempotency key નો ઉપયોગ કરો, failure બતાવો, આગળ વધો.
langchain-core આવૃત્તિને મેળવો
blockchain0x-langchain 0.1.x નું target langchain-core >=0.2,<0.4 છે. જો તમે adapter સમર્થન કરતાં નવા core પર હો, તો બંનેના latest પાછળ દોડવાને બદલે મેળ ખાતી pair ને pin કરો. support matrix docs માં છે.