@parallel-protocol/x402 0.5.0

package/dist/express.js

@@ -0,0 +1,128 @@
+import { raceTimeout, HANDLER_TIMEOUT } from './chunk-2UEAVMCH.js';
+import { createPaymentMiddleware } from './chunk-FDQULXKG.js';
+
+// src/express/adapter.ts
+var TIMEOUT_BODY = JSON.stringify({
+  error: "HANDLER_TIMEOUT",
+  message: "The resource handler did not respond in time."
+});
+var ExpressAdapter = class {
+  constructor(req, res, next) {
+    this.req = req;
+    this.res = res;
+    this.next = next;
+  }
+  req;
+  res;
+  next;
+  getHeader(name) {
+    const value = this.req.header(name);
+    return Array.isArray(value) ? value[0] : value;
+  }
+  getMethod() {
+    return this.req.method;
+  }
+  getPath() {
+    return this.req.path;
+  }
+  getUrl() {
+    return `${this.req.protocol}://${this.req.headers.host}${this.req.originalUrl}`;
+  }
+  async runHandler() {
+    const res = this.res;
+    const next = this.next;
+    const originalWriteHead = res.writeHead.bind(res);
+    const originalWrite = res.write.bind(res);
+    const originalEnd = res.end.bind(res);
+    const buffered = [];
+    let settled = false;
+    let discarded = false;
+    let endCalled;
+    const endPromise = new Promise((resolve) => {
+      endCalled = resolve;
+    });
+    const restore = () => {
+      res.writeHead = originalWriteHead;
+      res.write = originalWrite;
+      res.end = originalEnd;
+    };
+    res.writeHead = ((...args) => {
+      if (discarded) return res;
+      if (!settled) {
+        buffered.push(["writeHead", args]);
+        return res;
+      }
+      return originalWriteHead(...args);
+    });
+    res.write = ((...args) => {
+      if (discarded) return true;
+      if (!settled) {
+        buffered.push(["write", args]);
+        return true;
+      }
+      return originalWrite(...args);
+    });
+    res.end = ((...args) => {
+      if (discarded) return res;
+      if (!settled) {
+        buffered.push(["end", args]);
+        endCalled();
+        return res;
+      }
+      return originalEnd(...args);
+    });
+    next();
+    const outcome = await raceTimeout(endPromise);
+    if (outcome === HANDLER_TIMEOUT) {
+      discarded = true;
+      return {
+        status: 504,
+        setResponseHeader: (name, value) => {
+          if (!res.headersSent) res.setHeader(name, value);
+        },
+        sendResponse: () => {
+          if (res.headersSent) return;
+          originalWriteHead(504, { "Content-Type": "application/json" });
+          originalEnd(TIMEOUT_BODY);
+        },
+        discardResponse: () => {
+        }
+      };
+    }
+    return {
+      status: res.statusCode,
+      setResponseHeader: (name, value) => res.setHeader(name, value),
+      sendResponse: () => {
+        settled = true;
+        restore();
+        for (const [method, args] of buffered) {
+          if (method === "writeHead") originalWriteHead(...args);
+          else if (method === "write") originalWrite(...args);
+          else if (method === "end") originalEnd(...args);
+        }
+      },
+      discardResponse: () => {
+        settled = true;
+        restore();
+      }
+    };
+  }
+};
+
+// src/express/index.ts
+function paymentMiddleware(config) {
+  const middleware = createPaymentMiddleware(config);
+  return async (req, res, next) => {
+    const result = await middleware(new ExpressAdapter(req, res, next));
+    if ("pass" in result) {
+      if (result.handlerRan) return;
+      return next();
+    }
+    for (const [key, value] of Object.entries(result.headers)) {
+      res.setHeader(key, value);
+    }
+    res.status(result.status).json(result.body);
+  };
+}
+
+export { ExpressAdapter, paymentMiddleware };

