@parallel-protocol/mpp 0.1.0

package/dist/chunk-RNM3RDKR.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+// src/timeout.ts
+var HANDLER_TIMEOUT_MS = 3e4;
+var HANDLER_TIMEOUT = /* @__PURE__ */ Symbol("mpp:handler-timeout");
+async function raceTimeout(promise, ms = HANDLER_TIMEOUT_MS) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(HANDLER_TIMEOUT), ms);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+exports.HANDLER_TIMEOUT = HANDLER_TIMEOUT;
+exports.raceTimeout = raceTimeout;

package/dist/express.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+var chunkRNM3RDKR_cjs = require('./chunk-RNM3RDKR.cjs');
+var chunkILKUNJBE_cjs = require('./chunk-ILKUNJBE.cjs');
+
+// src/express/adapter.ts
+var TIMEOUT_BODY = JSON.stringify({
+  error: "HANDLER_TIMEOUT",
+  message: "The resource handler did not respond in time."
+});
+var ExpressAdapter = class {
+  constructor(req, res, next) {
+    this.req = req;
+    this.res = res;
+    this.next = next;
+  }
+  req;
+  res;
+  next;
+  getHeader(name) {
+    const value = this.req.header(name);
+    return Array.isArray(value) ? value[0] : value;
+  }
+  getMethod() {
+    return this.req.method;
+  }
+  getPath() {
+    return this.req.path;
+  }
+  getUrl() {
+    return `${this.req.protocol}://${this.req.headers.host}${this.req.originalUrl}`;
+  }
+  async runHandler() {
+    const res = this.res;
+    const next = this.next;
+    const originalWriteHead = res.writeHead.bind(res);
+    const originalWrite = res.write.bind(res);
+    const originalEnd = res.end.bind(res);
+    const buffered = [];
+    let settled = false;
+    let discarded = false;
+    let endCalled;
+    const endPromise = new Promise((resolve) => {
+      endCalled = resolve;
+    });
+    const restore = () => {
+      res.writeHead = originalWriteHead;
+      res.write = originalWrite;
+      res.end = originalEnd;
+    };
+    res.writeHead = ((...args) => {
+      if (discarded) return res;
+      if (!settled) {
+        buffered.push(["writeHead", args]);
+        return res;
+      }
+      return originalWriteHead(...args);
+    });
+    res.write = ((...args) => {
+      if (discarded) return true;
+      if (!settled) {
+        buffered.push(["write", args]);
+        return true;
+      }
+      return originalWrite(...args);
+    });
+    res.end = ((...args) => {
+      if (discarded) return res;
+      if (!settled) {
+        buffered.push(["end", args]);
+        endCalled();
+        return res;
+      }
+      return originalEnd(...args);
+    });
+    next();
+    const outcome = await chunkRNM3RDKR_cjs.raceTimeout(endPromise);
+    if (outcome === chunkRNM3RDKR_cjs.HANDLER_TIMEOUT) {
+      discarded = true;
+      return {
+        status: 504,
+        setResponseHeader: (name, value) => {
+          if (!res.headersSent) res.setHeader(name, value);
+        },
+        sendResponse: () => {
+          if (res.headersSent) return;
+          originalWriteHead(504, { "Content-Type": "application/json" });
+          originalEnd(TIMEOUT_BODY);
+        },
+        discardResponse: () => {
+        }
+      };
+    }
+    return {
+      status: res.statusCode,
+      setResponseHeader: (name, value) => res.setHeader(name, value),
+      sendResponse: () => {
+        settled = true;
+        restore();
+        for (const [method, args] of buffered) {
+          if (method === "writeHead") originalWriteHead(...args);
+          else if (method === "write") originalWrite(...args);
+          else if (method === "end") originalEnd(...args);
+        }
+      },
+      discardResponse: () => {
+        settled = true;
+        restore();
+      }
+    };
+  }
+};
+
+// src/express/index.ts
+function paymentMiddleware(config) {
+  const middleware = chunkILKUNJBE_cjs.createMppPaymentMiddleware(config);
+  return async (req, res, next) => {
+    const result = await middleware(new ExpressAdapter(req, res, next));
+    if ("pass" in result) {
+      if (result.handlerRan) return;
+      return next();
+    }
+    for (const [key, value] of Object.entries(result.headers)) {
+      res.setHeader(key, value);
+    }
+    res.status(result.status).json(result.body);
+  };
+}
+
+exports.ExpressAdapter = ExpressAdapter;
+exports.paymentMiddleware = paymentMiddleware;

