@armory-sh/middleware-elysia 0.3.26 → 0.3.28

package/dist/{chunk-XZ4WVA3M.js → chunk-L45RQOFN.js}

@@ -1,5 +1,5 @@
-import { Elysia } from 'elysia';
 import { matchRoute, PAYMENT_SIGNATURE_HEADER, createPaymentRequiredHeaders, decodePayloadHeader, verifyPayment, settlePayment, createSettlementHeaders, validateRouteConfig } from '@armory-sh/base';
+import { Elysia } from 'elysia';
 
 // src/routes.ts
 var resolveRouteConfig = (config) => {
@@ -37,18 +37,25 @@ var routeAwarePaymentMiddleware = (perRouteConfig) => {
     try {
       if (configError) {
         return errorResponse(
-          { error: "Payment middleware configuration error", details: configError.message },
+          {
+            error: "Payment middleware configuration error",
+            details: configError.message
+          },
           500
         );
       }
       const path = new URL(context.request.url).pathname;
-      const matchedRoute = resolvedRoutes.find((r) => matchRoute(r.pattern, path));
+      const matchedRoute = resolvedRoutes.find(
+        (r) => matchRoute(r.pattern, path)
+      );
       if (!matchedRoute) {
         return;
       }
       const routeConfig = matchedRoute.config;
       const { requirements, facilitatorUrl } = routeConfig;
-      const paymentHeader = context.request.headers.get(PAYMENT_SIGNATURE_HEADER);
+      const paymentHeader = context.request.headers.get(
+        PAYMENT_SIGNATURE_HEADER
+      );
       if (!paymentHeader) {
         return errorResponse(
           { error: "Payment required", accepts: [requirements] },
@@ -62,16 +69,29 @@ var routeAwarePaymentMiddleware = (perRouteConfig) => {
           accepted: requirements
         });
       } catch (error) {
-        return errorResponse({
-          error: "Invalid payment payload",
-          message: error instanceof Error ? error.message : "Unknown error"
-        }, 400);
+        return errorResponse(
+          {
+            error: "Invalid payment payload",
+            message: error instanceof Error ? error.message : "Unknown error"
+          },
+          400
+        );
       }
       if (!facilitatorUrl) {
-        return errorResponse({ error: "Payment middleware configuration error", message: "Facilitator URL is required for verification" }, 500);
+        return errorResponse(
+          {
+            error: "Payment middleware configuration error",
+            message: "Facilitator URL is required for verification"
+          },
+          500
+        );
       }
       const verifyConfig = { url: facilitatorUrl };
-      const verifyResult = await verifyPayment(payload, requirements, verifyConfig);
+      const verifyResult = await verifyPayment(
+        payload,
+        requirements,
+        verifyConfig
+      );
       if (!verifyResult.isValid) {
         return errorResponse(
           { error: verifyResult.invalidReason },
@@ -80,12 +100,20 @@ var routeAwarePaymentMiddleware = (perRouteConfig) => {
         );
       }
       const payerAddress = verifyResult.payer ?? payload.payload.authorization.from;
-      context.payment = { payload, payerAddress, verified: true, route: matchedRoute.pattern };
+      context.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);
+      return errorResponse(
+        {
+          error: "Payment middleware error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        },
+        500
+      );
     }
   }).onAfterHandle(async (context) => {
     const payment = context.payment;
@@ -102,12 +130,25 @@ var routeAwarePaymentMiddleware = (perRouteConfig) => {
       return;
     }
     if (!routeConfig.facilitatorUrl) {
-      return errorResponse({ error: "Payment middleware configuration error", message: "Facilitator URL is required for settlement" }, 500);
+      return errorResponse(
+        {
+          error: "Payment middleware configuration error",
+          message: "Facilitator URL is required for settlement"
+        },
+        500
+      );
     }
     const settleConfig = { url: routeConfig.facilitatorUrl };
-    const settlementResult = await settlePayment(payment.payload, routeConfig.requirements, settleConfig);
+    const settlementResult = await settlePayment(
+      payment.payload,
+      routeConfig.requirements,
+      settleConfig
+    );
     if (!settlementResult.success) {
-      return errorResponse({ error: "Settlement failed", details: settlementResult.errorReason }, 502);
+      return errorResponse(
+        { error: "Settlement failed", details: settlementResult.errorReason },
+        502
+      );
     }
     return {
       headers: createSettlementHeaders(settlementResult)

package/dist/index.d.ts

@@ -1,20 +1,33 @@
+import { PaymentRequirementsV2, X402PaymentPayload, X402PaymentRequirements } from '@armory-sh/base';
 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;
-}
-interface PaymentInfo {
-    payload: X402PaymentPayload;
-    payerAddress: string;
-    verified: boolean;
+type NetworkId = string | number;
+type TokenId = string;
+interface PaymentConfig {
+    payTo?: string;
+    requirements?: PaymentRequirementsV2 | PaymentRequirementsV2[];
+    chains?: NetworkId[];
+    chain?: NetworkId;
+    tokens?: TokenId[];
+    token?: TokenId;
+    amount?: string;
+    maxTimeoutSeconds?: number;
+    facilitatorUrl?: string;
+    facilitatorUrlByChain?: Record<string, string>;
+    facilitatorUrlByToken?: Record<string, Record<string, string>>;
+    extensions?: Record<string, unknown>;
 }
-interface PaymentContext {
-    payment: PaymentInfo;
+interface ResolvedRequirementsConfig {
+    requirements: PaymentRequirementsV2[];
+    error?: {
+        code: string;
+        message: string;
+    };
 }
-declare const paymentMiddleware: (config: PaymentMiddlewareConfig) => Elysia<"", {
+declare function resolveFacilitatorUrlFromRequirement(config: PaymentConfig, requirement: PaymentRequirementsV2): string | undefined;
+declare function createPaymentRequirements(config: PaymentConfig): ResolvedRequirementsConfig;
+declare const paymentMiddleware: (config: PaymentConfig) => Elysia<"", {
     decorator: {};
     store: {};
     derive: {};
@@ -37,7 +50,12 @@ declare const paymentMiddleware: (config: PaymentMiddlewareConfig) => Elysia<"",
     response: {};
 }, {
     derive: {
-        readonly payment: PaymentInfo | undefined;
+        readonly payment: {
+            payload: X402PaymentPayload;
+            payerAddress: string;
+            verified: boolean;
+            selectedRequirement: PaymentRequirementsV2;
+        } | undefined;
     };
     resolve: {};
     schema: {};
@@ -49,4 +67,17 @@ declare const paymentMiddleware: (config: PaymentMiddlewareConfig) => Elysia<"",
     };
 }>;
 
-export { type PaymentContext, type PaymentInfo, type PaymentMiddlewareConfig, paymentMiddleware };
+interface PaymentMiddlewareConfig {
+    requirements: X402PaymentRequirements;
+    facilitatorUrl: string;
+}
+interface PaymentInfo {
+    payload: X402PaymentPayload;
+    payerAddress: string;
+    verified: boolean;
+}
+interface PaymentContext {
+    payment: PaymentInfo;
+}
+
+export { type PaymentConfig, type PaymentContext, type PaymentInfo, type PaymentMiddlewareConfig, type ResolvedRequirementsConfig, createPaymentRequirements, paymentMiddleware, resolveFacilitatorUrlFromRequirement };

package/dist/index.js

@@ -1,56 +1,216 @@
-export { routeAwarePaymentMiddleware } from './chunk-XZ4WVA3M.js';
+export { routeAwarePaymentMiddleware } from './chunk-L45RQOFN.js';
+import { resolveNetwork, isValidationError, resolveToken, createPaymentRequirements as createPaymentRequirements$1, PAYMENT_SIGNATURE_HEADER, decodePayloadHeader, findRequirementByAccepted, verifyPayment, settlePayment, createSettlementHeaders, createPaymentRequiredHeaders, TOKENS, registerToken, getSupported } from '@armory-sh/base';
 import { Elysia } from 'elysia';
-import { PAYMENT_SIGNATURE_HEADER, createPaymentRequiredHeaders, decodePayloadHeader, verifyPayment, settlePayment, createSettlementHeaders } from '@armory-sh/base';
 
+var extensionCapabilityCache = /* @__PURE__ */ new Map();
+var EXTENSION_CAPABILITY_TTL_MS = 5 * 60 * 1e3;
+function ensureTokensRegistered() {
+  for (const token of Object.values(TOKENS)) {
+    try {
+      registerToken(token);
+    } catch {
+    }
+  }
+}
+function resolveFacilitatorUrlFromRequirement(config, requirement) {
+  const chainId = parseInt(requirement.network.split(":")[1] || "0", 10);
+  const assetAddress = requirement.asset.toLowerCase();
+  if (config.facilitatorUrlByToken) {
+    for (const [chainKey, tokenMap] of Object.entries(
+      config.facilitatorUrlByToken
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (isValidationError(resolvedChain) || resolvedChain.config.chainId !== chainId) {
+        continue;
+      }
+      for (const [tokenKey, url] of Object.entries(tokenMap)) {
+        const resolvedToken = resolveToken(tokenKey, resolvedChain);
+        if (!isValidationError(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === assetAddress) {
+          return url;
+        }
+      }
+    }
+  }
+  if (config.facilitatorUrlByChain) {
+    for (const [chainKey, url] of Object.entries(
+      config.facilitatorUrlByChain
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        return url;
+      }
+    }
+  }
+  return config.facilitatorUrl;
+}
+function createPaymentRequirements(config) {
+  if (config.requirements) {
+    return {
+      requirements: Array.isArray(config.requirements) ? config.requirements : [config.requirements]
+    };
+  }
+  if (!config.payTo) {
+    return {
+      requirements: [],
+      error: {
+        code: "VALIDATION_FAILED",
+        message: "Missing payment configuration: provide payTo or explicit requirements"
+      }
+    };
+  }
+  ensureTokensRegistered();
+  return createPaymentRequirements$1(config);
+}
+async function resolvePaymentRequiredExtensions(config, requirements) {
+  if (!config.extensions) {
+    return {};
+  }
+  let filtered = { ...config.extensions };
+  for (const requirement of requirements) {
+    const facilitatorUrl = resolveFacilitatorUrlFromRequirement(config, requirement);
+    if (!facilitatorUrl) {
+      continue;
+    }
+    const cacheKey = `${facilitatorUrl}|${requirement.network.toLowerCase()}`;
+    const now = Date.now();
+    let keys = extensionCapabilityCache.get(cacheKey);
+    if (!keys || keys.expiresAt <= now) {
+      try {
+        const supported = await getSupported({ url: facilitatorUrl });
+        const nextKeys = /* @__PURE__ */ new Set();
+        for (const kind of supported.kinds) {
+          if (kind.network.toLowerCase() !== requirement.network.toLowerCase()) {
+            continue;
+          }
+          if (kind.extra && typeof kind.extra === "object") {
+            for (const key of Object.keys(kind.extra)) {
+              nextKeys.add(key);
+            }
+          }
+        }
+        keys = { expiresAt: now + EXTENSION_CAPABILITY_TTL_MS, keys: nextKeys };
+      } catch {
+        keys = { expiresAt: now + EXTENSION_CAPABILITY_TTL_MS, keys: /* @__PURE__ */ new Set() };
+      }
+      extensionCapabilityCache.set(cacheKey, keys);
+    }
+    filtered = Object.fromEntries(
+      Object.entries(filtered).filter(([key]) => keys.keys.has(key))
+    );
+    if (Object.keys(filtered).length === 0) {
+      return {};
+    }
+  }
+  return filtered;
+}
 var errorResponse = (error, status, headers) => new Response(JSON.stringify(error), {
   status,
   headers: { "Content-Type": "application/json", ...headers }
 });
 var paymentMiddleware = (config) => {
-  const { requirements, facilitatorUrl } = config;
+  const { requirements, error } = createPaymentRequirements(config);
+  const resolvePaymentRequiredHeaders = async () => createPaymentRequiredHeaders(requirements, {
+    extensions: await resolvePaymentRequiredExtensions(
+      config,
+      requirements
+    )
+  });
   return new Elysia({ name: "armory-payment" }).derive(() => ({
     payment: void 0
   })).onBeforeHandle(async (context) => {
+    if (error) {
+      return errorResponse(
+        {
+          error: "Payment middleware configuration error",
+          details: error.message
+        },
+        500
+      );
+    }
+    const primaryRequirement = requirements[0];
+    if (!primaryRequirement) {
+      return errorResponse(
+        {
+          error: "Payment middleware configuration error",
+          message: "No payment requirements configured"
+        },
+        500
+      );
+    }
+    const paymentHeader = context.request.headers.get(
+      PAYMENT_SIGNATURE_HEADER
+    );
+    if (!paymentHeader) {
+      const requiredHeaders = await resolvePaymentRequiredHeaders();
+      return errorResponse(
+        { error: "Payment required", accepts: requirements },
+        402,
+        requiredHeaders
+      );
+    }
+    let paymentPayload;
     try {
-      const paymentHeader = context.request.headers.get(PAYMENT_SIGNATURE_HEADER);
-      if (!paymentHeader) {
-        return errorResponse(
-          { error: "Payment required", accepts: [requirements] },
-          402,
-          createPaymentRequiredHeaders(requirements)
-        );
-      }
-      let paymentPayload;
-      try {
-        paymentPayload = decodePayloadHeader(paymentHeader, {
-          accepted: requirements
-        });
-      } catch (error) {
-        return errorResponse({
+      paymentPayload = decodePayloadHeader(paymentHeader, {
+        accepted: primaryRequirement
+      });
+    } catch (err) {
+      return errorResponse(
+        {
           error: "Invalid payment payload",
-          message: error instanceof Error ? error.message : "Unknown error"
-        }, 400);
-      }
-      if (!facilitatorUrl) {
-        return errorResponse({ error: "Payment middleware configuration error", message: "Facilitator URL is required for verification" }, 500);
-      }
-      const verifyConfig = { url: facilitatorUrl };
-      const verifyResult = await verifyPayment(paymentPayload, requirements, verifyConfig);
-      if (!verifyResult.isValid) {
-        return errorResponse(
-          { error: verifyResult.invalidReason },
-          402,
-          createPaymentRequiredHeaders(requirements)
-        );
-      }
-      const payerAddress = verifyResult.payer ?? paymentPayload.payload.authorization.from;
-      context.payment = { payload: paymentPayload, payerAddress, verified: true };
-    } catch (error) {
-      return errorResponse({
-        error: "Payment middleware error",
-        message: error instanceof Error ? error.message : "Unknown error"
-      }, 500);
+          message: err instanceof Error ? err.message : "Unknown error"
+        },
+        400
+      );
+    }
+    const selectedRequirement = findRequirementByAccepted(
+      requirements,
+      paymentPayload.accepted
+    );
+    if (!selectedRequirement) {
+      return errorResponse(
+        {
+          error: "Invalid payment payload",
+          message: "Accepted requirement is not configured for this endpoint"
+        },
+        400
+      );
     }
+    const facilitatorUrl = resolveFacilitatorUrlFromRequirement(
+      config,
+      selectedRequirement
+    );
+    if (!facilitatorUrl) {
+      return errorResponse(
+        {
+          error: "Payment middleware configuration error",
+          message: "Facilitator URL is required for verification"
+        },
+        500
+      );
+    }
+    const verifyResult = await verifyPayment(
+      paymentPayload,
+      selectedRequirement,
+      { url: facilitatorUrl }
+    );
+    if (!verifyResult.isValid) {
+      const requiredHeaders = await resolvePaymentRequiredHeaders();
+      return errorResponse(
+        {
+          error: "Payment verification failed",
+          message: verifyResult.invalidReason
+        },
+        402,
+        requiredHeaders
+      );
+    }
+    const payerAddress = verifyResult.payer ?? paymentPayload.payload.authorization.from;
+    context.payment = {
+      payload: paymentPayload,
+      payerAddress,
+      verified: true,
+      selectedRequirement
+    };
   }).onAfterHandle(async (context) => {
     const payment = context.payment;
     if (!payment) {
@@ -60,18 +220,34 @@ var paymentMiddleware = (config) => {
     if (statusCode >= 400) {
       return;
     }
+    const facilitatorUrl = resolveFacilitatorUrlFromRequirement(
+      config,
+      payment.selectedRequirement
+    );
     if (!facilitatorUrl) {
-      return errorResponse({ error: "Payment middleware configuration error", message: "Facilitator URL is required for settlement" }, 500);
+      return errorResponse(
+        {
+          error: "Payment middleware configuration error",
+          message: "Facilitator URL is required for settlement"
+        },
+        500
+      );
     }
-    const settleConfig = { url: facilitatorUrl };
-    const settlementResult = await settlePayment(payment.payload, requirements, settleConfig);
-    if (!settlementResult.success) {
-      return errorResponse({ error: "Settlement failed", details: settlementResult.errorReason }, 502);
+    const settleResult = await settlePayment(
+      payment.payload,
+      payment.selectedRequirement,
+      { url: facilitatorUrl }
+    );
+    if (!settleResult.success) {
+      return errorResponse(
+        { error: "Settlement failed", details: settleResult.errorReason },
+        502
+      );
     }
     return {
-      headers: createSettlementHeaders(settlementResult)
+      headers: createSettlementHeaders(settleResult)
     };
   });
 };
 
-export { paymentMiddleware };
+export { createPaymentRequirements, paymentMiddleware, resolveFacilitatorUrlFromRequirement };

package/dist/routes.d.ts

@@ -1,5 +1,5 @@
-import { Elysia } from 'elysia';
 import { X402PaymentRequirements, X402PaymentPayload } from '@armory-sh/base';
+import { Elysia } from 'elysia';
 
 interface RouteAwarePaymentMiddlewareConfig {
     route?: string;

package/dist/routes.js

@@ -1 +1 @@
-export { routeAwarePaymentMiddleware } from './chunk-XZ4WVA3M.js';
+export { routeAwarePaymentMiddleware } from './chunk-L45RQOFN.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-elysia",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "keywords": [
@@ -47,7 +47,7 @@
     "elysia": "^1"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.28"
+    "@armory-sh/base": "0.2.30"
   },
   "devDependencies": {
     "bun-types": "latest",
@@ -57,6 +57,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsup",
+    "lint": "bun run build",
+    "format": "bun run lint",
     "test": "bun test"
   }
 }