package/dist/fastify.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+var chunkW3SMR5LQ_cjs = require('./chunk-W3SMR5LQ.cjs');
+var fp = require('fastify-plugin');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fp__default = /*#__PURE__*/_interopDefault(fp);
+
+// src/fastify/adapter.ts
+var FastifyAdapter = class {
+  constructor(req) {
+    this.req = req;
+  }
+  req;
+  getHeader(name) {
+    const value = this.req.headers[name.toLowerCase()];
+    return Array.isArray(value) ? value[0] : value;
+  }
+  getMethod() {
+    return this.req.method;
+  }
+  getPath() {
+    return this.req.url.split("?")[0] ?? "/";
+  }
+  getUrl() {
+    return `${this.req.protocol}://${this.req.host || this.req.hostname}${this.req.url}`;
+  }
+};
+
+// src/fastify/index.ts
+function paymentMiddleware(config) {
+  return fp__default.default(async (fastify) => {
+    const gate = chunkW3SMR5LQ_cjs.createPaymentGate(config);
+    const settleMap = /* @__PURE__ */ new WeakMap();
+    fastify.addHook("onRequest", async (req, reply) => {
+      const gateResult = await gate(new FastifyAdapter(req));
+      if (gateResult.type === "pass") return;
+      if (gateResult.type === "error") {
+        for (const [key, value] of Object.entries(gateResult.result.headers)) {
+          reply.header(key, value);
+        }
+        reply.status(gateResult.result.status).send(gateResult.result.body);
+        return;
+      }
+      settleMap.set(req, gateResult.settle);
+    });
+    fastify.addHook("onSend", async (req, reply, payload) => {
+      const settle = settleMap.get(req);
+      if (!settle || reply.statusCode < 200 || reply.statusCode >= 300) {
+        return payload;
+      }
+      let settled = false;
+      try {
+        const settleResponse = await settle();
+        if (settleResponse.success) {
+          reply.header("payment-response", chunkW3SMR5LQ_cjs.encodeBase64(settleResponse));
+          reply.header("access-control-expose-headers", "payment-response");
+          settled = true;
+        }
+      } catch {
+      }
+      if (!settled) {
+        const body = JSON.stringify({
+          error: "PAYMENT_SETTLEMENT_FAILED",
+          message: "Payment could not be confirmed after multiple attempts. Please retry."
+        });
+        reply.status(402);
+        reply.header("Content-Type", "application/json");
+        reply.header("Content-Length", Buffer.byteLength(body));
+        return body;
+      }
+      return payload;
+    });
+  });
+}
+
+exports.FastifyAdapter = FastifyAdapter;
+exports.paymentMiddleware = paymentMiddleware;

package/dist/fastify.d.cts

@@ -0,0 +1,16 @@
+import { FastifyRequest, FastifyPluginAsync } from 'fastify';
+import { H as HTTPAdapter, P as PaymentMiddlewareConfig } from './types-CUi55YSx.cjs';
+import 'viem';
+
+declare class FastifyAdapter implements HTTPAdapter {
+    private readonly req;
+    constructor(req: FastifyRequest);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+}
+
+declare function paymentMiddleware(config: PaymentMiddlewareConfig): FastifyPluginAsync;
+
+export { FastifyAdapter, paymentMiddleware };

package/dist/fastify.d.ts

@@ -0,0 +1,16 @@
+import { FastifyRequest, FastifyPluginAsync } from 'fastify';
+import { H as HTTPAdapter, P as PaymentMiddlewareConfig } from './types-CUi55YSx.js';
+import 'viem';
+
+declare class FastifyAdapter implements HTTPAdapter {
+    private readonly req;
+    constructor(req: FastifyRequest);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+}
+
+declare function paymentMiddleware(config: PaymentMiddlewareConfig): FastifyPluginAsync;
+
+export { FastifyAdapter, paymentMiddleware };

package/dist/fastify.js

