@parallel-protocol/mpp 0.1.0

package/dist/chunk-HTUIO2MB.js

@@ -0,0 +1,340 @@
+import { CHAIN_NAMES, CHAINS_STATIC } from '@parallel-protocol/chains';
+import { MppChargeCredentialSchema, MppVerifyResponseSchema, MppReceiptSchema, encodeBase64Url } from '@parallel-protocol/mpp-types';
+import { z } from 'zod';
+
+// src/errors.ts
+var MPP_ERROR_CODES = {
+  FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE",
+  FACILITATOR_INVALID_RESPONSE: "FACILITATOR_INVALID_RESPONSE",
+  INVALID_CREDENTIAL: "INVALID_CREDENTIAL",
+  METHOD_MISMATCH: "METHOD_MISMATCH"
+};
+var MppConfigError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "MppConfigError";
+    this.cause = cause;
+  }
+};
+var MppRuntimeError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "MppRuntimeError";
+  }
+  code;
+};
+function parseDecimalAmount(amount, decimals) {
+  const multiplier = 10n ** BigInt(decimals);
+  const parts = amount.split(".");
+  const whole = parts[0] ?? "0";
+  const fraction = (parts[1] ?? "").padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole) * multiplier + BigInt(fraction || "0");
+}
+function parsePrice(price, decimals = 6) {
+  if (typeof price === "bigint") return price;
+  const match = price.match(/^(\d+(?:\.\d+)?)$/);
+  if (match?.[1]) return parseDecimalAmount(match[1], decimals);
+  throw new Error(
+    `Invalid price format: "${price}". Expected "0.01" or a bigint.`
+  );
+}
+var CHAIN_ID_BY_SLUG = new Map(
+  CHAIN_NAMES.map((c) => [c, CHAINS_STATIC[c].viem.id])
+);
+function chainIdFromSlug(network) {
+  return CHAIN_ID_BY_SLUG.get(network);
+}
+function isSuccessStatus(status) {
+  return status >= 200 && status < 300;
+}
+var SETTLE_FAILURE_BODY = {
+  error: "PAYMENT_SETTLEMENT_FAILED",
+  message: "Payment could not be confirmed after multiple attempts. Please retry."
+};
+function matchRoute(path, routes) {
+  if (routes[path]) return routes[path];
+  let bestMatch;
+  let bestLength = 0;
+  for (const [pattern, config] of Object.entries(routes)) {
+    if (path.startsWith(`${pattern}/`) && pattern.length > bestLength) {
+      bestMatch = config;
+      bestLength = pattern.length;
+    }
+  }
+  return bestMatch;
+}
+var DEFAULT_TIMEOUT_SECONDS = 300;
+function challengeId() {
+  return globalThis.crypto.randomUUID();
+}
+function buildChargeRequest(route, chainId) {
+  return {
+    amount: parsePrice(route.price, route.decimals).toString(),
+    currency: route.currency,
+    recipient: route.payTo,
+    ...route.description ? { description: route.description } : {},
+    methodDetails: { chainId }
+  };
+}
+function buildChargeRequestB64(route) {
+  const chainId = chainIdFromSlug(route.network);
+  if (chainId === void 0) {
+    throw new MppConfigError(
+      `Unknown network "${route.network}" \u2014 not in the @parallel-protocol/chains catalogue`
+    );
+  }
+  return encodeBase64Url(buildChargeRequest(route, chainId));
+}
+function buildChallenge(route, request = buildChargeRequestB64(route)) {
+  const ttl = (route.maxTimeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1e3;
+  return {
+    id: challengeId(),
+    ...route.realm ? { realm: route.realm } : {},
+    method: route.method ?? "evm",
+    intent: "charge",
+    request,
+    expires: new Date(Date.now() + ttl).toISOString(),
+    ...route.description ? { description: route.description } : {}
+  };
+}
+function quote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function serializeChallenge(challenge) {
+  const params = [
+    ["realm", challenge.realm],
+    ["id", challenge.id],
+    ["method", challenge.method],
+    ["intent", challenge.intent],
+    ["request", challenge.request],
+    ["digest", challenge.digest],
+    ["expires", challenge.expires],
+    ["description", challenge.description],
+    ["opaque", challenge.opaque]
+  ];
+  const serialized = params.filter((p) => p[1] !== void 0).map(([k, v]) => `${k}=${quote(v)}`).join(", ");
+  return `Payment ${serialized}`;
+}
+function parseAuthorizationHeader(header) {
+  if (!header) return null;
+  const match = header.match(/^Payment\s+(.+)$/i);
+  if (!match?.[1]) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(
+      Buffer.from(match[1].trim(), "base64url").toString("utf8")
+    );
+  } catch {
+    return null;
+  }
+  const parsed = MppChargeCredentialSchema.safeParse(decoded);
+  return parsed.success ? parsed.data : null;
+}
+var FACILITATOR_TIMEOUT_MS = 1e4;
+var MppFacilitatorClient = class {
+  url;
+  headers;
+  constructor(config) {
+    this.url = config.url;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.apiKey ? { "X-API-Key": config.apiKey } : {}
+    };
+  }
+  /** Verify a credential (phase 1, no on-chain tx). Throws {@link MppRuntimeError} on failure. */
+  async verify(credential) {
+    let json;
+    try {
+      const response = await fetch(`${this.url}/mpp/verify`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ credential }),
+        signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => null);
+        const code = errorBody?.error ?? MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE;
+        throw new MppRuntimeError(code);
+      }
+      json = await response.json();
+    } catch (e) {
+      if (e instanceof MppRuntimeError) throw e;
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+    }
+    try {
+      MppVerifyResponseSchema.parse(json);
+    } catch {
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
+    }
+  }
+  /** Settle a credential (phase 2, on-chain). Returns the receipt or a failure. */
+  async settle(credential) {
+    let json;
+    try {
+      const response = await fetch(`${this.url}/mpp/settle`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ credential }),
+        signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => null);
+        return {
+          success: false,
+          error: {
+            code: errorBody?.error ?? "SETTLEMENT_FAILED",
+            message: errorBody?.message ?? "Settlement failed"
+          }
+        };
+      }
+      json = await response.json();
+    } catch (e) {
+      if (e instanceof MppRuntimeError) throw e;
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+    }
+    const parsed = MppReceiptSchema.safeParse(json);
+    if (!parsed.success) {
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
+    }
+    return { success: true, receipt: parsed.data };
+  }
+};
+var ethereumAddressSchema = z.string().regex(/^0x[0-9a-fA-F]{40}$/, "Invalid Ethereum address");
+var priceSchema = z.union([
+  z.bigint().positive("Price must be greater than 0"),
+  z.string().regex(/^\d+(?:\.\d+)?$/, 'Price must be in format "0.01"').refine((price) => Number(price) > 0, "Price must be greater than 0")
+]);
+var facilitatorConfigSchema = z.object({
+  url: z.string().refine((v) => URL.canParse(v), "Invalid facilitator URL"),
+  apiKey: z.string().optional()
+});
+var routeConfigSchema = z.object({
+  price: priceSchema,
+  decimals: z.number().int().nonnegative().optional(),
+  network: z.string().min(1, "Network is required"),
+  payTo: ethereumAddressSchema,
+  currency: ethereumAddressSchema,
+  method: z.enum(["evm", "parallel"]).optional(),
+  maxTimeoutSeconds: z.number().int().positive().optional(),
+  description: z.string().optional(),
+  realm: z.string().optional()
+});
+var mppMiddlewareConfigSchema = z.object({
+  facilitator: facilitatorConfigSchema,
+  routes: z.record(z.string(), routeConfigSchema).refine((r) => Object.keys(r).length > 0, "At least one route is required")
+});
+
+// src/middleware.ts
+function challengeResponse(route, request, error) {
+  const challenge = buildChallenge(route, request);
+  return {
+    status: 402,
+    headers: {
+      "Content-Type": "application/json",
+      "WWW-Authenticate": serializeChallenge(challenge),
+      "access-control-expose-headers": "WWW-Authenticate"
+    },
+    body: {
+      ...error ? { error } : {},
+      challenge
+    }
+  };
+}
+function createMppPaymentGate(config) {
+  try {
+    mppMiddlewareConfigSchema.parse(config);
+  } catch (cause) {
+    throw new MppConfigError(
+      "Invalid MPP middleware config \u2014 check your routes, facilitator URL, payTo and currency addresses",
+      cause
+    );
+  }
+  const client = new MppFacilitatorClient(config.facilitator);
+  const requestByRoute = new Map(
+    Object.values(config.routes).map((route) => [
+      route,
+      buildChargeRequestB64(route)
+    ])
+  );
+  return async (adapter) => {
+    if (adapter.getMethod().toUpperCase() === "OPTIONS")
+      return { type: "pass" };
+    const route = matchRoute(adapter.getPath(), config.routes);
+    if (!route) return { type: "pass" };
+    const request = requestByRoute.get(route);
+    const credential = parseAuthorizationHeader(
+      adapter.getHeader("authorization")
+    );
+    if (!credential) {
+      return { type: "error", result: challengeResponse(route, request) };
+    }
+    if (credential.challenge.method !== (route.method ?? "evm")) {
+      return {
+        type: "error",
+        result: challengeResponse(
+          route,
+          request,
+          MPP_ERROR_CODES.METHOD_MISMATCH
+        )
+      };
+    }
+    try {
+      await client.verify(credential);
+    } catch (e) {
+      const code = e instanceof MppRuntimeError ? e.code : MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE;
+      return {
+        type: "error",
+        result: challengeResponse(route, request, code)
+      };
+    }
+    return {
+      type: "verified",
+      settle: () => client.settle(credential)
+    };
+  };
+}
+function createMppPaymentMiddleware(config) {
+  const gate = createMppPaymentGate(config);
+  return async (adapter) => {
+    const gateResult = await gate(adapter);
+    if (gateResult.type === "pass") return { pass: true };
+    if (gateResult.type === "error") return gateResult.result;
+    let handlerResult;
+    try {
+      handlerResult = await adapter.runHandler();
+    } catch {
+      return { pass: true, handlerRan: true };
+    }
+    if (isSuccessStatus(handlerResult.status)) {
+      let settled = false;
+      try {
+        const settleResponse = await gateResult.settle();
+        if (settleResponse.success) {
+          handlerResult.setResponseHeader(
+            "Payment-Receipt",
+            encodeBase64Url(settleResponse.receipt)
+          );
+          handlerResult.setResponseHeader(
+            "access-control-expose-headers",
+            "Payment-Receipt"
+          );
+          settled = true;
+        }
+      } catch {
+      }
+      if (!settled) {
+        handlerResult.discardResponse();
+        return {
+          status: 402,
+          headers: { "Content-Type": "application/json" },
+          body: SETTLE_FAILURE_BODY
+        };
+      }
+    }
+    handlerResult.sendResponse();
+    return { pass: true, handlerRan: true };
+  };
+}
+
+export { MPP_ERROR_CODES, MppConfigError, MppFacilitatorClient, MppRuntimeError, SETTLE_FAILURE_BODY, buildChallenge, chainIdFromSlug, createMppPaymentGate, createMppPaymentMiddleware, isSuccessStatus, matchRoute, parseAuthorizationHeader, parsePrice, serializeChallenge };