package/dist/express.d.cts

@@ -0,0 +1,20 @@
+import { Request, Response, NextFunction } from 'express';
+import { H as HTTPAdapter, R as RunHandlerResult, M as MppMiddlewareConfig } from './types-CCE-FI8i.cjs';
+import '@parallel-protocol/mpp-types';
+import 'viem';
+
+declare class ExpressAdapter implements HTTPAdapter {
+    private readonly req;
+    private readonly res;
+    private readonly next;
+    constructor(req: Request, res: Response, next: NextFunction);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    runHandler(): Promise<RunHandlerResult>;
+}
+
+declare function paymentMiddleware(config: MppMiddlewareConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+
+export { ExpressAdapter, paymentMiddleware };

package/dist/express.d.ts

@@ -0,0 +1,20 @@
+import { Request, Response, NextFunction } from 'express';
+import { H as HTTPAdapter, R as RunHandlerResult, M as MppMiddlewareConfig } from './types-CCE-FI8i.js';
+import '@parallel-protocol/mpp-types';
+import 'viem';
+
+declare class ExpressAdapter implements HTTPAdapter {
+    private readonly req;
+    private readonly res;
+    private readonly next;
+    constructor(req: Request, res: Response, next: NextFunction);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    runHandler(): Promise<RunHandlerResult>;
+}
+
+declare function paymentMiddleware(config: MppMiddlewareConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+
+export { ExpressAdapter, paymentMiddleware };

package/dist/express.js

@@ -0,0 +1,128 @@
+import { raceTimeout, HANDLER_TIMEOUT } from './chunk-DXHOWEAQ.js';
+import { createMppPaymentMiddleware } from './chunk-HTUIO2MB.js';
+
+// src/express/adapter.ts
+var TIMEOUT_BODY = JSON.stringify({
+  error: "HANDLER_TIMEOUT",
+  message: "The resource handler did not respond in time."
+});
+var ExpressAdapter = class {
+  constructor(req, res, next) {
+    this.req = req;
+    this.res = res;
+    this.next = next;
+  }
+  req;
+  res;
+  next;
+  getHeader(name) {
+    const value = this.req.header(name);
+    return Array.isArray(value) ? value[0] : value;
+  }
+  getMethod() {
+    return this.req.method;
+  }
+  getPath() {
+    return this.req.path;
+  }
+  getUrl() {
+    return `${this.req.protocol}://${this.req.headers.host}${this.req.originalUrl}`;
+  }
+  async runHandler() {
+    const res = this.res;
+    const next = this.next;
+    const originalWriteHead = res.writeHead.bind(res);
+    const originalWrite = res.write.bind(res);
+    const originalEnd = res.end.bind(res);
+    const buffered = [];
+    let settled = false;
+    let discarded = false;
+    let endCalled;
+    const endPromise = new Promise((resolve) => {
+      endCalled = resolve;
+    });
+    const restore = () => {
+      res.writeHead = originalWriteHead;
+      res.write = originalWrite;
+      res.end = originalEnd;
+    };
+    res.writeHead = ((...args) => {
+      if (discarded) return res;
+      if (!settled) {
+        buffered.push(["writeHead", args]);
+        return res;
+      }
+      return originalWriteHead(...args);
+    });
+    res.write = ((...args) => {
+      if (discarded) return true;
+      if (!settled) {
+        buffered.push(["write", args]);
+        return true;
+      }
+      return originalWrite(...args);
+    });
+    res.end = ((...args) => {
+      if (discarded) return res;
+      if (!settled) {
+        buffered.push(["end", args]);
+        endCalled();
+        return res;
+      }
+      return originalEnd(...args);
+    });
+    next();
+    const outcome = await raceTimeout(endPromise);
+    if (outcome === HANDLER_TIMEOUT) {
+      discarded = true;
+      return {
+        status: 504,
+        setResponseHeader: (name, value) => {
+          if (!res.headersSent) res.setHeader(name, value);
+        },
+        sendResponse: () => {
+          if (res.headersSent) return;
+          originalWriteHead(504, { "Content-Type": "application/json" });
+          originalEnd(TIMEOUT_BODY);
+        },
+        discardResponse: () => {
+        }
+      };
+    }
+    return {
+      status: res.statusCode,
+      setResponseHeader: (name, value) => res.setHeader(name, value),
+      sendResponse: () => {
+        settled = true;
+        restore();
+        for (const [method, args] of buffered) {
+          if (method === "writeHead") originalWriteHead(...args);
+          else if (method === "write") originalWrite(...args);
+          else if (method === "end") originalEnd(...args);
+        }
+      },
+      discardResponse: () => {
+        settled = true;
+        restore();
+      }
+    };
+  }
+};
+
+// src/express/index.ts
+function paymentMiddleware(config) {
+  const middleware = createMppPaymentMiddleware(config);
+  return async (req, res, next) => {
+    const result = await middleware(new ExpressAdapter(req, res, next));
+    if ("pass" in result) {
+      if (result.handlerRan) return;
+      return next();
+    }
+    for (const [key, value] of Object.entries(result.headers)) {
+      res.setHeader(key, value);
+    }
+    res.status(result.status).json(result.body);
+  };
+}
+
+export { ExpressAdapter, paymentMiddleware };

package/dist/fastify.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var chunkILKUNJBE_cjs = require('./chunk-ILKUNJBE.cjs');
+var mppTypes = require('@parallel-protocol/mpp-types');
+
+// src/fastify/adapter.ts
+var FastifyAdapter = class {
+  constructor(req) {
+    this.req = req;
+  }
+  req;
+  getHeader(name) {
+    const value = this.req.headers[name.toLowerCase()];
+    return Array.isArray(value) ? value[0] : value;
+  }
+  getMethod() {
+    return this.req.method;
+  }
+  getPath() {
+    return this.req.url.split("?")[0] ?? "/";
+  }
+  getUrl() {
+    return `${this.req.protocol}://${this.req.host || this.req.hostname}${this.req.url}`;
+  }
+};
+
+// src/fastify/index.ts
+function paymentMiddleware(config) {
+  return async (fastify) => {
+    const gate = chunkILKUNJBE_cjs.createMppPaymentGate(config);
+    const settleMap = /* @__PURE__ */ new WeakMap();
+    fastify.addHook("onRequest", async (req, reply) => {
+      const gateResult = await gate(new FastifyAdapter(req));
+      if (gateResult.type === "pass") return;
+      if (gateResult.type === "error") {
+        for (const [key, value] of Object.entries(gateResult.result.headers)) {
+          reply.header(key, value);
+        }
+        reply.status(gateResult.result.status).send(gateResult.result.body);
+        return;
+      }
+      settleMap.set(req, gateResult.settle);
+    });
+    fastify.addHook("onSend", async (req, reply, payload) => {
+      const settle = settleMap.get(req);
+      if (!settle || !chunkILKUNJBE_cjs.isSuccessStatus(reply.statusCode)) {
+        return payload;
+      }
+      let settled = false;
+      try {
+        const settleResponse = await settle();
+        if (settleResponse.success) {
+          reply.header(
+            "Payment-Receipt",
+            mppTypes.encodeBase64Url(settleResponse.receipt)
+          );
+          reply.header("access-control-expose-headers", "Payment-Receipt");
+          settled = true;
+        }
+      } catch {
+      }
+      if (!settled) {
+        const body = JSON.stringify(chunkILKUNJBE_cjs.SETTLE_FAILURE_BODY);
+        reply.status(402);
+        reply.header("Content-Type", "application/json");
+        reply.header("Content-Length", Buffer.byteLength(body));
+        return body;
+      }
+      return payload;
+    });
+  };
+}
+
+exports.FastifyAdapter = FastifyAdapter;
+exports.paymentMiddleware = paymentMiddleware;

package/dist/fastify.d.cts

@@ -0,0 +1,17 @@
+import { FastifyRequest, FastifyPluginAsync } from 'fastify';
+import { H as HTTPAdapter, M as MppMiddlewareConfig } from './types-CCE-FI8i.cjs';
+import '@parallel-protocol/mpp-types';
+import 'viem';
+
+declare class FastifyAdapter implements HTTPAdapter {
+    private readonly req;
+    constructor(req: FastifyRequest);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+}
+
+declare function paymentMiddleware(config: MppMiddlewareConfig): FastifyPluginAsync;
+
+export { FastifyAdapter, paymentMiddleware };

package/dist/fastify.d.ts

@@ -0,0 +1,17 @@
+import { FastifyRequest, FastifyPluginAsync } from 'fastify';
+import { H as HTTPAdapter, M as MppMiddlewareConfig } from './types-CCE-FI8i.js';
+import '@parallel-protocol/mpp-types';
+import 'viem';
+
+declare class FastifyAdapter implements HTTPAdapter {
+    private readonly req;
+    constructor(req: FastifyRequest);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+}
+
+declare function paymentMiddleware(config: MppMiddlewareConfig): FastifyPluginAsync;
+
+export { FastifyAdapter, paymentMiddleware };

package/dist/fastify.js

@@ -0,0 +1,72 @@
+import { createMppPaymentGate, isSuccessStatus, SETTLE_FAILURE_BODY } from './chunk-HTUIO2MB.js';
+import { encodeBase64Url } from '@parallel-protocol/mpp-types';
+
+// src/fastify/adapter.ts
+var FastifyAdapter = class {
+  constructor(req) {
+    this.req = req;
+  }
+  req;
+  getHeader(name) {
+    const value = this.req.headers[name.toLowerCase()];
+    return Array.isArray(value) ? value[0] : value;
+  }
+  getMethod() {
+    return this.req.method;
+  }
+  getPath() {
+    return this.req.url.split("?")[0] ?? "/";
+  }
+  getUrl() {
+    return `${this.req.protocol}://${this.req.host || this.req.hostname}${this.req.url}`;
+  }
+};
+
+// src/fastify/index.ts
+function paymentMiddleware(config) {
+  return async (fastify) => {
+    const gate = createMppPaymentGate(config);
+    const settleMap = /* @__PURE__ */ new WeakMap();
+    fastify.addHook("onRequest", async (req, reply) => {
+      const gateResult = await gate(new FastifyAdapter(req));
+      if (gateResult.type === "pass") return;
+      if (gateResult.type === "error") {
+        for (const [key, value] of Object.entries(gateResult.result.headers)) {
+          reply.header(key, value);
+        }
+        reply.status(gateResult.result.status).send(gateResult.result.body);
+        return;
+      }
+      settleMap.set(req, gateResult.settle);
+    });
+    fastify.addHook("onSend", async (req, reply, payload) => {
+      const settle = settleMap.get(req);
+      if (!settle || !isSuccessStatus(reply.statusCode)) {
+        return payload;
+      }
+      let settled = false;
+      try {
+        const settleResponse = await settle();
+        if (settleResponse.success) {
+          reply.header(
+            "Payment-Receipt",
+            encodeBase64Url(settleResponse.receipt)
+          );
+          reply.header("access-control-expose-headers", "Payment-Receipt");
+          settled = true;
+        }
+      } catch {
+      }
+      if (!settled) {
+        const body = JSON.stringify(SETTLE_FAILURE_BODY);
+        reply.status(402);
+        reply.header("Content-Type", "application/json");
+        reply.header("Content-Length", Buffer.byteLength(body));
+        return body;
+      }
+      return payload;
+    });
+  };
+}
+
+export { FastifyAdapter, paymentMiddleware };

package/dist/hono.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var chunkRNM3RDKR_cjs = require('./chunk-RNM3RDKR.cjs');
+var chunkILKUNJBE_cjs = require('./chunk-ILKUNJBE.cjs');
+
+// src/hono/adapter.ts
+var TIMEOUT_BODY = JSON.stringify({
+  error: "HANDLER_TIMEOUT",
+  message: "The resource handler did not respond in time."
+});
+var HonoAdapter = class {
+  constructor(c, next) {
+    this.c = c;
+    this.next = next;
+  }
+  c;
+  next;
+  getHeader(name) {
+    return this.c.req.header(name);
+  }
+  getMethod() {
+    return this.c.req.method;
+  }
+  getPath() {
+    return this.c.req.path;
+  }
+  getUrl() {
+    return this.c.req.url;
+  }
+  async runHandler() {
+    const outcome = await chunkRNM3RDKR_cjs.raceTimeout(this.next());
+    if (outcome === chunkRNM3RDKR_cjs.HANDLER_TIMEOUT) {
+      return {
+        status: 504,
+        setResponseHeader: () => {
+        },
+        sendResponse: () => {
+          this.c.res = new Response(TIMEOUT_BODY, {
+            status: 504,
+            headers: { "Content-Type": "application/json" }
+          });
+        },
+        discardResponse: () => {
+        }
+      };
+    }
+    const res = this.c.res;
+    return {
+      status: res.status,
+      setResponseHeader: (name, value) => res.headers.set(name, value),
+      sendResponse: () => {
+      },
+      discardResponse: () => {
+      }
+    };
+  }
+};
+
+// src/hono/index.ts
+function paymentMiddleware(config) {
+  const middleware = chunkILKUNJBE_cjs.createMppPaymentMiddleware(config);
+  return async (c, next) => {
+    const result = await middleware(new HonoAdapter(c, next));
+    if ("pass" in result) {
+      if (result.handlerRan) return;
+      await next();
+      return;
+    }
+    return new Response(JSON.stringify(result.body), {
+      status: result.status,
+      headers: { ...result.headers, "Content-Type": "application/json" }
+    });
+  };
+}
+
+exports.HonoAdapter = HonoAdapter;
+exports.paymentMiddleware = paymentMiddleware;

package/dist/hono.d.cts

@@ -0,0 +1,19 @@
+import { Context, Next, MiddlewareHandler } from 'hono';
+import { H as HTTPAdapter, R as RunHandlerResult, M as MppMiddlewareConfig } from './types-CCE-FI8i.cjs';
+import '@parallel-protocol/mpp-types';
+import 'viem';
+
+declare class HonoAdapter implements HTTPAdapter {
+    private readonly c;
+    private readonly next;
+    constructor(c: Context, next: Next);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    runHandler(): Promise<RunHandlerResult>;
+}
+
+declare function paymentMiddleware(config: MppMiddlewareConfig): MiddlewareHandler;
+
+export { HonoAdapter, paymentMiddleware };

package/dist/hono.d.ts

@@ -0,0 +1,19 @@
+import { Context, Next, MiddlewareHandler } from 'hono';
+import { H as HTTPAdapter, R as RunHandlerResult, M as MppMiddlewareConfig } from './types-CCE-FI8i.js';
+import '@parallel-protocol/mpp-types';
+import 'viem';
+
+declare class HonoAdapter implements HTTPAdapter {
+    private readonly c;
+    private readonly next;
+    constructor(c: Context, next: Next);
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    runHandler(): Promise<RunHandlerResult>;
+}
+
+declare function paymentMiddleware(config: MppMiddlewareConfig): MiddlewareHandler;
+
+export { HonoAdapter, paymentMiddleware };

package/dist/hono.js

@@ -0,0 +1,74 @@
+import { raceTimeout, HANDLER_TIMEOUT } from './chunk-DXHOWEAQ.js';
+import { createMppPaymentMiddleware } from './chunk-HTUIO2MB.js';
+
+// src/hono/adapter.ts
+var TIMEOUT_BODY = JSON.stringify({
+  error: "HANDLER_TIMEOUT",
+  message: "The resource handler did not respond in time."
+});
+var HonoAdapter = class {
+  constructor(c, next) {
+    this.c = c;
+    this.next = next;
+  }
+  c;
+  next;
+  getHeader(name) {
+    return this.c.req.header(name);
+  }
+  getMethod() {
+    return this.c.req.method;
+  }
+  getPath() {
+    return this.c.req.path;
+  }
+  getUrl() {
+    return this.c.req.url;
+  }
+  async runHandler() {
+    const outcome = await raceTimeout(this.next());
+    if (outcome === HANDLER_TIMEOUT) {
+      return {
+        status: 504,
+        setResponseHeader: () => {
+        },
+        sendResponse: () => {
+          this.c.res = new Response(TIMEOUT_BODY, {
+            status: 504,
+            headers: { "Content-Type": "application/json" }
+          });
+        },
+        discardResponse: () => {
+        }
+      };
+    }
+    const res = this.c.res;
+    return {
+      status: res.status,
+      setResponseHeader: (name, value) => res.headers.set(name, value),
+      sendResponse: () => {
+      },
+      discardResponse: () => {
+      }
+    };
+  }
+};
+
+// src/hono/index.ts
+function paymentMiddleware(config) {
+  const middleware = createMppPaymentMiddleware(config);
+  return async (c, next) => {
+    const result = await middleware(new HonoAdapter(c, next));
+    if ("pass" in result) {
+      if (result.handlerRan) return;
+      await next();
+      return;
+    }
+    return new Response(JSON.stringify(result.body), {
+      status: result.status,
+      headers: { ...result.headers, "Content-Type": "application/json" }
+    });
+  };
+}
+
+export { HonoAdapter, paymentMiddleware };