@foldset/core 0.1.0

package/dist/api.d.ts

@@ -0,0 +1,5 @@
+import type { ApiRestriction, PaymentMethod, ProcessRequestResult } from "./types";
+export declare function formatApiPaymentError(result: Extract<ProcessRequestResult, {
+    type: "payment-error";
+}>, restriction: ApiRestriction, paymentMethods: PaymentMethod[], termsOfServiceUrl?: string): void;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEnF,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,CAAC,oBAAoB,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC,EAChE,WAAW,EAAE,cAAc,EAC3B,cAAc,EAAE,aAAa,EAAE,EAC/B,iBAAiB,CAAC,EAAE,MAAM,GACzB,IAAI,CAiBN"}

package/dist/api.js

@@ -0,0 +1,18 @@
+export function formatApiPaymentError(result, restriction, paymentMethods, termsOfServiceUrl) {
+    result.response.body = JSON.stringify({
+        error: "payment_required",
+        ...result.metadata,
+        message: restriction.description,
+        price: restriction.price,
+        ...(termsOfServiceUrl && { terms_of_service_url: termsOfServiceUrl }),
+        payment_methods: paymentMethods.map((pm) => ({
+            network: pm.caip2_id,
+            asset: pm.contract_address,
+            decimals: pm.decimals,
+            pay_to: pm.circle_wallet_address,
+            chain: pm.chain_display_name,
+            asset_name: pm.asset_display_name,
+        })),
+    });
+    result.response.headers["Content-Type"] = "application/json";
+}

package/dist/config.d.ts

