@armory-sh/middleware-next 0.1.1

package/README.md

@@ -0,0 +1,110 @@
+# @armory-sh/middleware-next
+
+x402 payment middleware for Next.js App Router.
+
+## Installation
+
+```bash
+bun add @armory-sh/middleware-next
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+// middleware.ts
+import { paymentProxy, x402ResourceServer } from "@armory-sh/middleware-next";
+
+const facilitatorClient = {
+  async verify(headers: Headers) {
+    // Implement verification logic
+    return { success: true, payerAddress: "0x..." };
+  }
+};
+
+const resourceServer = new x402ResourceServer(facilitatorClient);
+
+export const proxy = paymentProxy(
+  {
+    "/api/protected": {
+      accepts: {
+        scheme: "exact",
+        price: "1000000",
+        network: "eip155:8453",
+        payTo: "0x...",
+      },
+      description: "Access to protected API",
+    },
+  },
+  resourceServer
+);
+
+export const config = { matcher: ["/api/protected/:path*"] };
+```
+
+### Per-Route Configuration
+
+```typescript
+export const proxy = paymentProxy(
+  {
+    "/api/basic": {
+      accepts: { scheme: "exact", price: "1000000", network: "eip155:8453", payTo: "0x..." },
+      description: "Basic tier",
+    },
+    "/api/premium": {
+      accepts: { scheme: "exact", price: "50000000", network: "eip155:8453", payTo: "0x..." },
+      description: "Premium tier",
+    },
+  },
+  resourceServer
+);
+```
+
+### With Facilitator Settlement
+
+```typescript
+const facilitatorClient = {
+  async verify(headers: Headers) {
+    const response = await fetch("https://facilitator.com/verify", {
+      headers: Object.fromEntries(headers.entries()),
+    });
+    return response.json();
+  },
+  async settle(headers: Headers) {
+    const response = await fetch("https://facilitator.com/settle", {
+      method: "POST",
+      headers: Object.fromEntries(headers.entries()),
+    });
+    return response.json();
+  },
+};
+```
+
+## Route Patterns
+
+- Exact match: `/api/users`
+- Wildcard: `/api/*` (matches `/api/users`, `/api/posts/123`)
+- Next.js style: `/protected/:path*` (matches `/protected/foo/bar`)
+
+## API
+
+### `paymentProxy(routes, resourceServer)`
+
+Creates a payment proxy handler for Next.js middleware.
+
+**Parameters:**
+- `routes`: Record mapping route patterns to payment config
+- `resourceServer`: x402ResourceServer instance
+
+**Returns:** Next.js middleware function
+
+### `x402ResourceServer`
+
+Registers and manages payment schemes.
+
+**Methods:**
+- `register(chainId, scheme)`: Register a payment scheme
+- `getRequirements(chainId)`: Get requirements for a chain
+- `getAllRequirements()`: Get all registered requirements
+- `getFacilitator()`: Get the facilitator client

package/dist/index.js

@@ -0,0 +1,127 @@
+// src/resource-server.ts
+var x402ResourceServer = class {
+  facilitator;
+  schemes;
+  constructor(facilitatorClient) {
+    this.facilitator = facilitatorClient;
+    this.schemes = /* @__PURE__ */ new Map();
+  }
+  register(chainId, scheme) {
+    this.schemes.set(chainId, scheme);
+    return this;
+  }
+  getRequirements(chainId) {
+    const scheme = this.schemes.get(chainId);
+    if (!scheme) {
+      throw new Error(`No scheme registered for chain: ${chainId}`);
+    }
+    return scheme.getRequirements();
+  }
+  getAllRequirements() {
+    return Array.from(this.schemes.values()).map((s) => s.getRequirements());
+  }
+  getFacilitator() {
+    return this.facilitator;
+  }
+};
+
+// src/proxy.ts
+import {
+  safeBase64Encode,
+  V2_HEADERS,
+  findMatchingRoute
+} from "@armory-sh/base";
+function paymentProxy(routes, resourceServer) {
+  const routeConfigs = Object.entries(routes).map(
+    ([pattern, config]) => ({ pattern, config })
+  );
+  return async (request) => {
+    const path = new URL(request.url).pathname;
+    const matchedRoute = findMatchingRoute(routeConfigs, path);
+    if (!matchedRoute) {
+      return new Response(
+        JSON.stringify({ error: "Route not found" }),
+        { status: 404, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    const paymentHeader = request.headers.get(V2_HEADERS.PAYMENT_SIGNATURE);
+    if (!paymentHeader) {
+      const config = matchedRoute.config;
+      const resource = {
+        url: request.url,
+        description: config.description || "API Access",
+        mimeType: "application/json"
+      };
+      const paymentRequired = {
+        x402Version: 2,
+        error: "Payment required",
+        resource,
+        accepts: [
+          {
+            scheme: config.accepts.scheme,
+            network: config.accepts.network,
+            amount: config.accepts.price,
+            asset: config.accepts.payTo,
+            payTo: config.accepts.payTo,
+            maxTimeoutSeconds: 300,
+            extra: {}
+          }
+        ]
+      };
+      return new Response(
+        JSON.stringify({
+          error: "Payment required",
+          accepts: paymentRequired.accepts
+        }),
+        {
+          status: 402,
+          headers: {
+            "Content-Type": "application/json",
+            [V2_HEADERS.PAYMENT_REQUIRED]: safeBase64Encode(
+              JSON.stringify(paymentRequired)
+            )
+          }
+        }
+      );
+    }
+    const facilitator = resourceServer.getFacilitator();
+    const verifyResult = await facilitator.verify(request.headers);
+    if (!verifyResult.success) {
+      return new Response(
+        JSON.stringify({
+          error: "Payment verification failed",
+          details: verifyResult.error
+        }),
+        { status: 402, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    return new Response(
+      JSON.stringify({
+        verified: true,
+        payerAddress: verifyResult.payerAddress
+      }),
+      {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Payment-Verified": "true",
+          "X-Payer-Address": verifyResult.payerAddress || ""
+        }
+      }
+    );
+  };
+}
+
+// src/middleware.ts
+function createMiddleware(routes, resourceServer) {
+  const proxy = paymentProxy(routes, resourceServer);
+  return async (request) => {
+    const response = await proxy(request);
+    return NextResponse.json(await response.json(), { status: response.status });
+  };
+}
+export {
+  createMiddleware,
+  paymentProxy,
+  x402ResourceServer
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@armory-sh/middleware-next",
+  "version": "0.1.1",
+  "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-next"
+  },
+  "peerDependencies": {
+    "next": ">=13"
+  },
+  "dependencies": {
+    "@armory-sh/base": "0.2.20"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "next": "latest",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsup",
+    "build:dts": "rm -rf dist && tsc --emitDeclarationOnly",
+    "test": "bun test"
+  }
+}