@armory-sh/middleware-hono 0.3.28 → 0.3.30

package/README.md

@@ -14,24 +14,47 @@ bun add @armory-sh/middleware-hono
 
 Armory enables HTTP API payments via EIP-3009 `transferWithAuthorization`. Accept payments from any x402-compatible client—Coinbase SDK, Armory SDK, or your own implementation.
 
-## Key Exports
+## API Reference
+
+### Middleware
 
 ```typescript
 import {
-  // Middleware
   paymentMiddleware,
   routeAwarePaymentMiddleware,
 
-  // Requirements
-  createPaymentRequirements,
-
   // Types
   type PaymentConfig,
   type RouteAwarePaymentConfig,
-  type HonoPaymentContext,
+  type AugmentedContext,
 } from '@armory-sh/middleware-hono';
 ```
 
+### Payment Requirements
+
+```typescript
+import {
+  createPaymentRequirements,
+
+  // Types
+  type ResolvedRequirementsConfig,
+} from '@armory-sh/middleware-hono';
+```
+
+### Extensions
+
+```typescript
+import {
+  buildExtensions,
+  extractExtension,
+
+  // Types
+  type ExtensionConfig,
+} from '@armory-sh/middleware-hono';
+```
+
+---
+
 ## Quick Start
 
 ### Basic Middleware
