@armory-sh/middleware-elysia 0.3.2

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import { Context } from 'elysia';
+import { VerifyPaymentOptions } from '@armory-sh/facilitator';
+import { X402PaymentPayload, X402PaymentRequirements } from '@armory-sh/base';
+
+interface LegacyPaymentPayloadV1 {
+    amount: string;
+    network: string;
+    contractAddress: string;
+    payTo: string;
+    from: string;
+    expiry: number;
+    signature: string;
+}
+interface LegacyPaymentPayloadV2 {
+    to: string;
+    from: string;
+    amount: string;
+    chainId: string;
+    assetId: string;
+    nonce: string;
+    expiry: number;
+    signature: string;
+}
+type AnyPaymentPayload = X402PaymentPayload | LegacyPaymentPayloadV1 | LegacyPaymentPayloadV2;
+type PaymentPayload = AnyPaymentPayload;
+
+interface PaymentMiddlewareConfig {
+    requirements: X402PaymentRequirements;
+    facilitatorUrl?: string;
+    verifyOptions?: VerifyPaymentOptions;
+    skipVerification?: boolean;
+}
+interface PaymentInfo {
+    payload: PaymentPayload;
+    payerAddress: string;
+    version: 1 | 2;
+    verified: boolean;
+}
+interface PaymentContext {
+    payment: PaymentInfo;
+}
+declare const paymentMiddleware: (config: PaymentMiddlewareConfig) => {
+    beforeHandle: (context: Context & {
+        store: Record<string, unknown>;
+    }) => Promise<unknown>;
+};
+
+export { type PaymentContext, type PaymentInfo, type PaymentMiddlewareConfig, paymentMiddleware };

package/dist/index.js

@@ -0,0 +1,164 @@
+// 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 getRequirementsVersion = (requirements) => "contractAddress" in requirements && "network" in requirements ? 1 : 2;
+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 verifyWithFacilitator = async (facilitatorUrl, payload, requirements, verifyOptions) => {
+  try {
+    const response = await fetch(`${facilitatorUrl}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ payload, requirements, options: verifyOptions })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      return { success: false, error: JSON.stringify(error) };
+    }
+    const result = await response.json();
+    if (!result.success) {
+      return { success: false, error: result.error ?? "Verification failed" };
+    }
+    return { success: true, payerAddress: result.payerAddress ?? "" };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown facilitator error"
+    };
+  }
+};
+var verifyLocally = async (payload, requirements, verifyOptions) => {
+  if (isLegacyV1(payload) || isLegacyV2(payload)) {
+    return {
+      success: false,
+      error: "Local verification not supported for legacy payload formats. Use a facilitator."
+    };
+  }
+  const result = await verifyPayment(payload, requirements, verifyOptions);
+  if (!result.success) {
+    return {
+      success: false,
+      error: JSON.stringify({
+        error: "Payment verification failed",
+        reason: result.error.name,
+        message: result.error.message
+      })
+    };
+  }
+  return { success: true, payerAddress: result.payerAddress };
+};
+var verifyPaymentWithRetry = async (payload, requirements, facilitatorUrl, verifyOptions) => facilitatorUrl ? verifyWithFacilitator(facilitatorUrl, payload, requirements, verifyOptions) : verifyLocally(payload, requirements, verifyOptions);
+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");
+};
+var createResponseHeaders = (payerAddress, version) => ({
+  [getHeadersForVersion(version).response]: JSON.stringify({
+    status: "verified",
+    payerAddress,
+    version
+  })
+});
+
+// src/index.ts
+var errorResponse = (error, status, headers) => new Response(JSON.stringify(error), {
+  status,
+  headers: { "Content-Type": "application/json", ...headers }
+});
+var paymentMiddleware = (config) => {
+  const { requirements, facilitatorUrl, verifyOptions, skipVerification = false } = config;
+  const version = getRequirementsVersion(requirements);
+  const headers = getHeadersForVersion(version);
+  return {
+    beforeHandle: async (context) => {
+      try {
+        const paymentHeader = context.request.headers.get(headers.payment);
+        if (!paymentHeader) {
+          return errorResponse(
+            { error: "Payment required", requirements },
+            402,
+            { [headers.required]: encodeRequirements(requirements) }
+          );
+        }
+        let payload;
+        let payloadVersion;
+        try {
+          ({ payload, version: payloadVersion } = decodePayload(paymentHeader));
+        } catch (error) {
+          return errorResponse({
+            error: "Invalid payment payload",
+            message: error instanceof Error ? error.message : "Unknown error"
+          }, 400);
+        }
+        if (payloadVersion !== version) {
+          return errorResponse({
+            error: "Payment version mismatch",
+            expected: version,
+            received: payloadVersion
+          }, 400);
+        }
+        const verifyResult = skipVerification ? { success: true, payerAddress: extractPayerAddress(payload) } : await verifyPaymentWithRetry(payload, requirements, facilitatorUrl, verifyOptions);
+        if (!verifyResult.success) {
+          return errorResponse(
+            { error: verifyResult.error },
+            402,
+            { [headers.required]: encodeRequirements(requirements) }
+          );
+        }
+        const payerAddress = verifyResult.payerAddress;
+        context.store.payment = { payload, payerAddress, version, verified: !skipVerification };
+        context.set.headers = {
+          ...context.set.headers,
+          ...createResponseHeaders(payerAddress, version)
+        };
+      } catch (error) {
+        return errorResponse({
+          error: "Payment middleware error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        }, 500);
+      }
+    }
+  };
+};
+export {
+  paymentMiddleware
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@armory-sh/middleware-elysia",
+  "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-elysia"
+  },
+  "peerDependencies": {
+    "elysia": "^1"
+  },
+  "dependencies": {
+    "@armory-sh/base": "0.2.4",
+    "@armory-sh/facilitator": "0.2.4"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "typescript": "5.9.3",
+    "elysia": "^1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "bun test"
+  }
+}