LangGraph ચુકવણી ઇન્ટિગ્રેશન.
કોઈ LangGraph પેકેજની જરૂર નથી. એક સામાન્ય નોડ વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરે છે, interrupt() ચુકવણી વેબહૂક લેન્ડ થાય ત્યાં સુધી સ્થગિત કરે છે, અને ગ્રાફ પુનઃપ્રારંભ કરે છે - ચલણમાં ટકાઉ.
કોઈ LangGraph package નથી, અને તમને તેની જરૂર પણ નથી. તમારા માંનું એક plain node real client ને call કરે છે, એક payment webhook આવે ત્યાં સુધી graph ને suspend કરે છે, અને handler તેને LangGraph ના પોતાના + સાથે resume કરે છે. Payments Base પર settle થાય છે.
ટકાઉ અમલ ચુકવણી પછી પુનરુત્પન્ન પેટર્નને કુદરતી બનાવે છે.
એજન્ટ-ચાલિત ચુકવણીઓનો કઠણ ભાગ એ અસંક્રામક ખાડો છે: તમે ચુકવણીની વિનંતી કરો છો, ખરીદક મિનિટો પછી (અથવા ક્યારેય નહીં) ચૂકવે છે, અને તમારે જ્યાં હતા ત્યાંની સ્થિતિ ગુમાવ્યા વિના કામ ફરી શરૂ કરવું પડશે. મોટાભાગના એજન્ટ ફ્રેમવર્ક્સ આ ખાડાને કવર કરવા માટે નોકરીની કતાર + મેન્યુઅલ સ્ટેટ-સ્ટોર પર આધાર રાખે છે. LangGraph માં પહેલેથી જ પ્રિમિટિવ બનાવવામાં આવ્યું છે: interrupt() એક નોડ પર ગ્રાફને સ્થગિત કરે છે અને ચેકપોઈન્ટર સ્થિતિને ડિસ્ક પર જાળવે છે. ફરી શરૂ કરવું એક કૉલ છે.
આ recipe કોઈ ખાસ machinery વિના આનો લાભ લે છે. એક સાદો pay node blockchain0x.payments.create ને call કરે છે. await_settlement node suspend કરવા interrupt() call કરે છે, અને checkpointer state સાચવે છે. webhook handler signature verify કરે છે, graph.updateState સાથે matching thread પર settled set કરે છે, અને interruptમાંથી આગળ વધવા graph.invoke call કરે છે. Graph જ્યાં રોકાયું હતું ત્યાંથી જ પાછું ચાલુ થાય છે, અગાઉના nodesમાંથી કોઈપણ LLM context સહિત - બધું LangGraphની પોતાની APIs વડે.
LangGraph અને મુખ્ય SDK સ્થાપિત કરો. કોઈ વધારાનું પેકેજ નથી.
નોડ 18+ અને @langchain/langgraph 0.2+ અને વાસ્તવિક @blockchain0x/node ક્લાયન્ટ. બંને ભાષામાં ઉમેરવા માટે કોઈ LangGraph એડેપ્ટર નથી - પાયથન LangGraph વપરાશકર્તાઓ langgraph અને blockchain0x પાયથન ક્લાયન્ટને સ્થાપિત કરે છે અને સમાન રેસીપી લખે છે, Python તરફ interrupt() અને Command(resume=...) સાથે.
npm install @langchain/langgraph @blockchain0x/node
export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet export BLOCKCHAIN0X_WEBHOOK_SECRET=... # for the webhook handler
BLOCKCHAIN0X_API_KEY તમારા dashboardમાંથી મળતી sk_test_ testnet અથવા sk_live_ mainnet key છે; client તેને environmentમાંથી વાંચે છે. BLOCKCHAIN0X_WEBHOOK_SECRET (webhook create અથવા rotate કરતાં એકવાર મળતું) webhook હેન્ડલ કરતી પ્રક્રિયામાં જરૂરી છે. જો તમારો graph એક processમાં ચાલે અને handler બીજા processમાં, તો બંનેને એ જ checkpointer (જેમ કે shared Postgres) જોઈએ જેથી handler suspended thread શોધી શકે.
એક ત્રણ-નોડ ગ્રાફ: ચૂકવો, સ્થગિત કરો, ડિલિવર કરો.
નીચે typed State સાથેનું સંપૂર્ણ LangGraph workflow છે, pay node જે વાસ્તવિક blockchain0x.payments.create ને call કરે છે, interrupt-based await_settlement node, અને deliver node જે chain payment move થયું તેની પુષ્ટિ કરે પછી dependent work ચલાવે છે.
import { StateGraph, START, END, MemorySaver, interrupt, Annotation } from "@langchain/langgraph"; import { createClient } from "@blockchain0x/node"; const blockchain0x = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! }); const State = Annotation.Root({ agentId: Annotation<string>(), to: Annotation<string>(), amountWei: Annotation<string>(), // USDC base units: "10000" = 0.01 USDC settled: Annotation<boolean>(), }); // A plain node that calls the real SDK. No dedicated package needed. async function pay(state: typeof State.State) { await blockchain0x.payments.create({ agentId: state.agentId, to: state.to, amountWei: state.amountWei, }); return {}; } // Suspend the graph until the payment.sent webhook resumes this thread. function awaitSettlement() { interrupt("awaiting on-chain settlement"); return {}; } async function deliver() { // Funds have moved - do the work that depended on the payment. return {}; } const graph = new StateGraph(State) .addNode("pay", pay) .addNode("await_settlement", awaitSettlement) .addNode("deliver", deliver) .addEdge(START, "pay") .addEdge("pay", "await_settlement") .addConditionalEdges("await_settlement", (s) => (s.settled ? "deliver" : END)) .addEdge("deliver", END) .compile({ checkpointer: new MemorySaver() });
When the graph runs, the pay node submits the USDC transfer through the SDK. The await_settlement node calls interrupt(), which suspends the graph and persists state via the checkpointer. The conditional edge waits to be told settled=true before routing to deliver; if settlement never lands, a timeout sweep routes it to END. amountWei is base units, so 0.01 USDC is "10000".
વેબહુકની પુષ્ટિ કરો, પછી થ્રેડને પુનઃપ્રારંભ કરો.
હેન્ડલર સાઇનેચરનું માન્યકરણ કરે છે webhooks.verify સાથે નોડ SDK માંથી, તમારા પોતાના મેપિંગમાંથી સસ્પેન્ડ થયેલ LangGraph થ્રેડને શોધે છે, graph.updateState સાથે સેટલ કરે છે, અને graph.invoke(null, config) ને અવરોધમાંથી આગળ વધવા માટે કૉલ કરે છે. કોઈ વિશેષ સહાયક નથી - તે LangGraph ની પોતાની APIs છે.
import express from "express"; import { webhooks } from "@blockchain0x/node"; import { graph } from "./graph"; 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", async (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.sent") { // You map the event to the suspended graph thread (your own store). const config = { configurable: { thread_id: threadFor(result.eventId) } }; await graph.updateState(config, { settled: true }); await graph.invoke(null, config); // resume from the interrupt } res.status(200).send("ok"); });
webhooks.verify કાચા શરીર પર સ્થિર સમયમાં HMAC-SHA256 કરે છે અને એક ભેદિત યુનિયન આપે છે - result.ok પર શાખા બનાવો, કોઈ પ્રયાસ/કેચ નથી. result.eventId ને તે થ્રેડ પર નકશા બનાવો જે તમે રોકી રાખ્યું હતું, પછી graph.updateState + graph.invoke(null, config) જાળવેલ ચેકપોઇન્ટમાંથી પુનઃપ્રારંભ કરે છે અને ગ્રાફ ચલાવે છે. મોકલવામાં આવેલા ઇવેન્ટ્સ payment.received, payment.sent, wallet.deployed, અને webhook.test છે.
તમે લપેટી રહેલા ક્લાયન્ટ ખુલ્લા છે. તેને વાંચો.
ક્લોન કરવા માટે કોઈ LangGraph starter package નથી - ઉપર આપેલું recipe જ integration છે. blockchain0x SDKs GitHub પર open source છે; આ recipe Python SDK (blockchain0x-python)ને wrap કરે છે, અને સંપૂર્ણ method surface docsમાં છે. node bodies અને webhook verify માટે reference તરીકે તેને વાંચો.
github.com/tosh-labs/blockchain0x-pythonસંપૂર્ણ SDK method surface અને webhook signature scheme the docsમાં documented છે. Base Sepolia સામે sk_test_ keyથી શરૂ કરો, પછી graph અપેક્ષા મુજબ ફરી શરૂ થાય ત્યારે sk_live_ પર switch કરો.
પાંચ LangGraph-વિશિષ્ટ જાળાઓથી બચવું.
LangGraphનું ટકાઉ-કાર્યન્વિત મોડેલ શક્તિશાળી છે પરંતુ ચેકપોઈન્ટ્સ, અવરોધો, અને રાજ્ય અપડેટ્સના આસપાસ તેની પોતાની ખોટી બાબતો છે.
કોઈ LangGraph પેકેજ નથી - એક સાદો નોડ SDK ને કૉલ કરે છે
Blockchain0x LangChain અને CrewAI માટે એડેપ્ટર્સ મોકલે છે અને MCP સર્વર; npm અથવા pipમાં કોઈ સમર્પિત LangGraph પેકેજ નથી. ઉપરનો નુસખો માર્ગ છે: એક સામાન્ય ગ્રાફ નોડ વાસ્તવિક @blockchain0x/node ક્લાયન્ટને કોલ કરે છે, અને તમે LangGraphના પોતાના graph.updateState + graph.invoke સાથે ફરીથી શરૂ કરો છો. કોઈ ખાસ ચુકવણી-નોડ વર્ગ અને આયાત કરવા માટે કોઈ પુનઃપ્રારંભ સહાયક નથી - તે ક્યારેય હાજર નહોતા.
ચેકપોઈન્ટ ગુમ છે
LangGraphનું interrupt() માત્ર ત્યારે જ કાર્ય કરે છે જ્યારે ગ્રાફમાં ચેકપોઇન્ટર હોય. એક ન હોય ત્યારે, જ્યારે તમારી પ્રક્રિયા બહાર નીકળે છે ત્યારે રાજ્ય વપરાય જાય છે અને વેબહૂક હેન્ડલર પાસે પુનઃપ્રારંભ કરવા માટે કોઈ થ્રેડ નથી. વિકાસ માટે MemorySaver નો ઉપયોગ કરો અને ઉત્પાદનમાં SqliteSaver અથવા PostgresSaver નો ઉપયોગ કરો. જો તમારું ગ્રાફ અને વેબહૂક હેન્ડલર અલગ પ્રક્રિયાઓમાં ચલાવે છે, તો તેમને સમાન ચેકપોઇન્ટર (ઉદાહરણ તરીકે, એક Postgres) શેર કરવું જોઈએ જેથી હેન્ડલર સ્થગિત થ્રેડને શોધી શકે.
વેબહૂકને યોગ્ય થ્રેડ પર નકશો બનાવવું તમારી નોકરી છે
વેબહૂક તમને જણાવે છે કે એક ચુકવણી સેટલ થઈ છે; તે તમારા LangGraph thread_id ને જાણતું નથી. તમારી પોતાની મેપિંગ રાખો - જ્યારે તમે ગ્રાફ શરૂ કરો છો, ત્યારે એજન્ટ, પ્રાપ્તકર્તા, અથવા તમે સેટ કરેલા idempotency કી દ્વારા કી કરેલા thread_id ને સ્ટોર કરો, પછી તેને હેન્ડલરમાં શોધો. ઉપરનું threadFor() કૉલ એ શોધ છે. આ ખોટું મેળવો અને graph.invoke ખોટા થ્રેડને પુનઃપ્રારંભ કરે છે અથવા બિલકુલ નહીં.
કોઈ-નિકાલ માર્ગને સંભાળો, અથવા સદાય માટે સ્થગિત કરો
await_settlementમાંથી શરતી કિનારો ફક્ત ત્યારે જ પહોંચાડવા માટે માર્ગ બનાવે છે જ્યારે સમાધાન સાચું હોય. જો પેમેન્ટ ક્યારેય ન આવે, તો થ્રેડ અનંતકાળ માટે સસ્પેન્ડ રહે છે. એક ટાઇમઆઉટ ઉમેરો: એક શેડ્યૂલ કરેલી સફાઈ જે સમાધાન=false સાથે જૂની થ્રેડને પુનરુત્પન્ન કરે છે જેથી કિનારો END પર માર્ગ બનાવે, અથવા એક payment.sent-versus-deadline ચેક. એક સસ્પેન્ડ થ્રેડનો કોઈ ખર્ચ નથી, પરંતુ તે પોતે ક્યારેય પૂર્ણ નથી થતું.
રકમ USDC આધાર એકમો છે, સ્ટ્રિંગ્સ તરીકે
payments.create takes amountWei: a string of USDC base units (6 decimals), so 0.01 USDC is "10000" and 5 USDC is "5000000". It also does not retry by default and can answer 503 until the chain adapter is wired for your network. Handle that in the pay node - route to END or a retry node on error rather than letting the graph wedge.