@armory-sh/middleware-hono 0.3.18 → 0.3.20

package/README.md

@@ -0,0 +1,220 @@
+# @armory-sh/middleware-hono
+
+x402 payment middleware for Hono applications.
+
+## Installation
+
+```bash
+bun add @armory-sh/middleware-hono
+```
+
+## Features
+
+- Simple payment middleware for Hono
+- Route-aware payment configuration
+- Multi-network, multi-token support
+- Per-route facilitator configuration
+- Full TypeScript support
+
+## Basic Usage
+
+```typescript
+import { Hono } from "hono";
+import { paymentMiddleware } from "@armory-sh/middleware-hono";
+
+const app = new Hono();
+
+app.use("/*", paymentMiddleware({
+  payTo: "0xYourAddress...",
+  chain: "base",
+  token: "usdc",
+  amount: "1.0",
+}));
+
+app.get("/api/data", (c) => {
+  const payment = c.get("payment");
+  return c.json({
+    data: "protected data",
+    payerAddress: payment?.payload?.authorization?.from,
+  });
+});
+```
+
+## Route-Aware Middleware
+
+Configure different payment requirements for different routes:
+
+```typescript
+import { routeAwarePaymentMiddleware } from "@armory-sh/middleware-hono";
+
+const app = new Hono();
+
+// Single route with wildcard
+app.use("/api/premium/*", routeAwarePaymentMiddleware({
+  routes: ["/api/premium/*"],
+  payTo: "0xYourAddress...",
+  amount: "$5.00",
+  network: "base"
+}));
+
+// Multiple routes with per-route configuration
+app.use("/api/*", routeAwarePaymentMiddleware({
+  routes: ["/api/basic", "/api/premium/*"],
+  payTo: "0xYourAddress...",
+  amount: "$1.00",  // Default amount
+  network: "base",
+  perRoute: {
+    "/api/premium/*": {
+      amount: "$5.00",  // Override for premium routes
+      network: "ethereum",
+    }
+  }
+}));
+```
+
+## Configuration Options
+
+### PaymentConfig
+
+```typescript
+interface PaymentConfig {
+  payTo: string;                    // Payment recipient address
+  chain?: string | number;          // Network (name or chain ID)
+  chains?: Array<string | number>;  // Multiple networks
+  token?: string;                   // Token symbol
+  tokens?: string[];                // Multiple tokens
+  amount?: string;                  // Amount (default: "1.0")
+  maxTimeoutSeconds?: number;       // Payment timeout (default: 300)
+
+  // Per-chain configuration
+  payToByChain?: Record<string, string>;
+  facilitatorUrlByChain?: Record<string, string>;
+
+  // Per-token-per-chain configuration
+  payToByToken?: Record<string, Record<string, string>>;
+  facilitatorUrlByToken?: Record<string, Record<string, string>>;
+}
+```
+
+### RouteAwarePaymentConfig
+
+```typescript
+interface RouteAwarePaymentConfig extends PaymentConfig {
+  route?: string;    // Single exact route (no wildcards)
+  routes?: string[];  // Multiple routes (allows wildcards)
+  perRoute?: Record<string, Partial<PaymentConfig>>;
+}
+```
+
+## Payment Context
+
+The middleware adds payment information to the Hono context:
+
+```typescript
+app.get("/api/data", (c) => {
+  const payment = c.get("payment");
+  // payment.payload: PaymentPayloadV2
+  // payment.verified: boolean
+  // payment.route: string (only for route-aware middleware)
+});
+```
+
+## Input Formats
+
+**Networks** - Use any format:
+```typescript
+'base'              // name
+8453                // chain ID
+'eip155:8453'       // CAIP-2
+```
+
+**Tokens** - Use any format:
+```typescript
+'usdc'              // symbol (case-insensitive)
+'0x8335...'         // EVM address
+'eip155:8453/erc20:0x8335...'  // CAIP Asset ID
+```
+
+## Route Pattern Matching
+
+- **Exact**: `/api/users` - matches only `/api/users`
+- **Wildcard**: `/api/*` - matches `/api/users`, `/api/posts/123`
+- **Parameterized**: `/api/users/:id` - matches `/api/users/123`
+
+Priority order: Exact matches > Parameterized routes > Wildcard routes
+
+## Examples
+
+### Multi-Network Support
+
+```typescript
+app.use("/*", paymentMiddleware({
+  payTo: "0xYourAddress...",
+  chains: ["base", "ethereum", "skale-base"],
+  tokens: ["usdc", "eurc"],
+  amount: "1.0"
+}));
+```
+
+### Per-Chain Configuration
+
+```typescript
+app.use("/*", paymentMiddleware({
+  payTo: "0xDefaultAddress...",
+  payToByChain: {
+    base: "0xBaseAddress...",
+    ethereum: "0xEthAddress...",
+  },
+  chain: "base",
+  token: "usdc"
+}));
+```
+
+### Route-Specific Pricing
+
+```typescript
+app.use("/api/*", routeAwarePaymentMiddleware({
+  routes: ["/api/basic", "/api/pro", "/api/enterprise"],
+  payTo: "0xYourAddress...",
+  amount: "$1.00",
+  network: "base",
+  perRoute: {
+    "/api/pro": {
+      amount: "$5.00",
+    },
+    "/api/enterprise": {
+      amount: "$50.00",
+      network: "ethereum",
+    }
+  }
+}));
+```
+
+## API
+
+### `paymentMiddleware(config)`
+
+Creates a basic payment middleware for Hono.
+
+**Parameters:**
+- `config`: Payment configuration
+
+**Returns:** Hono middleware function
+
+### `createPaymentRequirements(config)`
+
+Creates payment requirements from configuration (for advanced use).
+
+**Parameters:**
+- `config`: Payment configuration
+
+**Returns:** Object with `requirements` array and optional `error`
+
+### `routeAwarePaymentMiddleware(config)`
+
+Creates a route-aware payment middleware for Hono.
+
+**Parameters:**
+- `config`: Route-aware payment configuration
+
+**Returns:** Hono middleware function

