powertools-x402 0.1.0 → 0.1.2

package/dist/stripe.cjs

@@ -0,0 +1,316 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/stripe.ts
+var stripe_exports = {};
+__export(stripe_exports, {
+  createStripeX402: () => createStripeX402
+});
+module.exports = __toCommonJS(stripe_exports);
+var import_stripe = __toESM(require("stripe"), 1);
+
+// src/coinbase.ts
+var import_x402 = require("@coinbase/x402");
+var coinbaseFacilitator = (apiKeyId, apiKeySecret) => (0, import_x402.createFacilitatorConfig)(apiKeyId, apiKeySecret);
+
+// src/index.ts
+var import_metrics = require("@aws-lambda-powertools/metrics");
+var import_server = require("@x402/core/server");
+var import_server2 = require("@x402/evm/exact/server");
+
+// src/adapter.ts
+var PowertoolsAdapter = class {
+  constructor(request) {
+    this.request = request;
+  }
+  request;
+  getHeader(name) {
+    return this.request.headers.get(name) ?? void 0;
+  }
+  getMethod() {
+    return this.request.method;
+  }
+  getPath() {
+    return new URL(this.request.url).pathname;
+  }
+  getUrl() {
+    return this.request.url;
+  }
+  getAcceptHeader() {
+    return this.request.headers.get("accept") ?? "";
+  }
+  getUserAgent() {
+    return this.request.headers.get("user-agent") ?? "";
+  }
+  getQueryParams() {
+    const params = new URL(this.request.url).searchParams;
+    const result = {};
+    for (const key of new Set(params.keys())) {
+      const values = params.getAll(key);
+      result[key] = values.length === 1 ? values[0] : values;
+    }
+    return result;
+  }
+  getQueryParam(name) {
+    const values = new URL(this.request.url).searchParams.getAll(name);
+    if (values.length === 0) return void 0;
+    return values.length === 1 ? values[0] : values;
+  }
+  async getBody() {
+    try {
+      return await this.request.clone().json();
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/facilitator.ts
+var CachingFacilitatorClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  #supported;
+  verify(payload, requirements) {
+    return this.client.verify(payload, requirements);
+  }
+  settle(payload, requirements) {
+    return this.client.settle(payload, requirements);
+  }
+  getSupported() {
+    this.#supported ??= this.client.getSupported().catch((error) => {
+      this.#supported = void 0;
+      throw error;
+    });
+    return this.#supported;
+  }
+};
+
+// src/index.ts
+var toFacilitatorClient = (facilitator) => {
+  if (typeof facilitator === "string") return new import_server.HTTPFacilitatorClient({ url: facilitator });
+  if ("getSupported" in facilitator) return facilitator;
+  return new import_server.HTTPFacilitatorClient(facilitator);
+};
+var toResponse = ({ status, headers, body, isHtml }) => new Response(isHtml ? String(body ?? "") : JSON.stringify(body ?? {}), { status, headers });
+function createX402(options) {
+  const facilitator = new CachingFacilitatorClient(toFacilitatorClient(options.facilitator));
+  const resourceServer = new import_server.x402ResourceServer(facilitator);
+  for (const register of options.schemes ?? [import_server2.registerExactEvmScheme]) {
+    register(resourceServer);
+  }
+  const { logger } = options;
+  const metrics = options.enableMetrics ? options.metrics ?? new import_metrics.Metrics({ namespace: "x402" }) : void 0;
+  const count = (name) => metrics && (metrics.singleMetric?.() ?? metrics).addMetric(name, "Count", 1);
+  const payers = /* @__PURE__ */ new WeakMap();
+  resourceServer.onAfterVerify(async ({ paymentPayload, result }) => {
+    if (result.payer) payers.set(paymentPayload, result.payer);
+  });
+  function paid(route) {
+    const { price, accepts, onProtectedRequest, ...routeConfig } = route;
+    if (accepts === void 0 && price === void 0) {
+      throw new Error("paid() requires a price or an accepts configuration");
+    }
+    const httpServer = new import_server.x402HTTPResourceServer(resourceServer, {
+      ...routeConfig,
+      mimeType: routeConfig.mimeType ?? "application/json",
+      accepts: accepts ?? {
+        scheme: "exact",
+        network: options.network,
+        payTo: options.payTo,
+        price
+      }
+    });
+    if (onProtectedRequest) httpServer.onProtectedRequest(onProtectedRequest);
+    let ready;
+    const initialize = () => ready ??= httpServer.initialize().catch((error) => {
+      ready = void 0;
+      throw error;
+    });
+    return async ({ reqCtx, next }) => {
+      await initialize();
+      const adapter = new PowertoolsAdapter(reqCtx.req);
+      const context = {
+        adapter,
+        path: adapter.getPath(),
+        method: adapter.getMethod()
+      };
+      const result = await httpServer.processHTTPRequest(context, options.paywall);
+      if (result.type === "no-payment-required") {
+        await next();
+        return;
+      }
+      if (result.type === "payment-error") {
+        count(adapter.getHeader("payment-signature") ? "PaymentRejected" : "PaymentRequired");
+        logger?.debug("x402 payment not accepted", { status: result.response.status });
+        reqCtx.res = toResponse(result.response);
+        return;
+      }
+      const {
+        cancellationDispatcher,
+        beforeHandlerSettlement,
+        paymentPayload,
+        paymentRequirements,
+        declaredExtensions
+      } = result;
+      reqCtx.set("payment", {
+        network: paymentRequirements.network,
+        scheme: paymentRequirements.scheme,
+        asset: paymentRequirements.asset,
+        amount: paymentRequirements.amount,
+        payer: payers.get(paymentPayload)
+      });
+      count("PaymentVerified");
+      try {
+        await next();
+      } catch (error) {
+        await cancellationDispatcher.cancel({ reason: "handler_threw", error });
+        count("PaymentCancelled");
+        logger?.warn("x402 payment cancelled: handler threw", { path: context.path });
+        throw error;
+      }
+      if (reqCtx.res.status >= 400) {
+        await cancellationDispatcher.cancel({
+          reason: "handler_failed",
+          responseStatus: reqCtx.res.status
+        });
+        count("PaymentCancelled");
+        logger?.warn("x402 payment cancelled: handler failed", {
+          path: context.path,
+          status: reqCtx.res.status
+        });
+        return;
+      }
+      const settlement = await httpServer.processSettlement(
+        paymentPayload,
+        paymentRequirements,
+        declaredExtensions,
+        {
+          request: context,
+          responseBody: Buffer.from(await reqCtx.res.clone().arrayBuffer()),
+          responseHeaders: Object.fromEntries(reqCtx.res.headers.entries())
+        },
+        void 0,
+        beforeHandlerSettlement
+      );
+      if (!settlement.success) {
+        count("SettlementFailed");
+        logger?.error("x402 settlement failed", {
+          path: context.path,
+          errorReason: settlement.errorReason
+        });
+        reqCtx.res = toResponse(settlement.response);
+        return;
+      }
+      count("PaymentSettled");
+      logger?.debug("x402 payment settled", { path: context.path, transaction: settlement.transaction });
+      for (const [name, value] of Object.entries(settlement.headers)) {
+        reqCtx.res.headers.set(name, value);
+      }
+      const cacheControl = reqCtx.res.headers.get("cache-control");
+      reqCtx.res.headers.set("cache-control", cacheControl ? `${cacheControl}, private` : "private");
+    };
+  }
+  return { paid, resourceServer };
+}
+
+// src/stripe.ts
+var BASE_MAINNET = "eip155:8453";
+var BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var STRIPE_PREVIEW_API_VERSION = "2026-05-27.preview";
+function createStripeX402(options = {}) {
+  const {
+    depositAddress = process.env.STRIPE_DEPOSIT_ADDRESS,
+    stripeSecretKey = process.env.STRIPE_SECRET_KEY,
+    stripe,
+    cdpApiKeyId,
+    cdpApiKeySecret,
+    facilitator,
+    ...rest
+  } = options;
+  if (!depositAddress) {
+    throw new Error(
+      "createStripeX402 requires a depositAddress (or STRIPE_DEPOSIT_ADDRESS). Create one with POST /v1/crypto/deposit_addresses."
+    );
+  }
+  if (!stripe && !stripeSecretKey) {
+    throw new Error("createStripeX402 requires a stripe client or stripeSecretKey (or STRIPE_SECRET_KEY).");
+  }
+  const stripeClient = stripe ?? new import_stripe.default(stripeSecretKey, {
+    apiVersion: STRIPE_PREVIEW_API_VERSION
+  });
+  const x402 = createX402({
+    ...rest,
+    network: BASE_MAINNET,
+    facilitator: facilitator ?? coinbaseFacilitator(cdpApiKeyId, cdpApiKeySecret),
+    payTo: depositAddress
+  });
+  x402.resourceServer.onAfterSettle(async ({ result, requirements }) => {
+    if (!result.success || !result.transaction) return;
+    if (requirements.network !== BASE_MAINNET) return;
+    if (requirements.asset.toLowerCase() !== BASE_USDC.toLowerCase()) return;
+    const amountInCents = Math.round(Number(requirements.amount) / 1e4);
+    if (amountInCents < 1) return;
+    try {
+      await stripeClient.paymentIntents.create(
+        {
+          amount: amountInCents,
+          currency: "usd",
+          confirm: true,
+          payment_method_data: { type: "crypto" },
+          payment_method_types: ["crypto"],
+          payment_method_options: {
+            // transaction_verification ships in the 2026-05-27.preview API
+            // version and is not yet in stripe-node's stable types
+            crypto: {
+              mode: "transaction_verification",
+              transaction_verification_options: {
+                network: "base",
+                transaction_hash: result.transaction
+              }
+            }
+          }
+        },
+        { idempotencyKey: result.transaction }
+      );
+    } catch (error) {
+      (rest.logger ?? console).error("stripe payment intent recording failed", {
+        transaction: result.transaction,
+        amountInCents,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  return x402;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStripeX402
+});

package/dist/stripe.d.cts

@@ -0,0 +1,38 @@
+import * as _x402_core_server from '@x402/core/server';
+import * as _aws_lambda_powertools_event_handler_types from '@aws-lambda-powertools/event-handler/types';
+import { CreateX402Options, PaidRouteOptions, X402Environment } from './index.cjs';
+import Stripe from 'stripe';
+import '@x402/core/http';
+import '@x402/core/types';
+
+interface StripeClient {
+    paymentIntents: {
+        create(params: Stripe.PaymentIntentCreateParams, options: {
+            idempotencyKey: string;
+        }): Promise<unknown>;
+    };
+}
+interface StripeX402Options extends Omit<CreateX402Options, 'facilitator' | 'payTo' | 'network'> {
+    depositAddress?: string;
+    stripeSecretKey?: string;
+    stripe?: StripeClient;
+    cdpApiKeyId?: string;
+    cdpApiKeySecret?: string;
+    facilitator?: CreateX402Options['facilitator'];
+}
+/**
+ * x402 routes that settle into your Stripe balance: payments go to a Stripe
+ * crypto deposit address via the Coinbase facilitator, and each settled
+ * payment is recorded as a Stripe PaymentIntent (transaction_verification).
+ *
+ * Intentionally pinned to USDC on Base mainnet; the PaymentIntent recording
+ * assumes that network and asset. A failed recording never fails the request:
+ * the payment already settled on-chain, so the failure is logged with the
+ * transaction hash for reconciliation instead.
+ */
+declare function createStripeX402(options?: StripeX402Options): {
+    paid: (route: PaidRouteOptions) => _aws_lambda_powertools_event_handler_types.Middleware<X402Environment>;
+    resourceServer: _x402_core_server.x402ResourceServer;
+};
+
+export { type StripeClient, type StripeX402Options, createStripeX402 };

package/dist/stripe.d.ts

@@ -0,0 +1,38 @@
+import * as _x402_core_server from '@x402/core/server';
+import * as _aws_lambda_powertools_event_handler_types from '@aws-lambda-powertools/event-handler/types';
+import { CreateX402Options, PaidRouteOptions, X402Environment } from './index.js';
+import Stripe from 'stripe';
+import '@x402/core/http';
+import '@x402/core/types';
+
+interface StripeClient {
+    paymentIntents: {
+        create(params: Stripe.PaymentIntentCreateParams, options: {
+            idempotencyKey: string;
+        }): Promise<unknown>;
+    };
+}
+interface StripeX402Options extends Omit<CreateX402Options, 'facilitator' | 'payTo' | 'network'> {
+    depositAddress?: string;
+    stripeSecretKey?: string;
+    stripe?: StripeClient;
+    cdpApiKeyId?: string;
+    cdpApiKeySecret?: string;
+    facilitator?: CreateX402Options['facilitator'];
+}
+/**
+ * x402 routes that settle into your Stripe balance: payments go to a Stripe
+ * crypto deposit address via the Coinbase facilitator, and each settled
+ * payment is recorded as a Stripe PaymentIntent (transaction_verification).
+ *
+ * Intentionally pinned to USDC on Base mainnet; the PaymentIntent recording
+ * assumes that network and asset. A failed recording never fails the request:
+ * the payment already settled on-chain, so the failure is logged with the
+ * transaction hash for reconciliation instead.
+ */
+declare function createStripeX402(options?: StripeX402Options): {
+    paid: (route: PaidRouteOptions) => _aws_lambda_powertools_event_handler_types.Middleware<X402Environment>;
+    resourceServer: _x402_core_server.x402ResourceServer;
+};
+
+export { type StripeClient, type StripeX402Options, createStripeX402 };

package/dist/stripe.js

@@ -0,0 +1,80 @@
+import {
+  coinbaseFacilitator
+} from "./chunk-FLK2T35N.js";
+import {
+  createX402
+} from "./chunk-D46V2DLG.js";
+
+// src/stripe.ts
+import Stripe from "stripe";
+var BASE_MAINNET = "eip155:8453";
+var BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var STRIPE_PREVIEW_API_VERSION = "2026-05-27.preview";
+function createStripeX402(options = {}) {
+  const {
+    depositAddress = process.env.STRIPE_DEPOSIT_ADDRESS,
+    stripeSecretKey = process.env.STRIPE_SECRET_KEY,
+    stripe,
+    cdpApiKeyId,
+    cdpApiKeySecret,
+    facilitator,
+    ...rest
+  } = options;
+  if (!depositAddress) {
+    throw new Error(
+      "createStripeX402 requires a depositAddress (or STRIPE_DEPOSIT_ADDRESS). Create one with POST /v1/crypto/deposit_addresses."
+    );
+  }
+  if (!stripe && !stripeSecretKey) {
+    throw new Error("createStripeX402 requires a stripe client or stripeSecretKey (or STRIPE_SECRET_KEY).");
+  }
+  const stripeClient = stripe ?? new Stripe(stripeSecretKey, {
+    apiVersion: STRIPE_PREVIEW_API_VERSION
+  });
+  const x402 = createX402({
+    ...rest,
+    network: BASE_MAINNET,
+    facilitator: facilitator ?? coinbaseFacilitator(cdpApiKeyId, cdpApiKeySecret),
+    payTo: depositAddress
+  });
+  x402.resourceServer.onAfterSettle(async ({ result, requirements }) => {
+    if (!result.success || !result.transaction) return;
+    if (requirements.network !== BASE_MAINNET) return;
+    if (requirements.asset.toLowerCase() !== BASE_USDC.toLowerCase()) return;
+    const amountInCents = Math.round(Number(requirements.amount) / 1e4);
+    if (amountInCents < 1) return;
+    try {
+      await stripeClient.paymentIntents.create(
+        {
+          amount: amountInCents,
+          currency: "usd",
+          confirm: true,
+          payment_method_data: { type: "crypto" },
+          payment_method_types: ["crypto"],
+          payment_method_options: {
+            // transaction_verification ships in the 2026-05-27.preview API
+            // version and is not yet in stripe-node's stable types
+            crypto: {
+              mode: "transaction_verification",
+              transaction_verification_options: {
+                network: "base",
+                transaction_hash: result.transaction
+              }
+            }
+          }
+        },
+        { idempotencyKey: result.transaction }
+      );
+    } catch (error) {
+      (rest.logger ?? console).error("stripe payment intent recording failed", {
+        transaction: result.transaction,
+        amountInCents,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  return x402;
+}
+export {
+  createStripeX402
+};

package/dist/testing.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  TEST_PAYER_ADDRESS: () => TEST_PAYER_ADDRESS,
+  TEST_TRANSACTION_HASH: () => TEST_TRANSACTION_HASH,
+  stubFacilitator: () => stubFacilitator,
+  testPayer: () => testPayer
+});
+module.exports = __toCommonJS(testing_exports);
+var import_client = require("@x402/core/client");
+var import_client2 = require("@x402/evm/exact/client");
+var import_accounts = require("viem/accounts");
+var TEST_PAYER_ADDRESS = "0x0000000000000000000000000000000000C0FFEE";
+var TEST_TRANSACTION_HASH = `0x${"ab".repeat(32)}`;
+function stubFacilitator(options = {}) {
+  const networks = [options.network ?? "eip155:84532"].flat();
+  const payer = options.payer ?? TEST_PAYER_ADDRESS;
+  return {
+    async getSupported() {
+      return {
+        kinds: networks.map((network) => ({ x402Version: 2, scheme: "exact", network })),
+        extensions: [],
+        signers: {}
+      };
+    },
+    async verify() {
+      return { isValid: true, payer, ...options.verify };
+    },
+    async settle() {
+      return {
+        success: true,
+        transaction: TEST_TRANSACTION_HASH,
+        network: networks[0],
+        payer,
+        ...options.settle
+      };
+    }
+  };
+}
+var getHeaderFrom = (challenge) => (name) => {
+  if (challenge.headers instanceof Headers) return challenge.headers.get(name) ?? void 0;
+  const value = challenge.headers?.[name.toLowerCase()];
+  return value === void 0 ? void 0 : String(value);
+};
+function testPayer(privateKey) {
+  const account = (0, import_accounts.privateKeyToAccount)(privateKey ?? (0, import_accounts.generatePrivateKey)());
+  const client = new import_client.x402HTTPClient(
+    (0, import_client2.registerExactEvmScheme)(new import_client.x402Client(), { signer: account })
+  );
+  return {
+    address: account.address,
+    async payFor(challenge) {
+      const paymentRequired = client.getPaymentRequiredResponse(getHeaderFrom(challenge));
+      const payload = await client.createPaymentPayload(paymentRequired);
+      return client.encodePaymentSignatureHeader(payload);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TEST_PAYER_ADDRESS,
+  TEST_TRANSACTION_HASH,
+  stubFacilitator,
+  testPayer
+});

package/dist/testing.d.cts

@@ -0,0 +1,29 @@
+import { FacilitatorClient } from '@x402/core/server';
+import { Network, VerifyResponse, SettleResponse } from '@x402/core/types';
+
+declare const TEST_PAYER_ADDRESS = "0x0000000000000000000000000000000000C0FFEE";
+declare const TEST_TRANSACTION_HASH: string;
+interface StubFacilitatorOptions {
+    network?: Network | Network[];
+    payer?: string;
+    verify?: Partial<VerifyResponse>;
+    settle?: Partial<SettleResponse>;
+}
+/**
+ * In-memory facilitator that approves every payment. Spy on its methods or
+ * override verify/settle responses to exercise failure paths.
+ */
+declare function stubFacilitator(options?: StubFacilitatorOptions): FacilitatorClient;
+type ChallengeLike = Response | {
+    headers?: Record<string, unknown>;
+};
+/**
+ * A payment client backed by a throwaway account. Feed it a 402 response and
+ * it returns the headers that make the retried request a valid paid request.
+ */
+declare function testPayer(privateKey?: `0x${string}`): {
+    address: `0x${string}`;
+    payFor(challenge: ChallengeLike): Promise<Record<string, string>>;
+};
+
+export { type StubFacilitatorOptions, TEST_PAYER_ADDRESS, TEST_TRANSACTION_HASH, stubFacilitator, testPayer };

package/dist/testing.d.ts

@@ -0,0 +1,29 @@
+import { FacilitatorClient } from '@x402/core/server';
+import { Network, VerifyResponse, SettleResponse } from '@x402/core/types';
+
+declare const TEST_PAYER_ADDRESS = "0x0000000000000000000000000000000000C0FFEE";
+declare const TEST_TRANSACTION_HASH: string;
+interface StubFacilitatorOptions {
+    network?: Network | Network[];
+    payer?: string;
+    verify?: Partial<VerifyResponse>;
+    settle?: Partial<SettleResponse>;
+}
+/**
+ * In-memory facilitator that approves every payment. Spy on its methods or
+ * override verify/settle responses to exercise failure paths.
+ */
+declare function stubFacilitator(options?: StubFacilitatorOptions): FacilitatorClient;
+type ChallengeLike = Response | {
+    headers?: Record<string, unknown>;
+};
+/**
+ * A payment client backed by a throwaway account. Feed it a 402 response and
+ * it returns the headers that make the retried request a valid paid request.
+ */
+declare function testPayer(privateKey?: `0x${string}`): {
+    address: `0x${string}`;
+    payFor(challenge: ChallengeLike): Promise<Record<string, string>>;
+};
+
+export { type StubFacilitatorOptions, TEST_PAYER_ADDRESS, TEST_TRANSACTION_HASH, stubFacilitator, testPayer };

package/dist/testing.js

@@ -0,0 +1,56 @@
+// src/testing.ts
+import { x402Client, x402HTTPClient } from "@x402/core/client";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+var TEST_PAYER_ADDRESS = "0x0000000000000000000000000000000000C0FFEE";
+var TEST_TRANSACTION_HASH = `0x${"ab".repeat(32)}`;
+function stubFacilitator(options = {}) {
+  const networks = [options.network ?? "eip155:84532"].flat();
+  const payer = options.payer ?? TEST_PAYER_ADDRESS;
+  return {
+    async getSupported() {
+      return {
+        kinds: networks.map((network) => ({ x402Version: 2, scheme: "exact", network })),
+        extensions: [],
+        signers: {}
+      };
+    },
+    async verify() {
+      return { isValid: true, payer, ...options.verify };
+    },
+    async settle() {
+      return {
+        success: true,
+        transaction: TEST_TRANSACTION_HASH,
+        network: networks[0],
+        payer,
+        ...options.settle
+      };
+    }
+  };
+}
+var getHeaderFrom = (challenge) => (name) => {
+  if (challenge.headers instanceof Headers) return challenge.headers.get(name) ?? void 0;
+  const value = challenge.headers?.[name.toLowerCase()];
+  return value === void 0 ? void 0 : String(value);
+};
+function testPayer(privateKey) {
+  const account = privateKeyToAccount(privateKey ?? generatePrivateKey());
+  const client = new x402HTTPClient(
+    registerExactEvmScheme(new x402Client(), { signer: account })
+  );
+  return {
+    address: account.address,
+    async payFor(challenge) {
+      const paymentRequired = client.getPaymentRequiredResponse(getHeaderFrom(challenge));
+      const payload = await client.createPaymentPayload(paymentRequired);
+      return client.encodePaymentSignatureHeader(payload);
+    }
+  };
+}
+export {
+  TEST_PAYER_ADDRESS,
+  TEST_TRANSACTION_HASH,
+  stubFacilitator,
+  testPayer
+};