@armory-sh/middleware-hono 0.3.9 → 0.3.11

package/dist/index.d.ts

@@ -1,8 +1,25 @@
 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';
 
+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"
@@ -41,6 +58,44 @@ declare const acceptPaymentsViaArmory: (config: SimpleMiddlewareConfig & {
     defaultVersion?: 1 | 2;
 }) => (c: Context, next: Next) => Promise<(Response & hono.TypedResponse<{
     error: string;
+    x402Version: number;
+    requirements: {
+        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 };

package/dist/index.js

@@ -1,3 +1,9 @@
+// src/index.ts
+import {
+  V1_HEADERS as V1_HEADERS2,
+  V2_HEADERS as V2_HEADERS2
+} from "@armory-sh/base";
+
 // src/simple.ts
 import {
   resolveNetwork,
@@ -11,8 +17,12 @@ import {
 import {
   getNetworkConfig,
   getNetworkByChainId,
-  encodePaymentPayload,
-  normalizeNetworkName
+  normalizeNetworkName,
+  encodeX402PaymentRequiredV1,
+  encodeX402SettlementResponseV1,
+  safeBase64Encode,
+  V1_HEADERS,
+  V2_HEADERS
 } from "@armory-sh/base";
 var toSlug = (network) => {
   if (typeof network === "number") {
@@ -21,7 +31,9 @@ var toSlug = (network) => {
     return normalizeNetworkName(net.name);
   }
   if (network.startsWith("eip155:")) {
-    const chainId = parseInt(network.split(":")[1], 10);
+    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);
@@ -46,37 +58,62 @@ var toEip155 = (network) => {
 };
 var getNetworkName = (network) => toSlug(network);
 var getChainId = (network) => toEip155(network);
-var createV1Requirements = (config, expiry) => {
+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 {
-    amount: config.amount,
+    scheme: "exact",
     network: networkName,
-    contractAddress: network.usdcAddress,
+    maxAmountRequired: atomicAmount,
+    asset: network.usdcAddress,
     payTo: config.payTo,
-    expiry
+    resource: resourceUrl,
+    description: "API Access",
+    mimeType: "application/json",
+    maxTimeoutSeconds: 300,
+    extra: {
+      name: "USDC",
+      version: "2"
+    }
   };
 };
-var createV2Requirements = (config, expiry) => {
+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 {
-    amount: config.amount,
-    to: config.payTo,
-    chainId: getChainId(config.network),
-    assetId: network.caipAssetId,
-    nonce: `${Date.now()}-${crypto.randomUUID()}`,
-    expiry
+    scheme: "exact",
+    network: getChainId(config.network),
+    amount: atomicAmount,
+    asset,
+    payTo: config.payTo,
+    maxTimeoutSeconds: 300,
+    extra: {
+      name: "USDC",
+      version: "2"
+    }
   };
 };
-var createPaymentRequirements = (config, version = 1) => {
+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, expiry) : createV2Requirements(config, expiry);
+  return version === 1 ? createV1Requirements(config, resourceUrl, expiry) : createV2Requirements(config, resourceUrl);
 };
 var findHeaderValue = (headers, name) => {
   const value = headers[name];
@@ -140,6 +177,58 @@ var verifyWithFacilitator = async (request, facilitator) => {
     };
   }
 };
+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) => {
@@ -211,7 +300,6 @@ var getPrimaryConfig = (resolved) => {
 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) => Buffer.from(JSON.stringify(requirements)).toString("base64");
 function isLegacyV1(payload) {
   return typeof payload === "object" && payload !== null && "contractAddress" in payload && "network" in payload && "signature" in payload && typeof payload.signature === "string";
 }
@@ -269,37 +357,74 @@ var acceptPaymentsViaArmory = (config) => {
   }
   const primaryConfig = getPrimaryConfig(resolved);
   const defaultVersion = config.defaultVersion ?? 2;
-  const createRequirements = (version) => createPaymentRequirements(primaryConfig, version);
+  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 }
+    );
+  };
   return async (c, next) => {
-    const paymentHeader = c.req.header("X-Payment") || c.req.header("x402-payment");
+    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;
     if (!paymentHeader) {
       const version = defaultVersion === 1 ? 1 : 2;
-      const requirements = createRequirements(version);
-      const headers = getHeadersForVersion(version);
+      const requirements = createRequirementsForVersion(version, resourceUrl);
+      const headers = createPaymentRequiredResponse(version, requirements, resourceUrl);
       c.status(402);
-      c.header(headers.required, encodeRequirements(requirements));
-      c.header("Content-Type", "application/json");
-      return c.json({ error: "Payment required", requirements });
+      for (const [key, value] of Object.entries(headers)) {
+        c.header(key, value);
+      }
+      return c.json({
+        error: "Payment required",
+        x402Version: version,
+        requirements
+      });
     }
     try {
       const { payload, version } = decodePayload(paymentHeader);
       if (primaryConfig.facilitator) {
         const verifyResult = await verifyWithFacilitator(toHttpRequest(c), primaryConfig.facilitator);
         if (!verifyResult.success) {
-          const requirements = createRequirements(version);
-          const headers2 = getHeadersForVersion(version);
+          const requirements = createRequirementsForVersion(version, resourceUrl);
+          const headers = createPaymentRequiredResponse(
+            version,
+            requirements,
+            resourceUrl,
+            `Payment verification failed: ${verifyResult.error}`
+          );
           c.status(402);
-          c.header(headers2.required, encodeRequirements(requirements));
-          c.header("Content-Type", "application/json");
-          return c.json({ error: `Payment verification failed: ${verifyResult.error}` });
+          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 headers = getHeadersForVersion(version);
+      const responseHeaders = 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 }));
+      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) {
       c.status(400);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-hono",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -28,8 +28,8 @@
     "hono": "^4"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.9",
-    "@armory-sh/facilitator": "0.2.9"
+    "@armory-sh/base": "0.2.12",
+    "@armory-sh/facilitator": "0.2.12"
   },
   "devDependencies": {
     "bun-types": "latest",