package/dist/extensions.d.ts

@@ -0,0 +1,39 @@
+import { Extensions } from '@armory-sh/base';
+
+/**
+ * Extension handling for Hono middleware
+ * Integrates with @armory-sh/extensions package
+ */
+
+type BazaarDiscoveryConfig = {
+    input?: unknown;
+    inputSchema?: Record<string, unknown>;
+    bodyType?: "json" | "form-data" | "text";
+    output?: {
+        example?: unknown;
+        schema?: Record<string, unknown>;
+    };
+};
+type SIWxExtensionConfig = {
+    domain?: string;
+    resourceUri?: string;
+    network?: string | string[];
+    statement?: string;
+    version?: string;
+    expirationSeconds?: number;
+};
+type Extension<T = unknown> = {
+    info: T;
+    schema: Record<string, unknown>;
+};
+interface ExtensionConfig {
+    bazaar?: BazaarDiscoveryConfig;
+    signInWithX?: SIWxExtensionConfig;
+}
+interface PaymentConfigWithExtensions {
+    extensions?: ExtensionConfig;
+}
+declare function buildExtensions(config: ExtensionConfig): Extensions;
+declare function extractExtension<T>(extensions: Extensions | undefined, key: string): Extension<T> | null;
+
+export { type ExtensionConfig, type PaymentConfigWithExtensions, buildExtensions, extractExtension };

package/dist/extensions.js

