powertools-x402 0.1.1 → 0.2.0

package/dist/stripe.js

@@ -0,0 +1,80 @@
+import {
+  coinbaseFacilitator
+} from "./chunk-FLK2T35N.js";
+import {
+  createX402
+} from "./chunk-4ZP7AJJC.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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powertools-x402",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "x402 payment middleware for AWS Lambda Powertools Event Handler",
   "license": "MIT",
   "author": "Allen Helton <allenheltondev@gmail.com>",
@@ -30,6 +30,36 @@
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./stripe": {
+      "import": {
+        "types": "./dist/stripe.d.ts",
+        "default": "./dist/stripe.js"
+      },
+      "require": {
+        "types": "./dist/stripe.d.cts",
+        "default": "./dist/stripe.cjs"
+      }
+    },
+    "./coinbase": {
+      "import": {
+        "types": "./dist/coinbase.d.ts",
+        "default": "./dist/coinbase.js"
+      },
+      "require": {
+        "types": "./dist/coinbase.d.cts",
+        "default": "./dist/coinbase.cjs"
+      }
+    },
+    "./testing": {
+      "import": {
+        "types": "./dist/testing.d.ts",
+        "default": "./dist/testing.js"
+      },
+      "require": {
+        "types": "./dist/testing.d.cts",
+        "default": "./dist/testing.cjs"
+      }
     }
   },
   "files": [
@@ -52,7 +82,21 @@
     "@x402/evm": "^2.23.0"
   },
   "peerDependencies": {
-    "@aws-lambda-powertools/event-handler": "^2.35.0"
+    "@aws-lambda-powertools/event-handler": "^2.35.0",
+    "@coinbase/x402": "^2.1.0",
+    "stripe": "^22.0.0",
+    "viem": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@coinbase/x402": {
+      "optional": true
+    },
+    "stripe": {
+      "optional": true
+    },
+    "viem": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@aws-lambda-powertools/event-handler": "^2.35.0",