@@ -168,6 +191,7 @@ interface RouteAwarePaymentConfig extends PaymentConfig {
 | Base Sepolia | 84532 |
 | SKALE Base | 1187947933 |
 | SKALE Base Sepolia | 324705682 |
+| Ethereum Sepolia | 11155111 |
 
 ## License
 

package/dist/index.d.ts

@@ -1,56 +1,46 @@
+import { X402PaymentPayload, PaymentRequirementsV2 } from '@armory-sh/base';
 import { Context, Next } from 'hono';
-import { PaymentRequirementsV2, ValidationError, PaymentRequirements, X402PaymentPayload } from '@armory-sh/base';
-import { ExtensionConfig } from './extensions.js';
-export { buildExtensions, extractExtension } from './extensions.js';
+export { ExtensionConfig, buildExtensions, extractExtension } from './extensions.js';
 
-/**
- * Simplified middleware API for easy x402 payment integration
- * Just specify payTo address and optional chains/tokens by name
- */
+interface RouteAwarePaymentConfig extends PaymentConfig {
+    route?: string;
+    routes?: string[];
+    perRoute?: Record<string, Partial<PaymentConfig>>;
+}
+declare const routeAwarePaymentMiddleware: (config: RouteAwarePaymentConfig) => (c: Context, next: Next) => Promise<Response | undefined>;
 
 type NetworkId = string | number;
 type TokenId = string;
 interface PaymentConfig {
-    payTo: string;
+    payTo?: string;
+    requirements?: PaymentRequirementsV2 | PaymentRequirementsV2[];
     chains?: NetworkId[];
     chain?: NetworkId;
     tokens?: TokenId[];
     token?: TokenId;
     amount?: string;
     maxTimeoutSeconds?: number;
-    payToByChain?: Record<NetworkId, string>;
-    payToByToken?: Record<NetworkId, Record<TokenId, string>>;
     facilitatorUrl?: string;
-    facilitatorUrlByChain?: Record<NetworkId, string>;
-    facilitatorUrlByToken?: Record<NetworkId, Record<TokenId, string>>;
-    extensions?: ExtensionConfig;
+    facilitatorUrlByChain?: Record<string, string>;
+    facilitatorUrlByToken?: Record<string, Record<string, string>>;
+    extensions?: Record<string, unknown>;
 }
-interface ResolvedSimpleConfig {
+interface ResolvedRequirementsConfig {
     requirements: PaymentRequirementsV2[];
-    error?: ValidationError;
-}
-declare function createPaymentRequirements(config: PaymentConfig): ResolvedSimpleConfig;
-declare function paymentMiddleware(config: PaymentConfig): (c: Context, next: Next) => Promise<Response | void>;
-
-interface RouteAwarePaymentConfig extends PaymentConfig {
-    route?: string;
-    routes?: string[];
-    perRoute?: Record<string, Partial<PaymentConfig>>;
-}
-declare const routeAwarePaymentMiddleware: (config: RouteAwarePaymentConfig) => (c: Context, next: Next) => Promise<Response | void>;
-
-interface AdvancedPaymentConfig {
-    requirements: PaymentRequirements;
-    facilitatorUrl: string;
-    network?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
 }
-interface AugmentedRequest extends Request {
+interface AugmentedContext extends Context {
     payment?: {
         payload: X402PaymentPayload;
         payerAddress: string;
         verified: boolean;
     };
 }
-declare const advancedPaymentMiddleware: (config: AdvancedPaymentConfig) => (c: Context, next: Next) => Promise<Response | void>;
+declare function resolveFacilitatorUrlFromRequirement(config: PaymentConfig, requirement: PaymentRequirementsV2): string | undefined;
+declare function createPaymentRequirements(config: PaymentConfig): ResolvedRequirementsConfig;
+declare function paymentMiddleware(config: PaymentConfig): (c: Context, next: Next) => Promise<Response | undefined>;
 
-export { type AdvancedPaymentConfig, type AugmentedRequest, ExtensionConfig, type PaymentConfig, type RouteAwarePaymentConfig, advancedPaymentMiddleware, createPaymentRequirements, paymentMiddleware, routeAwarePaymentMiddleware };
+export { type AugmentedContext, type PaymentConfig, type ResolvedRequirementsConfig, type RouteAwarePaymentConfig, createPaymentRequirements, paymentMiddleware, resolveFacilitatorUrlFromRequirement, routeAwarePaymentMiddleware };

package/dist/index.js

@@ -1,294 +1,6 @@
-import { buildExtensions } from './chunk-XYM6YXAQ.js';
 export { buildExtensions, extractExtension } from './chunk-XYM6YXAQ.js';
-import { V2_HEADERS, safeBase64Encode, decodePayloadHeader, verifyPayment, createPaymentRequiredHeaders, settlePayment, createSettlementHeaders, matchRoute, PAYMENT_SIGNATURE_HEADER, TOKENS, registerToken, resolveNetwork, resolveToken, validateRouteConfig } from '@armory-sh/base';
+import { matchRoute, V2_HEADERS, safeBase64Encode, decodePayloadHeader, findRequirementByAccepted, verifyPayment, createPaymentRequiredHeaders, settlePayment, createSettlementHeaders, resolveNetwork, isValidationError, resolveToken, createPaymentRequirements as createPaymentRequirements$1, PAYMENT_SIGNATURE_HEADER, PAYMENT_REQUIRED_HEADER, validateRouteConfig, TOKENS, registerToken, getSupported } from '@armory-sh/base';
 
-var isValidationError = (value) => {
-  return typeof value === "object" && value !== null && "code" in value;
-};
-function ensureTokensRegistered() {
-  for (const token of Object.values(TOKENS)) {
-    try {
-      registerToken(token);
-    } catch {
-    }
-  }
-}
-function resolveChainTokenInputs(chains, tokens) {
-  const resolvedNetworks = [];
-  const resolvedTokens = [];
-  const errors = [];
-  const networkInputs = chains?.length ? chains : Object.keys({
-    ethereum: 1,
-    base: 8453,
-    "base-sepolia": 84532,
-    "skale-base": 1187947933,
-    "skale-base-sepolia": 324705682,
-    "ethereum-sepolia": 11155111
-  });
-  for (const networkId of networkInputs) {
-    const resolved = resolveNetwork(networkId);
-    if (isValidationError(resolved)) {
-      errors.push(`Network "${networkId}": ${resolved.message}`);
-    } else {
-      resolvedNetworks.push(resolved);
-    }
-  }
-  const tokenInputs = tokens?.length ? tokens : ["usdc"];
-  for (const tokenId of tokenInputs) {
-    let found = false;
-    for (const network of resolvedNetworks) {
-      const resolved = resolveToken(tokenId, network);
-      if (isValidationError(resolved)) {
-        continue;
-      }
-      resolvedTokens.push(resolved);
-      found = true;
-      break;
-    }
-    if (!found) {
-      errors.push(`Token "${tokenId}" not found on any specified network`);
-    }
-  }
-  if (errors.length > 0) {
-    return {
-      networks: resolvedNetworks,
-      tokens: resolvedTokens,
-      error: {
-        code: "VALIDATION_FAILED",
-        message: errors.join("; ")
-      }
-    };
-  }
-  return { networks: resolvedNetworks, tokens: resolvedTokens };
-}
-function toAtomicUnits(amount) {
-  if (amount.includes(".")) {
-    const [whole, fractional = ""] = amount.split(".");
-    const paddedFractional = fractional.padEnd(6, "0").slice(0, 6);
-    return `${whole}${paddedFractional}`.replace(/^0+/, "") || "0";
-  }
-  return `${amount}000000`;
-}
-function resolvePayTo(config, network, token) {
-  const chainId = network.config.chainId;
-  if (config.payToByToken) {
-    for (const [chainKey, tokenMap] of Object.entries(config.payToByToken)) {
-      const resolvedChain = resolveNetwork(chainKey);
-      if (!isValidationError(resolvedChain) && resolvedChain.config.chainId === chainId) {
-        for (const [tokenKey, address] of Object.entries(tokenMap)) {
-          const resolvedToken = resolveToken(tokenKey, network);
-          if (!isValidationError(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase()) {
-            return address;
-          }
-        }
-      }
-    }
-  }
-  if (config.payToByChain) {
-    for (const [chainKey, address] of Object.entries(config.payToByChain)) {
-      const resolvedChain = resolveNetwork(chainKey);
-      if (!isValidationError(resolvedChain) && resolvedChain.config.chainId === chainId) {
-        return address;
-      }
-    }
-  }
-  return config.payTo;
-}
-function resolveFacilitatorUrl(config, network, token) {
-  const chainId = network.config.chainId;
-  if (config.facilitatorUrlByToken) {
-    for (const [chainKey, tokenMap] of Object.entries(config.facilitatorUrlByToken)) {
-      const resolvedChain = resolveNetwork(chainKey);
-      if (!isValidationError(resolvedChain) && resolvedChain.config.chainId === chainId) {
-        for (const [tokenKey, url] of Object.entries(tokenMap)) {
-          const resolvedToken = resolveToken(tokenKey, network);
-          if (!isValidationError(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === token.config.contractAddress.toLowerCase()) {
-            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 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) {
-        for (const [, url] of Object.entries(tokenMap)) {
-          const network = resolveNetwork(chainKey);
-          if (!isValidationError(network)) {
-            for (const tokenKey of Object.keys(tokenMap)) {
-              const resolvedToken = resolveToken(tokenKey, network);
-              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) {
-  ensureTokensRegistered();
-  const {
-    payTo,
-    chains,
-    chain,
-    tokens,
-    token,
-    amount = "1.0",
-    maxTimeoutSeconds = 300
-  } = config;
-  const chainInputs = chain ? [chain] : chains;
-  const tokenInputs = token ? [token] : tokens;
-  const { networks, tokens: resolvedTokens, error } = resolveChainTokenInputs(
-    chainInputs,
-    tokenInputs
-  );
-  if (error) {
-    return { requirements: [], error };
-  }
-  const requirements = [];
-  for (const network of networks) {
-    for (const resolvedToken of resolvedTokens) {
-      if (resolvedToken.network.config.chainId !== network.config.chainId) {
-        continue;
-      }
-      const atomicAmount = toAtomicUnits(amount);
-      const tokenConfig = resolvedToken.config;
-      const resolvedPayTo = resolvePayTo(config, network, resolvedToken);
-      resolveFacilitatorUrl(config, network, resolvedToken);
-      requirements.push({
-        scheme: "exact",
-        network: network.caip2,
-        amount: atomicAmount,
-        asset: tokenConfig.contractAddress,
-        payTo: resolvedPayTo,
-        maxTimeoutSeconds,
-        extra: {
-          name: tokenConfig.name,
-          version: tokenConfig.version
-        }
-      });
-    }
-  }
-  return { requirements };
-}
-function paymentMiddleware(config) {
-  const { requirements, error } = createPaymentRequirements(config);
-  console.log("[payment-middleware] Initialized with requirements:", JSON.stringify(requirements, null, 2));
-  return async (c, next) => {
-    if (error) {
-      console.log("[payment-middleware] Configuration error:", error.message);
-      c.status(500);
-      return c.json({
-        error: "Payment middleware configuration error",
-        details: error.message
-      });
-    }
-    const paymentHeader = c.req.header(V2_HEADERS.PAYMENT_SIGNATURE);
-    console.log("[payment-middleware] Payment header present:", !!paymentHeader);
-    if (!paymentHeader) {
-      const resource = {
-        url: c.req.url,
-        description: "API Access",
-        mimeType: "application/json"
-      };
-      const paymentRequired = {
-        x402Version: 2,
-        error: "Payment required",
-        resource,
-        accepts: requirements,
-        extensions: config.extensions ? buildExtensions(config.extensions) : void 0
-      };
-      console.log("[payment-middleware] Returning 402 with requirements:", JSON.stringify(paymentRequired.accepts, null, 2));
-      c.status(402);
-      c.header(V2_HEADERS.PAYMENT_REQUIRED, safeBase64Encode(JSON.stringify(paymentRequired)));
-      return c.json({
-        error: "Payment required",
-        accepts: requirements
-      });
-    }
-    const primaryRequirement = requirements[0];
-    if (!primaryRequirement) {
-      console.log("[payment-middleware] No requirements configured");
-      c.status(500);
-      return c.json({ error: "Payment middleware configuration error", details: "No payment requirements configured" });
-    }
-    console.log("[payment-middleware] Primary requirement:", JSON.stringify(primaryRequirement, null, 2));
-    let parsedPayload;
-    try {
-      parsedPayload = decodePayloadHeader(paymentHeader, {
-        accepted: primaryRequirement
-      });
-    } catch {
-      c.status(400);
-      return c.json({ error: "Invalid payment payload" });
-    }
-    const facilitatorUrl = resolveFacilitatorUrlFromRequirement(config, primaryRequirement);
-    console.log("[payment-middleware] Facilitator URL:", facilitatorUrl);
-    if (!facilitatorUrl) {
-      console.log("[payment-middleware] No facilitator URL configured");
-      c.status(500);
-      return c.json({ error: "Payment middleware configuration error", message: "Facilitator URL is required for verification" });
-    }
-    console.log("[payment-middleware] Verifying payment with facilitator...");
-    const verifyResult = await verifyPayment(parsedPayload, primaryRequirement, { url: facilitatorUrl });
-    console.log("[payment-middleware] Verify result:", JSON.stringify(verifyResult, null, 2));
-    if (!verifyResult.isValid) {
-      console.log("[payment-middleware] Verification failed:", verifyResult.invalidReason);
-      c.status(402);
-      c.header(V2_HEADERS.PAYMENT_REQUIRED, createPaymentRequiredHeaders(requirements)[V2_HEADERS.PAYMENT_REQUIRED]);
-      return c.json({ error: "Payment verification failed", message: verifyResult.invalidReason });
-    }
-    console.log("[payment-middleware] Payment verified, setting payment context");
-    c.set("payment", {
-      payload: parsedPayload,
-      payerAddress: verifyResult.payer,
-      verified: true
-    });
-    await next();
-    if (c.res.status >= 400) {
-      return;
-    }
-    console.log("[payment-middleware] Settling payment...");
-    const settleResult = await settlePayment(parsedPayload, primaryRequirement, { url: facilitatorUrl });
-    console.log("[payment-middleware] Settle result:", JSON.stringify(settleResult, null, 2));
-    if (!settleResult.success) {
-      console.log("[payment-middleware] Settlement failed:", settleResult.errorReason);
-      c.status(502);
-      c.res = c.json({ error: "Settlement failed", details: settleResult.errorReason }, 502);
-      return;
-    }
-    console.log("[payment-middleware] Payment settled, tx:", settleResult.transaction);
-    const headers = createSettlementHeaders(settleResult);
-    for (const [key, value] of Object.entries(headers)) {
-      c.header(key, value);
-    }
-  };
-}
 var resolveRouteConfig = (config) => {
   const validationError = validateRouteConfig(config);
   if (validationError) {
@@ -323,7 +35,8 @@ var routeAwarePaymentMiddleware = (config) => {
     const path = new URL(c.req.url).pathname;
     const matchedRoute = routes.find((r) => matchRoute(r.pattern, path));
     if (!matchedRoute) {
-      return next();
+      await next();
+      return;
     }
     const { requirements, error: requirementsError } = createPaymentRequirements(matchedRoute.config);
     if (requirementsError) {
@@ -359,7 +72,10 @@ var routeAwarePaymentMiddleware = (config) => {
     const primaryRequirement = requirements[0];
     if (!primaryRequirement) {
       c.status(500);
-      return c.json({ error: "Payment middleware configuration error", details: "No payment requirements configured" });
+      return c.json({
+        error: "Payment middleware configuration error",
+        details: "No payment requirements configured"
+      });
     }
     let parsedPayload;
     try {
@@ -370,16 +86,43 @@ var routeAwarePaymentMiddleware = (config) => {
       c.status(400);
       return c.json({ error: "Invalid payment payload" });
     }
-    const facilitatorUrl = matchedRoute.config.facilitatorUrl ?? resolveFacilitatorUrlFromRequirement(matchedRoute.config, primaryRequirement);
+    const selectedRequirement = findRequirementByAccepted(
+      requirements,
+      parsedPayload.accepted
+    );
+    if (!selectedRequirement) {
+      c.status(400);
+      return c.json({
+        error: "Invalid payment payload",
+        message: "Accepted requirement is not configured for this route"
+      });
+    }
+    const facilitatorUrl = matchedRoute.config.facilitatorUrl ?? resolveFacilitatorUrlFromRequirement(
+      matchedRoute.config,
+      selectedRequirement
+    );
     if (!facilitatorUrl) {
       c.status(500);
-      return c.json({ error: "Payment middleware configuration error", message: "Facilitator URL is required for verification" });
+      return c.json({
+        error: "Payment middleware configuration error",
+        message: "Facilitator URL is required for verification"
+      });
     }
-    const verifyResult = await verifyPayment(parsedPayload, primaryRequirement, { url: facilitatorUrl });
+    const verifyResult = await verifyPayment(
+      parsedPayload,
+      selectedRequirement,
+      { url: facilitatorUrl }
+    );
     if (!verifyResult.isValid) {
       c.status(402);
-      c.header(V2_HEADERS.PAYMENT_REQUIRED, createPaymentRequiredHeaders(requirements)[V2_HEADERS.PAYMENT_REQUIRED]);
-      return c.json({ error: "Payment verification failed", message: verifyResult.invalidReason });
+      c.header(
+        V2_HEADERS.PAYMENT_REQUIRED,
+        createPaymentRequiredHeaders(requirements)[V2_HEADERS.PAYMENT_REQUIRED]
+      );
+      return c.json({
+        error: "Payment verification failed",
+        message: verifyResult.invalidReason
+      });
     }
     c.set("payment", {
       payload: parsedPayload,
@@ -391,10 +134,17 @@ var routeAwarePaymentMiddleware = (config) => {
     if (c.res.status >= 400) {
       return;
     }
-    const settleResult = await settlePayment(parsedPayload, primaryRequirement, { url: facilitatorUrl });
+    const settleResult = await settlePayment(
+      parsedPayload,
+      selectedRequirement,
+      { url: facilitatorUrl }
+    );
     if (!settleResult.success) {
       c.status(502);
-      c.res = c.json({ error: "Settlement failed", details: settleResult.errorReason }, 502);
+      c.res = c.json(
+        { error: "Settlement failed", details: settleResult.errorReason },
+        502
+      );
       return;
     }
     const headers = createSettlementHeaders(settleResult);
@@ -405,67 +155,228 @@ var routeAwarePaymentMiddleware = (config) => {
 };
 
 // src/index.ts
-var advancedPaymentMiddleware = (config) => {
-  const { requirements, facilitatorUrl } = config;
+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;
+}
+function paymentMiddleware(config) {
+  const { requirements, error } = createPaymentRequirements(config);
+  const resolvePaymentRequiredHeader = async () => createPaymentRequiredHeaders(requirements, {
+    extensions: await resolvePaymentRequiredExtensions(
+      config,
+      requirements
+    )
+  })[PAYMENT_REQUIRED_HEADER];
   return async (c, next) => {
+    if (error) {
+      c.status(500);
+      return c.json({
+        error: "Payment middleware configuration error",
+        details: error.message
+      });
+    }
+    const primaryRequirement = requirements[0];
+    if (!primaryRequirement) {
+      c.status(500);
+      return c.json({
+        error: "Payment middleware configuration error",
+        details: "No payment requirements configured"
+      });
+    }
     const paymentHeader = c.req.header(PAYMENT_SIGNATURE_HEADER);
     if (!paymentHeader) {
-      const requiredHeaders = createPaymentRequiredHeaders(requirements);
+      const resource = {
+        url: c.req.url,
+        description: "API Access",
+        mimeType: "application/json"
+      };
+      const paymentRequired = {
+        x402Version: 2,
+        error: "Payment required",
+        resource,
+        accepts: requirements
+      };
       c.status(402);
-      for (const [key, value] of Object.entries(requiredHeaders)) {
-        c.header(key, value);
-      }
+      c.header(
+        PAYMENT_REQUIRED_HEADER,
+        await resolvePaymentRequiredHeader() ?? safeBase64Encode(JSON.stringify(paymentRequired))
+      );
       return c.json({
         error: "Payment required",
-        accepts: [requirements]
+        accepts: requirements
       });
     }
-    let paymentPayload;
+    let parsedPayload;
     try {
-      paymentPayload = decodePayloadHeader(paymentHeader, {
-        accepted: requirements
+      parsedPayload = decodePayloadHeader(paymentHeader, {
+        accepted: primaryRequirement
       });
-    } catch (e) {
+    } catch {
+      c.status(400);
+      return c.json({ error: "Invalid payment payload" });
+    }
+    const selectedRequirement = findRequirementByAccepted(
+      requirements,
+      parsedPayload.accepted
+    );
+    if (!selectedRequirement) {
       c.status(400);
-      return c.json({ error: "Invalid payment payload", details: String(e) });
+      return c.json({
+        error: "Invalid payment payload",
+        message: "Accepted requirement is not configured for this endpoint"
+      });
     }
+    const facilitatorUrl = resolveFacilitatorUrlFromRequirement(
+      config,
+      selectedRequirement
+    );
     if (!facilitatorUrl) {
       c.status(500);
-      return c.json({ error: "Payment middleware configuration error", message: "Facilitator URL is required for verification" });
+      return c.json({
+        error: "Payment middleware configuration error",
+        message: "Facilitator URL is required for verification"
+      });
     }
-    const verifyResult = await verifyPayment(paymentPayload, requirements, { url: facilitatorUrl });
+    const verifyResult = await verifyPayment(
+      parsedPayload,
+      selectedRequirement,
+      { url: facilitatorUrl }
+    );
     if (!verifyResult.isValid) {
-      const requiredHeaders = createPaymentRequiredHeaders(requirements);
       c.status(402);
-      for (const [key, value] of Object.entries(requiredHeaders)) {
-        c.header(key, value);
-      }
+      c.header(
+        PAYMENT_REQUIRED_HEADER,
+        await resolvePaymentRequiredHeader()
+      );
       return c.json({
         error: "Payment verification failed",
         message: verifyResult.invalidReason
       });
     }
-    const payerAddress = verifyResult.payer ?? paymentPayload.payload.authorization.from;
     c.set("payment", {
-      payload: paymentPayload,
-      payerAddress,
+      payload: parsedPayload,
+      payerAddress: verifyResult.payer,
       verified: true
     });
     await next();
     if (c.res.status >= 400) {
       return;
     }
-    const settleResult = await settlePayment(paymentPayload, requirements, { url: facilitatorUrl });
+    const settleResult = await settlePayment(
+      parsedPayload,
+      selectedRequirement,
+      { url: facilitatorUrl }
+    );
     if (!settleResult.success) {
       c.status(502);
-      c.res = c.json({ error: "Settlement failed", details: settleResult.errorReason }, 502);
+      c.res = c.json(
+        { error: "Settlement failed", details: settleResult.errorReason },
+        502
+      );
       return;
     }
-    const settlementHeaders = createSettlementHeaders(settleResult);
-    for (const [key, value] of Object.entries(settlementHeaders)) {
+    const headers = createSettlementHeaders(settleResult);
+    for (const [key, value] of Object.entries(headers)) {
       c.header(key, value);
     }
   };
-};
+}
 
-export { advancedPaymentMiddleware, createPaymentRequirements, paymentMiddleware, routeAwarePaymentMiddleware };
+export { createPaymentRequirements, paymentMiddleware, resolveFacilitatorUrlFromRequirement, routeAwarePaymentMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-hono",
-  "version": "0.3.28",
+  "version": "0.3.30",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "keywords": [
@@ -52,8 +52,8 @@
     "hono": "^4"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.28",
-    "@armory-sh/extensions": "0.1.9"
+    "@armory-sh/base": "0.2.30",
+    "@armory-sh/extensions": "0.1.11"
   },
   "devDependencies": {
     "bun-types": "latest",
@@ -64,6 +64,8 @@
   "scripts": {
     "build": "rm -rf dist && tsup",
     "build:dts": "rm -rf dist && tsc --declaration --skipLibCheck",
+    "lint": "bun run build",
+    "format": "bun run lint",
     "test": "bun test"
   }
 }