@@ -0,0 +1,60 @@
+// src/extensions.ts
+var declareDiscoveryExtension = (config = {}) => {
+  const info = {};
+  if (config.input !== void 0) {
+    info.input = config.input;
+  }
+  if (config.inputSchema !== void 0) {
+    info.inputSchema = config.inputSchema;
+  }
+  if (config.output !== void 0) {
+    info.output = config.output;
+  }
+  return { info, schema: { type: "object" } };
+};
+var declareSIWxExtension = (config = {}) => {
+  const info = {};
+  if (config.domain !== void 0) {
+    info.domain = config.domain;
+  }
+  if (config.resourceUri !== void 0) {
+    info.resourceUri = config.resourceUri;
+  }
+  if (config.network !== void 0) {
+    info.network = config.network;
+  }
+  if (config.statement !== void 0) {
+    info.statement = config.statement;
+  }
+  if (config.version !== void 0) {
+    info.version = config.version;
+  }
+  if (config.expirationSeconds !== void 0) {
+    info.expirationSeconds = config.expirationSeconds;
+  }
+  return { info, schema: { type: "object" } };
+};
+function buildExtensions(config) {
+  const extensions = {};
+  if (config.bazaar) {
+    extensions.bazaar = declareDiscoveryExtension(config.bazaar);
+  }
+  if (config.signInWithX) {
+    extensions["sign-in-with-x"] = declareSIWxExtension(config.signInWithX);
+  }
+  return extensions;
+}
+function extractExtension(extensions, key) {
+  if (!extensions || typeof extensions !== "object") {
+    return null;
+  }
+  const extension = extensions[key];
+  if (!extension || typeof extension !== "object") {
+    return null;
+  }
+  return extension;
+}
+export {
+  buildExtensions,
+  extractExtension
+};

package/dist/index.d.ts

@@ -1,10 +1,47 @@
 import { Context, Next } from 'hono';
-import { PaymentPayloadV2, PaymentRequirements } from '@armory-sh/base';
+import { PaymentRequirementsV2, ValidationError, PaymentRequirements, PaymentPayloadV2 } from '@armory-sh/base';
+import { ExtensionConfig } from './extensions.js';
+export { buildExtensions, extractExtension } from './extensions.js';
 
