@faremeter/facilitator 0.7.0 → 0.9.0

package/dist/src/promise.d.ts

@@ -0,0 +1,4 @@
+export declare function sleep<T>(sleepMs: number, value?: T): Promise<T | undefined>;
+export declare function timeout<T>(timeoutMs: number, msg?: string): Promise<T>;
+export declare function allSettledWithTimeout<T>(promises: readonly Promise<T>[], timeoutMs: number): Promise<PromiseSettledResult<Awaited<Awaited<T>>>[]>;
+//# sourceMappingURL=promise.d.ts.map

package/dist/src/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../../src/promise.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAE3E;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,cAIzD;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,QAAQ,EAAE,SAAS,OAAO,CAAC,CAAC,CAAC,EAAE,EAC/B,SAAS,EAAE,MAAM,wDAOlB"}

package/dist/src/promise.js

@@ -0,0 +1,10 @@
+export function sleep(sleepMs, value) {
+    return new Promise((resolve) => setTimeout(() => resolve(value), sleepMs));
+}
+export function timeout(timeoutMs, msg) {
+    return new Promise((_, reject) => setTimeout(() => reject(new Error(msg ?? "timed out")), timeoutMs));
+}
+export function allSettledWithTimeout(promises, timeoutMs) {
+    const timedPromises = promises.map((p) => Promise.race([p, timeout(timeoutMs, "request timed out")]));
+    return Promise.allSettled(timedPromises);
+}

package/dist/src/promise.test.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env pnpm tsx
+export {};
+//# sourceMappingURL=promise.test.d.ts.map

package/dist/src/promise.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.test.d.ts","sourceRoot":"","sources":["../../src/promise.test.ts"],"names":[],"mappings":""}

package/dist/src/promise.test.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env pnpm tsx
+import t from "tap";
+import { sleep, allSettledWithTimeout } from "./promise.js";
+async function checkDuration(min, max, f) {
+    if (max <= min) {
+        throw new Error("max duration must be greater than min");
+    }
+    const start = Date.now();
+    const res = await f();
+    const delta = Date.now() - start;
+    t.ok(delta >= min, `duration took ${delta} ms, which isn't >= ${min} ms`);
+    t.ok(delta <= max, `duration took ${delta} ms, which isn't <= ${max} ms`);
+    return res;
+}
+await t.test("checkAllSettledNoTimeout", async (t) => {
+    const results = await checkDuration(25, 50, () => allSettledWithTimeout([sleep(10, "good"), sleep(30, "to"), sleep(1, "go")], 100));
+    t.equal(results.length, 3);
+    results.forEach((x) => {
+        if (x === undefined) {
+            t.bailout();
+        }
+        t.matchOnly(x.status, "fulfilled");
+    });
+    t.matchOnly(results.map((x) => x.value), ["good", "to", "go"]);
+    t.pass();
+    t.end();
+});
+await t.test("checkAllSettledWithTimeout", async (t) => {
+    const results = await checkDuration(20, 125, () => allSettledWithTimeout([sleep(10), sleep(500)], 100));
+    t.equal(results.length, 2);
+    const [result0, result1] = results;
+    if (result0 == undefined) {
+        return t.bailout();
+    }
+    if (result1 == undefined) {
+        return t.bailout();
+    }
+    t.matchOnly(result0.status, "fulfilled");
+    t.matchOnly(result1.status, "rejected");
+    t.pass();
+    t.end();
+});
+await t.test("checkAllSettleException", async (t) => {
+    const results = await checkDuration(10, 45, async () => allSettledWithTimeout([
+        sleep(10, 42),
+        (async () => {
+            throw new Error("an error happened");
+        })(),
+        sleep(15, 1337),
+    ], 50));
+    t.equal(results.length, 3);
+    const [result0, result1, result2] = results;
+    if (result0 === undefined) {
+        return t.bailout();
+    }
+    if (result1 === undefined) {
+        return t.bailout();
+    }
+    if (result2 === undefined) {
+        return t.bailout();
+    }
+    if (result0.status !== "fulfilled") {
+        return t.fail();
+    }
+    t.matchOnly(result0.value, 42);
+    if (result1.status !== "rejected") {
+        return t.fail();
+    }
+    t.matchOnly(result1.reason, new Error("an error happened"));
+    if (result2.status !== "fulfilled") {
+        return t.fail();
+    }
+    t.matchOnly(result2.value, 1337);
+});

package/dist/src/routes.d.ts

