@armory-sh/middleware-elysia 0.3.16 → 0.3.18

package/README.md

@@ -0,0 +1,76 @@
+# @armory-sh/middleware-elysia
+
+x402 payment middleware for Elysia applications.
+
+## Installation
+
+```bash
+bun add @armory-sh/middleware-elysia
+```
+
+## Features
+
+- Simple payment plugin for Elysia
+- Route-aware payment configuration
+- Multi-network, multi-token support
+- Full TypeScript support
+
+## Basic Usage
+
+```typescript
+import { Elysia } from "elysia";
+import { paymentMiddleware } from "@armory-sh/middleware-elysia";
+
+const requirements = {
+  scheme: "exact" as const,
+  network: "eip155:8453",
+  amount: "1000000",
+  asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as `0x${string}`,
+  payTo: "0xYourAddress..." as `0x${string}`,
+  maxTimeoutSeconds: 300,
+  extra: {},
+};
+
+const app = new Elysia()
+  .use(paymentMiddleware({ requirements }))
+  .get("/api/data", ({ payment }) => {
+    return {
+      data: "protected data",
+      payerAddress: payment?.payerAddress,
+    };
+  })
+  .listen(3000);
+```
+
+## Route-Aware Middleware
+
+```typescript
+import { routeAwarePaymentMiddleware } from "@armory-sh/middleware-elysia";
+
+const premiumRequirements = {
+  scheme: "exact" as const,
+  network: "eip155:8453",
+  amount: "5000000",
+  asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as `0x${string}`,
+  payTo: "0xYourAddress..." as `0x${string}`,
+  maxTimeoutSeconds: 300,
+  extra: {},
+};
+
+const app = new Elysia()
+  .use(routeAwarePaymentMiddleware({
+    "/api/premium": { requirements: premiumRequirements },
+    "/api/basic": { requirements: basicRequirements },
+  }))
+  .listen(3000);
+```
+
+## API
+
+### `paymentMiddleware(config)`
+
+Creates a payment plugin for Elysia.
+
+### `routeAwarePaymentMiddleware(perRouteConfig)`
+
+Creates a route-aware payment plugin for Elysia. Takes a record mapping route patterns to payment configuration entries.

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { Elysia } from 'elysia';
 import { X402PaymentPayload, X402PaymentRequirements } from '@armory-sh/base';
+export { PaymentMiddlewareConfigEntry, RouteAwarePaymentInfo, RouteAwarePaymentMiddlewareConfig, routeAwarePaymentMiddleware } from './routes.js';
 
 interface PaymentMiddlewareConfig {
     requirements: X402PaymentRequirements;
     facilitatorUrl?: string;
-    skipVerification?: boolean;
 }
 interface PaymentInfo {
     payload: X402PaymentPayload;

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { Elysia } from "elysia";
+import { Elysia as Elysia2 } from "elysia";
 
 // src/payment-utils.ts
 import { extractPaymentFromHeaders, PAYMENT_SIGNATURE_HEADER } from "@armory-sh/base";
@@ -73,18 +73,6 @@ var verifyLocally = async (payload, requirements) => {
   };
 };
 var verifyPaymentWithRetry = async (payload, requirements, facilitatorUrl) => facilitatorUrl ? verifyWithFacilitator(facilitatorUrl, payload, requirements) : verifyLocally(payload, requirements);
