@armory-sh/middleware-hono 0.3.2

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import * as hono from 'hono';
+import { Context, Next } from 'hono';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import { Address, AcceptPaymentOptions, PricingConfig } from '@armory-sh/base';
+
+/**
+ * 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) */
+    facilitatorUrl?: string;
+    /** Per-network/token/facilitator pricing overrides */
+    pricing?: PricingConfig[];
+}
+
+/**
+ * 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;
+}, hono_utils_http_status.ContentfulStatusCode, "json">) | undefined>;
+
+export { acceptPaymentsViaArmory };

package/dist/index.js

@@ -0,0 +1,288 @@
+// src/simple.ts
+import {
+  resolveNetwork,
+  resolveToken,
+  validateAcceptConfig,
+  isValidationError
+} from "@armory-sh/base";
+
+// src/core.ts
+import {
+  getNetworkConfig,
+  getNetworkByChainId,
+  encodePaymentPayload
+} from "@armory-sh/base";
+var getNetworkName = (network) => {
+  if (typeof network === "string") return network;
+  const net = getNetworkByChainId(network);
+  if (!net) throw new Error(`No network found for chainId: ${network}`);
+  return net.name.toLowerCase().replace(" mainnet", "").replace(" sepolia", "-sepolia");
+};
+var createV1Requirements = (config, expiry) => {
+  const networkName = getNetworkName(config.network);
+  const network = getNetworkConfig(networkName);
+  if (!network) throw new Error(`Unsupported network: ${networkName}`);
+  return {
+    amount: config.amount,
+    network: networkName,
+    contractAddress: network.usdcAddress,
+    payTo: config.payTo,
+    expiry
+  };
+};
+var createV2Requirements = (config, expiry) => {
+  const networkName = getNetworkName(config.network);
+  const network = getNetworkConfig(networkName);
+  if (!network) throw new Error(`Unsupported network: ${networkName}`);
+  return {
+    amount: config.amount,
+    to: config.payTo,
+    chainId: network.caip2Id,
+    assetId: network.caipAssetId,
+    nonce: `${Date.now()}-${crypto.randomUUID()}`,
+    expiry
+  };
+};
+var createPaymentRequirements = (config, version = 1) => {
+  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, expiry) : createV2Requirements(config, expiry);
+};
+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"
+    };
+  }
+};
+
+// 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 = 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: 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";
+import { verifyX402Payment as verifyPayment } from "@armory-sh/facilitator";
+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" };
+var encodeRequirements = (requirements) => JSON.stringify(requirements);
+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;
+  try {
+    if (headerValue.startsWith("{")) {
+      parsed = JSON.parse(headerValue);
+    } else {
+      parsed = JSON.parse(atob(headerValue));
+    }
+  } catch {
+    throw new Error("Invalid payment payload");
+  }
+  const headers = new Headers();
+  headers.set(X402_HEADERS.PAYMENT, headerValue);
+  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 requirementsV1 = createPaymentRequirements(primaryConfig, 1);
+  const requirementsV2 = createPaymentRequirements(primaryConfig, 2);
+  return async (c, next) => {
+    const paymentHeader = c.req.header("X-Payment") || c.req.header("x402-payment");
+    if (!paymentHeader) {
+      const requirements = defaultVersion === 1 ? requirementsV1 : requirementsV2;
+      const version = defaultVersion === 1 ? 1 : 2;
+      const headers = getHeadersForVersion(version);
+      c.status(402);
+      c.header(headers.required, encodeRequirements(requirements));
+      c.header("Content-Type", "application/json");
+      return c.json({ error: "Payment required", requirements });
+    }
+    try {
+      const { payload, version } = decodePayload(paymentHeader);
+      if (primaryConfig.facilitator) {
+        const verifyResult = await verifyWithFacilitator(toHttpRequest(c), primaryConfig.facilitator);
+        if (!verifyResult.success) {
+          const requirements = version === 1 ? requirementsV1 : requirementsV2;
+          const headers2 = getHeadersForVersion(version);
+          c.status(402);
+          c.header(headers2.required, encodeRequirements(requirements));
+          c.header("Content-Type", "application/json");
+          return c.json({ error: `Payment verification failed: ${verifyResult.error}` });
+        }
+      }
+      const payerAddress = extractPayerAddress(payload);
+      const headers = getHeadersForVersion(version);
+      c.set("payment", { payload, payerAddress, version, verified: true });
+      c.header("X-Payment-Verified", "true");
+      c.header("X-Payer-Address", payerAddress);
+      c.header(headers.response, JSON.stringify({ status: "verified", payerAddress, version }));
+      await next();
+    } catch (error) {
+      c.status(400);
+      return c.json({
+        error: "Invalid payment payload",
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  };
+};
+export {
+  acceptPaymentsViaArmory
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@armory-sh/middleware-hono",
+  "version": "0.3.2",
+  "license": "MIT",
+  "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thegreataxios/armory.git",
+    "directory": "packages/middleware-hono"
+  },
+  "peerDependencies": {
+    "hono": "^4"
+  },
+  "dependencies": {
+    "@armory-sh/base": "0.2.4",
+    "@armory-sh/facilitator": "0.2.4"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "typescript": "5.9.3",
+    "hono": "^4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:dts": "tsc --declaration --skipLibCheck",
+    "test": "bun test"
+  }
+}