@@ -0,0 +1,72 @@
+import { createPaymentGate, encodeBase64 } from './chunk-FDQULXKG.js';
+import fp from 'fastify-plugin';
+
+// src/fastify/adapter.ts
+var FastifyAdapter = class {
+  constructor(req) {
+    this.req = req;
+  }
+  req;
+  getHeader(name) {
+    const value = this.req.headers[name.toLowerCase()];
+    return Array.isArray(value) ? value[0] : value;
+  }
+  getMethod() {
+    return this.req.method;
+  }
+  getPath() {
+    return this.req.url.split("?")[0] ?? "/";
+  }
+  getUrl() {
+    return `${this.req.protocol}://${this.req.host || this.req.hostname}${this.req.url}`;
+  }
+};
+
+// src/fastify/index.ts
+function paymentMiddleware(config) {
+  return fp(async (fastify) => {
+    const gate = createPaymentGate(config);
+    const settleMap = /* @__PURE__ */ new WeakMap();
+    fastify.addHook("onRequest", async (req, reply) => {
+      const gateResult = await gate(new FastifyAdapter(req));
+      if (gateResult.type === "pass") return;
+      if (gateResult.type === "error") {
+        for (const [key, value] of Object.entries(gateResult.result.headers)) {
+          reply.header(key, value);
+        }
+        reply.status(gateResult.result.status).send(gateResult.result.body);
+        return;
+      }
+      settleMap.set(req, gateResult.settle);
+    });
+    fastify.addHook("onSend", async (req, reply, payload) => {
+      const settle = settleMap.get(req);
+      if (!settle || reply.statusCode < 200 || reply.statusCode >= 300) {
+        return payload;
+      }
+      let settled = false;
+      try {
+        const settleResponse = await settle();
+        if (settleResponse.success) {
+          reply.header("payment-response", encodeBase64(settleResponse));
+          reply.header("access-control-expose-headers", "payment-response");
+          settled = true;
+        }
+      } catch {
+      }
+      if (!settled) {
+        const body = JSON.stringify({
+          error: "PAYMENT_SETTLEMENT_FAILED",
+          message: "Payment could not be confirmed after multiple attempts. Please retry."
+        });
+        reply.status(402);
+        reply.header("Content-Type", "application/json");
+        reply.header("Content-Length", Buffer.byteLength(body));
+        return body;
+      }
+      return payload;
+    });
+  });
+}
+
+export { FastifyAdapter, paymentMiddleware };

package/dist/hono.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var chunkXUNNMCO5_cjs = require('./chunk-XUNNMCO5.cjs');
+var chunkW3SMR5LQ_cjs = require('./chunk-W3SMR5LQ.cjs');
+
+// src/hono/adapter.ts
+var TIMEOUT_BODY = JSON.stringify({
+  error: "HANDLER_TIMEOUT",
+  message: "The resource handler did not respond in time."
+});
+var HonoAdapter = class {
+  constructor(c, next) {
+    this.c = c;
+    this.next = next;
+  }
+  c;
+  next;
+  getHeader(name) {
+    return this.c.req.header(name);
+  }
+  getMethod() {
+    return this.c.req.method;
+  }
+  getPath() {
+    return this.c.req.path;
+  }
+  getUrl() {
+    return this.c.req.url;
+  }
+  async runHandler() {
+    const outcome = await chunkXUNNMCO5_cjs.raceTimeout(this.next());
+    if (outcome === chunkXUNNMCO5_cjs.HANDLER_TIMEOUT) {
+      return {
+        status: 504,
+        setResponseHeader: () => {
+        },
+        sendResponse: () => {
+          this.c.res = new Response(TIMEOUT_BODY, {
+            status: 504,
+            headers: { "Content-Type": "application/json" }
+          });
+        },
+        discardResponse: () => {
+        }
+      };
+    }
+    const res = this.c.res;
+    return {
+      status: res.status,
+      setResponseHeader: (name, value) => res.headers.set(name, value),
+      sendResponse: () => {
+      },
+      discardResponse: () => {
+      }
+    };
+  }
+};
+
+// src/hono/index.ts
+function paymentMiddleware(config) {
+  const middleware = chunkW3SMR5LQ_cjs.createPaymentMiddleware(config);
+  return async (c, next) => {
+    const result = await middleware(new HonoAdapter(c, next));
+    if ("pass" in result) {
+      if (result.handlerRan) return;
+      await next();
+      return;
+    }
+    return new Response(JSON.stringify(result.body), {
+      status: result.status,
+      headers: { ...result.headers, "Content-Type": "application/json" }
+    });
+  };
+}
+
+exports.HonoAdapter = HonoAdapter;
+exports.paymentMiddleware = paymentMiddleware;