-var extractPayerAddress = (payload) => {
-  if ("payload" in payload) {
-    const x402Payload = payload;
-    if ("authorization" in x402Payload.payload) {
-      return x402Payload.payload.authorization.from;
-    }
-  }
-  if ("from" in payload && typeof payload.from === "string") {
-    return payload.from;
-  }
-  throw new Error("Unable to extract payer address from payload");
-};
 var createResponseHeaders = (payerAddress) => ({
   [PAYMENT_HEADERS.RESPONSE]: JSON.stringify({
     status: "verified",
@@ -92,17 +80,55 @@ var createResponseHeaders = (payerAddress) => ({
   })
 });
 
-// src/index.ts
+// src/routes.ts
+import { Elysia } from "elysia";
+import { matchRoute, validateRouteConfig } from "@armory-sh/base";
+var resolveRouteConfig = (config) => {
+  const validationError = validateRouteConfig(config);
+  if (validationError) {
+    return { routes: [], error: validationError };
+  }
+  const { route, routes, perRoute } = config;
+  const routePatterns = route ? [route] : routes || [];
+  const resolvedRoutes = [];
+  for (const pattern of routePatterns) {
+    const routeConfig = perRoute?.[pattern];
+    if (routeConfig) {
+      resolvedRoutes.push({
+        pattern,
+        config: routeConfig
+      });
+    }
+  }
+  return { routes: resolvedRoutes };
+};
 var errorResponse = (error, status, headers) => new Response(JSON.stringify(error), {
   status,
   headers: { "Content-Type": "application/json", ...headers }
 });
-var paymentMiddleware = (config) => {
-  const { requirements, facilitatorUrl, skipVerification = false } = config;
-  return new Elysia({ name: "armory-payment" }).derive(() => ({
+var routeAwarePaymentMiddleware = (perRouteConfig) => {
+  const config = {
+    routes: Object.keys(perRouteConfig),
+    perRoute: perRouteConfig
+  };
+  const { routes: resolvedRoutes, error: configError } = resolveRouteConfig(config);
+  return new Elysia({ name: "armory-route-aware-payment" }).derive(() => ({
     payment: void 0
   })).onBeforeHandle(async ({ payment, request }) => {
     try {
+      if (configError) {
+        return errorResponse(
+          { error: "Payment middleware configuration error", details: configError.message },
+          500
+        );
+      }
+      const path = new URL(request.url).pathname;
+      const matchedRoute = resolvedRoutes.find((r) => matchRoute(r.pattern, path));
+      if (!matchedRoute) {
+        return;
+      }
+      const routeConfig = matchedRoute.config;
+      const { requirements, facilitatorUrl } = routeConfig;
       const paymentHeader = request.headers.get(PAYMENT_HEADERS.PAYMENT);
       if (!paymentHeader) {
         return errorResponse(
@@ -120,7 +146,7 @@ var paymentMiddleware = (config) => {
           message: error instanceof Error ? error.message : "Unknown error"
         }, 400);
       }
-      const verifyResult = skipVerification ? { success: true, payerAddress: extractPayerAddress(payload) } : await verifyPaymentWithRetry(payload, requirements, facilitatorUrl);
+      const verifyResult = await verifyPaymentWithRetry(payload, requirements, facilitatorUrl);
       if (!verifyResult.success) {
         return errorResponse(
           { error: verifyResult.error },
@@ -129,7 +155,7 @@ var paymentMiddleware = (config) => {
         );
       }
       const payerAddress = verifyResult.payerAddress;
-      payment = { payload, payerAddress, verified: !skipVerification };
+      payment = { payload, payerAddress, verified: true, route: matchedRoute.pattern };
     } catch (error) {
       return errorResponse({
         error: "Payment middleware error",
@@ -145,6 +171,61 @@ var paymentMiddleware = (config) => {
     }
   });
 };
+
+// src/index.ts
+var errorResponse2 = (error, status, headers) => new Response(JSON.stringify(error), {
+  status,
+  headers: { "Content-Type": "application/json", ...headers }
+});
+var paymentMiddleware = (config) => {
+  const { requirements, facilitatorUrl } = config;
+  return new Elysia2({ name: "armory-payment" }).derive(() => ({
+    payment: void 0
+  })).onBeforeHandle(async ({ payment, request }) => {
+    try {
+      const paymentHeader = request.headers.get(PAYMENT_HEADERS.PAYMENT);
+      if (!paymentHeader) {
+        return errorResponse2(
+          { error: "Payment required", accepts: [requirements] },
+          402,
+          { [PAYMENT_HEADERS.REQUIRED]: encodeRequirements(requirements) }
+        );
+      }
+      let payload;
+      try {
+        ({ payload } = decodePayload(paymentHeader));
+      } catch (error) {
+        return errorResponse2({
+          error: "Invalid payment payload",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }, 400);
+      }
+      const verifyResult = await verifyPaymentWithRetry(payload, requirements, facilitatorUrl);
+      if (!verifyResult.success) {
+        return errorResponse2(
+          { error: verifyResult.error },
+          402,
+          { [PAYMENT_HEADERS.REQUIRED]: encodeRequirements(requirements) }
+        );
+      }
+      const payerAddress = verifyResult.payerAddress;
+      payment = { payload, payerAddress, verified: true };
+    } catch (error) {
+      return errorResponse2({
+        error: "Payment middleware error",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }, 500);
+    }
+  }).onAfterHandle(({ payment }) => {
+    if (payment) {
+      const { payerAddress } = payment;
+      return {
+        headers: createResponseHeaders(payerAddress)
+      };
+    }
+  });
+};
 export {
-  paymentMiddleware
+  paymentMiddleware,
+  routeAwarePaymentMiddleware
 };

package/dist/routes.d.ts

@@ -0,0 +1,57 @@
+import { Elysia } from 'elysia';
+import { X402PaymentRequirements, X402PaymentPayload } from '@armory-sh/base';
+
+interface RouteAwarePaymentMiddlewareConfig {
+    route?: string;
+    routes?: string[];
+    perRoute?: Record<string, PaymentMiddlewareConfigEntry>;
+}
+interface PaymentMiddlewareConfigEntry {
+    requirements: X402PaymentRequirements;
+    facilitatorUrl?: string;
+}
+interface RouteAwarePaymentInfo {
+    payload: X402PaymentPayload;
+    payerAddress: string;
+    verified: boolean;
+    route?: string;
+}
+interface PaymentContext {
+    payment: RouteAwarePaymentInfo;
+}
+declare const routeAwarePaymentMiddleware: (perRouteConfig: Record<string, PaymentMiddlewareConfigEntry>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {
+        readonly payment: RouteAwarePaymentInfo | undefined;
+    };
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response | {
+            headers: Record<string, string>;
+        };
+    };
+}>;
+
+export { type PaymentContext, type PaymentMiddlewareConfigEntry, type RouteAwarePaymentInfo, type RouteAwarePaymentMiddlewareConfig, routeAwarePaymentMiddleware };

package/dist/routes.js

@@ -0,0 +1,175 @@
+// src/routes.ts
+import { Elysia } from "elysia";
+
+// src/payment-utils.ts
+import { extractPaymentFromHeaders, PAYMENT_SIGNATURE_HEADER } from "@armory-sh/base";
+var PAYMENT_HEADERS = {
+  PAYMENT: "PAYMENT-SIGNATURE",
+  REQUIRED: "PAYMENT-REQUIRED",
+  RESPONSE: "PAYMENT-RESPONSE"
+};
+var encodeRequirements = (requirements) => JSON.stringify(requirements);
+function isLegacyV2(payload) {
+  return typeof payload === "object" && payload !== null && "chainId" in payload && "assetId" in payload && "signature" in payload && typeof payload.signature === "string";
+}
+var decodePayload = (headerValue) => {
+  let parsed;
+  let isJsonString = false;
+  try {
+    if (headerValue.startsWith("{")) {
+      parsed = JSON.parse(headerValue);
+      isJsonString = true;
+    } else {
+      parsed = JSON.parse(atob(headerValue));
+    }
+  } catch {
+    throw new Error("Invalid payment payload");
+  }
+  const base64Value = isJsonString ? Buffer.from(headerValue).toString("base64") : headerValue;
+  const headers = new Headers();
+  headers.set(PAYMENT_SIGNATURE_HEADER, base64Value);
+  const x402Payload = extractPaymentFromHeaders(headers);
+  if (x402Payload) {
+    return { payload: x402Payload };
+  }
+  if (isLegacyV2(parsed)) {
+    return { payload: parsed };
+  }
+  throw new Error("Unrecognized payment payload format");
+};
+var verifyWithFacilitator = async (facilitatorUrl, payload, requirements) => {
+  try {
+    const response = await fetch(`${facilitatorUrl}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ payload, requirements })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      return { success: false, error: JSON.stringify(error) };
+    }
+    const result = await response.json();
+    if (!result.success) {
+      return { success: false, error: result.error ?? "Verification failed" };
+    }
+    return { success: true, payerAddress: result.payerAddress ?? "" };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown facilitator error"
+    };
+  }
+};
+var verifyLocally = async (payload, requirements) => {
+  if (isLegacyV2(payload)) {
+    return {
+      success: false,
+      error: "Local verification not supported for legacy payload format. Use a facilitator."
+    };
+  }
+  return {
+    success: true,
+    payerAddress: payload.payload.authorization.from
+  };
+};
+var verifyPaymentWithRetry = async (payload, requirements, facilitatorUrl) => facilitatorUrl ? verifyWithFacilitator(facilitatorUrl, payload, requirements) : verifyLocally(payload, requirements);
+var createResponseHeaders = (payerAddress) => ({
+  [PAYMENT_HEADERS.RESPONSE]: JSON.stringify({
+    status: "verified",
+    payerAddress
+  })
+});
+
+// src/routes.ts
+import { matchRoute, validateRouteConfig } from "@armory-sh/base";
+var resolveRouteConfig = (config) => {
+  const validationError = validateRouteConfig(config);
+  if (validationError) {
+    return { routes: [], error: validationError };
+  }
+  const { route, routes, perRoute } = config;
+  const routePatterns = route ? [route] : routes || [];
+  const resolvedRoutes = [];
+  for (const pattern of routePatterns) {
+    const routeConfig = perRoute?.[pattern];
+    if (routeConfig) {
+      resolvedRoutes.push({
+        pattern,
+        config: routeConfig
+      });
+    }
+  }
+  return { routes: resolvedRoutes };
+};
+var errorResponse = (error, status, headers) => new Response(JSON.stringify(error), {
+  status,
+  headers: { "Content-Type": "application/json", ...headers }
+});
+var routeAwarePaymentMiddleware = (perRouteConfig) => {
+  const config = {
+    routes: Object.keys(perRouteConfig),
+    perRoute: perRouteConfig
+  };
+  const { routes: resolvedRoutes, error: configError } = resolveRouteConfig(config);
+  return new Elysia({ name: "armory-route-aware-payment" }).derive(() => ({
+    payment: void 0
+  })).onBeforeHandle(async ({ payment, request }) => {
+    try {
+      if (configError) {
+        return errorResponse(
+          { error: "Payment middleware configuration error", details: configError.message },
+          500
+        );
+      }
+      const path = new URL(request.url).pathname;
+      const matchedRoute = resolvedRoutes.find((r) => matchRoute(r.pattern, path));
+      if (!matchedRoute) {
+        return;
+      }
+      const routeConfig = matchedRoute.config;
+      const { requirements, facilitatorUrl } = routeConfig;
+      const paymentHeader = request.headers.get(PAYMENT_HEADERS.PAYMENT);
+      if (!paymentHeader) {
+        return errorResponse(
+          { error: "Payment required", accepts: [requirements] },
+          402,
+          { [PAYMENT_HEADERS.REQUIRED]: encodeRequirements(requirements) }
+        );
+      }
+      let payload;
+      try {
+        ({ payload } = decodePayload(paymentHeader));
+      } catch (error) {
+        return errorResponse({
+          error: "Invalid payment payload",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }, 400);
+      }
+      const verifyResult = await verifyPaymentWithRetry(payload, requirements, facilitatorUrl);
+      if (!verifyResult.success) {
+        return errorResponse(
+          { error: verifyResult.error },
+          402,
+          { [PAYMENT_HEADERS.REQUIRED]: encodeRequirements(requirements) }
+        );
+      }
+      const payerAddress = verifyResult.payerAddress;
+      payment = { payload, payerAddress, verified: true, route: matchedRoute.pattern };
+    } catch (error) {
+      return errorResponse({
+        error: "Payment middleware error",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }, 500);
+    }
+  }).onAfterHandle(({ payment }) => {
+    if (payment) {
+      const { payerAddress } = payment;
+      return {
+        headers: createResponseHeaders(payerAddress)
+      };
+    }
+  });
+};
+export {
+  routeAwarePaymentMiddleware
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-elysia",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -28,10 +28,11 @@
     "elysia": "^1"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.18"
+    "@armory-sh/base": "0.2.20"
   },
   "devDependencies": {
     "bun-types": "latest",
+    "tsup": "^8.5.1",
     "typescript": "5.9.3",
     "elysia": "^1"
   },