LangGraph ਭੁਗਤਾਨ ਇੰਟੀਗ੍ਰੇਸ਼ਨ।
ਕੋਈ LangGraph ਪੈਕੇਜ ਦੀ ਲੋੜ ਨਹੀਂ। ਇੱਕ ਸਧਾਰਨ ਨੋਡ ਅਸਲ blockchain0x ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, interrupt() ਭੁਗਤਾਨ webhook ਲੈਂਡ ਹੋਣ ਤੱਕ ਰੋਕਦਾ ਹੈ, ਅਤੇ ਗ੍ਰਾਫ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ - ਚਲਾਉਣਾਂ ਵਿੱਚ ਟਿਕਾਊ।
LangGraph-specific ਕੋਈ package ਨਹੀਂ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਵੀ ਨਹੀਂ। ਤੁਹਾਡੇ ਵਿੱਚ ਇੱਕ plain node ਅਸਲੀ client ਨੂੰ call ਕਰਦਾ ਹੈ, ਇੱਕ payment webhook ਆਉਣ ਤੱਕ graph ਨੂੰ suspend ਕਰ ਦਿੰਦਾ ਹੈ, ਅਤੇ handler ਇਸਨੂੰ LangGraph ਦੇ ਆਪਣੇ + ਨਾਲ resume ਕਰ ਦਿੰਦਾ ਹੈ। Payments Base 'ਤੇ settle ਹੁੰਦੀਆਂ ਹਨ।
ਟਿਕਾਊ ਕਾਰਵਾਈ ਭੁਗਤਾਨ ਤੋਂ ਬਾਅਦ ਦੇ ਪੈਟਰਨ ਨੂੰ ਕੁਦਰਤੀ ਬਣਾਉਂਦੀ ਹੈ।
ਏਜੰਟ-ਚਲਾਈ ਭੁਗਤਾਨਾਂ ਦਾ ਮੁਸ਼ਕਲ ਹਿੱਸਾ ਐਸਿੰਕ ਗੈਪ ਹੈ: ਤੁਸੀਂ ਭੁਗਤਾਨ ਦੀ ਬੇਨਤੀ ਕਰਦੇ ਹੋ, ਖਰੀਦਦਾਰ ਕੁਝ ਮਿੰਟਾਂ ਬਾਅਦ (ਜਾਂ ਕਦੇ ਨਹੀਂ) ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਉਸ ਸਥਿਤੀ ਨੂੰ ਗੁਆਏ ਬਿਨਾਂ ਕੰਮ ਜਾਰੀ ਰੱਖਣਾ ਪੈਂਦਾ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਸੀ। ਜ਼ਿਆਦਾਤਰ ਏਜੰਟ ਫਰੇਮਵਰਕ ਇਸ ਗੈਪ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਇੱਕ ਨੌਕਰੀ ਕਿਊ + ਮੈਨੂਅਲ ਸਥਿਤੀ-ਸਟੋਰ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। LangGraph ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਪ੍ਰਿਮਿਟਿਵ ਬਣਿਆ ਹੋਇਆ ਹੈ: interrupt() ਇੱਕ ਨੋਡ 'ਤੇ ਇੱਕ ਗ੍ਰਾਫ ਨੂੰ ਰੋਕਦਾ ਹੈ ਅਤੇ ਇੱਕ ਚੈਕਪੋਇੰਟਰ ਸਥਿਤੀ ਨੂੰ ਡਿਸਕ 'ਤੇ ਸਥਿਰ ਕਰਦਾ ਹੈ। ਦੁਬਾਰਾ ਜਾਰੀ ਕਰਨਾ ਇੱਕ ਕਾਲ ਹੈ.
Recipe ਇਸਨੂੰ ਕਿਸੇ special machinery ਤੋਂ ਬਿਨਾਂ ਅਪਣਾਉਂਦੀ ਹੈ। ਇੱਕ plain pay node blockchain0x.payments.create ਨੂੰ call ਕਰਦਾ ਹੈ। ਇੱਕ await_settlement node suspend ਕਰਨ ਲਈ interrupt() call ਕਰਦਾ ਹੈ, ਅਤੇ checkpointer state persist ਕਰਦਾ ਹੈ। Webhook handler signature verify ਕਰਦਾ ਹੈ, graph.updateState ਨਾਲ matching thread 'ਤੇ settled set ਕਰਦਾ ਹੈ, ਅਤੇ interrupt ਤੋਂ ਜਾਰੀ ਰੱਖਣ ਲਈ graph.invoke call ਕਰਦਾ ਹੈ। Graph ਬਿਲਕੁਲ ਉੱਥੋਂ ਜਾਰੀ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਉਹ ਰੁਕੀ ਸੀ, ਜਿਸ ਵਿੱਚ ਪਹਿਲਾਂ ਵਾਲੇ nodes ਦਾ ਕੋਈ ਵੀ LLM context ਸ਼ਾਮਲ ਹੈ - ਸਭ ਕੁਝ LangGraph ਦੀਆਂ ਆਪਣੀਆਂ APIs ਨਾਲ।
LangGraph ਅਤੇ ਕੋਰ SDK ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ। ਕੋਈ ਵਾਧੂ ਪੈਕੇਜ ਨਹੀਂ।
Node 18+ ਅਤੇ @langchain/langgraph 0.2+ ਅਤੇ ਅਸਲ @blockchain0x/node ਕਲਾਇੰਟ। ਕਿਸੇ ਵੀ ਭਾਸ਼ਾ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਕੋਈ LangGraph ਐਡਾਪਟਰ ਨਹੀਂ ਹੈ - Python LangGraph ਉਪਭੋਗਤਾ langgraph ਅਤੇ blockchain0x Python ਕਲਾਇੰਟ ਨੂੰ ਇੰਸਟਾਲ ਕਰਦੇ ਹਨ ਅਤੇ ਇੱਕੋ ਹੀ ਨੁਸਖਾ ਲਿਖਦੇ ਹਨ, 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 ਕਰਨ ਸਮੇਂ ਇਕ ਵਾਰ ਮਿਲਦਾ ਹੈ) ਉਸ process ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੈ ਜੋ webhooks handle ਕਰਦੀ ਹੈ। ਜੇ ਤੁਹਾਡਾ graph ਇੱਕ process ਵਿੱਚ ਚੱਲਦਾ ਹੈ ਅਤੇ handler ਦੂਜੇ ਵਿੱਚ, ਤਾਂ ਦੋਹਾਂ ਨੂੰ ਉਹੀ checkpointer (ਉਦਾਹਰਨ ਲਈ shared Postgres) ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ handler suspended thread ਲੱਭ ਸਕੇ।
ਇੱਕ ਤਿੰਨ-ਨੋਡ ਗ੍ਰਾਫ: ਭੁਗਤਾਨ, ਰੋਕੋ, ਡਿਲਿਵਰੀ.
ਹੇਠਾਂ ਇੱਕ complete LangGraph workflow ਹੈ ਜਿਸ ਵਿੱਚ typed State, ਇੱਕ 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".
ਵੈਬਹੂਕ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ, ਫਿਰ ਥ੍ਰੇਡ ਨੂੰ ਦੁਬਾਰਾ ਚਾਲੂ ਕਰੋ।
Handler Node SDK ਤੋਂ webhooks.verify ਨਾਲ signature verify ਕਰਦਾ ਹੈ, ਤੁਹਾਡੀ ਆਪਣੀ mapping ਤੋਂ suspended LangGraph thread ਲੱਭਦਾ ਹੈ, graph.updateState ਨਾਲ settled set ਕਰਦਾ ਹੈ, ਅਤੇ interrupt ਤੋਂ ਜਾਰੀ ਰੱਖਣ ਲਈ graph.invoke(null, config) call ਕਰਦਾ ਹੈ। ਕੋਈ special helper ਨਹੀਂ - ਇਹ 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.
ਜਿਸ client ਨੂੰ ਤੁਸੀਂ wrap ਕਰ ਰਹੇ ਹੋ ਉਹ open ਹੈ। ਉਸਨੂੰ ਪੜ੍ਹੋ।
ਕੋਈ LangGraph starter package ਨਹੀਂ ਹੈ ਜਿਸਨੂੰ clone ਕੀਤਾ ਜਾ ਸਕੇ - ਉੱਪਰ ਦਿੱਤਾ 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 ਤੁਹਾਡੀ ਉਮੀਦ ਅਨੁਸਾਰ resume ਕਰੇ, sk_live_ 'ਤੇ switch ਕਰੋ।
ਪੰਜ LangGraph-ਵਿਸ਼ੇਸ਼ ਜਾਲਾਂ ਤੋਂ ਬਚਣ ਲਈ।
LangGraph ਦਾ ਡਿਊਰੇਬਲ-ਐਕਜ਼ਿਕਿਊਸ਼ਨ ਮਾਡਲ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ ਪਰ ਇਸਦੇ ਚੈਕਪੋਇੰਟਰ, ਰੁਕਾਵਟਾਂ, ਅਤੇ ਸਟੇਟ ਅੱਪਡੇਟਸ ਦੇ ਆਸ-ਪਾਸ ਆਪਣੇ ਹੀ ਫੁੱਟਗਨ ਹਨ।
ਕੋਈ LangGraph ਪੈਕੇਜ ਨਹੀਂ ਹੈ - ਇੱਕ ਸਧਾਰਨ ਨੋਡ ਐਸਡੀਕੇ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ
Blockchain0x LangChain ਅਤੇ CrewAI ਲਈ ਐਡਾਪਟਰਾਂ ਨੂੰ ਭੇਜਦਾ ਹੈ ਅਤੇ MCP ਸਰਵਰ; npm ਜਾਂ pip ਵਿੱਚ ਕੋਈ ਸਮਰਪਿਤ LangGraph ਪੈਕੇਜ ਨਹੀਂ ਹੈ। ਉਪਰੋਕਤ ਨੁਸਖਾ ਉਹ ਰਸਤਾ ਹੈ: ਇੱਕ ਆਮ ਗ੍ਰਾਫ ਨੋਡ ਅਸਲ @blockchain0x/node ਕਲਾਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ LangGraph ਦੇ ਆਪਣੇ graph.updateState + graph.invoke ਨਾਲ ਮੁੜ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ। ਕੋਈ ਵਿਸ਼ੇਸ਼ ਭੁਗਤਾਨ-ਨੋਡ ਕਲਾਸ ਅਤੇ ਕੋਈ ਮੁੜ ਸ਼ੁਰੂ ਕਰਨ ਵਾਲਾ ਸਹਾਇਕ ਆਯਾਤ ਕਰਨ ਲਈ ਨਹੀਂ ਹੈ - ਉਹ ਕਦੇ ਵੀ ਮੌਜੂਦ ਨਹੀਂ ਸੀ।
ਗੁੰਝਲਦਾਰ ਚੈਕਪੋਇੰਟਰ
LangGraph ਦੀ interrupt() ਸਿਰਫ ਉਸ ਵੇਲੇ ਕੰਮ ਕਰਦੀ ਹੈ ਜਦੋਂ ਗ੍ਰਾਫ ਵਿੱਚ ਇੱਕ ਚੈਕਪੋਇੰਟਰ ਹੁੰਦਾ ਹੈ। ਬਿਨਾਂ ਕਿਸੇ ਦੇ, ਜਦੋਂ ਤੁਹਾਡਾ ਪ੍ਰਕਿਰਿਆ ਬੰਦ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸਥਿਤੀ ਉਡ ਜਾਂਦੀ ਹੈ ਅਤੇ webhook ਹੈਂਡਲਰ ਕੋਲ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕੋਈ ਥ੍ਰੇਡ ਨਹੀਂ ਹੁੰਦਾ। ਵਿਕਾਸ ਲਈ MemorySaver ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਉਤਪਾਦਨ ਵਿੱਚ SqliteSaver ਜਾਂ PostgresSaver ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜੇ ਤੁਹਾਡਾ ਗ੍ਰਾਫ ਅਤੇ webhook ਹੈਂਡਲਰ ਵੱਖਰੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਚੱਲਦੇ ਹਨ, ਤਾਂ ਉਨ੍ਹਾਂ ਨੂੰ ਇੱਕੋ ਚੈਕਪੋਇੰਟਰ ਨੂੰ ਸਾਂਝਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ Postgres) ਤਾਂ ਜੋ ਹੈਂਡਲਰ ਰੁਕਿਆ ਹੋਇਆ ਥ੍ਰੇਡ ਲੱਭ ਸਕੇ।
Webhook ਨੂੰ ਸਹੀ ਥ੍ਰੈਡ 'ਤੇ ਨਕਸ਼ਾ ਬਣਾਉਣਾ ਤੁਹਾਡਾ ਕੰਮ ਹੈ
Webhook ਤੁਹਾਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ payment settle ਹੋ ਗਈ ਹੈ; ਇਹ ਤੁਹਾਡਾ LangGraph thread_id ਨਹੀਂ ਜਾਣਦਾ। ਆਪਣਾ mapping ਖੁਦ ਰੱਖੋ - ਜਦੋਂ ਤੁਸੀਂ graph ਸ਼ੁਰੂ ਕਰੋ, thread_id ਨੂੰ agent, recipient, ਜਾਂ ਤੁਹਾਡੇ ਦੁਆਰਾ ਸੈੱਟ ਕੀਤੇ idempotency key ਨਾਲ key ਕਰਕੇ ਸਟੋਰ ਕਰੋ, ਫਿਰ handler ਵਿੱਚ ਇਸਨੂੰ lookup ਕਰੋ। ਉੱਪਰ ਵਾਲੀ threadFor() call ਉਹੀ lookup ਹੈ। ਇਸਨੂੰ ਗਲਤ ਕਰੋ, ਤਾਂ graph.invoke ਗਲਤ thread ਜਾਂ ਕਿਸੇ ਵੀ thread 'ਤੇ resume ਹੋ ਸਕਦਾ ਹੈ।
ਕੋਈ ਨਿਪਟਾਰਾ ਰਾਹ ਸੰਭਾਲੋ, ਜਾਂ ਸਦਾ ਲਈ ਰੋਕੋ
await_settlement ਤੋਂ ਆਉਣ ਵਾਲੀ conditional edge ਸਿਰਫ਼ ਤਦੋਂ deliver ਵੱਲ ਜਾਂਦੀ ਹੈ ਜਦੋਂ settled true ਹੋਵੇ। ਜੇ payment ਕਦੇ ਨਾ ਪਹੁੰਚੇ, thread ਅਨੰਤਕਾਲ ਲਈ suspended ਰਹਿੰਦੀ ਹੈ। ਇੱਕ timeout ਜੋੜੋ: stale threads ਨੂੰ settled=false ਨਾਲ resume ਕਰਨ ਲਈ scheduled sweep, ਤਾਂ ਜੋ edge END ਵੱਲ route ਕਰੇ, ਜਾਂ payment.sent-versus-deadline check। Suspended thread ਦੀ ਕੋਈ cost ਨਹੀਂ ਹੁੰਦੀ, ਪਰ ਉਹ ਆਪਣੇ ਆਪ ਕਦੇ finish ਵੀ ਨਹੀਂ ਹੁੰਦੀ।
ਰਕਮਾਂ 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.