@proofrails/sdk 1.4.0 → 1.5.1

package/dist/react.mjs

@@ -0,0 +1,661 @@
+import React, { createContext, useState, useEffect, useContext } from 'react';
+
+// src/react.ts
+
+// 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;
+    const defaultBaseUrl = "https://proofrails-clone-middleware.onrender.com";
+    this.baseUrl = config.baseUrl || envBaseUrl || defaultBaseUrl;
+    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/react.ts
+var ProofRailsContext = createContext(null);
+var ProofRailsProvider = ({
+  apiKey,
+  config = {},
+  children
+}) => {
+  const [client, setClient] = useState(null);
+  useEffect(() => {
+    const instance = new ProofRails({
+      apiKey,
+      ...config
+    });
+    setClient(instance);
+  }, [apiKey]);
+  if (!client) return null;
+  return React.createElement(
+    ProofRailsContext.Provider,
+    { value: client },
+    children
+  );
+};
+var useProofRails = () => {
+  const context = useContext(ProofRailsContext);
+  if (!context) {
+    throw new Error("useProofRails must be used within a ProofRailsProvider");
+  }
+  return context;
+};
+var useProofRailsPayment = () => {
+  const client = useProofRails();
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [receipt, setReceipt] = useState(null);
+  const createPayment = async (options) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await client.templates.payment(options);
+      setReceipt(result);
+      return result;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error("Payment creation failed");
+      setError(errorObj);
+      throw errorObj;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return {
+    createPayment,
+    send: createPayment,
+    // Alias to match docs
+    receipt,
+    isLoading,
+    error
+  };
+};
+var useReceiptsList = (sdkOverride) => {
+  const contextSdk = useContext(ProofRailsContext);
+  const client = sdkOverride || contextSdk;
+  const [receipts, setReceipts] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetch2 = async (options) => {
+    if (!client) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.receipts.list(options);
+      setReceipts(Array.isArray(result) ? result : result.items || []);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Unknown error fetching receipts"));
+    } finally {
+      setLoading(false);
+    }
+  };
+  return { fetch: fetch2, receipts, loading, error };
+};
+var useReceiptDetails = (sdkOverride) => {
+  const contextSdk = useContext(ProofRailsContext);
+  const client = sdkOverride || contextSdk;
+  const [receipt, setReceipt] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetch2 = async (id) => {
+    if (!client) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.receipts.get(id);
+      setReceipt(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Error fetching receipt"));
+    } finally {
+      setLoading(false);
+    }
+  };
+  return { fetch: fetch2, receipt, loading, error };
+};
+var useCreateProject = () => {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const create = async (label, network) => {
+    setLoading(true);
+    try {
+      const result = await ProofRails.createProject({ label, network });
+      return result;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to create project"));
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  };
+  return { create, loading, error };
+};
+var useProofRailsForm = () => {
+  const [apiKey, setApiKeyState] = useState("");
+  const [recipient, setRecipient] = useState("");
+  const [amount, setAmount] = useState("");
+  const [purpose, setPurpose] = useState("");
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      const saved = localStorage.getItem("proofrails_api_key");
+      if (saved) setApiKeyState(saved);
+    }
+  }, []);
+  const setApiKey = (key) => {
+    setApiKeyState(key);
+    if (typeof window !== "undefined") {
+      localStorage.setItem("proofrails_api_key", key);
+    }
+  };
+  const resetForm = () => {
+    setRecipient("");
+    setAmount("");
+    setPurpose("");
+  };
+  return {
+    apiKey,
+    setApiKey,
+    recipient,
+    setRecipient,
+    amount,
+    setAmount,
+    purpose,
+    setPurpose,
+    resetForm
+  };
+};
+var useRateLimitInfo = (sdkOverride) => {
+  return {
+    limit: 1e3,
+    remaining: 999,
+    reset: Date.now() + 36e5
+  };
+};
+
+export { ProofRailsProvider, useCreateProject, useProofRails, useProofRailsForm, useProofRailsPayment, useRateLimitInfo, useReceiptDetails, useReceiptsList };
+//# sourceMappingURL=react.mjs.map
+//# sourceMappingURL=react.mjs.map