package/dist/hono.d.cts

@@ -0,0 +1,18 @@
+import { Context, Next, MiddlewareHandler } from 'hono';
+import { H as HTTPAdapter, R as RunHandlerResult, P as PaymentMiddlewareConfig } from './types-CUi55YSx.cjs';
+import 'viem';
+
+declare class HonoAdapter implements HTTPAdapter {
+    private readonly c;
+    private readonly next;
+    constructor(c: Context, next: Next);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    runHandler(): Promise<RunHandlerResult>;
+}
+
+declare function paymentMiddleware(config: PaymentMiddlewareConfig): MiddlewareHandler;
+
+export { HonoAdapter, paymentMiddleware };

package/dist/hono.d.ts

@@ -0,0 +1,18 @@
+import { Context, Next, MiddlewareHandler } from 'hono';
+import { H as HTTPAdapter, R as RunHandlerResult, P as PaymentMiddlewareConfig } from './types-CUi55YSx.js';
+import 'viem';
+
+declare class HonoAdapter implements HTTPAdapter {
+    private readonly c;
+    private readonly next;
+    constructor(c: Context, next: Next);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    runHandler(): Promise<RunHandlerResult>;
+}
+
+declare function paymentMiddleware(config: PaymentMiddlewareConfig): MiddlewareHandler;
+
+export { HonoAdapter, paymentMiddleware };

package/dist/hono.js

@@ -0,0 +1,74 @@
+import { raceTimeout, HANDLER_TIMEOUT } from './chunk-2UEAVMCH.js';
+import { createPaymentMiddleware } from './chunk-FDQULXKG.js';
+
+// src/hono/adapter.ts
+var TIMEOUT_BODY = JSON.stringify({
+  error: "HANDLER_TIMEOUT",
+  message: "The resource handler did not respond in time."
+});
+var HonoAdapter = class {
+  constructor(c, next) {
+    this.c = c;
+    this.next = next;
+  }
+  c;
+  next;
+  getHeader(name) {
+    return this.c.req.header(name);
+  }
+  getMethod() {
+    return this.c.req.method;
+  }
+  getPath() {
+    return this.c.req.path;
+  }
+  getUrl() {
+    return this.c.req.url;
+  }
+  async runHandler() {
+    const outcome = await raceTimeout(this.next());
+    if (outcome === HANDLER_TIMEOUT) {
+      return {
+        status: 504,
+        setResponseHeader: () => {
+        },
+        sendResponse: () => {
+          this.c.res = new Response(TIMEOUT_BODY, {
+            status: 504,
+            headers: { "Content-Type": "application/json" }
+          });
+        },
+        discardResponse: () => {
+        }
+      };
+    }
+    const res = this.c.res;
+    return {
+      status: res.status,
+      setResponseHeader: (name, value) => res.headers.set(name, value),
+      sendResponse: () => {
+      },
+      discardResponse: () => {
+      }
+    };
+  }
+};
+
+// src/hono/index.ts
+function paymentMiddleware(config) {
+  const middleware = createPaymentMiddleware(config);
+  return async (c, next) => {
+    const result = await middleware(new HonoAdapter(c, next));
+    if ("pass" in result) {
+      if (result.handlerRan) return;
+      await next();
+      return;
+    }
+    return new Response(JSON.stringify(result.body), {
+      status: result.status,
+      headers: { ...result.headers, "Content-Type": "application/json" }
+    });
+  };
+}
+
+export { HonoAdapter, paymentMiddleware };

