@armory-sh/middleware-hono 0.3.14 → 0.3.16

package/dist/index.d.ts

@@ -1,101 +1,19 @@
-import * as hono from 'hono';
 import { Context, Next } from 'hono';
-import * as hono_utils_http_status from 'hono/utils/http-status';
-import * as hono_utils_types from 'hono/utils/types';
-import * as _armory_sh_base from '@armory-sh/base';
-import { Address, AcceptPaymentOptions, PricingConfig } from '@armory-sh/base';
+import { PaymentPayloadV2, PaymentRequirements } from '@armory-sh/base';
 
-type PaymentVersion = 1 | 2;
-
-/**
- * Armory V1 Types - x402 Protocol V1 Compatible
- *
- * Supports both the x402 V1 specification format and legacy Armory V1 format.
- *
- * x402 V1 Specification: https://github.com/coinbase/x402
- */
-
-/**
- * Network name for x402 V1 (e.g., "base-sepolia", "ethereum-mainnet")
- */
-type X402V1Network = string;
-
-/**
- * Simple one-line middleware API for Armory merchants
- * Focus on DX/UX - "everything just magically works"
- */
-
-/**
- * Simple configuration for acceptPaymentsViaArmory middleware
- */
-interface SimpleMiddlewareConfig {
-    /** Address to receive payments */
-    payTo: Address;
-    /** Default amount to charge (default: "1.0") */
-    amount?: string;
-    /** Payment acceptance options */
-    accept?: AcceptPaymentOptions;
-    /** Fallback facilitator URL (if not using accept.facilitators) */
+interface PaymentMiddlewareConfig {
+    requirements: PaymentRequirements;
     facilitatorUrl?: string;
-    /** Per-network/token/facilitator pricing overrides */
-    pricing?: PricingConfig[];
+    skipVerification?: boolean;
+    network?: string;
 }
+interface AugmentedRequest extends Request {
+    payment?: {
+        payload: PaymentPayloadV2;
+        payerAddress: string;
+        verified: boolean;
+    };
+}
+declare const paymentMiddleware: (config: PaymentMiddlewareConfig) => (c: Context, next: Next) => Promise<Response | void>;
 
-/**
- * One-line middleware setup for accepting Armory payments in Hono
- *
- * @example
- * ```ts
- * import { acceptPaymentsViaArmory } from '@armory-sh/middleware/integrations/hono-simple'
- *
- * app.use('/api/*', acceptPaymentsViaArmory({
- *   payTo: '0xMerchantAddress...',
- *   amount: '1.0'
- * }))
- * ```
- */
-declare const acceptPaymentsViaArmory: (config: SimpleMiddlewareConfig & {
-    defaultVersion?: 1 | 2;
-}) => (c: Context, next: Next) => Promise<(Response & hono.TypedResponse<{
-    error: string;
-    x402Version: number;
-    accepts: ({
-        scheme: "exact";
-        network: X402V1Network;
-        maxAmountRequired: string;
-        asset: _armory_sh_base.Address;
-        payTo: _armory_sh_base.Address;
-        resource: string;
-        description: string;
-        mimeType?: string | undefined;
-        outputSchema?: null | undefined;
-        maxTimeoutSeconds: number;
-        extra?: {
-            [x: string]: hono_utils_types.JSONValue;
-        } | undefined;
-    } | {
-        scheme: "exact";
-        network: _armory_sh_base.CAIP2ChainId;
-        amount: string;
-        asset: _armory_sh_base.Address;
-        payTo: _armory_sh_base.Address;
-        maxTimeoutSeconds: number;
-        extra?: {
-            [x: string]: hono_utils_types.JSONValue;
-        } | undefined;
-    } | {
-        amount: string;
-        network: string;
-        contractAddress: string;
-        payTo: string;
-        expiry: number;
-    })[];
-}, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-    error: string;
-    x402Version: PaymentVersion;
-}, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-    error: string;
-    message: string;
-}, hono_utils_http_status.ContentfulStatusCode, "json">) | undefined>;
-
-export { acceptPaymentsViaArmory };
+export { type AugmentedRequest, type PaymentMiddlewareConfig, paymentMiddleware };

package/dist/index.js

