Es gibt kein LangGraph-Paket, und Sie brauchen auch keines. Ein einfacher Node in Ihrem ruft den echten -Client auf, ein setzt den Graphen aus, bis der Zahlungs-Webhook eintrifft, und der Handler setzt ihn mit LangGraphs eigenem + fort. Zahlungen werden auf Base abgewickelt.

Installieren Sie LangGraph und das Kern-SDK. Kein zusätzliches Paket.

Node 18+ und @langchain/langgraph 0.2+ plus den echten @blockchain0x/node-Client. Es gibt keinen LangGraph-Adapter, der in einer der beiden Sprachen hinzugefügt werden kann - Python LangGraph-Benutzer installieren langgraph und den blockchain0x Python-Client und schreiben dasselbe Rezept, mit interrupt() und Command(resume=...) auf der Python-Seite.

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 ist ein sk_test_ Testnet- oder sk_live_ Mainnet-Schlüssel von Ihrem Dashboard; der Client liest ihn aus der Umgebung. BLOCKCHAIN0X_WEBHOOK_SECRET (einmal zurückgegeben, wenn Sie einen Webhook erstellen oder rotieren) wird im Prozess benötigt, der Webhooks verarbeitet. Wenn Ihr Graph in einem Prozess läuft und der Handler in einem anderen, benötigen beide denselben Checkpointer (z.B. gemeinsames Postgres), damit der Handler den angehaltenen Thread finden kann.

Überprüfen Sie das Webhook und setzen Sie dann den Thread fort.

Der Handler überprüft die Signatur mit webhooks.verify aus dem Node SDK, sucht den ausgesetzten LangGraph-Thread aus Ihrer eigenen Zuordnung, setzt settled mit graph.updateState und ruft graph.invoke(null, config) auf, um vom Interrupt fortzufahren. Kein spezieller Helfer - das sind die eigenen APIs von LangGraph.

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 führt HMAC-SHA256 in konstanter Zeit über den Rohkörper aus und gibt eine diskriminierte Vereinigung zurück - verzweigen Sie auf result.ok, kein try/catch. Zuordnen result.eventId zu dem Thread, den Sie angehalten haben, dann graph.updateState + graph.invoke(null, config) setzt vom persistierten Checkpoint fort und die Graphausführungen liefern. Die gelieferten Ereignisse sind payment.received, payment.sent, wallet.deployed und webhook.test.

Fünf LangGraph-spezifische Fallen, die zu vermeiden sind.

Das langlebige Ausführungsmodell von LangGraph ist leistungsstark, hat jedoch seine eigenen Fallstricke in Bezug auf Checkpoints, Interrupts und Statusaktualisierungen.