@armory-sh/middleware-elysia 0.3.11 → 0.3.13

package/dist/index.d.ts

@@ -1,48 +1,52 @@
-import { Context } from 'elysia';
-import { VerifyPaymentOptions } from '@armory-sh/facilitator';
+import { Elysia } from 'elysia';
 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;
+    payload: X402PaymentPayload;
     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>;
-};
+declare const paymentMiddleware: (config: PaymentMiddlewareConfig) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {
+        readonly payment: PaymentInfo | undefined;
+    };
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response | {
+            headers: Record<string, string>;
+        };
+    };
+}>;
 
 export { type PaymentContext, type PaymentInfo, type PaymentMiddlewareConfig, paymentMiddleware };

package/dist/index.js

@@ -1,46 +1,48 @@
+// src/index.ts
+import { Elysia } from "elysia";
+
 // 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;
+import { extractPaymentFromHeaders, PAYMENT_SIGNATURE_HEADER } from "@armory-sh/base";
+var PAYMENT_HEADERS = {
+  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;
+  let isJsonString = false;
   try {
     if (headerValue.startsWith("{")) {
       parsed = JSON.parse(headerValue);
+      isJsonString = true;
     } else {
       parsed = JSON.parse(atob(headerValue));
     }
   } catch {
     throw new Error("Invalid payment payload");
   }
+  const base64Value = isJsonString ? Buffer.from(headerValue).toString("base64") : headerValue;
   const headers = new Headers();
-  headers.set(X402_HEADERS.PAYMENT, headerValue);
+  headers.set(PAYMENT_SIGNATURE_HEADER, base64Value);
   const x402Payload = extractPaymentFromHeaders(headers);
   if (x402Payload) {
-    return { payload: x402Payload, version: 2 };
-  }
-  if (isLegacyV1(parsed)) {
-    return { payload: parsed, version: 1 };
+    return { payload: x402Payload };
   }
   if (isLegacyV2(parsed)) {
-    return { payload: parsed, version: 2 };
+    return { payload: parsed };
   }
   throw new Error("Unrecognized payment payload format");
 };
-var verifyWithFacilitator = async (facilitatorUrl, payload, requirements, verifyOptions) => {
+var verifyWithFacilitator = async (facilitatorUrl, payload, requirements) => {
   try {
     const response = await fetch(`${facilitatorUrl}/verify`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ payload, requirements, options: verifyOptions })
+      body: JSON.stringify({ payload, requirements })
     });
     if (!response.ok) {
       const error = await response.json();
@@ -58,27 +60,19 @@ var verifyWithFacilitator = async (facilitatorUrl, payload, requirements, verify
     };
   }
 };
-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) {
+var verifyLocally = async (payload, requirements) => {
+  if (isLegacyV2(payload)) {
     return {
       success: false,
-      error: JSON.stringify({
-        error: "Payment verification failed",
-        reason: result.error.name,
-        message: result.error.message
-      })
+      error: "Local verification not supported for legacy payload format. Use a facilitator."
     };
   }
-  return { success: true, payerAddress: result.payerAddress };
+  return {
+    success: true,
+    payerAddress: payload.payload.authorization.from
+  };
 };
-var verifyPaymentWithRetry = async (payload, requirements, facilitatorUrl, verifyOptions) => facilitatorUrl ? verifyWithFacilitator(facilitatorUrl, payload, requirements, verifyOptions) : verifyLocally(payload, requirements, verifyOptions);
+var verifyPaymentWithRetry = async (payload, requirements, facilitatorUrl) => facilitatorUrl ? verifyWithFacilitator(facilitatorUrl, payload, requirements) : verifyLocally(payload, requirements);
 var extractPayerAddress = (payload) => {
   if ("payload" in payload) {
     const x402Payload = payload;
@@ -91,11 +85,10 @@ var extractPayerAddress = (payload) => {
   }
   throw new Error("Unable to extract payer address from payload");
 };
-var createResponseHeaders = (payerAddress, version) => ({
-  [getHeadersForVersion(version).response]: JSON.stringify({
+var createResponseHeaders = (payerAddress) => ({
+  [PAYMENT_HEADERS.RESPONSE]: JSON.stringify({
     status: "verified",
-    payerAddress,
-    version
+    payerAddress
   })
 });
 
@@ -105,59 +98,52 @@ var errorResponse = (error, status, headers) => new Response(JSON.stringify(erro
   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) => {
+  const { requirements, facilitatorUrl, skipVerification = false } = config;
+  return new Elysia({ name: "armory-payment" }).derive(() => ({
+    payment: void 0
+  })).onBeforeHandle(async ({ payment, request }) => {
+    try {
+      const paymentHeader = request.headers.get(PAYMENT_HEADERS.PAYMENT);
+      if (!paymentHeader) {
+        return errorResponse(
+          { error: "Payment required", accepts: [requirements] },
+          402,
+          { [PAYMENT_HEADERS.REQUIRED]: encodeRequirements(requirements) }
+        );
+      }
+      let payload;
       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)
-        };
+        ({ payload } = decodePayload(paymentHeader));
       } catch (error) {
         return errorResponse({
-          error: "Payment middleware error",
+          error: "Invalid payment payload",
           message: error instanceof Error ? error.message : "Unknown error"
-        }, 500);
+        }, 400);
+      }
+      const verifyResult = skipVerification ? { success: true, payerAddress: extractPayerAddress(payload) } : await verifyPaymentWithRetry(payload, requirements, facilitatorUrl);
+      if (!verifyResult.success) {
+        return errorResponse(
+          { error: verifyResult.error },
+          402,
+          { [PAYMENT_HEADERS.REQUIRED]: encodeRequirements(requirements) }
+        );
       }
+      const payerAddress = verifyResult.payerAddress;
+      payment = { payload, payerAddress, verified: !skipVerification };
+    } catch (error) {
+      return errorResponse({
+        error: "Payment middleware error",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }, 500);
     }
-  };
+  }).onAfterHandle(({ payment }) => {
+    if (payment) {
+      const { payerAddress } = payment;
+      return {
+        headers: createResponseHeaders(payerAddress)
+      };
+    }
+  });
 };
 export {
   paymentMiddleware

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-elysia",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "type": "module",
@@ -28,8 +28,7 @@
     "elysia": "^1"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.12",
-    "@armory-sh/facilitator": "0.2.12"
+    "@armory-sh/base": "workspace:*"
   },
   "devDependencies": {
     "bun-types": "latest",
@@ -37,7 +36,7 @@
     "elysia": "^1"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "rm -rf dist && tsup",
     "test": "bun test"
   }
 }