-interface PaymentMiddlewareConfig {
+/**
+ * Simplified middleware API for easy x402 payment integration
+ * Just specify payTo address and optional chains/tokens by name
+ */
+
+type NetworkId = string | number;
+type TokenId = string;
+interface PaymentConfig {
+    payTo: string;
+    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;
+}
+interface ResolvedSimpleConfig {
+    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;
-    skipVerification?: boolean;
     network?: string;
 }
 interface AugmentedRequest extends Request {
@@ -14,6 +51,6 @@ interface AugmentedRequest extends Request {
         verified: boolean;
     };
 }
-declare const paymentMiddleware: (config: PaymentMiddlewareConfig) => (c: Context, next: Next) => Promise<Response | void>;
+declare const advancedPaymentMiddleware: (config: AdvancedPaymentConfig) => (c: Context, next: Next) => Promise<Response | void>;
 
-export { type AugmentedRequest, type PaymentMiddlewareConfig, paymentMiddleware };
+export { type AdvancedPaymentConfig, type AugmentedRequest, ExtensionConfig, type PaymentConfig, type RouteAwarePaymentConfig, advancedPaymentMiddleware, createPaymentRequirements, paymentMiddleware, routeAwarePaymentMiddleware };

package/dist/index.js

@@ -1,12 +1,394 @@
 // src/index.ts
 import {
   createPaymentRequiredHeaders,
-  createSettlementHeaders,
   PAYMENT_SIGNATURE_HEADER,
   decodePaymentV2
 } from "@armory-sh/base";
-var paymentMiddleware = (config) => {
-  const { requirements, facilitatorUrl, skipVerification = false, network = "base" } = config;
+
+// src/simple.ts
+import {
+  resolveNetwork,
+  resolveToken,
+  safeBase64Encode,
+  V2_HEADERS,
+  registerToken
+} from "@armory-sh/base";
+import {
+  TOKENS
+} from "@armory-sh/base";
+
+// src/extensions.ts
+var declareDiscoveryExtension = (config = {}) => {
+  const info = {};
+  if (config.input !== void 0) {
+    info.input = config.input;
+  }
+  if (config.inputSchema !== void 0) {
+    info.inputSchema = config.inputSchema;
+  }
+  if (config.output !== void 0) {
+    info.output = config.output;
+  }
+  return { info, schema: { type: "object" } };
+};
+var declareSIWxExtension = (config = {}) => {
+  const info = {};
+  if (config.domain !== void 0) {
+    info.domain = config.domain;
+  }
+  if (config.resourceUri !== void 0) {
+    info.resourceUri = config.resourceUri;
+  }
+  if (config.network !== void 0) {
+    info.network = config.network;
+  }
+  if (config.statement !== void 0) {
+    info.statement = config.statement;
+  }
+  if (config.version !== void 0) {
+    info.version = config.version;
+  }
+  if (config.expirationSeconds !== void 0) {
+    info.expirationSeconds = config.expirationSeconds;
+  }
+  return { info, schema: { type: "object" } };
+};
+function buildExtensions(config) {
+  const extensions = {};
+  if (config.bazaar) {
+    extensions.bazaar = declareDiscoveryExtension(config.bazaar);
+  }
+  if (config.signInWithX) {
+    extensions["sign-in-with-x"] = declareSIWxExtension(config.signInWithX);
+  }
+  return extensions;
+}
+function extractExtension(extensions, key) {
+  if (!extensions || typeof extensions !== "object") {
+    return null;
+  }
+  const extension = extensions[key];
+  if (!extension || typeof extension !== "object") {
+    return null;
+  }
+  return extension;
+}
+
+// src/simple.ts
+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 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);
+      const resolvedFacilitatorUrl = 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,
+          ...resolvedFacilitatorUrl && { facilitatorUrl: resolvedFacilitatorUrl }
+        }
+      });
+    }
+  }
+  return { requirements };
+}
+function paymentMiddleware(config) {
+  const { requirements, error } = createPaymentRequirements(config);
+  return async (c, next) => {
+    if (error) {
+      c.status(500);
+      return c.json({
+        error: "Payment middleware configuration error",
+        details: error.message
+      });
+    }
+    const paymentHeader = c.req.header(V2_HEADERS.PAYMENT_SIGNATURE);
+    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
+      };
+      c.status(402);
+      c.header(V2_HEADERS.PAYMENT_REQUIRED, safeBase64Encode(JSON.stringify(paymentRequired)));
+      return c.json({
+        error: "Payment required",
+        accepts: requirements
+      });
+    }
+    const payload = paymentHeader;
+    let parsedPayload;
+    try {
+      const decoded = atob(payload);
+      parsedPayload = JSON.parse(decoded);
+    } catch {
+      try {
+        parsedPayload = JSON.parse(payload);
+      } catch {
+        c.status(400);
+        return c.json({ error: "Invalid payment payload" });
+      }
+    }
+    c.set("payment", {
+      payload: parsedPayload,
+      verified: false
+    });
+    return next();
+  };
+}
+
+// src/routes.ts
+import {
+  safeBase64Encode as safeBase64Encode2,
+  V2_HEADERS as V2_HEADERS2,
+  matchRoute,
+  validateRouteConfig
+} from "@armory-sh/base";
+var resolveRouteConfig = (config) => {
+  const validationError = validateRouteConfig(config);
+  if (validationError) {
+    return { routes: [], error: validationError };
+  }
+  const { route, routes, perRoute, ...baseConfig } = config;
+  const routePatterns = route ? [route] : routes || [];
+  const resolvedRoutes = [];
+  for (const pattern of routePatterns) {
+    const perRouteOverride = perRoute?.[pattern];
+    const mergedConfig = {
+      ...baseConfig,
+      ...perRouteOverride
+    };
+    resolvedRoutes.push({
+      pattern,
+      config: mergedConfig
+    });
+  }
+  return { routes: resolvedRoutes };
+};
+var routeAwarePaymentMiddleware = (config) => {
+  const { routes, error } = resolveRouteConfig(config);
+  return async (c, next) => {
+    if (error) {
+      c.status(500);
+      return c.json({
+        error: "Payment middleware configuration error",
+        details: error.message
+      });
+    }
+    const path = new URL(c.req.url).pathname;
+    const matchedRoute = routes.find((r) => matchRoute(r.pattern, path));
+    if (!matchedRoute) {
+      return next();
+    }
+    const { requirements, error: requirementsError } = createPaymentRequirements(matchedRoute.config);
+    if (requirementsError) {
+      c.status(500);
+      return c.json({
+        error: "Payment middleware configuration error",
+        details: requirementsError.message
+      });
+    }
+    const paymentHeader = c.req.header(V2_HEADERS2.PAYMENT_SIGNATURE);
+    if (!paymentHeader) {
+      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);
+      c.header(
+        V2_HEADERS2.PAYMENT_REQUIRED,
+        safeBase64Encode2(JSON.stringify(paymentRequired))
+      );
+      return c.json({
+        error: "Payment required",
+        accepts: requirements
+      });
+    }
+    let parsedPayload;
+    try {
+      const decoded = atob(paymentHeader);
+      parsedPayload = JSON.parse(decoded);
+    } catch {
+      try {
+        parsedPayload = JSON.parse(paymentHeader);
+      } catch {
+        c.status(400);
+        return c.json({ error: "Invalid payment payload" });
+      }
+    }
+    c.set("payment", {
+      payload: parsedPayload,
+      verified: false,
+      route: matchedRoute.pattern
+    });
+    return next();
+  };
+};
+
+// src/index.ts
+var advancedPaymentMiddleware = (config) => {
+  const { requirements, facilitatorUrl, network = "base" } = config;
   return async (c, next) => {
     const paymentHeader = c.req.header(PAYMENT_SIGNATURE_HEADER);
     if (!paymentHeader) {
@@ -22,11 +404,8 @@ var paymentMiddleware = (config) => {
     }
     let paymentPayload = null;
     try {
-      console.log("[x402 Debug] Raw payment header:", paymentHeader);
       paymentPayload = decodePaymentV2(paymentHeader);
-      console.log("[x402 Debug] Decoded payload:", JSON.stringify(paymentPayload, null, 2));
     } catch (e) {
-      console.error("[x402 Debug] Decode error:", e);
       c.status(400);
       return c.json({ error: "Invalid payment payload", details: String(e) });
     }
@@ -35,23 +414,19 @@ var paymentMiddleware = (config) => {
       return c.json({ error: "Invalid payment payload" });
     }
     const payerAddress = paymentPayload.payload.authorization.from;
-    const settlement = {
-      success: true,
-      transaction: "",
-      network
-    };
-    const settlementHeaders = createSettlementHeaders(settlement);
-    for (const [key, value] of Object.entries(settlementHeaders)) {
-      c.header(key, value);
-    }
     c.set("payment", {
       payload: paymentPayload,
       payerAddress,
-      verified: !skipVerification
+      verified: true
     });
     return next();
   };
 };
 export {
-  paymentMiddleware
+  advancedPaymentMiddleware,
+  buildExtensions,
+  createPaymentRequirements,
+  extractExtension,
+  paymentMiddleware,
+  routeAwarePaymentMiddleware
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-hono",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -11,6 +11,11 @@
       "types": "./dist/index.d.ts",
       "bun": "./src/index.ts",
       "default": "./dist/index.js"
+    },
+    "./extensions": {
+      "types": "./dist/extensions.d.ts",
+      "bun": "./src/extensions.ts",
+      "default": "./dist/extensions.js"
     }
   },
   "files": [
@@ -28,10 +33,12 @@
     "hono": "^4"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.18"
+    "@armory-sh/base": "0.2.20",
+    "@armory-sh/extensions": "0.1.1"
   },
   "devDependencies": {
     "bun-types": "latest",
+    "tsup": "^8.5.1",
     "typescript": "5.9.3",
     "hono": "^4"
   },