powertools-x402 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,208 +1,8 @@
-// src/index.ts
-import { Metrics } from "@aws-lambda-powertools/metrics";
 import {
-  HTTPFacilitatorClient,
-  x402HTTPResourceServer,
-  x402ResourceServer
-} from "@x402/core/server";
-import { registerExactEvmScheme } from "@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 HTTPFacilitatorClient({ url: facilitator });
-  if ("getSupported" in facilitator) return facilitator;
-  return new 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 x402ResourceServer(facilitator);
-  for (const register of options.schemes ?? [registerExactEvmScheme]) {
-    register(resourceServer);
-  }
-  const { logger } = options;
-  const metrics = options.enableMetrics ? options.metrics ?? new 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 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 };
-}
+  CachingFacilitatorClient,
+  PowertoolsAdapter,
+  createX402
+} from "./chunk-4ZP7AJJC.js";
 export {
   CachingFacilitatorClient,
   PowertoolsAdapter,

package/dist/stripe.cjs

@@ -0,0 +1,336 @@
+"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 isBillable = async (predicate, reqCtx, path) => {
+    try {
+      return await predicate(reqCtx.res.clone(), reqCtx);
+    } catch (error) {
+      logger?.error("x402 billable predicate threw", { path, error });
+      return false;
+    }
+  };
+  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, billable, ...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;
+      }
+      if (billable && !await isBillable(billable, reqCtx, context.path)) {
+        if (beforeHandlerSettlement) {
+          logger?.error("x402 billable ignored: flow settles before the handler", {
+            path: context.path
+          });
+        } else {
+          await cancellationDispatcher.cancel({ reason: "after_verify_aborted" });
+          count("PaymentNotBillable");
+          logger?.warn("x402 payment not billed: route declined", { path: context.path });
+          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 };