@foldset/cloudflare 0.0.1

package/README.md

@@ -0,0 +1 @@
+# Typescript library for foldset?

package/dist/adapter.d.ts

@@ -0,0 +1,71 @@
+import { HTTPAdapter } from "@x402/core/server";
+import { Context } from "hono";
+/**
+ * Hono adapter implementation
+ */
+export declare class HonoAdapter implements HTTPAdapter {
+    private c;
+    /**
+     * Creates a new HonoAdapter instance.
+     *
+     * @param c - The Hono context object
+     */
+    constructor(c: Context);
+    /**
+     * Gets a header value from the request.
+     *
+     * @param name - The header name
+     * @returns The header value or undefined
+     */
+    getHeader(name: string): string | undefined;
+    /**
+     * Gets the HTTP method of the request.
+     *
+     * @returns The HTTP method
+     */
+    getMethod(): string;
+    /**
+     * Gets the path of the request.
+     *
+     * @returns The request path
+     */
+    getPath(): string;
+    /**
+     * Gets the full URL of the request.
+     *
+     * @returns The full request URL
+     */
+    getUrl(): string;
+    /**
+     * Gets the Accept header from the request.
+     *
+     * @returns The Accept header value or empty string
+     */
+    getAcceptHeader(): string;
+    /**
+     * Gets the User-Agent header from the request.
+     *
+     * @returns The User-Agent header value or empty string
+     */
+    getUserAgent(): string;
+    /**
+     * Gets all query parameters from the request URL.
+     *
+     * @returns Record of query parameter key-value pairs
+     */
+    getQueryParams(): Record<string, string | string[]>;
+    /**
+     * Gets a specific query parameter by name.
+     *
+     * @param name - The query parameter name
+     * @returns The query parameter value(s) or undefined
+     */
+    getQueryParam(name: string): string | string[] | undefined;
+    /**
+     * Gets the parsed request body.
+     * Requires appropriate body parsing middleware.
+     *
+     * @returns The parsed request body
+     */
+    getBody(): Promise<unknown>;
+}

package/dist/adapter.js

