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 ਰੇਂਜ 'ਤੇ ਪਿੰਨ ਕਰੋ ਜੋ ਇਹ ਸਹਾਰਦਾ ਹੈ ਬਜਾਏ ਦੋਹਾਂ ਦੇ ਨਵੇਂ ਰੁਝਾਨਾਂ ਦੇ ਪਿੱਛੇ ਭੱਜਣ ਦੇ।
ਇੱਕ ਇੰਸਟਾਲ ਕਰੋ। ਇੱਕ ਵਾਤਾਵਰਣ ਚਲ। ਤਿਆਰ।
ਇਸ package ਲਈ Python 3.9 ਜਾਂ ਇਸ ਤੋਂ ਨਵਾਂ ਵਰਜਨ ਚਾਹੀਦਾ ਹੈ। ਇਹ core blockchain0x SDK ਅਤੇ langchain-core ਨੂੰ dependencies ਵਜੋਂ ਲਿਆਉਂਦਾ ਹੈ; ਹੋਰ ਕੁਝ add ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ।
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 ਤੱਕ forward ਕਰਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਕੋਲ ਕੋਈ secret ਨਹੀਂ ਰੱਖਦਾ। ਹੇਠਾਂ ਦਿਖਾਏ webhook handler ਲਈ ਤੁਸੀਂ BLOCKCHAIN0X_WEBHOOK_SECRET ਵੀ set ਕਰਦੇ ਹੋ, ਜੋ dashboard webhook create ਜਾਂ rotate ਕਰਨ ਸਮੇਂ ਇਕ ਵਾਰ ਦਿੰਦਾ ਹੈ।
ਇੱਕ ਕੰਮ ਕਰਦਾ LangChain ਏਜੰਟ ਜੋ ਭੁਗਤਾਨ ਸਹਾਇਤਾ ਨਾਲ ਹੈ।
ਹੇਠਾਂ ਇੱਕ ਪੂਰਾ LangChain ਏਜੰਟ ਹੈ ਜੋ ਪਾਇਥਨ ਵਿੱਚ ਹੈ। 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.
ਯੂਜ਼ਰ ਭੁਗਤਾਨ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕੀ ਹੁੰਦਾ ਹੈ।
ਤੁਹਾਡੇ ਏਜੰਟ ਦਾ webhook URL (Blockchain0x ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਸੈਟ ਕੀਤਾ ਗਿਆ) ਇੱਕ POST ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਭੁਗਤਾਨ ਨਿਪਟਦਾ ਹੈ। webhook ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਵਾਲਾ ਸਹਾਇਕ Node SDK ਵਿੱਚ ਹੈ, ਇਸ ਲਈ ਇਹ ਹੈਂਡਲਰ TypeScript ਹੈ ਹਾਲਾਂਕਿ ਤੁਹਾਡਾ ਏਜੰਟ Python ਹੈ। ਹੇਠਾਂ ਇੱਕ Express ਹੈਂਡਲਰ ਹੈ ਜੋ ਦਸਤਖਤ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਅਤੇ ਭੁਗਤਾਨ ਕੀਤੇ ਕੰਮ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਕਿਸੇ ਵੀ 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 adapter ਸਿਰਫ Python ਲਈ ਹੈ। npm ਉੱਤੇ ਕੋਈ LangChain adapter ਨਹੀਂ ਹੈ। TypeScript LangChain ਜਾਂ LangGraph agent ਲਈ, ਤੁਸੀਂ real x402 client ਨੂੰ ਖੁਦ LangChain.js tool ਵਿੱਚ wrap ਕਰਦੇ ਹੋ। ਇਹ ਕੁਝ ਹੀ lines ਹਨ, ਅਤੇ exactly ਉਹੀ ਹੈ ਜੋ dedicated adapter ਅੰਦਰੋਂ ਕਰਦਾ।
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.
Invoice tool settle ਕਰਦਾ ਹੈ, create ਨਹੀਂ ਕਰਦਾ
blockchain0x_settle_invoice ਇੱਕ ਮੌਜੂਦਾ ਭੁਗਤਾਨ ਬੇਨਤੀ ਨੂੰ ਚੇਨ ਸਬੂਤ ਨਾਲ ਨਿਪਟਾਉਂਦਾ ਹੈ। ਕੋਈ ਟੂਲ ਨਹੀਂ ਹੈ ਜੋ ਇੱਕ ਨਵਾਂ ਇਨਵੌਇਸ ਜਾਂ ਹੋਸਟ ਕੀਤਾ ਗਿਆ ਚੈਕਆਉਟ ਲਿੰਕ ਬਣਾਉਂਦਾ ਹੈ: ਭੁਗਤਾਨ ਦੀਆਂ ਬੇਨਤੀਆਂ ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਅਤੇ ਮੁੱਖ SDK ਸਿਰਫ਼ ਨਿਪਟਾਰਾ ਖੋਲ੍ਹਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਉਮੀਦ ਕਰਦੇ ਸੀ ਕਿ ਏਜੰਟ ਤੁਰੰਤ ਭੁਗਤਾਨ ਯੋਗ ਲਿੰਕ ਬਣਾਉਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਕਾਰ ਨਹੀਂ ਹੈ। ਬੇਨਤੀ ਨੂੰ ਬਾਹਰੋਂ ਬਣਾਓ, ਫਿਰ ਏਜੰਟ ਨੂੰ ਇਸਨੂੰ ਨਿਪਟਾਉਣ ਦਿਓ।
ਵੈਬਹੂਕ ਨੂੰ ਕੱਚੇ ਸਰੀਰ ਦੇ ਖਿਲਾਫ ਪੁਸ਼ਟੀ ਕਰੋ
Webhooks ਤੁਹਾਡੇ URL 'ਤੇ POST ਕਰਦੇ ਹਨ, ਅਤੇ ਜੋ ਵੀ ਉਹ URL ਜਾਣ ਲਵੇ ਉਹ junk POST ਕਰ ਸਕਦਾ ਹੈ। ਕਿਸੇ event 'ਤੇ ਭਰੋਸਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ RAW request bytes ਉੱਤੇ @blockchain0x/node ਤੋਂ webhooks.verify ਚਲਾਓ। ਪਹਿਲਾਂ JSON parse ਕਰਨ ਨਾਲ HMAC match ਨਹੀਂ ਹੋਵੇਗਾ, ਕਿਉਂਕਿ signature ਆਏ ਹੋਏ exact bytes ਨੂੰ cover ਕਰਦੀ ਹੈ। ਇਹ 300-second replay window ਨਾਲ HMAC-SHA256 ਹੈ। ਇਸਨੂੰ ਛੱਡਣਾ production ਵਿੱਚ ਸਭ ਤੋਂ ਆਮ ਗਲਤੀ ਹੈ।
send_payment ਪਹਿਲਾਂ 503 ਦਾ ਜਵਾਬ ਦੇ ਸਕਦਾ ਹੈ
payments.create, ਜੋ blockchain0x_send_payment ਨੂੰ ਲਪੇਟਦਾ ਹੈ, ਡਿਫਾਲਟ ਵਜੋਂ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦਾ ਅਤੇ ਤੁਹਾਡੇ ਨੈੱਟਵਰਕ ਲਈ ਚੇਨ ਐਡਾਪਟਰ ਵਾਇਰ ਹੋਣ ਤੱਕ 503 ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ। LLM ਨੂੰ ਗਲਤੀ 'ਤੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਵਾਲੇ ਲੂਪ ਵਿੱਚ ਟੂਲ ਨੂੰ ਮਾਰਨ ਨਾ ਦਿਓ: ਇਹ ਟੋਕਨ ਬਰਬਾਦ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਇਰਾਦੇ ਦੇ ਲੌਗ ਨੂੰ ਗੰਦਲਾ ਕਰਦਾ ਹੈ। ਬਣੇ ਬਣਾਏ idempotency ਕੁੰਜੀ 'ਤੇ ਨਿਰਭਰ ਕਰੋ, ਅਸਫਲਤਾ ਨੂੰ ਉੱਪਰ ਲਿਆਓ, ਅੱਗੇ ਵਧੋ।
langchain-core ਵਰਜਨ ਨਾਲ ਮੇਲ ਖਾਓ
blockchain0x-langchain 0.1.x ਦਾ target langchain-core >=0.2,<0.4 ਹੈ। ਜੇ ਤੁਸੀਂ adapter ਦੇ support ਤੋਂ ਨਵੇਂ core 'ਤੇ ਹੋ, ਤਾਂ ਦੋਵਾਂ ਦੇ ਸਭ ਤੋਂ ਨਵੇਂ versions ਪਿੱਛੇ ਦੌੜਨ ਦੀ ਬਜਾਏ ਮਿਲਦੀ pair ਨੂੰ pin ਕਰੋ। support matrix docs ਵਿੱਚ ਹੈ।