package/dist/index.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var chunkW3SMR5LQ_cjs = require('./chunk-W3SMR5LQ.cjs');
+
+
+
+Object.defineProperty(exports, "FacilitatorClient", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.FacilitatorClient; }
+});
+Object.defineProperty(exports, "PARALLEL_TOKENS", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.PARALLEL_TOKENS; }
+});
+Object.defineProperty(exports, "X402ConfigError", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.X402ConfigError; }
+});
+Object.defineProperty(exports, "X402RuntimeError", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.X402RuntimeError; }
+});
+Object.defineProperty(exports, "X402_ERROR_CODES", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.X402_ERROR_CODES; }
+});
+Object.defineProperty(exports, "createPaymentGate", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.createPaymentGate; }
+});
+Object.defineProperty(exports, "createPaymentMiddleware", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.createPaymentMiddleware; }
+});
+Object.defineProperty(exports, "encodeBase64", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.encodeBase64; }
+});
+Object.defineProperty(exports, "getDefaultAcceptedTokens", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.getDefaultAcceptedTokens; }
+});
+Object.defineProperty(exports, "parsePrice", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.parsePrice; }
+});
+Object.defineProperty(exports, "toEip155Network", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.toEip155Network; }
+});
+Object.defineProperty(exports, "validateAddress", {
+  enumerable: true,
+  get: function () { return chunkW3SMR5LQ_cjs.validateAddress; }
+});

package/dist/index.d.cts