@@ -0,0 +1,36 @@
+import { HTTPFacilitatorClient } from "@x402/core/server";
+import type { Bot, ConfigStore, HostConfig, PaymentMethod, ProcessRequestResult, RequestMetadata, Restriction } from "./types";
+export declare const CACHE_TTL_MS = 30000;
+export declare const API_BASE_URL = "https://api.foldset.com";
+export declare function buildRequestMetadata(): RequestMetadata;
+export declare function noPaymentRequired(metadata: RequestMetadata): ProcessRequestResult;
+export declare class CachedConfigManager<T> {
+    protected configStore: ConfigStore;
+    protected key: string;
+    protected fallback: T;
+    protected cached: T;
+    protected cacheTimestamp: number;
+    constructor(configStore: ConfigStore, key: string, fallback: T);
+    protected isCacheValid(): boolean;
+    protected deserialize(raw: string): T;
+    get(): Promise<T>;
+}
+export declare class HostConfigManager extends CachedConfigManager<HostConfig | null> {
+    constructor(store: ConfigStore);
+}
+export declare class RestrictionsManager extends CachedConfigManager<Restriction[]> {
+    constructor(store: ConfigStore);
+}
+export declare class PaymentMethodsManager extends CachedConfigManager<PaymentMethod[]> {
+    constructor(store: ConfigStore);
+}
+export declare class BotsManager extends CachedConfigManager<Bot[]> {
+    constructor(store: ConfigStore);
+    protected deserialize(raw: string): Bot[];
+    matchBot(userAgent: string): Promise<Bot | null>;
+}
+export declare class FacilitatorManager extends CachedConfigManager<HTTPFacilitatorClient | null> {
+    constructor(store: ConfigStore);
+    protected deserialize(raw: string): HTTPFacilitatorClient;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAK1D,OAAO,KAAK,EACV,GAAG,EACH,WAAW,EAEX,UAAU,EACV,aAAa,EACb,oBAAoB,EACpB,eAAe,EACf,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,YAAY,QAAS,CAAC;AAEnC,eAAO,MAAM,YAAY,4BAA4B,CAAC;AAEtD,wBAAgB,oBAAoB,IAAI,eAAe,CAMtD;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,GAAG,oBAAoB,CAEjF;AAED,qBAAa,mBAAmB,CAAC,CAAC;IAK9B,SAAS,CAAC,WAAW,EAAE,WAAW;IAClC,SAAS,CAAC,GAAG,EAAE,MAAM;IACrB,SAAS,CAAC,QAAQ,EAAE,CAAC;IANvB,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;IACpB,SAAS,CAAC,cAAc,SAAK;gBAGjB,WAAW,EAAE,WAAW,EACxB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,CAAC;IAKvB,SAAS,CAAC,YAAY,IAAI,OAAO;IAIjC,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC;IAI/B,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;CAOxB;AAED,qBAAa,iBAAkB,SAAQ,mBAAmB,CAAC,UAAU,GAAG,IAAI,CAAC;gBAC/D,KAAK,EAAE,WAAW;CAG/B;AAED,qBAAa,mBAAoB,SAAQ,mBAAmB,CAAC,WAAW,EAAE,CAAC;gBAC7D,KAAK,EAAE,WAAW;CAG/B;AAED,qBAAa,qBAAsB,SAAQ,mBAAmB,CAAC,aAAa,EAAE,CAAC;gBACjE,KAAK,EAAE,WAAW;CAG/B;AAED,qBAAa,WAAY,SAAQ,mBAAmB,CAAC,GAAG,EAAE,CAAC;gBAC7C,KAAK,EAAE,WAAW;cAIX,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE;IAK5C,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC;CAKvD;AAED,qBAAa,kBAAmB,SAAQ,mBAAmB,CAAC,qBAAqB,GAAG,IAAI,CAAC;gBAC3E,KAAK,EAAE,WAAW;cAIX,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB;CAiBnE"}

package/dist/config.js

@@ -0,0 +1,90 @@
+import { HTTPFacilitatorClient } from "@x402/core/server";
+import packageJson from "../package.json" with { type: "json" };
+const PACKAGE_VERSION = packageJson.version;
+export const CACHE_TTL_MS = 30_000;
+export const API_BASE_URL = "https://api.foldset.com";
+export function buildRequestMetadata() {
+    return {
+        version: PACKAGE_VERSION,
+        request_id: crypto.randomUUID(),
+        timestamp: new Date().toISOString(),
+    };
+}
+export function noPaymentRequired(metadata) {
+    return { type: "no-payment-required", metadata };
+}
+export class CachedConfigManager {
+    configStore;
+    key;
+    fallback;
+    cached;
+    cacheTimestamp = 0;
+    constructor(configStore, key, fallback) {
+        this.configStore = configStore;
+        this.key = key;
+        this.fallback = fallback;
+        this.cached = fallback;
+    }
+    isCacheValid() {
+        return this.cacheTimestamp > 0 && Date.now() - this.cacheTimestamp < CACHE_TTL_MS;
+    }
+    deserialize(raw) {
+        return JSON.parse(raw);
+    }
+    async get() {
+        if (this.isCacheValid())
+            return this.cached;
+        const raw = await this.configStore.get(this.key);
+        this.cached = raw ? this.deserialize(raw) : this.fallback;
+        this.cacheTimestamp = Date.now();
+        return this.cached;
+    }
+}
+export class HostConfigManager extends CachedConfigManager {
+    constructor(store) {
+        super(store, "host-config", null);
+    }
+}
+export class RestrictionsManager extends CachedConfigManager {
+    constructor(store) {
+        super(store, "restrictions", []);
+    }
+}
+export class PaymentMethodsManager extends CachedConfigManager {
+    constructor(store) {
+        super(store, "payment-methods", []);
+    }
+}
+export class BotsManager extends CachedConfigManager {
+    constructor(store) {
+        super(store, "bots", []);
+    }
+    deserialize(raw) {
+        const parsed = JSON.parse(raw);
+        return parsed.map((b) => ({ ...b, user_agent: b.user_agent.toLowerCase() }));
+    }
+    async matchBot(userAgent) {
+        const bots = await this.get();
+        const ua = userAgent.toLowerCase();
+        return bots.find((bot) => ua.includes(bot.user_agent)) ?? null;
+    }
+}
+export class FacilitatorManager extends CachedConfigManager {
+    constructor(store) {
+        super(store, "facilitator", null);
+    }
+    deserialize(raw) {
+        const config = JSON.parse(raw);
+        const hasAuthHeaders = config.verifyHeaders || config.settleHeaders || config.supportedHeaders;
+        return new HTTPFacilitatorClient({
+            url: config.url,
+            ...(hasAuthHeaders && {
+                createAuthHeaders: async () => ({
+                    verify: config.verifyHeaders ?? {},
+                    settle: config.settleHeaders ?? {},
+                    supported: config.supportedHeaders ?? {},
+                }),
+            }),
+        });
+    }
+}

package/dist/handler.d.ts

@@ -0,0 +1,8 @@
+import type { ProcessSettleResultResponse } from "@x402/core/server";
+import type { PaymentPayload, PaymentRequirements } from "@x402/core/types";
+import type { WorkerCore } from "./index";
+import type { ProcessRequestResult, RequestAdapter, RequestMetadata } from "./types";
+export declare function handlePaymentRequest(core: WorkerCore, adapter: RequestAdapter, metadata: RequestMetadata, pathOverride?: string): Promise<ProcessRequestResult>;
+export declare function handleRequest(core: WorkerCore, adapter: RequestAdapter, metadata: RequestMetadata): Promise<ProcessRequestResult>;
+export declare function handleSettlement(core: WorkerCore, adapter: RequestAdapter, paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements, upstreamStatusCode: number, requestId: string): Promise<ProcessSettleResultResponse>;
+//# sourceMappingURL=handler.d.ts.map

package/dist/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AACzF,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAI5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAUrF,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,eAAe,EACzB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,oBAAoB,CAAC,CAiC/B;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,oBAAoB,CAAC,CAsC/B;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,cAAc,EACvB,cAAc,EAAE,cAAc,EAC9B,mBAAmB,EAAE,mBAAmB,EACxC,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,2BAA2B,CAAC,CAwBtC"}

package/dist/handler.js

@@ -0,0 +1,85 @@
+import { formatApiPaymentError } from "./api";
+import { noPaymentRequired } from "./config";
+import { logEvent } from "./telemetry";
+import { formatWebPaymentError } from "./web";
+function settlementFailure(reason, network) {
+    return { success: false, errorReason: reason, network, transaction: "" };
+}
+export async function handlePaymentRequest(core, adapter, metadata, pathOverride) {
+    const httpServer = await core.httpServer.get();
+    if (!httpServer) {
+        return noPaymentRequired(metadata);
+    }
+    const path = pathOverride ?? adapter.getPath();
+    const paymentContext = {
+        adapter,
+        path,
+        method: adapter.getMethod(),
+        paymentHeader: adapter.getHeader("PAYMENT-SIGNATURE") ||
+            adapter.getHeader("X-PAYMENT"),
+    };
+    if (!httpServer.requiresPayment(paymentContext)) {
+        return noPaymentRequired(metadata);
+    }
+    const result = await httpServer.processHTTPRequest(paymentContext, undefined);
+    result.metadata = metadata;
+    if (result.type === "payment-error") {
+        if (result.restriction.price === 0) {
+            await logEvent(core, adapter, 200, metadata.request_id);
+            return noPaymentRequired(metadata);
+        }
+        await logEvent(core, adapter, result.response.status, metadata.request_id);
+    }
+    return result;
+}
+export async function handleRequest(core, adapter, metadata) {
+    const userAgent = adapter.getUserAgent();
+    const bot = userAgent ? await core.bots.matchBot(userAgent) : null;
+    const hostConfig = await core.hostConfig.get();
+    const shouldCheck = bot || hostConfig?.apiProtectionMode === "all";
+    if (!shouldCheck) {
+        return noPaymentRequired(metadata);
+    }
+    const result = await handlePaymentRequest(core, adapter, metadata);
+    if (result.type !== "payment-error") {
+        return result;
+    }
+    // TODO: Figure out a way to classify whether web or api sooner in the flow
+    // so we don't run handlePaymentRequest for web restrictions on non-bot requests
+    // Web restrictions are always bot-only
+    if (result.restriction.type === "web" && !bot) {
+        return noPaymentRequired(metadata);
+    }
+    const paymentMethods = await core.paymentMethods.get();
+    if (paymentMethods.length > 0) {
+        if (result.restriction.type === "api") {
+            formatApiPaymentError(result, result.restriction, paymentMethods, hostConfig?.termsOfServiceUrl);
+        }
+        else if (result.restriction.type === "web") {
+            formatWebPaymentError(result, result.restriction, paymentMethods, adapter, hostConfig?.termsOfServiceUrl);
+        }
+    }
+    if (bot?.force_200) {
+        result.response.status = 200;
+    }
+    return result;
+}
+export async function handleSettlement(core, adapter, paymentPayload, paymentRequirements, upstreamStatusCode, requestId) {
+    const httpServer = await core.httpServer.get();
+    if (!httpServer) {
+        return settlementFailure("Server not initialized", paymentRequirements.network);
+    }
+    if (upstreamStatusCode >= 400) {
+        await logEvent(core, adapter, upstreamStatusCode, requestId);
+        return settlementFailure("Upstream error", paymentRequirements.network);
+    }
+    const result = await httpServer.processSettlement(paymentPayload, paymentRequirements);
+    if (result.success) {
+        const paymentResponse = result.headers["PAYMENT-RESPONSE"];
+        await logEvent(core, adapter, upstreamStatusCode, requestId, paymentResponse);
+    }
+    else {
+        await logEvent(core, adapter, 402, requestId);
+    }
+    return result;
+}

package/dist/health.d.ts

@@ -0,0 +1,3 @@
+export declare const HEALTH_PATH = "/.well-known/foldset";
+export declare function buildHealthResponse(platform: string, sdkVersion: string): string;
+//# sourceMappingURL=health.d.ts.map

package/dist/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../src/health.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,yBAAyB,CAAC;AAElD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAQhF"}

package/dist/health.js

@@ -0,0 +1,11 @@
+import packageJson from "../package.json" with { type: "json" };
+export const HEALTH_PATH = "/.well-known/foldset";
+export function buildHealthResponse(platform, sdkVersion) {
+    return JSON.stringify({
+        status: "ok",
+        core_version: packageJson.version,
+        sdk_version: sdkVersion,
+        platform,
+        timestamp: new Date().toISOString(),
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import type { ProcessSettleResultResponse } from "@x402/core/server";
+import type { PaymentPayload, PaymentRequirements } from "@x402/core/types";
+import { BotsManager, HostConfigManager, PaymentMethodsManager, RestrictionsManager } from "./config";
+import { HttpServerManager } from "./server";
+import type { ConfigStore, FoldsetOptions, ProcessRequestResult, RequestAdapter } from "./types";
+export declare class WorkerCore {
+    readonly hostConfig: HostConfigManager;
+    readonly restrictions: RestrictionsManager;
+    readonly paymentMethods: PaymentMethodsManager;
+    readonly bots: BotsManager;
+    readonly apiKey: string;
+    readonly httpServer: HttpServerManager;
+    readonly platform: string;
+    readonly sdkVersion: string;
+    constructor(store: ConfigStore, apiKey: string, platform: string, sdkVersion: string);
+    static fromOptions(options: FoldsetOptions): Promise<WorkerCore>;
+    processRequest(adapter: RequestAdapter): Promise<ProcessRequestResult>;
+    processSettlement(adapter: RequestAdapter, paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements, upstreamStatusCode: number, requestId: string): Promise<ProcessSettleResultResponse>;
+}
+export type { ApiRestriction, Bot, ConfigStore, ErrorReport, EventPayload, FacilitatorConfig, FoldsetOptions, HostConfig, HttpServerResult, McpRestriction, PaymentMethod, ProcessRequestResult, RequestAdapter, RequestMetadata, Restriction, RestrictionBase, WebRestriction, } from "./types";
+export { createRedisStore, fetchRedisCredentials } from "./store";
+export type { RedisCredentials } from "./store";
+export { generatePaywallHtml } from "./paywall";
+export { buildRoutesConfig, priceToAmount } from "./routes";
+export { BotsManager, CachedConfigManager, FacilitatorManager, HostConfigManager, PaymentMethodsManager, RestrictionsManager, } from "./config";
+export { HttpServerManager } from "./server";
+export { buildJsonRpcError, buildMcpRouteKey, buildMcpRoutesConfig, getMcpListPaymentRequirements, getMcpRouteKey, handleMcpRequest, isMcpListMethod, parseMcpRequest, } from "./mcp";
+export type { JsonRpcError, JsonRpcRequest, McpPaymentRequirement } from "./mcp";
+export { buildEventPayload, logEvent, reportError, sendEvent } from "./telemetry";
+export { handlePaymentRequest, handleRequest, handleSettlement } from "./handler";
+export { formatApiPaymentError } from "./api";
+export { formatWebPaymentError } from "./web";
+export { HEALTH_PATH, buildHealthResponse } from "./health";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5E,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,EAEpB,MAAM,UAAU,CAAC;AAIlB,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,oBAAoB,EACpB,cAAc,EACf,MAAM,SAAS,CAAC;AAIjB,qBAAa,UAAU;IACrB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;WAWvE,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IAYhE,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAyBtE,iBAAiB,CACrB,OAAO,EAAE,cAAc,EACvB,cAAc,EAAE,cAAc,EAC9B,mBAAmB,EAAE,mBAAmB,EACxC,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,2BAA2B,CAAC;CAUxC;AAGD,YAAY,EACV,cAAc,EACd,GAAG,EACH,WAAW,EACX,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,WAAW,EACX,eAAe,EACf,cAAc,GACf,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAClE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAGhD,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG5D,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,6BAA6B,EAC7B,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,eAAe,GAChB,MAAM,OAAO,CAAC;AACf,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAGjF,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGlF,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClF,OAAO,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAG9C,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,79 @@
+import { BotsManager, HostConfigManager, PaymentMethodsManager, RestrictionsManager, buildRequestMetadata, } from "./config";
+import { handleRequest, handleSettlement } from "./handler";
+import { HEALTH_PATH, buildHealthResponse } from "./health";
+import { handleMcpRequest } from "./mcp";
+import { HttpServerManager } from "./server";
+import { createRedisStore, fetchRedisCredentials } from "./store";
+let cachedCore = null;
+export class WorkerCore {
+    hostConfig;
+    restrictions;
+    paymentMethods;
+    bots;
+    apiKey;
+    httpServer;
+    platform;
+    sdkVersion;
+    constructor(store, apiKey, platform, sdkVersion) {
+        this.hostConfig = new HostConfigManager(store);
+        this.restrictions = new RestrictionsManager(store);
+        this.paymentMethods = new PaymentMethodsManager(store);
+        this.bots = new BotsManager(store);
+        this.apiKey = apiKey;
+        this.httpServer = new HttpServerManager(store);
+        this.platform = platform;
+        this.sdkVersion = sdkVersion;
+    }
+    static async fromOptions(options) {
+        if (cachedCore) {
+            return cachedCore;
+        }
+        const credentials = options.redisCredentials ?? (await fetchRedisCredentials(options.apiKey));
+        const store = createRedisStore(credentials);
+        cachedCore = new WorkerCore(store, options.apiKey, options.platform ?? "unknown", options.sdkVersion ?? "unknown");
+        return cachedCore;
+    }
+    async processRequest(adapter) {
+        const metadata = buildRequestMetadata();
+        if (adapter.getPath() === HEALTH_PATH) {
+            return {
+                type: "health-check",
+                metadata,
+                response: {
+                    status: 200,
+                    body: buildHealthResponse(this.platform, this.sdkVersion),
+                    headers: { "Content-Type": "application/json" },
+                },
+            };
+        }
+        const hostConfig = await this.hostConfig.get();
+        const mcpEndpoint = hostConfig?.mcpEndpoint;
+        if (mcpEndpoint && adapter.getPath() === mcpEndpoint) {
+            return handleMcpRequest(this, adapter, mcpEndpoint, metadata);
+        }
+        return handleRequest(this, adapter, metadata);
+    }
+    async processSettlement(adapter, paymentPayload, paymentRequirements, upstreamStatusCode, requestId) {
+        return handleSettlement(this, adapter, paymentPayload, paymentRequirements, upstreamStatusCode, requestId);
+    }
+}
+// Store
+export { createRedisStore, fetchRedisCredentials } from "./store";
+// Paywall
+export { generatePaywallHtml } from "./paywall";
+// Routes
+export { buildRoutesConfig, priceToAmount } from "./routes";
+// Config managers
+export { BotsManager, CachedConfigManager, FacilitatorManager, HostConfigManager, PaymentMethodsManager, RestrictionsManager, } from "./config";
+// Server
+export { HttpServerManager } from "./server";
+// MCP
+export { buildJsonRpcError, buildMcpRouteKey, buildMcpRoutesConfig, getMcpListPaymentRequirements, getMcpRouteKey, handleMcpRequest, isMcpListMethod, parseMcpRequest, } from "./mcp";
+// Telemetry
+export { buildEventPayload, logEvent, reportError, sendEvent } from "./telemetry";
+// Handlers
+export { handlePaymentRequest, handleRequest, handleSettlement } from "./handler";
+export { formatApiPaymentError } from "./api";
+export { formatWebPaymentError } from "./web";
+// Health
+export { HEALTH_PATH, buildHealthResponse } from "./health";

package/dist/mcp.d.ts

@@ -0,0 +1,50 @@
+import type { RoutesConfig } from "@x402/core/http";
+import type { WorkerCore } from "./index";
+import type { McpRestriction, PaymentMethod, ProcessRequestResult, RequestAdapter, RequestMetadata, Restriction } from "./types";
+export interface JsonRpcRequest {
+    jsonrpc: string;
+    id?: string | number | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export declare function parseMcpRequest(body: unknown): JsonRpcRequest | null;
+/**
+ * Build the route key for an MCP restriction: "endpointPath/method:name".
+ */
+export declare function buildMcpRouteKey(endpointPath: string, restriction: McpRestriction): string;
+export declare function buildMcpRoutesConfig(restrictions: Restriction[], paymentMethods: PaymentMethod[], mcpEndpoint: string, termsOfServiceUrl?: string): RoutesConfig;
+export declare function getMcpRouteKey(endpointPath: string, method: string, params?: Record<string, unknown>): string | null;
+export declare function isMcpListMethod(method: string): boolean;
+export interface McpPaymentRequirement {
+    name: string;
+    method: string;
+    description: string;
+    price: number;
+    scheme: string;
+    accepts: Array<{
+        network: string;
+        chainDisplayName: string;
+        asset: string;
+        assetDisplayName: string;
+        amount: string;
+        payTo: string;
+    }>;
+}
+export interface JsonRpcError {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare function buildJsonRpcError(id: string | number | null, code: number, message: string, data?: unknown): JsonRpcError;
+/**
+ * Build payment requirements for all gated MCP tools/resources/prompts
+ * matching the given list method. Returns clear payment instructions
+ * built directly from Foldset restrictions and payment methods.
+ */
+export declare function getMcpListPaymentRequirements(listMethod: string, restrictions: Restriction[], paymentMethods: PaymentMethod[]): McpPaymentRequirement[];
+export declare function handleMcpRequest(core: WorkerCore, adapter: RequestAdapter, mcpEndpoint: string, metadata: RequestMetadata): Promise<ProcessRequestResult>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAG1C,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAQD,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAUpE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,cAAc,GAC1B,MAAM,CAER;AAED,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,WAAW,EAAE,EAC3B,cAAc,EAAE,aAAa,EAAE,EAC/B,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,MAAM,GACzB,YAAY,CAUd;AAED,wBAAgB,cAAc,CAC5B,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,MAAM,GAAG,IAAI,CAIf;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,gBAAgB,EAAE,MAAM,CAAC;QACzB,KAAK,EAAE,MAAM,CAAC;QACd,gBAAgB,EAAE,MAAM,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC1D;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,GACb,YAAY,CAId;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,WAAW,EAAE,EAC3B,cAAc,EAAE,aAAa,EAAE,GAC9B,qBAAqB,EAAE,CAwBzB;AA+BD,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,oBAAoB,CAAC,CAiD/B"}

package/dist/mcp.js

@@ -0,0 +1,138 @@
+import { noPaymentRequired } from "./config";
+import { handlePaymentRequest } from "./handler";
+import { buildRouteEntry, priceToAmount } from "./routes";
+import { logEvent } from "./telemetry";
+const MCP_LIST_CALL_METHODS = {
+    "tools/list": "tools/call",
+    "resources/list": "resources/read",
+    "prompts/list": "prompts/get",
+};
+export function parseMcpRequest(body) {
+    if (typeof body !== "object" ||
+        body === null ||
+        !("jsonrpc" in body) ||
+        !("method" in body)) {
+        return null;
+    }
+    return body;
+}
+/**
+ * Build the route key for an MCP restriction: "endpointPath/method:name".
+ */
+export function buildMcpRouteKey(endpointPath, restriction) {
+    return `${endpointPath}/${restriction.method}:${restriction.name}`;
+}
+export function buildMcpRoutesConfig(restrictions, paymentMethods, mcpEndpoint, termsOfServiceUrl) {
+    const routesConfig = {};
+    for (const r of restrictions) {
+        if (r.type !== "mcp")
+            continue;
+        const key = buildMcpRouteKey(mcpEndpoint, r);
+        routesConfig[key] = buildRouteEntry(r, paymentMethods, termsOfServiceUrl);
+    }
+    return routesConfig;
+}
+export function getMcpRouteKey(endpointPath, method, params) {
+    const identifier = params?.name ?? params?.uri;
+    if (typeof identifier !== "string")
+        return null;
+    return `${endpointPath}/${method}:${identifier}`;
+}
+export function isMcpListMethod(method) {
+    return method in MCP_LIST_CALL_METHODS;
+}
+export function buildJsonRpcError(id, code, message, data) {
+    const error = { jsonrpc: "2.0", id, error: { code, message } };
+    if (data !== undefined)
+        error.error.data = data;
+    return error;
+}
+/**
+ * Build payment requirements for all gated MCP tools/resources/prompts
+ * matching the given list method. Returns clear payment instructions
+ * built directly from Foldset restrictions and payment methods.
+ */
+export function getMcpListPaymentRequirements(listMethod, restrictions, paymentMethods) {
+    const callMethod = MCP_LIST_CALL_METHODS[listMethod];
+    if (!callMethod)
+        return [];
+    const relevant = restrictions.filter((r) => r.type === "mcp" && r.method === callMethod && r.price > 0);
+    if (!relevant.length)
+        return [];
+    return relevant.map((r) => ({
+        name: r.name,
+        method: r.method,
+        description: r.description,
+        price: r.price,
+        scheme: r.scheme,
+        accepts: paymentMethods.map((pm) => ({
+            network: pm.caip2_id,
+            chainDisplayName: pm.chain_display_name,
+            asset: pm.contract_address,
+            assetDisplayName: pm.asset_display_name,
+            amount: priceToAmount(r.price, pm.decimals),
+            payTo: pm.circle_wallet_address,
+        })),
+    }));
+}
+async function formatMcpPaymentError(core, result, rpcId) {
+    const [paymentMethods, hostConfig] = await Promise.all([
+        core.paymentMethods.get(),
+        core.hostConfig.get(),
+    ]);
+    result.response.body = JSON.stringify(buildJsonRpcError(rpcId, 402, "Payment required", {
+        ...result.metadata,
+        description: result.restriction.description,
+        price: result.restriction.price,
+        ...(hostConfig?.termsOfServiceUrl && { terms_of_service_url: hostConfig.termsOfServiceUrl }),
+        payment_methods: paymentMethods.map((pm) => ({
+            network: pm.caip2_id,
+            asset: pm.contract_address,
+            decimals: pm.decimals,
+            pay_to: pm.circle_wallet_address,
+            chain: pm.chain_display_name,
+            asset_name: pm.asset_display_name,
+        })),
+    }));
+    result.response.headers["Content-Type"] = "application/json";
+}
+export async function handleMcpRequest(core, adapter, mcpEndpoint, metadata) {
+    if (adapter.getMethod() !== "POST") {
+        return noPaymentRequired(metadata);
+    }
+    const body = await adapter.getBody();
+    const rpc = parseMcpRequest(body);
+    if (!rpc) {
+        return noPaymentRequired(metadata);
+    }
+    // List methods, pass through with payment requirements header
+    if (isMcpListMethod(rpc.method)) {
+        const [restrictions, paymentMethods, hostConfig] = await Promise.all([
+            core.restrictions.get(),
+            core.paymentMethods.get(),
+            core.hostConfig.get(),
+        ]);
+        // TODO rfradkin: We shouldn't really be regenerating this list each time,
+        // it should be every time requirements change
+        const requirements = getMcpListPaymentRequirements(rpc.method, restrictions, paymentMethods);
+        const headers = {};
+        if (requirements.length > 0) {
+            const payload = { requirements };
+            if (hostConfig?.termsOfServiceUrl) {
+                payload.terms_of_service_url = hostConfig.termsOfServiceUrl;
+            }
+            headers["Payment-Required"] = JSON.stringify(payload);
+        }
+        await logEvent(core, adapter, 200, metadata.request_id);
+        return { type: "no-payment-required", headers, metadata };
+    }
+    const routeKey = getMcpRouteKey(mcpEndpoint, rpc.method, rpc.params);
+    if (!routeKey) {
+        return noPaymentRequired(metadata);
+    }
+    const result = await handlePaymentRequest(core, adapter, metadata, routeKey);
+    if (result.type === "payment-error") {
+        await formatMcpPaymentError(core, result, rpc.id ?? null);
+    }
+    return result;
+}

package/dist/paywall.d.ts

@@ -0,0 +1,3 @@
+import type { PaymentMethod, Restriction } from "./types";
+export declare function generatePaywallHtml(restriction: Restriction, paymentMethods: PaymentMethod[], url: string, termsOfServiceUrl?: string): string;
+//# sourceMappingURL=paywall.d.ts.map

package/dist/paywall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paywall.d.ts","sourceRoot":"","sources":["../src/paywall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,aAAa,EAAE,EAC/B,GAAG,EAAE,MAAM,EACX,iBAAiB,CAAC,EAAE,MAAM,GACzB,MAAM,CA2FR"}

package/dist/paywall.js

@@ -0,0 +1,87 @@
+export function generatePaywallHtml(restriction, paymentMethods, url, termsOfServiceUrl) {
+    // Group payment methods by network
+    const methodsByNetwork = new Map();
+    for (const pm of paymentMethods) {
+        const existing = methodsByNetwork.get(pm.caip2_id) ?? [];
+        existing.push(pm);
+        methodsByNetwork.set(pm.caip2_id, existing);
+    }
+    const paymentOptionsHtml = Array.from(methodsByNetwork.values()).map((methods) => {
+        const chainDisplayName = methods[0].chain_display_name;
+        const chainCaip2Id = methods[0].caip2_id;
+        const recipientAddress = methods[0].circle_wallet_address;
+        const acceptedTokensHtml = methods.map((pm) => {
+            const scheme = restriction.scheme
+                .toLowerCase()
+                .replace(/^./, c => c.toUpperCase());
+            return `
+        <div class="token-row">
+          <span class="token-name">${pm.asset_display_name}</span>
+          <span class="token-details">
+            <span class="token-scheme">${scheme}</span>
+            <span class="token-price">$${restriction.price}</span>
+          </span>
+        </div>`;
+        }).join("");
+        return `
+    <div class="card">
+      <div class="card-header">
+        <h3>${chainDisplayName}</h3>
+        <span class="chain-id">${chainCaip2Id}</span>
+      </div>
+      <div class="pay-to"><strong>Pay to:</strong> <code>${recipientAddress}</code></div>
+      ${acceptedTokensHtml}
+    </div>`;
+    }).join("\n");
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>HTTP 402 - Payment Required</title>
+  <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500&family=Inter:wght@400;500;600&display=swap" rel="stylesheet">
+  <style>
+    * { box-sizing: border-box; }
+    body { font-family: 'Inter', system-ui, sans-serif; max-width: 600px; margin: 32px auto; padding: 0 16px; background: #fff; color: #111; -webkit-font-smoothing: antialiased; font-size: 14px; }
+    h1 { font-size: 20px; margin-bottom: 4px; }
+    h2 { font-size: 15px; margin-top: 24px; margin-bottom: 8px; }
+    h3 { font-size: 14px; margin-top: 0; margin-bottom: 10px; }
+    a { color: #00aa5e; }
+    code { background: #f0f0f0; padding: 2px 5px; border-radius: 3px; font-size: 11px; font-family: 'IBM Plex Mono', monospace; word-break: break-all; }
+    .resource { margin: 12px 0; padding: 10px 12px; background: #f7f7f7; border: 1px solid #e5e5e5; border-radius: 5px; }
+    .resource-row { display: flex; gap: 6px; align-items: baseline; margin-bottom: 4px; font-size: 13px; color: #555; }
+    .resource-row:last-child { margin-bottom: 0; }
+    .resource-row strong { color: #111; font-size: 11px; text-transform: uppercase; letter-spacing: 0.03em; white-space: nowrap; }
+    .card { margin: 12px 0; padding: 12px; border: 1px solid #e5e5e5; border-radius: 5px; }
+    .card-header { display: flex; align-items: baseline; gap: 8px; margin-bottom: 8px; }
+    .card-header h3 { margin: 0; }
+    .card-header .chain-id { color: #888; font-size: 11px; font-weight: 400; }
+    .pay-to { font-size: 12px; color: #555; margin-bottom: 10px; }
+    .pay-to strong { color: #111; }
+    .token-row { display: flex; justify-content: space-between; align-items: center; padding: 8px 0; border-top: 1px solid #f0f0f0; font-size: 13px; }
+    .token-name { font-weight: 500; color: #111; }
+    .token-details { display: flex; gap: 12px; align-items: center; color: #555; font-size: 12px; }
+    .token-price { font-weight: 500; color: #111; }
+    .token-scheme { font-size: 11px; color: #888; text-transform: capitalize; }
+    p { color: #555; font-size: 13px; line-height: 1.5; }
+    footer { margin-top: 24px; padding-top: 12px; border-top: 1px solid #e5e5e5; font-size: 12px; color: #888; }
+    ::selection { background: #00ff88; color: #000; }
+  </style>
+</head>
+<body>
+  <h1>402: Payment Required</h1>
+  <p>This content requires payment via the <a href="https://github.com/coinbase/x402">x402 protocol</a>.</p>
+
+  <div class="resource">
+    <div class="resource-row"><strong>URL</strong> <code>${url}</code></div>
+    <div class="resource-row"><strong>Description</strong> ${restriction.description}</div>${termsOfServiceUrl ? `\n    <div class="resource-row"><strong>Terms of Service</strong> <a href="${termsOfServiceUrl}">${termsOfServiceUrl}</a></div>` : ""}
+  </div>
+
+  <h2>Payment Options</h2>
+  ${paymentOptionsHtml}
+
+  <footer>
+    Powered by <a href="https://www.foldset.com">Foldset</a>
+  </footer>
+</body>
+</html>`;
+}

package/dist/routes.d.ts

@@ -0,0 +1,8 @@
+import type { RouteConfig, RoutesConfig } from "@x402/core/http";
+import type { PaymentMethod, Restriction } from "./types";
+export declare function priceToAmount(priceUsd: number, decimals: number): string;
+export declare function buildRouteEntry(restriction: Restriction, paymentMethods: PaymentMethod[], termsOfServiceUrl?: string): RouteConfig & {
+    restriction: Restriction;
+};
+export declare function buildRoutesConfig(restrictions: Restriction[], paymentMethods: PaymentMethod[], termsOfServiceUrl?: string): RoutesConfig;
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGjE,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGxE;AAED,wBAAgB,eAAe,CAC7B,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,aAAa,EAAE,EAC/B,iBAAiB,CAAC,EAAE,MAAM,GACzB,WAAW,GAAG;IAAE,WAAW,EAAE,WAAW,CAAA;CAAE,CAmB5C;AAED,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,WAAW,EAAE,EAC3B,cAAc,EAAE,aAAa,EAAE,EAC/B,iBAAiB,CAAC,EAAE,MAAM,GACzB,YAAY,CAUd"}

package/dist/routes.js

@@ -0,0 +1,34 @@
+export function priceToAmount(priceUsd, decimals) {
+    const amount = priceUsd * Math.pow(10, decimals);
+    return Math.round(amount).toString();
+}
+export function buildRouteEntry(restriction, paymentMethods, termsOfServiceUrl) {
+    return {
+        accepts: paymentMethods.map((pm) => ({
+            scheme: restriction.scheme,
+            price: {
+                amount: priceToAmount(restriction.price, pm.decimals),
+                asset: pm.contract_address,
+                extra: {
+                    ...pm.extra,
+                    ...(termsOfServiceUrl && { termsOfServiceUrl }),
+                },
+            },
+            network: pm.caip2_id,
+            payTo: pm.circle_wallet_address,
+        })),
+        description: restriction.description,
+        mimeType: "application/json",
+        restriction,
+    };
+}
+export function buildRoutesConfig(restrictions, paymentMethods, termsOfServiceUrl) {
+    const routesConfig = {};
+    for (const r of restrictions) {
+        if (r.type === "mcp")
+            continue;
+        const key = r.type === "api" && r.httpMethod ? `${r.httpMethod.toUpperCase()} ${r.path}` : r.path;
+        routesConfig[key] = buildRouteEntry(r, paymentMethods, termsOfServiceUrl);
+    }
+    return routesConfig;
+}

package/dist/server.d.ts

@@ -0,0 +1,17 @@
+import type { HTTPRequestContext, PaywallConfig } from "@x402/core/http";
+import { x402HTTPResourceServer } from "@x402/core/server";
+import type { ConfigStore, HttpServerResult } from "./types";
+export interface FoldsetX402HTTPServer extends x402HTTPResourceServer {
+    processHTTPRequest(context: HTTPRequestContext, paywallConfig?: PaywallConfig): Promise<HttpServerResult>;
+}
+export declare class HttpServerManager {
+    private cached;
+    private cacheTimestamp;
+    private hostConfig;
+    private restrictions;
+    private paymentMethods;
+    private facilitator;
+    constructor(store: ConfigStore);
+    get(): Promise<FoldsetX402HTTPServer | null>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAA4B,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnG,OAAO,EACL,sBAAsB,EAEvB,MAAM,mBAAmB,CAAC;AAc3B,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA8B7D,MAAM,WAAW,qBAAsB,SAAQ,sBAAsB;IACnE,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC3G;AAmBD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,WAAW,CAAqB;gBAE5B,KAAK,EAAE,WAAW;IAOxB,GAAG,IAAI,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;CA2CnD"}

package/dist/server.js

@@ -0,0 +1,86 @@
+import { x402HTTPResourceServer, x402ResourceServer, } from "@x402/core/server";
+import { registerExactEvmScheme } from "@x402/evm/exact/server";
+import { registerExactSvmScheme } from "@x402/svm/exact/server";
+import { CACHE_TTL_MS, FacilitatorManager, HostConfigManager, PaymentMethodsManager, RestrictionsManager, } from "./config";
+import { buildMcpRoutesConfig } from "./mcp";
+import { buildRoutesConfig } from "./routes";
+/**
+ * Custom parseRoutePattern that treats the path as a raw regex.
+ * Restriction paths (stored as regex in the DB) are used directly
+ * instead of being converted by x402's glob-like pattern parser.
+ */
+function foldsetParseRoutePattern(pattern) {
+    const [verb, path] = pattern.includes(" ") ? pattern.split(/\s+/) : ["*", pattern];
+    return { verb: verb.toUpperCase(), regex: new RegExp(path, "i") };
+}
+/**
+ * Always return payment-required headers regardless of browser detection.
+ * Body is left empty, web.ts and mcp.ts set their own response body.
+ */
+function foldsetCreatePaymentRequiredResponse(paymentRequired) {
+    // @ts-expect-error - accessing private method
+    const response = this.createHTTPPaymentRequiredResponse(paymentRequired);
+    return {
+        status: 402,
+        headers: response.headers,
+        body: "",
+    };
+}
+/**
+ * Attaches the matched restriction to payment-error results from the route config.
+ */
+const processHTTPRequestWithRestriction = async function (context, paywallConfig) {
+    const result = await x402HTTPResourceServer.prototype.processHTTPRequest.call(this, context, paywallConfig);
+    if (result.type === "payment-error") {
+        // @ts-expect-error - accessing private method
+        const routeConfig = this.getRouteConfig(context.path, context.method);
+        return { ...result, restriction: routeConfig?.restriction };
+    }
+    return result;
+};
+export class HttpServerManager {
+    cached = null;
+    cacheTimestamp = 0;
+    hostConfig;
+    restrictions;
+    paymentMethods;
+    facilitator;
+    constructor(store) {
+        this.hostConfig = new HostConfigManager(store);
+        this.restrictions = new RestrictionsManager(store);
+        this.paymentMethods = new PaymentMethodsManager(store);
+        this.facilitator = new FacilitatorManager(store);
+    }
+    async get() {
+        if (this.cached && Date.now() - this.cacheTimestamp < CACHE_TTL_MS) {
+            return this.cached;
+        }
+        const [hostConfig, restrictions, paymentMethods, facilitator] = await Promise.all([
+            this.hostConfig.get(),
+            this.restrictions.get(),
+            this.paymentMethods.get(),
+            this.facilitator.get(),
+        ]);
+        if (!hostConfig || !facilitator) {
+            return null;
+        }
+        const server = new x402ResourceServer(facilitator);
+        registerExactEvmScheme(server);
+        registerExactSvmScheme(server);
+        const contentRoutes = buildRoutesConfig(restrictions, paymentMethods, hostConfig.termsOfServiceUrl);
+        const mcpRoutes = hostConfig.mcpEndpoint
+            ? buildMcpRoutesConfig(restrictions, paymentMethods, hostConfig.mcpEndpoint, hostConfig.termsOfServiceUrl)
+            : {};
+        const routesConfig = { ...contentRoutes, ...mcpRoutes };
+        // @ts-expect-error - overriding private method
+        x402HTTPResourceServer.prototype.parseRoutePattern = foldsetParseRoutePattern;
+        const httpServer = new x402HTTPResourceServer(server, routesConfig);
+        // @ts-expect-error - overriding private method
+        httpServer.createHTTPResponse = foldsetCreatePaymentRequiredResponse;
+        httpServer.processHTTPRequest = processHTTPRequestWithRestriction;
+        await httpServer.initialize();
+        this.cached = httpServer;
+        this.cacheTimestamp = Date.now();
+        return this.cached;
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,9 @@
+import type { ConfigStore } from "./types";
+export interface RedisCredentials {
+    url: string;
+    token: string;
+    tenantId: string;
+}
+export declare function fetchRedisCredentials(apiKey: string): Promise<RedisCredentials>;
+export declare function createRedisStore(credentials: RedisCredentials): ConfigStore;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,gBAAgB,CAAC,CAa3B;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,GAAG,WAAW,CAa3E"}

package/dist/store.js

@@ -0,0 +1,25 @@
+import { Redis } from "@upstash/redis";
+import { API_BASE_URL } from "./config";
+export async function fetchRedisCredentials(apiKey) {
+    const response = await fetch(`${API_BASE_URL}/v1/config/redis`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch Redis credentials: ${response.status} ${response.statusText}`);
+    }
+    const { data } = (await response.json());
+    return data;
+}
+export function createRedisStore(credentials) {
+    const redis = new Redis({
+        url: credentials.url,
+        token: credentials.token,
+        automaticDeserialization: false,
+    });
+    const prefix = credentials.tenantId;
+    return {
+        async get(key) {
+            return redis.get(`${prefix}:${key}`);
+        },
+    };
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,7 @@
+import type { WorkerCore } from "./index";
+import type { EventPayload, RequestAdapter } from "./types";
+export declare function buildEventPayload(adapter: RequestAdapter, statusCode: number, requestId: string, paymentResponse?: string): EventPayload;
+export declare function sendEvent(apiKey: string, payload: EventPayload): Promise<void>;
+export declare function reportError(apiKey: string, error: unknown, adapter?: RequestAdapter): Promise<void>;
+export declare function logEvent(core: WorkerCore, adapter: RequestAdapter, statusCode: number, requestId: string, paymentResponse?: string): Promise<void>;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAe,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAOzE,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,YAAY,CAgBd;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAMf;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC,CAGf"}

package/dist/telemetry.js

@@ -0,0 +1,53 @@
+import { API_BASE_URL } from "./config";
+const JSON_HEADERS = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+};
+export function buildEventPayload(adapter, statusCode, requestId, paymentResponse) {
+    const url = new URL(adapter.getUrl());
+    return {
+        method: adapter.getMethod(),
+        status_code: statusCode,
+        user_agent: adapter.getUserAgent() || null,
+        referer: adapter.getHeader("referer") || null,
+        href: url.href,
+        hostname: url.hostname,
+        pathname: url.pathname,
+        search: url.search,
+        ip_address: adapter.getIpAddress(),
+        request_id: requestId,
+        ...(paymentResponse && { payment_response: paymentResponse }),
+    };
+}
+export async function sendEvent(apiKey, payload) {
+    await fetch(`${API_BASE_URL}/v1/events`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, ...JSON_HEADERS },
+        body: JSON.stringify(payload),
+    }).catch(() => { });
+}
+export async function reportError(apiKey, error, adapter) {
+    const payload = {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+    };
+    if (adapter) {
+        payload.context = {
+            method: adapter.getMethod(),
+            path: adapter.getPath(),
+            hostname: adapter.getHost(),
+            user_agent: adapter.getUserAgent() || null,
+            ip_address: adapter.getIpAddress(),
+        };
+    }
+    // Fail silently, error reporting must never break the request.
+    await fetch(`${API_BASE_URL}/v1/errors`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, ...JSON_HEADERS },
+        body: JSON.stringify(payload),
+    }).catch(() => { });
+}
+export async function logEvent(core, adapter, statusCode, requestId, paymentResponse) {
+    const payload = buildEventPayload(adapter, statusCode, requestId, paymentResponse);
+    await sendEvent(core.apiKey, payload);
+}

package/dist/types.d.ts

@@ -0,0 +1,113 @@
+import type { HTTPAdapter, HTTPProcessResult } from "@x402/core/server";
+import type { RedisCredentials } from "./store";
+export interface FoldsetOptions {
+    apiKey: string;
+    redisCredentials?: RedisCredentials;
+    platform?: string;
+    sdkVersion?: string;
+}
+export interface RequestMetadata {
+    version: string;
+    request_id: string;
+    timestamp: string;
+}
+export type HttpServerResult = {
+    metadata: RequestMetadata;
+} & ((Extract<HTTPProcessResult, {
+    type: "no-payment-required";
+}> & {
+    headers?: Record<string, string>;
+}) | (Extract<HTTPProcessResult, {
+    type: "payment-error";
+}> & {
+    restriction: Restriction;
+}) | Extract<HTTPProcessResult, {
+    type: "payment-verified";
+}>);
+export type ProcessRequestResult = HttpServerResult | {
+    metadata: RequestMetadata;
+    type: "health-check";
+    response: {
+        status: 200;
+        body: string;
+        headers: Record<string, string>;
+    };
+};
+export interface RequestAdapter extends HTTPAdapter {
+    getIpAddress(): string | null;
+    getHost(): string;
+    getBody(): Promise<unknown>;
+}
+export interface ConfigStore {
+    get(key: string): Promise<string | null>;
+}
+export interface EventPayload {
+    method: string;
+    status_code: number;
+    user_agent: string | null;
+    referer?: string | null;
+    href: string;
+    hostname: string;
+    pathname: string;
+    search: string;
+    ip_address?: string | null;
+    payment_response?: string;
+    request_id: string;
+}
+export interface ErrorReport {
+    error: string;
+    stack?: string;
+    context?: {
+        method?: string;
+        path?: string;
+        hostname?: string;
+        user_agent?: string | null;
+        ip_address?: string | null;
+    };
+}
+export interface HostConfig {
+    host: string;
+    mcpEndpoint?: string;
+    termsOfServiceUrl?: string;
+    apiProtectionMode: "bots" | "all";
+}
+export interface RestrictionBase {
+    description: string;
+    price: number;
+    scheme: string;
+}
+export interface WebRestriction extends RestrictionBase {
+    type: "web";
+    path: string;
+}
+export interface ApiRestriction extends RestrictionBase {
+    type: "api";
+    path: string;
+    httpMethod?: string;
+}
+export interface McpRestriction extends RestrictionBase {
+    type: "mcp";
+    method: string;
+    name: string;
+}
+export type Restriction = WebRestriction | ApiRestriction | McpRestriction;
+export interface PaymentMethod {
+    caip2_id: string;
+    decimals: number;
+    contract_address: string;
+    circle_wallet_address: string;
+    chain_display_name: string;
+    asset_display_name: string;
+    extra?: Record<string, string>;
+}
+export interface Bot {
+    user_agent: string;
+    force_200?: boolean;
+}
+export interface FacilitatorConfig {
+    url: string;
+    verifyHeaders?: Record<string, string>;
+    settleHeaders?: Record<string, string>;
+    supportedHeaders?: Record<string, string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

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

package/dist/web.d.ts

@@ -0,0 +1,5 @@
+import type { PaymentMethod, ProcessRequestResult, RequestAdapter, WebRestriction } from "./types";
+export declare function formatWebPaymentError(result: Extract<ProcessRequestResult, {
+    type: "payment-error";
+}>, restriction: WebRestriction, paymentMethods: PaymentMethod[], adapter: RequestAdapter, termsOfServiceUrl?: string): void;
+//# sourceMappingURL=web.d.ts.map

package/dist/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEnG,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,OAAO,CAAC,oBAAoB,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC,EAChE,WAAW,EAAE,cAAc,EAC3B,cAAc,EAAE,aAAa,EAAE,EAC/B,OAAO,EAAE,cAAc,EACvB,iBAAiB,CAAC,EAAE,MAAM,GACzB,IAAI,CAGN"}

package/dist/web.js

@@ -0,0 +1,5 @@
+import { generatePaywallHtml } from "./paywall";
+export function formatWebPaymentError(result, restriction, paymentMethods, adapter, termsOfServiceUrl) {
+    result.response.body = generatePaywallHtml(restriction, paymentMethods, adapter.getUrl(), termsOfServiceUrl);
+    result.response.headers["Content-Type"] = "text/html";
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@foldset/core",
+  "version": "0.1.0",
+  "description": "Core types and utilities for Foldset payment protection",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/foldset/sdks.git",
+    "directory": "typescript/core"
+  },
+  "homepage": "https://docs.foldset.com",
+  "keywords": [
+    "foldset",
+    "micropayments",
+    "stablecoin",
+    "ai",
+    "agents"
+  ],
+  "dependencies": {
+    "@upstash/redis": "^1.36.1",
+    "@x402/core": "^2.3.0",
+    "@x402/evm": "^2.3.0",
+    "@x402/svm": "^2.3.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  }
+}