@@ -0,0 +1,99 @@
+/**
+ * Hono adapter implementation
+ */
+export class HonoAdapter {
+    /**
+     * Creates a new HonoAdapter instance.
+     *
+     * @param c - The Hono context object
+     */
+    constructor(c) {
+        this.c = c;
+    }
+    /**
+     * Gets a header value from the request.
+     *
+     * @param name - The header name
+     * @returns The header value or undefined
+     */
+    getHeader(name) {
+        return this.c.req.header(name);
+    }
+    /**
+     * Gets the HTTP method of the request.
+     *
+     * @returns The HTTP method
+     */
+    getMethod() {
+        return this.c.req.method;
+    }
+    /**
+     * Gets the path of the request.
+     *
+     * @returns The request path
+     */
+    getPath() {
+        return this.c.req.path;
+    }
+    /**
+     * Gets the full URL of the request.
+     *
+     * @returns The full request URL
+     */
+    getUrl() {
+        return this.c.req.url;
+    }
+    /**
+     * Gets the Accept header from the request.
+     *
+     * @returns The Accept header value or empty string
+     */
+    getAcceptHeader() {
+        return this.c.req.header("Accept") || "";
+    }
+    /**
+     * Gets the User-Agent header from the request.
+     *
+     * @returns The User-Agent header value or empty string
+     */
+    getUserAgent() {
+        return this.c.req.header("User-Agent") || "";
+    }
+    /**
+     * Gets all query parameters from the request URL.
+     *
+     * @returns Record of query parameter key-value pairs
+     */
+    getQueryParams() {
+        const query = this.c.req.query();
+        // Convert single values to match the interface
+        const result = {};
+        for (const [key, value] of Object.entries(query)) {
+            result[key] = value;
+        }
+        return result;
+    }
+    /**
+     * Gets a specific query parameter by name.
+     *
+     * @param name - The query parameter name
+     * @returns The query parameter value(s) or undefined
+     */
+    getQueryParam(name) {
+        return this.c.req.query(name);
+    }
+    /**
+     * Gets the parsed request body.
+     * Requires appropriate body parsing middleware.
+     *
+     * @returns The parsed request body
+     */
+    async getBody() {
+        try {
+            return await this.c.req.json();
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { Hono, type MiddlewareHandler } from 'hono';
+import { PaywallConfig, PaywallProvider, x402ResourceServer } from '@x402/hono';
+import type { RoutesConfig } from '@x402/core/http';
+type Env = {
+    FOLDSET_API_KEY: string;
+};
+/**
+ * Hono payment middleware for x402 protocol (direct server instance).
+ *
+ * Use this when you want to pass a pre-configured x402ResourceServer instance.
+ * This provides more flexibility for testing, custom configuration, and reusing
+ * server instances across multiple middlewares.
+ *
+ * @param routes - Route configurations for protected endpoints
+ * @param server - Pre-configured x402ResourceServer instance
+ * @param paywallConfig - Optional configuration for the built-in paywall UI
+ * @param paywall - Optional custom paywall provider (overrides default)
+ * @param syncFacilitatorOnStart - Whether to sync with the facilitator on startup (defaults to true)
+ * @returns Hono middleware handler
+ *
+ * @example
+ * ```typescript
+ * import { paymentMiddleware } from "@x402/hono";
+ * import { x402ResourceServer } from "@x402/core/server";
+ * import { registerExactEvmScheme } from "@x402/evm/exact/server";
+ *
+ * const server = new x402ResourceServer(myFacilitatorClient);
+ * registerExactEvmScheme(server, {});
+ *
+ * app.use(paymentMiddleware(routes, server, paywallConfig));
+ * ```
+ */
+export declare function paymentMiddleware(routes: RoutesConfig, server: x402ResourceServer, paywallConfig?: PaywallConfig, paywall?: PaywallProvider, syncFacilitatorOnStart?: boolean): MiddlewareHandler;
+declare const app: Hono<{
+    Bindings: Env;
+}, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/index.js

@@ -0,0 +1,237 @@
+// TODO rfradkin: Make a lot of these types not just functions
+import { Hono } from 'hono';
+import { x402ResourceServer, x402HTTPResourceServer } from '@x402/hono';
+import { registerExactEvmScheme } from '@x402/evm/exact/server';
+import { HTTPFacilitatorClient } from '@x402/core/server';
+import pMemoize from 'p-memoize';
+import { HonoAdapter } from './adapter';
+async function _fetchFoldsetAPI(endpoint, env) {
+    const res = await fetch(`https://api.foldset.com/v1/${endpoint}`, {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${env.FOLDSET_API_KEY}`,
+            Accept: 'application/json',
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Foldset API (${endpoint}) failed: ${res.status}`);
+    }
+    return (await res.json());
+}
+const cacheTTL = 60000; // 60 seconds
+// This is an in memory cache. Cloudflare also has a cache but it is not
+// in memory, so it would survive cold starts (this won't). I think in-memory
+// makes more sense here for now.
+// TODO rfradkin: Also make sure this caching works, didn't test it
+const fetchFoldsetAPI = pMemoize(_fetchFoldsetAPI, {
+    maxAge: cacheTTL,
+    cacheKey: ([endpoint]) => endpoint,
+});
+async function getRestrictions(env) {
+    const restrictionList = await fetchFoldsetAPI('restrictions', env);
+    const restrictions = {};
+    for (const restriction of restrictionList) {
+        restrictions[restriction.pathname] = restriction.price;
+    }
+    return restrictions;
+}
+async function getEVMAddress(env) {
+    const data = await fetchFoldsetAPI('get-address', env);
+    return data.address;
+}
+// TODO rfradkin: Add metadata for bazaar finding
+// https://x402.gitbook.io/x402/getting-started/quickstart-for-sellers
+function buildRoutesConfig(restrictions, payTo) {
+    const routesConfig = {};
+    for (const [pathname, price] of Object.entries(restrictions)) {
+        routesConfig[pathname] = {
+            accepts: [
+                {
+                    scheme: 'exact',
+                    price: `$${price}`,
+                    network: 'eip155:84532',
+                    payTo,
+                },
+            ],
+            description: 'Access to premium content',
+            mimeType: 'application/json',
+        };
+    }
+    return routesConfig;
+}
+let server = null;
+// Right now, load times are like 800ms, which is pretty slow since
+// static site is 200ms. Look into later, this call probably takes most of the time.
+// This is like this cause can'd do async calls at module level in cloudflare
+function getServer() {
+    if (!server) {
+        // TODO rfradkin: Hard coded for now but consider making it configurable
+        const facilitatorClient = new HTTPFacilitatorClient({
+            url: 'https://x402.org/facilitator',
+        });
+        server = new x402ResourceServer(facilitatorClient);
+        registerExactEvmScheme(server);
+    }
+    return server;
+}
+/**
+ * Hono payment middleware for x402 protocol (direct server instance).
+ *
+ * Use this when you want to pass a pre-configured x402ResourceServer instance.
+ * This provides more flexibility for testing, custom configuration, and reusing
+ * server instances across multiple middlewares.
+ *
+ * @param routes - Route configurations for protected endpoints
+ * @param server - Pre-configured x402ResourceServer instance
+ * @param paywallConfig - Optional configuration for the built-in paywall UI
+ * @param paywall - Optional custom paywall provider (overrides default)
+ * @param syncFacilitatorOnStart - Whether to sync with the facilitator on startup (defaults to true)
+ * @returns Hono middleware handler
+ *
+ * @example
+ * ```typescript
+ * import { paymentMiddleware } from "@x402/hono";
+ * import { x402ResourceServer } from "@x402/core/server";
+ * import { registerExactEvmScheme } from "@x402/evm/exact/server";
+ *
+ * const server = new x402ResourceServer(myFacilitatorClient);
+ * registerExactEvmScheme(server, {});
+ *
+ * app.use(paymentMiddleware(routes, server, paywallConfig));
+ * ```
+ */
+export function paymentMiddleware(routes, server, paywallConfig, paywall, syncFacilitatorOnStart = true) {
+    // Create the x402 HTTP server instance with the resource server
+    const httpServer = new x402HTTPResourceServer(server, routes);
+    // Register custom paywall provider if provided
+    if (paywall) {
+        httpServer.registerPaywallProvider(paywall);
+    }
+    // Store initialization promise (not the result)
+    // httpServer.initialize() fetches facilitator support and validates routes
+    let initPromise = syncFacilitatorOnStart ? httpServer.initialize() : null;
+    // TODO rfradkin: Add bazaar extension
+    // // Dynamically register bazaar extension if routes declare it
+    // let bazaarPromise: Promise<void> | null = null;
+    // if (checkIfBazaarNeeded(routes)) {
+    //   bazaarPromise = import("@x402/extensions/bazaar")
+    //     .then(({ bazaarResourceServerExtension }) => {
+    //       server.registerExtension(bazaarResourceServerExtension);
+    //     })
+    //     .catch(err => {
+    //       console.error("Failed to load bazaar extension:", err);
+    //     });
+    // }
+    return async (c, next) => {
+        // Create adapter and context
+        const adapter = new HonoAdapter(c);
+        const context = {
+            adapter,
+            path: c.req.path,
+            method: c.req.method,
+            paymentHeader: adapter.getHeader("payment-signature") || adapter.getHeader("x-payment"),
+        };
+        // Check if route requires payment before initializing facilitator
+        if (!httpServer.requiresPayment(context)) {
+            return next();
+        }
+        // Only initialize when processing a protected route
+        if (initPromise) {
+            await initPromise;
+            initPromise = null; // Clear after first await
+        }
+        // // Await bazaar extension loading if needed
+        // if (bazaarPromise) {
+        //   await bazaarPromise;
+        //   bazaarPromise = null;
+        // }
+        // Process payment requirement check
+        const result = await httpServer.processHTTPRequest(context, paywallConfig);
+        // Handle the different result types
+        switch (result.type) {
+            case "no-payment-required":
+                // No payment needed, proceed directly to the route handler
+                return next();
+            case "payment-error":
+                // Payment required but not provided or invalid
+                const { response } = result;
+                Object.entries(response.headers).forEach(([key, value]) => {
+                    c.header(key, value);
+                });
+                if (response.isHtml) {
+                    return c.html(response.body, response.status);
+                }
+                else {
+                    return c.json(response.body || {}, response.status);
+                }
+            case "payment-verified":
+                // Payment is valid, need to wrap response for settlement
+                const { paymentPayload, paymentRequirements } = result;
+                // Proceed to the next middleware or route handler
+                await next();
+                // Get the current response
+                let res = c.res;
+                // If the response from the protected route is >= 400, do not settle payment
+                if (res.status >= 400) {
+                    return;
+                }
+                // Clear the response so we can modify headers
+                c.res = undefined;
+                try {
+                    const settleResult = await httpServer.processSettlement(paymentPayload, paymentRequirements);
+                    if (!settleResult.success) {
+                        // Settlement failed - do not return the protected resource
+                        res = c.json({
+                            error: "Settlement failed",
+                            details: settleResult.errorReason,
+                        }, 402);
+                    }
+                    else {
+                        // Settlement succeeded - add headers to response
+                        Object.entries(settleResult.headers).forEach(([key, value]) => {
+                            res.headers.set(key, value);
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                    // If settlement fails, return an error response
+                    res = c.json({
+                        error: "Settlement failed",
+                        details: error instanceof Error ? error.message : "Unknown error",
+                    }, 402);
+                }
+                // Restore the response (potentially modified with settlement headers)
+                c.res = res;
+                return;
+        }
+    };
+}
+const app = new Hono();
+// TODO rfradkin: This is still potentially quite slow since it is getting
+// each of these on each request regardless of whether the request is in
+// the restrictions or not. Should find a better solution down the road
+app.use('*', async (c, next) => {
+    const [restrictions, payTo, server] = await Promise.all([
+        getRestrictions(c.env),
+        getEVMAddress(c.env),
+        getServer(),
+    ]);
+    const config = buildRoutesConfig(restrictions, payTo);
+    return paymentMiddleware(config, server)(c, next);
+});
+app.all('*', async (c) => {
+    const req = c.req.raw;
+    const resp = await fetch(req);
+    // This is cause the payment middleware needs to modify the headers to add the payment status
+    // (since it tags the data response after the request with settlement related headers)
+    // (ie success or failure)
+    // and the fetch headers returned by cloudlflare is immutable, so causes an issue
+    // TODO rfradkin: This could be cleaned up and made nicer, but works for now
+    return new Response(resp.body, {
+        status: resp.status,
+        statusText: resp.statusText,
+        headers: new Headers(resp.headers),
+    });
+});
+export default app;

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export type Price = number;
+export type Pathname = string;
+export type Restriction = {
+    price: Price;
+    pathname: Pathname;
+};
+export type Restrictions = Record<Pathname, Price>;
+export type AddressResponse = {
+    address: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@foldset/cloudflare",
+  "version": "0.0.1",
+  "description": "SDK for creating Foldset-enabled Cloudflare Workers",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "foldset",
+    "cloudflare",
+    "workers",
+    "x402"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@x402/core": "^2.1.0",
+    "@x402/evm": "^2.1.0",
+    "@x402/hono": "^2.1.0",
+    "hono": "^4.11.3",
+    "p-memoize": "^8.0.0"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}