@@ -1,458 +1,57 @@
 // src/index.ts
 import {
-  V1_HEADERS as V1_HEADERS2,
-  V2_HEADERS as V2_HEADERS2
+  createPaymentRequiredHeaders,
+  createSettlementHeaders,
+  PAYMENT_SIGNATURE_HEADER,
+  decodePaymentV2
 } from "@armory-sh/base";
-
-// src/simple.ts
-import {
-  resolveNetwork,
-  resolveToken,
-  validateAcceptConfig,
-  isValidationError,
-  normalizeNetworkName as normalizeNetworkName2
-} from "@armory-sh/base";
-
-// src/core.ts
-import {
-  getNetworkConfig,
-  getNetworkByChainId,
-  normalizeNetworkName,
-  encodeX402PaymentRequiredV1,
-  encodeX402SettlementResponseV1,
-  safeBase64Encode,
-  V1_HEADERS,
-  V2_HEADERS
-} from "@armory-sh/base";
-var toSlug = (network) => {
-  if (typeof network === "number") {
-    const net = getNetworkByChainId(network);
-    if (!net) throw new Error(`No network found for chainId: ${network}`);
-    return normalizeNetworkName(net.name);
-  }
-  if (network.startsWith("eip155:")) {
-    const chainIdStr = network.split(":")[1];
-    if (!chainIdStr) throw new Error(`Invalid eip155 format: ${network}`);
-    const chainId = parseInt(chainIdStr, 10);
-    const net = getNetworkByChainId(chainId);
-    if (!net) throw new Error(`No network found for chainId: ${chainId}`);
-    return normalizeNetworkName(net.name);
-  }
-  return normalizeNetworkName(network);
-};
-var toEip155 = (network) => {
-  if (typeof network === "number") {
-    const net2 = getNetworkByChainId(network);
-    if (!net2) throw new Error(`No network found for chainId: ${network}`);
-    return net2.caip2Id;
-  }
-  if (network.startsWith("eip155:")) {
-    const net2 = getNetworkConfig(network);
-    if (!net2) throw new Error(`No network found for: ${network}`);
-    return net2.caip2Id;
-  }
-  const slug = normalizeNetworkName(network);
-  const net = getNetworkConfig(slug);
-  if (!net) throw new Error(`No network found for: ${slug}`);
-  return net.caip2Id;
-};
-var getNetworkName = (network) => toSlug(network);
-var getChainId = (network) => toEip155(network);
-var createV1Requirements = (config, resourceUrl, expiry) => {
-  const networkName = getNetworkName(config.network);
-  const network = getNetworkConfig(networkName);
-  if (!network) throw new Error(`Unsupported network: ${networkName}`);
-  const atomicAmount = toAtomicUnits(config.amount);
-  return {
-    scheme: "exact",
-    network: networkName,
-    maxAmountRequired: atomicAmount,
-    asset: network.usdcAddress,
-    payTo: config.payTo,
-    resource: resourceUrl,
-    description: "API Access",
-    mimeType: "application/json",
-    maxTimeoutSeconds: 300,
-    extra: {
-      name: "USDC",
-      version: "2"
-    }
-  };
-};
-var 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`;
-};
-var createV2Requirements = (config, resourceUrl) => {
-  const networkName = getNetworkName(config.network);
-  const network = getNetworkConfig(networkName);
-  if (!network) throw new Error(`Unsupported network: ${networkName}`);
-  const assetIdMatch = network.caipAssetId.match(/\/erc20:(0x[a-fA-F0-9]{40})$/);
-  if (!assetIdMatch) throw new Error(`Invalid CAIP asset ID format: ${network.caipAssetId}`);
-  const asset = assetIdMatch[1];
-  const atomicAmount = toAtomicUnits(config.amount);
-  return {
-    scheme: "exact",
-    network: getChainId(config.network),
-    amount: atomicAmount,
-    asset,
-    payTo: config.payTo,
-    maxTimeoutSeconds: 300,
-    extra: {
-      name: "USDC",
-      version: "2"
-    }
-  };
-};
-var createPaymentRequirements = (config, version = 1, resourceUrl = "https://api.example.com") => {
-  const networkName = getNetworkName(config.network);
-  const network = getNetworkConfig(networkName);
-  if (!network) throw new Error(`Unsupported network: ${networkName}`);
-  const expiry = Math.floor(Date.now() / 1e3) + 3600;
-  return version === 1 ? createV1Requirements(config, resourceUrl, expiry) : createV2Requirements(config, resourceUrl);
-};
-var findHeaderValue = (headers, name) => {
-  const value = headers[name];
-  if (typeof value === "string") return value;
-  if (Array.isArray(value) && value.length > 0) return value[0];
-  const lowerName = name.toLowerCase();
-  for (const [key, val] of Object.entries(headers)) {
-    if (key.toLowerCase() === lowerName) {
-      if (typeof val === "string") return val;
-      if (Array.isArray(val) && val.length > 0) return val[0];
-    }
-  }
-  return void 0;
-};
-var parseHeader = (header) => {
-  try {
-    if (header.startsWith("{")) return JSON.parse(header);
-    return JSON.parse(atob(header));
-  } catch {
-    return null;
-  }
-};
-var extractPaymentPayload = (request) => {
-  const v1Header = findHeaderValue(request.headers, "X-PAYMENT");
-  if (v1Header) return parseHeader(v1Header);
-  const v2Header = findHeaderValue(request.headers, "PAYMENT-SIGNATURE");
-  if (v2Header) return parseHeader(v2Header);
-  return null;
-};
-var postFacilitator = async (url, headers, body) => {
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...headers },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(error || `Request failed: ${response.status}`);
-  }
-  return response.json();
-};
-var verifyWithFacilitator = async (request, facilitator) => {
-  const payload = extractPaymentPayload(request);
-  if (!payload) {
-    return { success: false, error: "No payment payload found in request headers" };
-  }
-  try {
-    const url = new URL("/verify", facilitator.url);
-    const headers = facilitator.createHeaders?.() ?? {};
-    const data = await postFacilitator(url.toString(), headers, { payload, headers: request.headers });
-    return {
-      success: true,
-      payerAddress: data.payerAddress,
-      balance: data.balance,
-      requiredAmount: data.requiredAmount
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown verification error"
-    };
-  }
-};
-var createX402V1PaymentRequiredHeaders = (requirements, errorMessage = "X-PAYMENT header is required") => {
-  const paymentRequired = {
-    x402Version: 1,
-    error: errorMessage,
-    accepts: [requirements]
-  };
-  return {
-    [V1_HEADERS.PAYMENT_REQUIRED]: encodeX402PaymentRequiredV1(paymentRequired),
-    "Content-Type": "application/json"
-  };
-};
-var createX402V2PaymentRequiredHeaders = (requirements, resourceUrl, options) => {
-  const resource = {
-    url: resourceUrl,
-    description: options?.description ?? "API Access",
-    mimeType: options?.mimeType ?? "application/json"
-  };
-  const paymentRequired = {
-    x402Version: 2,
-    ...options?.errorMessage && { error: options.errorMessage },
-    resource,
-    accepts: [requirements],
-    ...requirements.extra && { extensions: requirements.extra }
-  };
-  return {
-    [V2_HEADERS.PAYMENT_REQUIRED]: safeBase64Encode(JSON.stringify(paymentRequired)),
-    "Content-Type": "application/json"
-  };
-};
-var createSettlementHeaders = (response, version, network, payer) => {
-  if (version === 1) {
-    const txHash2 = "transaction" in response ? response.transaction : response.txHash || "";
-    const isSuccess2 = "success" in response ? response.success : false;
-    const networkName = network || "base-sepolia";
-    const settlementV1 = {
-      success: isSuccess2,
-      transaction: txHash2,
-      network: networkName,
-      payer: payer || "0x0000000000000000000000000000000000000000"
-    };
-    return { [V1_HEADERS.PAYMENT_RESPONSE]: encodeX402SettlementResponseV1(settlementV1) };
-  }
-  const txHash = "transaction" in response ? response.transaction : "";
-  const isSuccess = "success" in response ? response.success : false;
-  const settlementV2 = {
-    success: isSuccess,
-    transaction: txHash,
-    network: network || "eip155:84532",
-    ...payer && { payer }
-  };
-  return { [V2_HEADERS.PAYMENT_RESPONSE]: safeBase64Encode(JSON.stringify(settlementV2)) };
-};
-
-// src/simple.ts
-var findPricingConfig = (pricing, network, token, facilitatorUrl) => {
-  if (!pricing) return void 0;
-  const withFacilitator = pricing.find(
-    (p) => p.network === network && p.token === token && p.facilitator === facilitatorUrl
-  );
-  if (withFacilitator) return withFacilitator;
-  const withNetworkToken = pricing.find(
-    (p) => p.network === network && p.token === token && !p.facilitator
-  );
-  if (withNetworkToken) return withNetworkToken;
-  const networkOnly = pricing.find(
-    (p) => p.network === network && !p.token && !p.facilitator
-  );
-  if (networkOnly) return networkOnly;
-  return void 0;
-};
-var resolveMiddlewareConfig = (config) => {
-  const { payTo, amount = "1.0", accept = {}, facilitatorUrl, pricing } = config;
-  const acceptOptions = facilitatorUrl ? {
-    ...accept,
-    facilitators: accept.facilitators ? [...Array.isArray(accept.facilitators) ? accept.facilitators : [accept.facilitators], { url: facilitatorUrl }] : { url: facilitatorUrl }
-  } : accept;
-  const result = validateAcceptConfig(acceptOptions, payTo, amount);
-  if (!result.success) {
-    return result.error;
-  }
-  const facilitatorConfigs = result.config[0]?.facilitators.map((f) => ({
-    url: f.url,
-    createHeaders: f.input.headers
-  })) ?? [];
-  const enrichedConfigs = result.config.map((c) => {
-    const networkName = normalizeNetworkName2(c.network.config.name);
-    const tokenSymbol = c.token.config.symbol;
-    const facilitatorPricing = c.facilitators.map((f) => {
-      const pricingConfig = findPricingConfig(pricing, networkName, tokenSymbol, f.url);
-      return { url: f.url, pricing: pricingConfig };
-    });
-    const defaultPricing = findPricingConfig(pricing, networkName, tokenSymbol, "");
-    return {
-      ...c,
-      amount: defaultPricing?.amount ?? c.amount,
-      facilitatorUrl: facilitatorPricing[0]?.url,
-      pricing: defaultPricing
-    };
-  });
-  return {
-    configs: enrichedConfigs,
-    version: acceptOptions.version ?? "auto",
-    facilitators: facilitatorConfigs
-  };
-};
-var getPrimaryConfig = (resolved) => {
-  const primary = resolved.configs[0];
-  if (!primary) {
-    throw new Error("No valid payment configurations found");
-  }
-  return {
-    payTo: primary.payTo,
-    network: normalizeNetworkName2(primary.network.config.name),
-    amount: primary.amount,
-    facilitator: resolved.facilitators[0],
-    settlementMode: "verify"
-  };
-};
-
-// src/payment-utils.ts
-import { extractPaymentFromHeaders, X402_HEADERS } from "@armory-sh/base";
-var getHeadersForVersion = (version) => version === 1 ? { payment: "X-PAYMENT", required: "X-PAYMENT-REQUIRED", response: "X-PAYMENT-RESPONSE" } : { payment: "PAYMENT-SIGNATURE", required: "PAYMENT-REQUIRED", response: "PAYMENT-RESPONSE" };
-function isLegacyV1(payload) {
-  return typeof payload === "object" && payload !== null && "contractAddress" in payload && "network" in payload && "signature" in payload && typeof payload.signature === "string";
-}
-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 {
-      try {
-        parsed = JSON.parse(atob(headerValue));
-      } catch {
-        const padding = 4 - headerValue.length % 4;
-        const padded = padding !== 4 ? headerValue + "=".repeat(padding) : headerValue;
-        const standard = padded.replace(/-/g, "+").replace(/_/g, "/");
-        parsed = JSON.parse(atob(standard));
-      }
-    }
-  } catch {
-    throw new Error("Invalid payment payload");
-  }
-  if (typeof parsed === "object" && parsed !== null && "x402Version" in parsed) {
-    const version = parsed.x402Version;
-    if (version === 1) {
-      return { payload: parsed, version: 1 };
-    }
-    if (version === 2) {
-      return { payload: parsed, version: 2 };
-    }
-  }
-  const base64Value = isJsonString ? Buffer.from(headerValue).toString("base64") : headerValue;
-  const headers = new Headers();
-  headers.set(X402_HEADERS.PAYMENT, base64Value);
-  const x402Payload = extractPaymentFromHeaders(headers);
-  if (x402Payload) {
-    return { payload: x402Payload, version: 2 };
-  }
-  if (isLegacyV1(parsed)) {
-    return { payload: parsed, version: 1 };
-  }
-  if (isLegacyV2(parsed)) {
-    return { payload: parsed, version: 2 };
-  }
-  throw new Error("Unrecognized payment payload format");
-};
-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");
-};
-
-// src/index.ts
-var toHttpRequest = (c) => ({
-  headers: Object.fromEntries(Object.entries(c.req.header()).map(([k, v]) => [k, v ?? ""])),
-  method: c.req.method,
-  url: c.req.url
-});
-var acceptPaymentsViaArmory = (config) => {
-  const resolved = resolveMiddlewareConfig(config);
-  if ("code" in resolved) {
-    throw new Error(`Invalid payment configuration: ${resolved.message}`);
-  }
-  const primaryConfig = getPrimaryConfig(resolved);
-  const defaultVersion = config.defaultVersion ?? 2;
-  const createRequirementsForVersion = (version, resourceUrl) => createPaymentRequirements(primaryConfig, version, resourceUrl);
-  const createPaymentRequiredResponse = (version, requirements, resourceUrl, errorMessage) => {
-    if (version === 1) {
-      return createX402V1PaymentRequiredHeaders(
-        requirements,
-        errorMessage ?? "X-PAYMENT header is required"
-      );
-    }
-    return createX402V2PaymentRequiredHeaders(
-      requirements,
-      resourceUrl,
-      { errorMessage }
-    );
-  };
+var paymentMiddleware = (config) => {
+  const { requirements, facilitatorUrl, skipVerification = false, network = "base" } = config;
   return async (c, next) => {
-    const paymentHeader = c.req.header(V1_HEADERS2.PAYMENT) || c.req.header(V2_HEADERS2.PAYMENT_SIGNATURE) || c.req.header("X-PAYMENT");
-    const resourceUrl = c.req.url;
+    const paymentHeader = c.req.header(PAYMENT_SIGNATURE_HEADER);
     if (!paymentHeader) {
-      const version = defaultVersion === 1 ? 1 : 2;
-      const requirements = createRequirementsForVersion(version, resourceUrl);
-      const headers = createPaymentRequiredResponse(version, requirements, resourceUrl);
+      const requiredHeaders = createPaymentRequiredHeaders(requirements);
       c.status(402);
-      for (const [key, value] of Object.entries(headers)) {
+      for (const [key, value] of Object.entries(requiredHeaders)) {
         c.header(key, value);
       }
       return c.json({
         error: "Payment required",
-        x402Version: version,
         accepts: [requirements]
       });
     }
+    let paymentPayload = null;
     try {
-      const { payload, version } = decodePayload(paymentHeader);
-      if (primaryConfig.facilitator) {
-        const verifyResult = await verifyWithFacilitator(toHttpRequest(c), primaryConfig.facilitator);
-        if (!verifyResult.success) {
-          const requirements = createRequirementsForVersion(version, resourceUrl);
-          const headers = createPaymentRequiredResponse(
-            version,
-            requirements,
-            resourceUrl,
-            `Payment verification failed: ${verifyResult.error}`
-          );
-          c.status(402);
-          for (const [key, value] of Object.entries(headers)) {
-            c.header(key, value);
-          }
-          return c.json({
-            error: `Payment verification failed: ${verifyResult.error}`,
-            x402Version: version
-          });
-        }
-      }
-      const payerAddress = extractPayerAddress(payload);
-      const responseHeaders = getHeadersForVersion(version);
-      c.set("payment", { payload, payerAddress, version, verified: true });
-      c.header("X-Payment-Verified", "true");
-      c.header("X-Payer-Address", payerAddress);
-      const settlementResponse = {
-        success: true,
-        transaction: "",
-        network: version === 1 ? "base-sepolia" : "eip155:84532",
-        payer: payerAddress
-      };
-      const settlementHeaders = createSettlementHeaders(settlementResponse, version, void 0, payerAddress);
-      for (const [key, value] of Object.entries(settlementHeaders)) {
-        c.header(key, value);
-      }
-      await next();
-    } catch (error) {
+      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",
-        message: error instanceof Error ? error.message : "Unknown error"
-      });
+      return c.json({ error: "Invalid payment payload", details: String(e) });
+    }
+    if (!paymentPayload) {
+      c.status(400);
+      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
+    });
+    return next();
   };
 };
 export {
-  acceptPaymentsViaArmory
+  paymentMiddleware
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-hono",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",