@402lane/client 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# @402lane/client
+
+A fetch wrapper that transparently pays x402 challenges in USDG on Robinhood
+Chain (chain 4663) — part of [402LANE](https://402lane.vercel.app).
+
+```ts
+import { createSigner, payingFetch } from "@402lane/client";
+
+const pay = payingFetch({
+  account: createSigner(process.env.WALLET_KEY),
+  maxValue: 10_000n,        // spend cap per request: 0.01 USDG
+});
+
+const res = await pay("https://api.example.dev/report");
+// 402 → signs EIP-3009 authorization → retries → 200
+```
+
+Includes a per-payment spend cap and network allowlist so an agent can pay
+autonomously without being drained. See the [docs](https://402lane.vercel.app/docs). MIT.

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import { type PrivateKeyAccount } from "viem/accounts";
+import { type PaymentPayload, type PaymentRequirements } from "@402lane/core";
+export interface PayingFetchOptions {
+    account: PrivateKeyAccount;
+    /** Refuse any single payment above this many USDG base units. Default 1 USDG. */
+    maxValue?: bigint;
+    /** Restrict which CAIP-2 networks we will pay on. Default: all 402LANE networks. */
+    networks?: string[];
+    fetchImpl?: typeof fetch;
+    onPayment?: (info: {
+        resource: string;
+        value: string;
+        network: string;
+    }) => void;
+}
+export declare function createSigner(privateKey: `0x${string}`): PrivateKeyAccount;
+/**
+ * fetch wrapper that transparently pays x402 challenges in USDG on Robinhood Chain.
+ * On a 402 it signs an EIP-3009 authorization and retries once.
+ */
+export declare function payingFetch(options: PayingFetchOptions): typeof fetch;
+export declare function signPayment(account: PrivateKeyAccount, requirements: PaymentRequirements): Promise<PaymentPayload>;

package/dist/index.js

@@ -0,0 +1,71 @@
+import { randomBytes } from "node:crypto";
+import { privateKeyToAccount } from "viem/accounts";
+import { HEADER_PAYMENT_REQUIRED, HEADER_PAYMENT_SIGNATURE, NETWORKS, TRANSFER_WITH_AUTHORIZATION_TYPES, X402_VERSION, decodeHeader, eip3009Domain, encodeHeader, paymentRequiredBodySchema, toTypedMessage, } from "@402lane/core";
+export function createSigner(privateKey) {
+    return privateKeyToAccount(privateKey);
+}
+/**
+ * fetch wrapper that transparently pays x402 challenges in USDG on Robinhood Chain.
+ * On a 402 it signs an EIP-3009 authorization and retries once.
+ */
+export function payingFetch(options) {
+    const base = options.fetchImpl ?? fetch;
+    const allowed = new Set(options.networks ?? Object.keys(NETWORKS));
+    const maxValue = options.maxValue ?? 1000000n; // 1 USDG
+    return async (input, init) => {
+        const first = await base(input, init);
+        if (first.status !== 402)
+            return first;
+        const requirements = await extractRequirements(first);
+        const pick = requirements.find((r) => r.scheme === "exact" && allowed.has(r.network));
+        if (!pick)
+            return first;
+        if (BigInt(pick.maxAmountRequired) > maxValue) {
+            throw new Error(`402LANE client: challenge asks ${pick.maxAmountRequired} base units, above maxValue ${maxValue}`);
+        }
+        const payload = await signPayment(options.account, pick);
+        options.onPayment?.({
+            resource: pick.resource,
+            value: pick.maxAmountRequired,
+            network: pick.network,
+        });
+        const headers = new Headers(init?.headers);
+        headers.set(HEADER_PAYMENT_SIGNATURE, encodeHeader(payload));
+        return base(input, { ...init, headers });
+    };
+}
+async function extractRequirements(res) {
+    const header = res.headers.get(HEADER_PAYMENT_REQUIRED);
+    if (header)
+        return decodeHeader(header, paymentRequiredBodySchema).accepts;
+    try {
+        const body = paymentRequiredBodySchema.parse(await res.clone().json());
+        return body.accepts;
+    }
+    catch {
+        throw new Error("402LANE client: 402 without parseable payment requirements");
+    }
+}
+export async function signPayment(account, requirements) {
+    const now = Math.floor(Date.now() / 1000);
+    const authorization = {
+        from: account.address,
+        to: requirements.payTo,
+        value: requirements.maxAmountRequired,
+        validAfter: "0",
+        validBefore: String(now + (requirements.maxTimeoutSeconds ?? 300)),
+        nonce: `0x${randomBytes(32).toString("hex")}`,
+    };
+    const signature = await account.signTypedData({
+        domain: eip3009Domain(requirements.network),
+        types: TRANSFER_WITH_AUTHORIZATION_TYPES,
+        primaryType: "TransferWithAuthorization",
+        message: toTypedMessage(authorization),
+    });
+    return {
+        x402Version: X402_VERSION,
+        scheme: "exact",
+        network: requirements.network,
+        payload: { authorization, signature },
+    };
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@402lane/client",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@402lane/core": "workspace:*",
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "@types/node": "^22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oggyfoxy/lane402"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}