@openfacilitator/sdk 0.3.0 → 0.6.0

package/dist/index.js

@@ -28,14 +28,24 @@ __export(index_exports, {
   SettlementError: () => SettlementError,
   VerificationError: () => VerificationError,
   createDefaultFacilitator: () => createDefaultFacilitator,
+  createPaymentContext: () => createPaymentContext,
+  createPaymentMiddleware: () => createPaymentMiddleware,
+  createRefundMiddleware: () => createRefundMiddleware,
+  executeClaim: () => executeClaim,
+  getClaimHistory: () => getClaimHistory,
+  getClaimable: () => getClaimable,
   getMainnets: () => getMainnets,
   getNetwork: () => getNetwork,
   getNetworkType: () => getNetworkType,
   getTestnets: () => getTestnets,
+  honoPaymentMiddleware: () => honoPaymentMiddleware,
+  honoRefundMiddleware: () => honoRefundMiddleware,
   isPaymentPayload: () => isPaymentPayload,
   isValidNetwork: () => isValidNetwork,
+  reportFailure: () => reportFailure,
   toV1NetworkId: () => toV1NetworkId,
-  toV2NetworkId: () => toV2NetworkId
+  toV2NetworkId: () => toV2NetworkId,
+  withRefundProtection: () => withRefundProtection
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -334,6 +344,434 @@ function getMainnets() {
 function getTestnets() {
   return NETWORKS.filter((n) => n.testnet);
 }
+
+// src/claims.ts
+async function reportFailure(params) {
+  const {
+    facilitatorUrl,
+    apiKey,
+    originalTxHash,
+    userWallet,
+    amount,
+    asset,
+    network,
+    reason
+  } = params;
+  const baseUrl = facilitatorUrl.replace(/\/$/, "");
+  try {
+    const response = await fetch(`${baseUrl}/claims/report-failure`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Server-Api-Key": apiKey
+      },
+      body: JSON.stringify({
+        originalTxHash,
+        userWallet,
+        amount,
+        asset,
+        network,
+        reason
+      })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: data.error || `HTTP ${response.status}`
+      };
+    }
+    return data;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function getClaimable(params) {
+  const { facilitatorUrl, wallet, facilitator } = params;
+  const baseUrl = facilitatorUrl.replace(/\/$/, "");
+  const queryParams = new URLSearchParams({ wallet });
+  if (facilitator) {
+    queryParams.set("facilitator", facilitator);
+  }
+  const response = await fetch(`${baseUrl}/api/claims?${queryParams.toString()}`);
+  const data = await response.json();
+  if (!response.ok) {
+    throw new Error(data.error || `HTTP ${response.status}`);
+  }
+  return data;
+}
+async function getClaimHistory(params) {
+  const { facilitatorUrl, wallet, facilitator } = params;
+  const baseUrl = facilitatorUrl.replace(/\/$/, "");
+  const queryParams = new URLSearchParams({ wallet });
+  if (facilitator) {
+    queryParams.set("facilitator", facilitator);
+  }
+  const response = await fetch(`${baseUrl}/api/claims/history?${queryParams.toString()}`);
+  const data = await response.json();
+  if (!response.ok) {
+    throw new Error(data.error || `HTTP ${response.status}`);
+  }
+  return data;
+}
+async function executeClaim(params) {
+  const { facilitatorUrl, claimId, signature } = params;
+  const baseUrl = facilitatorUrl.replace(/\/$/, "");
+  try {
+    const response = await fetch(`${baseUrl}/api/claims/${claimId}/execute`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ signature })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: data.error || `HTTP ${response.status}`
+      };
+    }
+    return data;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+// src/middleware.ts
+function withRefundProtection(config, handler) {
+  return async (context) => {
+    try {
+      return await handler(context);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (config.shouldReport && !config.shouldReport(err)) {
+        throw error;
+      }
+      try {
+        const result = await reportFailure({
+          facilitatorUrl: config.facilitatorUrl,
+          apiKey: config.apiKey,
+          originalTxHash: context.transactionHash,
+          userWallet: context.userWallet,
+          amount: context.amount,
+          asset: context.asset,
+          network: context.network,
+          reason: err.message
+        });
+        if (config.onReport) {
+          config.onReport(result.claimId, err);
+        }
+      } catch (reportError) {
+        if (config.onReportError) {
+          config.onReportError(
+            reportError instanceof Error ? reportError : new Error(String(reportError)),
+            err
+          );
+        }
+      }
+      throw error;
+    }
+  };
+}
+function createRefundMiddleware(config) {
+  return async (req, res, next) => {
+    const originalNext = next;
+    const paymentContext = res.locals?.paymentContext || req.paymentContext;
+    if (!paymentContext) {
+      return originalNext();
+    }
+    const wrappedNext = async (error) => {
+      if (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (!config.shouldReport || config.shouldReport(err)) {
+          try {
+            const result = await reportFailure({
+              facilitatorUrl: config.facilitatorUrl,
+              apiKey: config.apiKey,
+              originalTxHash: paymentContext.transactionHash,
+              userWallet: paymentContext.userWallet,
+              amount: paymentContext.amount,
+              asset: paymentContext.asset,
+              network: paymentContext.network,
+              reason: err.message
+            });
+            if (config.onReport) {
+              config.onReport(result.claimId, err);
+            }
+          } catch (reportError) {
+            if (config.onReportError) {
+              config.onReportError(
+                reportError instanceof Error ? reportError : new Error(String(reportError)),
+                err
+              );
+            }
+          }
+        }
+      }
+      originalNext(error);
+    };
+    next = wrappedNext;
+    originalNext();
+  };
+}
+function honoRefundMiddleware(config) {
+  return async (c, next) => {
+    const paymentContext = config.getPaymentContext(c);
+    if (!paymentContext) {
+      return next();
+    }
+    try {
+      await next();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (!config.shouldReport || config.shouldReport(err)) {
+        try {
+          const result = await reportFailure({
+            facilitatorUrl: config.facilitatorUrl,
+            apiKey: config.apiKey,
+            originalTxHash: paymentContext.transactionHash,
+            userWallet: paymentContext.userWallet,
+            amount: paymentContext.amount,
+            asset: paymentContext.asset,
+            network: paymentContext.network,
+            reason: err.message
+          });
+          if (config.onReport) {
+            config.onReport(result.claimId, err);
+          }
+        } catch (reportError) {
+          if (config.onReportError) {
+            config.onReportError(
+              reportError instanceof Error ? reportError : new Error(String(reportError)),
+              err
+            );
+          }
+        }
+      }
+      throw error;
+    }
+  };
+}
+function createPaymentContext(settleResponse, paymentPayload) {
+  return {
+    transactionHash: settleResponse.transaction,
+    userWallet: settleResponse.payer,
+    amount: paymentPayload.payload.authorization.amount,
+    asset: paymentPayload.payload.authorization.asset,
+    network: settleResponse.network
+  };
+}
+function createPaymentMiddleware(config) {
+  const facilitator = typeof config.facilitator === "string" ? new OpenFacilitator({ url: config.facilitator }) : config.facilitator;
+  return async (req, res, next) => {
+    try {
+      const rawRequirements = await config.getRequirements(req);
+      const requirementsArray = Array.isArray(rawRequirements) ? rawRequirements : [rawRequirements];
+      const paymentHeader = req.headers["x-payment"];
+      const paymentString = Array.isArray(paymentHeader) ? paymentHeader[0] : paymentHeader;
+      if (!paymentString) {
+        if (config.on402) {
+          await config.on402(req, res, requirementsArray);
+        } else {
+          const accepts = requirementsArray.map((requirements2) => {
+            const extra = {
+              ...requirements2.extra
+            };
+            if (config.refundProtection) {
+              extra.supportsRefunds = true;
+            }
+            return {
+              scheme: requirements2.scheme,
+              network: requirements2.network,
+              maxAmountRequired: requirements2.maxAmountRequired,
+              asset: requirements2.asset,
+              payTo: requirements2.payTo,
+              resource: requirements2.resource || req.url,
+              description: requirements2.description,
+              ...Object.keys(extra).length > 0 ? { extra } : {}
+            };
+          });
+          res.status(402).json({
+            error: "Payment Required",
+            accepts
+          });
+        }
+        return;
+      }
+      let paymentPayload;
+      try {
+        paymentPayload = JSON.parse(paymentString);
+        if (!isPaymentPayload(paymentPayload)) {
+          throw new Error("Invalid payment payload structure");
+        }
+      } catch {
+        res.status(400).json({ error: "Invalid X-PAYMENT header" });
+        return;
+      }
+      const paymentNetwork = paymentPayload.network;
+      const requirements = requirementsArray.find((r) => r.network === paymentNetwork) || requirementsArray[0];
+      const verifyResult = await facilitator.verify(paymentPayload, requirements);
+      if (!verifyResult.isValid) {
+        res.status(402).json({
+          error: "Payment verification failed",
+          reason: verifyResult.invalidReason
+        });
+        return;
+      }
+      const settleResult = await facilitator.settle(paymentPayload, requirements);
+      if (!settleResult.success) {
+        res.status(402).json({
+          error: "Payment settlement failed",
+          reason: settleResult.errorReason
+        });
+        return;
+      }
+      const paymentContext = createPaymentContext(settleResult, paymentPayload);
+      req.paymentContext = paymentContext;
+      if (res.locals) {
+        res.locals.paymentContext = paymentContext;
+      }
+      if (config.refundProtection) {
+        const originalNext = next;
+        const refundConfig = config.refundProtection;
+        next = async (error) => {
+          if (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            if (!refundConfig.shouldReport || refundConfig.shouldReport(err)) {
+              try {
+                const result = await reportFailure({
+                  facilitatorUrl: refundConfig.facilitatorUrl,
+                  apiKey: refundConfig.apiKey,
+                  originalTxHash: paymentContext.transactionHash,
+                  userWallet: paymentContext.userWallet,
+                  amount: paymentContext.amount,
+                  asset: paymentContext.asset,
+                  network: paymentContext.network,
+                  reason: err.message
+                });
+                if (refundConfig.onReport) {
+                  refundConfig.onReport(result.claimId, err);
+                }
+              } catch (reportError) {
+                if (refundConfig.onReportError) {
+                  refundConfig.onReportError(
+                    reportError instanceof Error ? reportError : new Error(String(reportError)),
+                    err
+                  );
+                }
+              }
+            }
+          }
+          originalNext(error);
+        };
+      }
+      next();
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+function honoPaymentMiddleware(config) {
+  const facilitator = typeof config.facilitator === "string" ? new OpenFacilitator({ url: config.facilitator }) : config.facilitator;
+  return async (c, next) => {
+    const rawRequirements = await config.getRequirements(c);
+    const requirementsArray = Array.isArray(rawRequirements) ? rawRequirements : [rawRequirements];
+    const paymentString = c.req.header("x-payment");
+    if (!paymentString) {
+      const accepts = requirementsArray.map((requirements2) => {
+        const extra = {
+          ...requirements2.extra
+        };
+        if (config.refundProtection) {
+          extra.supportsRefunds = true;
+        }
+        return {
+          scheme: requirements2.scheme,
+          network: requirements2.network,
+          maxAmountRequired: requirements2.maxAmountRequired,
+          asset: requirements2.asset,
+          payTo: requirements2.payTo,
+          resource: requirements2.resource || c.req.url,
+          description: requirements2.description,
+          ...Object.keys(extra).length > 0 ? { extra } : {}
+        };
+      });
+      return c.json({
+        error: "Payment Required",
+        accepts
+      }, 402);
+    }
+    let paymentPayload;
+    try {
+      paymentPayload = JSON.parse(paymentString);
+      if (!isPaymentPayload(paymentPayload)) {
+        throw new Error("Invalid payment payload structure");
+      }
+    } catch {
+      return c.json({ error: "Invalid X-PAYMENT header" }, 400);
+    }
+    const paymentNetwork = paymentPayload.network;
+    const requirements = requirementsArray.find((r) => r.network === paymentNetwork) || requirementsArray[0];
+    const verifyResult = await facilitator.verify(paymentPayload, requirements);
+    if (!verifyResult.isValid) {
+      return c.json({
+        error: "Payment verification failed",
+        reason: verifyResult.invalidReason
+      }, 402);
+    }
+    const settleResult = await facilitator.settle(paymentPayload, requirements);
+    if (!settleResult.success) {
+      return c.json({
+        error: "Payment settlement failed",
+        reason: settleResult.errorReason
+      }, 402);
+    }
+    const paymentContext = createPaymentContext(settleResult, paymentPayload);
+    c.set("paymentContext", paymentContext);
+    if (config.refundProtection) {
+      const refundConfig = config.refundProtection;
+      try {
+        await next();
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (!refundConfig.shouldReport || refundConfig.shouldReport(err)) {
+          try {
+            const result = await reportFailure({
+              facilitatorUrl: refundConfig.facilitatorUrl,
+              apiKey: refundConfig.apiKey,
+              originalTxHash: paymentContext.transactionHash,
+              userWallet: paymentContext.userWallet,
+              amount: paymentContext.amount,
+              asset: paymentContext.asset,
+              network: paymentContext.network,
+              reason: err.message
+            });
+            if (refundConfig.onReport) {
+              refundConfig.onReport(result.claimId, err);
+            }
+          } catch (reportError) {
+            if (refundConfig.onReportError) {
+              refundConfig.onReportError(
+                reportError instanceof Error ? reportError : new Error(String(reportError)),
+                err
+              );
+            }
+          }
+        }
+        throw error;
+      }
+    } else {
+      await next();
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConfigurationError,
@@ -344,12 +782,22 @@ function getTestnets() {
   SettlementError,
   VerificationError,
   createDefaultFacilitator,
+  createPaymentContext,
+  createPaymentMiddleware,
+  createRefundMiddleware,
+  executeClaim,
+  getClaimHistory,
+  getClaimable,
   getMainnets,
   getNetwork,
   getNetworkType,
   getTestnets,
+  honoPaymentMiddleware,
+  honoRefundMiddleware,
   isPaymentPayload,
   isValidNetwork,
+  reportFailure,
   toV1NetworkId,
-  toV2NetworkId
+  toV2NetworkId,
+  withRefundProtection
 });