@proofrails/sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,730 @@
+// src/types/common.ts
+var ProofRailsError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "ProofRailsError";
+  }
+};
+
+// src/client.ts
+var APIClient = class {
+  constructor(config = {}) {
+    this.rateLimitInfo = null;
+    const envBaseUrl = typeof process !== "undefined" && process.env?.NEXT_PUBLIC_PROOFRAILS_BASE_URL;
+    this.baseUrl = config.baseUrl || envBaseUrl || "http://127.0.0.1:8000";
+    this.apiKey = config.apiKey;
+    this.adminToken = config.adminToken;
+    this.timeout = config.timeout || 3e4;
+    this.retries = config.retries ?? 3;
+    this.retryDelay = config.retryDelay ?? 1e3;
+  }
+  getRateLimitInfo() {
+    return this.rateLimitInfo;
+  }
+  async get(endpoint, options = {}) {
+    return this.request("GET", endpoint, void 0, options);
+  }
+  async post(endpoint, body, options = {}) {
+    return this.request("POST", endpoint, body, options);
+  }
+  async put(endpoint, body, options = {}) {
+    return this.request("PUT", endpoint, body, options);
+  }
+  async delete(endpoint, options = {}) {
+    return this.request("DELETE", endpoint, void 0, options);
+  }
+  async request(method, endpoint, body, options = {}, attempt = 0) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    if (this.adminToken) {
+      headers["Authorization"] = `Bearer ${this.adminToken}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      console.log(`[ProofRails SDK] ${method} ${url}${attempt > 0 ? ` (retry ${attempt}/${this.retries})` : ""}`);
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal,
+        ...options
+      });
+      clearTimeout(timeoutId);
+      this.extractRateLimitInfo(response);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const error = new ProofRailsError(
+          errorData.message || errorData.detail || `HTTP ${response.status}: ${response.statusText}`,
+          errorData.code,
+          response.status,
+          errorData
+        );
+        if (this.shouldRetry(response.status, attempt)) {
+          return this.retryRequest(method, endpoint, body, options, attempt);
+        }
+        throw error;
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ProofRailsError) {
+        if (this.shouldRetry(0, attempt)) {
+          return this.retryRequest(method, endpoint, body, options, attempt);
+        }
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new ProofRailsError(`Request timeout after ${this.timeout}ms`, "TIMEOUT");
+        }
+        if (this.shouldRetry(0, attempt)) {
+          return this.retryRequest(method, endpoint, body, options, attempt);
+        }
+        throw new ProofRailsError(error.message, "NETWORK_ERROR");
+      }
+      throw new ProofRailsError("Unknown error occurred", "UNKNOWN_ERROR");
+    }
+  }
+  shouldRetry(statusCode, attempt) {
+    if (attempt >= this.retries) return false;
+    if (statusCode === 0) return true;
+    if (statusCode >= 500 && statusCode < 600) return true;
+    if (statusCode === 429) return true;
+    return false;
+  }
+  async retryRequest(method, endpoint, body, options, attempt) {
+    const delay = this.retryDelay * Math.pow(2, attempt);
+    console.log(`[ProofRails SDK] Retrying in ${delay}ms...`);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return this.request(method, endpoint, body, options, attempt + 1);
+  }
+  extractRateLimitInfo(response) {
+    const limit = response.headers.get("X-RateLimit-Limit");
+    const remaining = response.headers.get("X-RateLimit-Remaining");
+    const reset = response.headers.get("X-RateLimit-Reset");
+    if (limit && remaining && reset) {
+      const resetTimestamp = parseInt(reset, 10);
+      this.rateLimitInfo = {
+        limit: parseInt(limit, 10),
+        remaining: parseInt(remaining, 10),
+        reset: resetTimestamp,
+        resetDate: new Date(resetTimestamp * 1e3)
+      };
+    }
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  setAdminToken(adminToken) {
+    this.adminToken = adminToken;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+};
+
+// src/modules/projects.ts
+var ProjectsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getInfo() {
+    return this.client.get("/v1/whoami");
+  }
+  async rotateKey() {
+    return this.client.post("/v1/api-keys/rotate");
+  }
+  async create(options = {}) {
+    return this.client.post("/v1/public/api-keys", options);
+  }
+};
+var AdminModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async createKey(options) {
+    return this.client.post("/v1/admin/api-keys", options);
+  }
+  async deleteKey(keyId) {
+    return this.client.delete(`/v1/admin/api-keys/${keyId}`);
+  }
+};
+
+// src/modules/receipts.ts
+var ReceiptsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(options) {
+    const payload = {
+      tip_tx_hash: options.transactionHash,
+      chain: options.chain,
+      amount: String(options.amount),
+      currency: options.currency,
+      sender_wallet: options.sender,
+      receiver_wallet: options.receiver,
+      reference: options.reference,
+      callback_url: options.callbackUrl
+    };
+    const response = await this.client.post(
+      "/v1/iso/record-tip",
+      payload
+    );
+    return {
+      id: response.receipt_id,
+      status: response.status,
+      transactionHash: options.transactionHash,
+      chain: options.chain,
+      amount: String(options.amount),
+      currency: options.currency,
+      sender: options.sender,
+      receiver: options.receiver,
+      reference: options.reference,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async get(receiptId) {
+    return this.client.get(`/v1/iso/receipts/${receiptId}`);
+  }
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", String(options.limit));
+    if (options.page) params.append("page", String(options.page));
+    if (options.status) params.append("status", options.status);
+    const query = params.toString();
+    const endpoint = `/v1/iso/receipts${query ? `?${query}` : ""}`;
+    const response = await this.client.get(endpoint);
+    const items = Array.isArray(response) ? response : response.items || [];
+    return {
+      items,
+      total: items.length,
+      page: options.page || 1,
+      limit: options.limit || 10
+    };
+  }
+  async getArtifacts(receiptId) {
+    const messages = await this.client.get(`/v1/iso/messages/${receiptId}`);
+    const baseUrl = this.client.getBaseUrl();
+    const artifacts = {};
+    messages.forEach((msg) => {
+      switch (msg.type) {
+        case "pain.001":
+          artifacts.pain001Url = msg.url;
+          break;
+        case "pain.002":
+          artifacts.pain002Url = msg.url;
+          break;
+        case "pain.007":
+          artifacts.pain007Url = msg.url;
+          break;
+        case "pain.008":
+          artifacts.pain008Url = msg.url;
+          break;
+        case "camt.054":
+          artifacts.camt054Url = msg.url;
+          break;
+      }
+    });
+    artifacts.bundleUrl = `${baseUrl}/files/${receiptId}/evidence.zip`;
+    artifacts.manifestUrl = `${baseUrl}/files/${receiptId}/manifest.json`;
+    return artifacts;
+  }
+};
+
+// src/modules/verification.ts
+var VerificationModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async byReceiptId(receiptId) {
+    const receipt = await this.client.get(`/v1/iso/receipts/${receiptId}`);
+    return {
+      valid: receipt.status === "anchored",
+      bundleHash: receipt.bundle_hash || receipt.bundleHash || "",
+      onChain: !!receipt.anchor_tx || !!receipt.anchorTx,
+      anchorTx: receipt.anchor_tx || receipt.anchorTx,
+      timestamp: receipt.anchored_at || receipt.anchoredAt
+    };
+  }
+  async byUrl(bundleUrl) {
+    return this.client.post("/v1/iso/verify", {
+      bundle_url: bundleUrl
+    });
+  }
+  async byHash(bundleHash) {
+    return this.client.post("/v1/iso/verify", {
+      bundle_hash: bundleHash
+    });
+  }
+  async getProof(receiptId) {
+    const receipt = await this.client.get(`/v1/iso/receipts/${receiptId}`);
+    return {
+      receiptId,
+      bundleHash: receipt.bundle_hash || receipt.bundleHash,
+      anchorTx: receipt.anchor_tx || receipt.anchorTx,
+      blockNumber: receipt.block_number || 0,
+      timestamp: receipt.anchored_at || receipt.anchoredAt,
+      signature: receipt.signature || "",
+      network: receipt.chain,
+      contractAddress: receipt.contract_address || ""
+    };
+  }
+};
+
+// src/modules/statements.ts
+var StatementsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async intraday(options = {}) {
+    const response = await this.client.post("/v1/iso/statement/camt052", {
+      date_from: options.dateFrom,
+      date_to: options.dateTo,
+      account_id: options.accountId
+    });
+    return {
+      type: "camt.052",
+      url: response.url,
+      downloadUrl: response.download_url || response.url,
+      messageId: response.message_id || response.messageId,
+      createdAt: response.created_at || (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async endOfDay(options = {}) {
+    const response = await this.client.post("/v1/iso/statement/camt053", {
+      date: options.dateTo || options.dateFrom,
+      account_id: options.accountId
+    });
+    return {
+      type: "camt.053",
+      url: response.url,
+      downloadUrl: response.download_url || response.url,
+      messageId: response.message_id || response.messageId,
+      createdAt: response.created_at || (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/modules/events.ts
+var EventsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  listen(receiptId, callback) {
+    const baseUrl = this.client.getBaseUrl();
+    const url = `${baseUrl}/v1/iso/events/${receiptId}`;
+    const eventSource = new EventSource(url);
+    eventSource.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        callback({
+          id: receiptId,
+          status: data.status,
+          anchorTx: data.anchor_tx || data.anchorTx,
+          bundleHash: data.bundle_hash || data.bundleHash,
+          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (error) {
+        console.error("Failed to parse SSE event:", error);
+      }
+    };
+    eventSource.onerror = (error) => {
+      console.error("SSE connection error:", error);
+      eventSource.close();
+    };
+    return {
+      stop: () => eventSource.close()
+    };
+  }
+};
+
+// src/modules/embed.ts
+var EmbedModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  widget(receiptId, options = {}) {
+    const baseUrl = this.client.getBaseUrl();
+    const theme = options.theme || "light";
+    const width = options.width || "100%";
+    const height = options.height || "400px";
+    const embedUrl = `${baseUrl}/embed/receipt?rid=${receiptId}&theme=${theme}`;
+    const iframeHtml = `<iframe src="${embedUrl}" width="${width}" height="${height}" frameborder="0" style="border: none;"></iframe>`;
+    return {
+      iframeHtml,
+      embedUrl
+    };
+  }
+  fullPage(receiptId) {
+    const baseUrl = this.client.getBaseUrl();
+    return `${baseUrl}/receipt/${receiptId}`;
+  }
+};
+
+// src/templates/payment.ts
+async function createPaymentReceipt(receiptsModule, options) {
+  return receiptsModule.create({
+    transactionHash: options.transactionHash,
+    chain: options.chain || "coston2",
+    // Smart default
+    amount: options.amount,
+    currency: options.currency || "C2FLR",
+    // Smart default
+    sender: options.senderWallet || options.from,
+    receiver: options.receiverWallet || options.to,
+    reference: `Payment: ${options.purpose} (Tx: ${options.transactionHash})`
+  });
+}
+
+// src/templates/donation.ts
+async function createDonationReceipt(receiptsModule, options) {
+  return receiptsModule.create({
+    transactionHash: options.transactionHash,
+    chain: "coston2",
+    amount: options.amount,
+    currency: "FLR",
+    sender: options.donorWallet || options.donor,
+    receiver: options.organizationWallet || options.organization,
+    reference: `Donation: ${options.campaign} (Donor: ${options.donor}, Organization: ${options.organization})`
+  });
+}
+
+// src/templates/escrow.ts
+async function createEscrowReceipt(receiptsModule, options) {
+  return receiptsModule.create({
+    transactionHash: options.transactionHash,
+    chain: "coston2",
+    amount: options.amount,
+    currency: "FLR",
+    sender: options.buyerWallet || options.buyer,
+    receiver: options.sellerWallet || options.seller,
+    reference: `Escrow Release: ${options.escrowId} - ${options.releaseReason} (Buyer: ${options.buyer}, Seller: ${options.seller})`
+  });
+}
+
+// src/templates/grant.ts
+async function createGrantReceipt(receiptsModule, options) {
+  return receiptsModule.create({
+    transactionHash: options.transactionHash,
+    chain: "coston2",
+    amount: options.amount,
+    currency: "FLR",
+    sender: options.grantorWallet || options.grantor,
+    receiver: options.granteeWallet || options.grantee,
+    reference: `Grant: ${options.grantId} - ${options.purpose} (Grantor: ${options.grantor}, Grantee: ${options.grantee})`
+  });
+}
+
+// src/templates/refund.ts
+async function createRefundReceipt(receiptsModule, options) {
+  return receiptsModule.create({
+    transactionHash: options.transactionHash,
+    chain: "coston2",
+    amount: options.amount,
+    currency: "FLR",
+    sender: options.businessWallet || "Business",
+    receiver: options.customerWallet || options.customer,
+    reference: `Refund: ${options.originalPayment} - ${options.reason} (Customer: ${options.customer})`
+  });
+}
+
+// src/sdk.ts
+var ProofRails = class _ProofRails {
+  constructor(config = {}) {
+    this.client = new APIClient(config);
+    this.project = new ProjectsModule(this.client);
+    this.admin = new AdminModule(this.client);
+    this.receipts = new ReceiptsModule(this.client);
+    this.verify = new VerificationModule(this.client);
+    this.statements = new StatementsModule(this.client);
+    this.events = new EventsModule(this.client);
+    this.embed = new EmbedModule(this.client);
+    this.templates = {
+      payment: (options) => createPaymentReceipt(this.receipts, options),
+      donation: (options) => createDonationReceipt(this.receipts, options),
+      escrow: (options) => createEscrowReceipt(this.receipts, options),
+      grant: (options) => createGrantReceipt(this.receipts, options),
+      refund: (options) => createRefundReceipt(this.receipts, options)
+    };
+  }
+  /**
+   * Create a new project with API key (self-serve)
+   * This is a convenience method for beginners
+   */
+  static async createProject(options = {}) {
+    const tempClient = new _ProofRails({ network: options.network, baseUrl: options.baseUrl });
+    const result = await tempClient.project.create({ label: options.label });
+    const apiKey = result.api_key || result.apiKey;
+    const projectId = result.project_id || result.projectId;
+    const client = new _ProofRails({
+      apiKey,
+      network: options.network,
+      baseUrl: options.baseUrl
+      // Propagate baseUrl
+    });
+    return {
+      client,
+      apiKey,
+      projectId
+    };
+  }
+  /**
+   * Update the API key for this client
+   */
+  setApiKey(apiKey) {
+    this.client.setApiKey(apiKey);
+  }
+  /**
+   * Update the admin token for this client
+   */
+  setAdminToken(adminToken) {
+    this.client.setAdminToken(adminToken);
+  }
+};
+
+// src/utils/errors.ts
+function getFriendlyError(error) {
+  const errorMsg = error?.message || error?.detail || String(error);
+  const statusCode = error?.statusCode || error?.status;
+  if (errorMsg.includes("UNIQUE constraint") || errorMsg.includes("already exists")) {
+    return {
+      title: "\u274C Duplicate Receipt",
+      message: "A receipt with this transaction hash already exists.",
+      solution: "This transaction has already been recorded. Check your receipts list.",
+      learnMore: "https://docs.proofrails.com/errors/duplicate"
+    };
+  }
+  if (errorMsg.includes("insufficient funds") || errorMsg.includes("gas")) {
+    return {
+      title: "\u274C Middleware Wallet Needs Funding",
+      message: "Your ProofRails middleware wallet doesn't have enough tokens to pay gas fees.",
+      solution: "Send 0.5-1.0 C2FLR tokens to your middleware wallet address (check your .env ANCHOR_PRIVATE_KEY).",
+      learnMore: "https://docs.proofrails.com/setup/funding"
+    };
+  }
+  if (errorMsg.includes("fetch") || errorMsg.includes("network") || errorMsg.includes("ECONNREFUSED")) {
+    return {
+      title: "\u274C Cannot Connect to Middleware",
+      message: "Unable to reach the ProofRails middleware server.",
+      solution: "Make sure your middleware is running on the correct port (default: 8000). Check your baseUrl configuration.",
+      learnMore: "https://docs.proofrails.com/troubleshooting/connection"
+    };
+  }
+  if (errorMsg.includes("timeout") || errorMsg.includes("TIMEOUT")) {
+    return {
+      title: "\u23F1\uFE0F Request Timed Out",
+      message: "The middleware took too long to respond.",
+      solution: "The middleware might be processing a large request or experiencing issues. Try again in a moment.",
+      learnMore: "https://docs.proofrails.com/troubleshooting/timeout"
+    };
+  }
+  if (statusCode === 401 || statusCode === 403 || errorMsg.includes("unauthorized") || errorMsg.includes("forbidden")) {
+    return {
+      title: "\u{1F510} Authentication Failed",
+      message: "Your API key is invalid or missing.",
+      solution: "Check that you've set your API key correctly. You can create a new one using ProofRails.createProject().",
+      learnMore: "https://docs.proofrails.com/setup/api-keys"
+    };
+  }
+  if (statusCode === 404 || errorMsg.includes("not found")) {
+    return {
+      title: "\u{1F50D} Not Found",
+      message: "The requested resource doesn't exist.",
+      solution: "Double-check the receipt ID or resource identifier you're trying to access.",
+      learnMore: "https://docs.proofrails.com/troubleshooting/not-found"
+    };
+  }
+  if (statusCode === 422 || errorMsg.includes("validation") || errorMsg.includes("invalid")) {
+    return {
+      title: "\u26A0\uFE0F Invalid Data",
+      message: "The data you provided is invalid or incomplete.",
+      solution: "Check that all required fields are filled correctly (amount, addresses, transaction hash, etc.).",
+      learnMore: "https://docs.proofrails.com/api/validation"
+    };
+  }
+  if (statusCode === 500 || statusCode === 502 || statusCode === 503) {
+    return {
+      title: "\u{1F527} Server Error",
+      message: "The middleware encountered an internal error.",
+      solution: "Check the middleware logs for details. The issue might be with database access or blockchain connectivity.",
+      learnMore: "https://docs.proofrails.com/troubleshooting/server-errors"
+    };
+  }
+  return {
+    title: "\u274C Error",
+    message: errorMsg,
+    solution: "If this error persists, please check the documentation or contact support.",
+    learnMore: "https://docs.proofrails.com/troubleshooting"
+  };
+}
+function formatErrorForDisplay(error) {
+  const friendly = getFriendlyError(error);
+  let output = `${friendly.title}
+${friendly.message}`;
+  if (friendly.solution) {
+    output += `
+
+\u{1F4A1} Solution: ${friendly.solution}`;
+  }
+  if (friendly.learnMore) {
+    output += `
+\u{1F4D6} Learn more: ${friendly.learnMore}`;
+  }
+  return output;
+}
+
+// src/utils/chain.ts
+var SUPPORTED_CHAINS = {
+  14: {
+    id: 14,
+    name: "Flare",
+    network: "flare",
+    currency: "FLR",
+    rpcUrl: "https://flare-api.flare.network/ext/C/rpc",
+    explorerUrl: "https://flare-explorer.flare.network"
+  },
+  114: {
+    id: 114,
+    name: "Coston2",
+    network: "coston2",
+    currency: "C2FLR",
+    rpcUrl: "https://coston2-api.flare.network/ext/C/rpc",
+    explorerUrl: "https://coston2-explorer.flare.network"
+  }
+};
+function detectNetwork(chainId) {
+  if (!chainId) return "coston2";
+  const chain = SUPPORTED_CHAINS[chainId];
+  return chain?.network || "coston2";
+}
+function detectCurrency(chainId) {
+  if (!chainId) return "C2FLR";
+  const chain = SUPPORTED_CHAINS[chainId];
+  return chain?.currency || "C2FLR";
+}
+function getChainInfo(chainId) {
+  return SUPPORTED_CHAINS[chainId] || null;
+}
+function isSupportedChain(chainId) {
+  return chainId in SUPPORTED_CHAINS;
+}
+function getExplorerUrl(chainId, txHash) {
+  const chain = SUPPORTED_CHAINS[chainId];
+  if (!chain) return "";
+  return `${chain.explorerUrl}/tx/${txHash}`;
+}
+function getAddressExplorerUrl(chainId, address) {
+  const chain = SUPPORTED_CHAINS[chainId];
+  if (!chain) return "";
+  return `${chain.explorerUrl}/address/${address}`;
+}
+
+// src/utils/validation.ts
+function validateAddress(address) {
+  if (!address) {
+    return { isValid: false, error: "Address is required" };
+  }
+  if (typeof address !== "string") {
+    return { isValid: false, error: "Address must be a string" };
+  }
+  if (!address.startsWith("0x")) {
+    return { isValid: false, error: "Address must start with 0x" };
+  }
+  if (address.length !== 42) {
+    return { isValid: false, error: "Address must be 42 characters long (0x + 40 hex digits)" };
+  }
+  const hexRegex = /^0x[0-9a-fA-F]{40}$/;
+  if (!hexRegex.test(address)) {
+    return { isValid: false, error: "Address contains invalid characters (must be hexadecimal)" };
+  }
+  return { isValid: true };
+}
+function validateAmount(amount) {
+  if (amount === "" || amount === null || amount === void 0) {
+    return { isValid: false, error: "Amount is required" };
+  }
+  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (isNaN(numAmount)) {
+    return { isValid: false, error: "Amount must be a valid number" };
+  }
+  if (numAmount <= 0) {
+    return { isValid: false, error: "Amount must be greater than 0" };
+  }
+  if (numAmount > Number.MAX_SAFE_INTEGER) {
+    return { isValid: false, error: "Amount is too large" };
+  }
+  return { isValid: true };
+}
+function validateTransactionHash(hash) {
+  if (!hash) {
+    return { isValid: false, error: "Transaction hash is required" };
+  }
+  if (typeof hash !== "string") {
+    return { isValid: false, error: "Transaction hash must be a string" };
+  }
+  if (!hash.startsWith("0x")) {
+    return { isValid: false, error: "Transaction hash must start with 0x" };
+  }
+  if (hash.length !== 66) {
+    return { isValid: false, error: "Transaction hash must be 66 characters long (0x + 64 hex digits)" };
+  }
+  const hexRegex = /^0x[0-9a-fA-F]{64}$/;
+  if (!hexRegex.test(hash)) {
+    return { isValid: false, error: "Transaction hash contains invalid characters (must be hexadecimal)" };
+  }
+  return { isValid: true };
+}
+function validateApiKey(apiKey) {
+  if (!apiKey) {
+    return { isValid: false, error: "API key is required" };
+  }
+  if (typeof apiKey !== "string") {
+    return { isValid: false, error: "API key must be a string" };
+  }
+  if (apiKey.length < 10) {
+    return { isValid: false, error: "API key is too short" };
+  }
+  return { isValid: true };
+}
+function validatePurpose(purpose) {
+  if (!purpose) {
+    return { isValid: false, error: "Purpose is required" };
+  }
+  if (typeof purpose !== "string") {
+    return { isValid: false, error: "Purpose must be a string" };
+  }
+  if (purpose.trim().length === 0) {
+    return { isValid: false, error: "Purpose cannot be empty" };
+  }
+  if (purpose.length > 500) {
+    return { isValid: false, error: "Purpose is too long (max 500 characters)" };
+  }
+  return { isValid: true };
+}
+function validatePayment(params) {
+  const amountCheck = validateAmount(params.amount);
+  if (!amountCheck.isValid) return amountCheck;
+  const addressCheck = validateAddress(params.to);
+  if (!addressCheck.isValid) return addressCheck;
+  const purposeCheck = validatePurpose(params.purpose);
+  if (!purposeCheck.isValid) return purposeCheck;
+  if (params.transactionHash) {
+    const hashCheck = validateTransactionHash(params.transactionHash);
+    if (!hashCheck.isValid) return hashCheck;
+  }
+  return { isValid: true };
+}
+
+export { ProofRails, ProofRailsError, SUPPORTED_CHAINS, ProofRails as default, detectCurrency, detectNetwork, formatErrorForDisplay, getAddressExplorerUrl, getChainInfo, getExplorerUrl, getFriendlyError, isSupportedChain, validateAddress, validateAmount, validateApiKey, validatePayment, validatePurpose, validateTransactionHash };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map