package/dist/chunk-ILKUNJBE.cjs

@@ -0,0 +1,355 @@
+'use strict';
+
+var chains = require('@parallel-protocol/chains');
+var mppTypes = require('@parallel-protocol/mpp-types');
+var zod = require('zod');
+
+// src/errors.ts
+var MPP_ERROR_CODES = {
+  FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE",
+  FACILITATOR_INVALID_RESPONSE: "FACILITATOR_INVALID_RESPONSE",
+  INVALID_CREDENTIAL: "INVALID_CREDENTIAL",
+  METHOD_MISMATCH: "METHOD_MISMATCH"
+};
+var MppConfigError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "MppConfigError";
+    this.cause = cause;
+  }
+};
+var MppRuntimeError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "MppRuntimeError";
+  }
+  code;
+};
+function parseDecimalAmount(amount, decimals) {
+  const multiplier = 10n ** BigInt(decimals);
+  const parts = amount.split(".");
+  const whole = parts[0] ?? "0";
+  const fraction = (parts[1] ?? "").padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole) * multiplier + BigInt(fraction || "0");
+}
+function parsePrice(price, decimals = 6) {
+  if (typeof price === "bigint") return price;
+  const match = price.match(/^(\d+(?:\.\d+)?)$/);
+  if (match?.[1]) return parseDecimalAmount(match[1], decimals);
+  throw new Error(
+    `Invalid price format: "${price}". Expected "0.01" or a bigint.`
+  );
+}
+var CHAIN_ID_BY_SLUG = new Map(
+  chains.CHAIN_NAMES.map((c) => [c, chains.CHAINS_STATIC[c].viem.id])
+);
+function chainIdFromSlug(network) {
+  return CHAIN_ID_BY_SLUG.get(network);
+}
+function isSuccessStatus(status) {
+  return status >= 200 && status < 300;
+}
+var SETTLE_FAILURE_BODY = {
+  error: "PAYMENT_SETTLEMENT_FAILED",
+  message: "Payment could not be confirmed after multiple attempts. Please retry."
+};
+function matchRoute(path, routes) {
+  if (routes[path]) return routes[path];
+  let bestMatch;
+  let bestLength = 0;
+  for (const [pattern, config] of Object.entries(routes)) {
+    if (path.startsWith(`${pattern}/`) && pattern.length > bestLength) {
+      bestMatch = config;
+      bestLength = pattern.length;
+    }
+  }
+  return bestMatch;
+}
+var DEFAULT_TIMEOUT_SECONDS = 300;
+function challengeId() {
+  return globalThis.crypto.randomUUID();
+}
+function buildChargeRequest(route, chainId) {
+  return {
+    amount: parsePrice(route.price, route.decimals).toString(),
+    currency: route.currency,
+    recipient: route.payTo,
+    ...route.description ? { description: route.description } : {},
+    methodDetails: { chainId }
+  };
+}
+function buildChargeRequestB64(route) {
+  const chainId = chainIdFromSlug(route.network);
+  if (chainId === void 0) {
+    throw new MppConfigError(
+      `Unknown network "${route.network}" \u2014 not in the @parallel-protocol/chains catalogue`
+    );
+  }
+  return mppTypes.encodeBase64Url(buildChargeRequest(route, chainId));
+}
+function buildChallenge(route, request = buildChargeRequestB64(route)) {
+  const ttl = (route.maxTimeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1e3;
+  return {
+    id: challengeId(),
+    ...route.realm ? { realm: route.realm } : {},
+    method: route.method ?? "evm",
+    intent: "charge",
+    request,
+    expires: new Date(Date.now() + ttl).toISOString(),
+    ...route.description ? { description: route.description } : {}
+  };
+}
+function quote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function serializeChallenge(challenge) {
+  const params = [
+    ["realm", challenge.realm],
+    ["id", challenge.id],
+    ["method", challenge.method],
+    ["intent", challenge.intent],
+    ["request", challenge.request],
+    ["digest", challenge.digest],
+    ["expires", challenge.expires],
+    ["description", challenge.description],
+    ["opaque", challenge.opaque]
+  ];
+  const serialized = params.filter((p) => p[1] !== void 0).map(([k, v]) => `${k}=${quote(v)}`).join(", ");
+  return `Payment ${serialized}`;
+}
+function parseAuthorizationHeader(header) {
+  if (!header) return null;
+  const match = header.match(/^Payment\s+(.+)$/i);
+  if (!match?.[1]) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(
+      Buffer.from(match[1].trim(), "base64url").toString("utf8")
+    );
+  } catch {
+    return null;
+  }
+  const parsed = mppTypes.MppChargeCredentialSchema.safeParse(decoded);
+  return parsed.success ? parsed.data : null;
+}
+var FACILITATOR_TIMEOUT_MS = 1e4;
+var MppFacilitatorClient = class {
+  url;
+  headers;
+  constructor(config) {
+    this.url = config.url;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.apiKey ? { "X-API-Key": config.apiKey } : {}
+    };
+  }
+  /** Verify a credential (phase 1, no on-chain tx). Throws {@link MppRuntimeError} on failure. */
+  async verify(credential) {
+    let json;
+    try {
+      const response = await fetch(`${this.url}/mpp/verify`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ credential }),
+        signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => null);
+        const code = errorBody?.error ?? MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE;
+        throw new MppRuntimeError(code);
+      }
+      json = await response.json();
+    } catch (e) {
+      if (e instanceof MppRuntimeError) throw e;
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+    }
+    try {
+      mppTypes.MppVerifyResponseSchema.parse(json);
+    } catch {
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
+    }
+  }
+  /** Settle a credential (phase 2, on-chain). Returns the receipt or a failure. */
+  async settle(credential) {
+    let json;
+    try {
+      const response = await fetch(`${this.url}/mpp/settle`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ credential }),
+        signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => null);
+        return {
+          success: false,
+          error: {
+            code: errorBody?.error ?? "SETTLEMENT_FAILED",
+            message: errorBody?.message ?? "Settlement failed"
+          }
+        };
+      }
+      json = await response.json();
+    } catch (e) {
+      if (e instanceof MppRuntimeError) throw e;
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+    }
+    const parsed = mppTypes.MppReceiptSchema.safeParse(json);
+    if (!parsed.success) {
+      throw new MppRuntimeError(MPP_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
+    }
+    return { success: true, receipt: parsed.data };
+  }
+};
+var ethereumAddressSchema = zod.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "Invalid Ethereum address");
+var priceSchema = zod.z.union([
+  zod.z.bigint().positive("Price must be greater than 0"),
+  zod.z.string().regex(/^\d+(?:\.\d+)?$/, 'Price must be in format "0.01"').refine((price) => Number(price) > 0, "Price must be greater than 0")
+]);
+var facilitatorConfigSchema = zod.z.object({
+  url: zod.z.string().refine((v) => URL.canParse(v), "Invalid facilitator URL"),
+  apiKey: zod.z.string().optional()
+});
+var routeConfigSchema = zod.z.object({
+  price: priceSchema,
+  decimals: zod.z.number().int().nonnegative().optional(),
+  network: zod.z.string().min(1, "Network is required"),
+  payTo: ethereumAddressSchema,
+  currency: ethereumAddressSchema,
+  method: zod.z.enum(["evm", "parallel"]).optional(),
+  maxTimeoutSeconds: zod.z.number().int().positive().optional(),
+  description: zod.z.string().optional(),
+  realm: zod.z.string().optional()
+});
+var mppMiddlewareConfigSchema = zod.z.object({
+  facilitator: facilitatorConfigSchema,
+  routes: zod.z.record(zod.z.string(), routeConfigSchema).refine((r) => Object.keys(r).length > 0, "At least one route is required")
+});
+
+// src/middleware.ts
+function challengeResponse(route, request, error) {
+  const challenge = buildChallenge(route, request);
+  return {
+    status: 402,
+    headers: {
+      "Content-Type": "application/json",
+      "WWW-Authenticate": serializeChallenge(challenge),
+      "access-control-expose-headers": "WWW-Authenticate"
+    },
+    body: {
+      ...error ? { error } : {},
+      challenge
+    }
+  };
+}
+function createMppPaymentGate(config) {
+  try {
+    mppMiddlewareConfigSchema.parse(config);
+  } catch (cause) {
+    throw new MppConfigError(
+      "Invalid MPP middleware config \u2014 check your routes, facilitator URL, payTo and currency addresses",
+      cause
+    );
+  }
+  const client = new MppFacilitatorClient(config.facilitator);
+  const requestByRoute = new Map(
+    Object.values(config.routes).map((route) => [
+      route,
+      buildChargeRequestB64(route)
+    ])
+  );
+  return async (adapter) => {
+    if (adapter.getMethod().toUpperCase() === "OPTIONS")
+      return { type: "pass" };
+    const route = matchRoute(adapter.getPath(), config.routes);
+    if (!route) return { type: "pass" };
+    const request = requestByRoute.get(route);
+    const credential = parseAuthorizationHeader(
+      adapter.getHeader("authorization")
+    );
+    if (!credential) {
+      return { type: "error", result: challengeResponse(route, request) };
+    }
+    if (credential.challenge.method !== (route.method ?? "evm")) {
+      return {
+        type: "error",
+        result: challengeResponse(
+          route,
+          request,
+          MPP_ERROR_CODES.METHOD_MISMATCH
+        )
+      };
+    }
+    try {
+      await client.verify(credential);
+    } catch (e) {
+      const code = e instanceof MppRuntimeError ? e.code : MPP_ERROR_CODES.FACILITATOR_UNAVAILABLE;
+      return {
+        type: "error",
+        result: challengeResponse(route, request, code)
+      };
+    }
+    return {
+      type: "verified",
+      settle: () => client.settle(credential)
+    };
+  };
+}
+function createMppPaymentMiddleware(config) {
+  const gate = createMppPaymentGate(config);
+  return async (adapter) => {
+    const gateResult = await gate(adapter);
+    if (gateResult.type === "pass") return { pass: true };
+    if (gateResult.type === "error") return gateResult.result;
+    let handlerResult;
+    try {
+      handlerResult = await adapter.runHandler();
+    } catch {
+      return { pass: true, handlerRan: true };
+    }
+    if (isSuccessStatus(handlerResult.status)) {
+      let settled = false;
+      try {
+        const settleResponse = await gateResult.settle();
+        if (settleResponse.success) {
+          handlerResult.setResponseHeader(
+            "Payment-Receipt",
+            mppTypes.encodeBase64Url(settleResponse.receipt)
+          );
+          handlerResult.setResponseHeader(
+            "access-control-expose-headers",
+            "Payment-Receipt"
+          );
+          settled = true;
+        }
+      } catch {
+      }
+      if (!settled) {
+        handlerResult.discardResponse();
+        return {
+          status: 402,
+          headers: { "Content-Type": "application/json" },
+          body: SETTLE_FAILURE_BODY
+        };
+      }
+    }
+    handlerResult.sendResponse();
+    return { pass: true, handlerRan: true };
+  };
+}
+
+exports.MPP_ERROR_CODES = MPP_ERROR_CODES;
+exports.MppConfigError = MppConfigError;
+exports.MppFacilitatorClient = MppFacilitatorClient;
+exports.MppRuntimeError = MppRuntimeError;
+exports.SETTLE_FAILURE_BODY = SETTLE_FAILURE_BODY;
+exports.buildChallenge = buildChallenge;
+exports.chainIdFromSlug = chainIdFromSlug;
+exports.createMppPaymentGate = createMppPaymentGate;
+exports.createMppPaymentMiddleware = createMppPaymentMiddleware;
+exports.isSuccessStatus = isSuccessStatus;
+exports.matchRoute = matchRoute;
+exports.parseAuthorizationHeader = parseAuthorizationHeader;
+exports.parsePrice = parsePrice;
+exports.serializeChallenge = serializeChallenge;