There is no LangGraph package, and you do not need one. A plain node in your calls the real client, an suspends the graph until the payment webhook lands, and the handler resumes it with LangGraph's own + . Payments settle on Base.

Install LangGraph and the core SDK. No extra package.

Node 18+ and @langchain/langgraph 0.2+ plus the real @blockchain0x/node client. There is no LangGraph adapter to add in either language - Python LangGraph users install langgraph and the blockchain0x Python client and write the same recipe, with interrupt() and Command(resume=...) on the Python side.

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 is a sk_test_ testnet or sk_live_ mainnet key from your dashboard; the client reads it from the environment. BLOCKCHAIN0X_WEBHOOK_SECRET (returned once when you create or rotate a webhook) is needed in the process that handles webhooks. If your graph runs in one process and the handler in another, both need the same checkpointer (e.g. shared Postgres) so the handler can find the suspended thread.

Verify the webhook, then resume the thread.

The handler verifies the signature with webhooks.verify from the Node SDK, looks up the suspended LangGraph thread from your own mapping, sets settled with graph.updateState, and calls graph.invoke(null, config) to continue from the interrupt. No special helper - those are LangGraph's own 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 does HMAC-SHA256 in constant time over the raw body and returns a discriminated union - branch on result.ok, no try/catch. Map result.eventId to the thread you suspended, then graph.updateState + graph.invoke(null, config) resumes from the persisted checkpoint and the graph runs deliver. The shipped events are payment.received, payment.sent, wallet.deployed, and webhook.test.

Five LangGraph-specific traps to avoid.

LangGraph's durable-execution model is powerful but has its own footguns around checkpoints, interrupts, and state updates.