@@ -2,6 +2,10 @@ import { Hono } from "hono";
 import type { FacilitatorHandler } from "@faremeter/types/facilitator";
 type CreateFacilitatorRoutesArgs = {
     handlers: FacilitatorHandler[];
+    timeout?: {
+        getRequirements?: number;
+        getSupported?: number;
+    };
 };
 export declare function createFacilitatorRoutes(args: CreateFacilitatorRoutesArgs): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
 export {};

package/dist/src/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/routes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAgB,MAAM,MAAM,CAAC;AAG1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAIvE,KAAK,2BAA2B,GAAG;IACjC,QAAQ,EAAE,kBAAkB,EAAE,CAAC;CAChC,CAAC;AAIF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,2BAA2B,8EAsGxE"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/routes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAgB,MAAM,MAAM,CAAC;AAI1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAKvE,KAAK,2BAA2B,GAAG;IACjC,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,OAAO,CAAC,EAAE;QACR,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH,CAAC;AAkBF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,2BAA2B,8EAmLxE"}

package/dist/src/routes.js

@@ -2,7 +2,17 @@ import { getLogger } from "@logtape/logtape";
 import { Hono } from "hono";
 import * as x from "@faremeter/types/x402";
 import { isValidationError } from "@faremeter/types";
+import {} from "@faremeter/types/x402";
+import { allSettledWithTimeout } from "./promise.js";
 const logger = getLogger(["faremeter", "facilitator"]);
+function summarizeRequirements({ scheme, network, asset, payTo, }) {
+    return {
+        scheme,
+        network,
+        asset,
+        payTo,
+    };
+}
 export function createFacilitatorRoutes(args) {
     const router = new Hono();
     function sendSettleError(c, status, msg) {
@@ -30,6 +40,7 @@ export function createFacilitatorRoutes(args) {
         if (isValidationError(paymentPayload)) {
             return sendSettleError(c, 400, `couldn't validate x402 payload: ${paymentPayload.summary}`);
         }
+        logger.debug("starting settlement attempt for request: {*}", x402Req);
         for (const handler of args.handlers) {
             let t;
             try {
@@ -50,21 +61,71 @@ export function createFacilitatorRoutes(args) {
             if (t === null) {
                 continue;
             }
+            logger.info(`${t.success ? "succeeded" : "failed"} settlement request: {*}`, {
+                requirements: summarizeRequirements(x402Req.paymentRequirements),
+                txHash: t.txHash,
+            });
             return c.json(t);
         }
         sendSettleError(c, 400, "no matching payment handler found");
+        logger.warning("attempt to settle was made with no handler found, requirements summary was: {*}", summarizeRequirements(x402Req.paymentRequirements));
     });
     router.post("/accepts", async (c) => {
         const x402Req = x.x402PaymentRequiredResponse(await c.req.json());
         if (isValidationError(x402Req)) {
             return sendSettleError(c, 400, `couldn't parse required response: ${x402Req.summary}`);
         }
-        const accepts = (await Promise.all(args.handlers.flatMap((x) => x.getRequirements(x402Req.accepts)))).flat();
+        const results = await allSettledWithTimeout(args.handlers.flatMap((x) => x.getRequirements(x402Req.accepts)), args.timeout?.getRequirements ?? 500);
+        const accepts = results
+            .filter((x) => x.status === "fulfilled")
+            .map((x) => x.value)
+            .flat();
+        results.forEach((x) => {
+            if (x.status === "rejected") {
+                let message;
+                if (x.reason instanceof Error) {
+                    message = x.reason.message;
+                }
+                else {
+                    message = "unknown reason";
+                }
+                logger.error(`failed to retrieve requirements from facilitator handler: ${message}`, x.reason);
+            }
+        });
+        logger.debug(`returning ${accepts.length} accepts: {*}`, {
+            accepts: accepts.map(summarizeRequirements),
+        });
         c.status(200);
         return c.json({
             x402Version: 1,
             accepts,
         });
     });
+    router.get("/supported", async (c) => {
+        const results = await allSettledWithTimeout(args.handlers.flatMap((x) => (x.getSupported ? x.getSupported() : [])), args.timeout?.getSupported ?? 500);
+        const kinds = results
+            .filter((x) => x.status === "fulfilled")
+            .map((x) => x.value)
+            .flat();
+        results.forEach((x) => {
+            if (x.status === "rejected") {
+                let message;
+                if (x.reason instanceof Error) {
+                    message = x.reason.message;
+                }
+                else {
+                    message = "unknown reason";
+                }
+                logger.error(`failed to retrieve supported from facilitator handler: ${message}`, x.reason);
+            }
+        });
+        logger.debug(`returning ${kinds.length} kinds supported: {*}`, {
+            kinds,
+        });
+        c.status(200);
+        return c.json({
+            kinds,
+        });
+    });
     return router;
 }