@@ -0,0 +1,52 @@
+import { F as FacilitatorConfig, a as FacilitatorPaymentRequirements, b as FacilitatorResponse, P as PaymentMiddlewareConfig, H as HTTPAdapter, c as PaymentGateResult, M as MiddlewareResult, d as PassResult } from './types-CUi55YSx.cjs';
+export { e as PaymentConfirmation, f as PaymentFailure, g as PaymentRequired, h as PaymentRequirements, i as ResourceInfo, j as RouteConfig, R as RunHandlerResult } from './types-CUi55YSx.cjs';
+import { Address } from 'viem';
+
+declare class FacilitatorClient {
+    private readonly config;
+    constructor(config: FacilitatorConfig);
+    verify(paymentHeader: string, paymentRequirements: FacilitatorPaymentRequirements): Promise<void>;
+    settle(paymentHeader: string, paymentRequirements: FacilitatorPaymentRequirements): Promise<FacilitatorResponse>;
+    pay(paymentHeader: string): Promise<FacilitatorResponse>;
+    private buildHeaders;
+}
+
+declare const X402_ERROR_CODES: {
+    readonly FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE";
+    readonly FACILITATOR_INVALID_RESPONSE: "FACILITATOR_INVALID_RESPONSE";
+    readonly INVALID_PAYMENT: "INVALID_PAYMENT";
+};
+type X402ErrorCode = (typeof X402_ERROR_CODES)[keyof typeof X402_ERROR_CODES];
+declare class X402ConfigError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+declare class X402RuntimeError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+
+declare function createPaymentGate(config: PaymentMiddlewareConfig): (adapter: Pick<HTTPAdapter, "getHeader" | "getPath" | "getUrl" | "getMethod">) => Promise<PaymentGateResult>;
+declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): (adapter: HTTPAdapter) => Promise<MiddlewareResult | PassResult>;
+
+type ParallelNetwork = "ethereum" | "base" | "avalanche" | "hyperevm";
+type ChainTokens = {
+    usdp: Address;
+    susdp: Address;
+    usdc: Address;
+    frxUSD?: Address;
+    sfrxUSD?: Address;
+    USDe?: Address;
+    sUSDe?: Address;
+    USDS?: Address;
+    sUSDS?: Address;
+    ygamiUSDC?: Address;
+};
+declare const PARALLEL_TOKENS: Record<ParallelNetwork, ChainTokens>;
+declare function getDefaultAcceptedTokens(network: string): [Address, Address, Address] | undefined;
+
+declare function parsePrice(price: string | bigint, decimals?: number): bigint;
+declare function validateAddress(address: string): address is Address;
+declare function toEip155Network(network: string): string;
+declare function encodeBase64(obj: unknown): string;
+
+export { FacilitatorClient, FacilitatorConfig, FacilitatorPaymentRequirements, FacilitatorResponse, HTTPAdapter, MiddlewareResult, PARALLEL_TOKENS, type ParallelNetwork, PassResult, PaymentGateResult, PaymentMiddlewareConfig, X402ConfigError, type X402ErrorCode, X402RuntimeError, X402_ERROR_CODES, createPaymentGate, createPaymentMiddleware, encodeBase64, getDefaultAcceptedTokens, parsePrice, toEip155Network, validateAddress };

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import { F as FacilitatorConfig, a as FacilitatorPaymentRequirements, b as FacilitatorResponse, P as PaymentMiddlewareConfig, H as HTTPAdapter, c as PaymentGateResult, M as MiddlewareResult, d as PassResult } from './types-CUi55YSx.js';
+export { e as PaymentConfirmation, f as PaymentFailure, g as PaymentRequired, h as PaymentRequirements, i as ResourceInfo, j as RouteConfig, R as RunHandlerResult } from './types-CUi55YSx.js';
+import { Address } from 'viem';
+
+declare class FacilitatorClient {
+    private readonly config;
+    constructor(config: FacilitatorConfig);
+    verify(paymentHeader: string, paymentRequirements: FacilitatorPaymentRequirements): Promise<void>;
+    settle(paymentHeader: string, paymentRequirements: FacilitatorPaymentRequirements): Promise<FacilitatorResponse>;
+    pay(paymentHeader: string): Promise<FacilitatorResponse>;
+    private buildHeaders;
+}
+
+declare const X402_ERROR_CODES: {
+    readonly FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE";
+    readonly FACILITATOR_INVALID_RESPONSE: "FACILITATOR_INVALID_RESPONSE";
+    readonly INVALID_PAYMENT: "INVALID_PAYMENT";
+};
+type X402ErrorCode = (typeof X402_ERROR_CODES)[keyof typeof X402_ERROR_CODES];
+declare class X402ConfigError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+declare class X402RuntimeError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+
+declare function createPaymentGate(config: PaymentMiddlewareConfig): (adapter: Pick<HTTPAdapter, "getHeader" | "getPath" | "getUrl" | "getMethod">) => Promise<PaymentGateResult>;
+declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): (adapter: HTTPAdapter) => Promise<MiddlewareResult | PassResult>;
+
+type ParallelNetwork = "ethereum" | "base" | "avalanche" | "hyperevm";
+type ChainTokens = {
+    usdp: Address;
+    susdp: Address;
+    usdc: Address;
+    frxUSD?: Address;
+    sfrxUSD?: Address;
+    USDe?: Address;
+    sUSDe?: Address;
+    USDS?: Address;
+    sUSDS?: Address;
+    ygamiUSDC?: Address;
+};
+declare const PARALLEL_TOKENS: Record<ParallelNetwork, ChainTokens>;
+declare function getDefaultAcceptedTokens(network: string): [Address, Address, Address] | undefined;
+
+declare function parsePrice(price: string | bigint, decimals?: number): bigint;
+declare function validateAddress(address: string): address is Address;
+declare function toEip155Network(network: string): string;
+declare function encodeBase64(obj: unknown): string;
+
+export { FacilitatorClient, FacilitatorConfig, FacilitatorPaymentRequirements, FacilitatorResponse, HTTPAdapter, MiddlewareResult, PARALLEL_TOKENS, type ParallelNetwork, PassResult, PaymentGateResult, PaymentMiddlewareConfig, X402ConfigError, type X402ErrorCode, X402RuntimeError, X402_ERROR_CODES, createPaymentGate, createPaymentMiddleware, encodeBase64, getDefaultAcceptedTokens, parsePrice, toEip155Network, validateAddress };

package/dist/index.js

@@ -0,0 +1 @@
+export { FacilitatorClient, PARALLEL_TOKENS, X402ConfigError, X402RuntimeError, X402_ERROR_CODES, createPaymentGate, createPaymentMiddleware, encodeBase64, getDefaultAcceptedTokens, parsePrice, toEip155Network, validateAddress } from './chunk-FDQULXKG.js';