@embarkai/ui-kit 0.3.5 → 0.4.1

package/dist/iframe/index.html

@@ -15,7 +15,7 @@
     <meta http-equiv="X-Content-Type-Options" content="nosniff" />
     <meta http-equiv="Referrer-Policy" content="strict-origin-when-cross-origin" />
 
-    <title>EmbarkAI Secure Wallet - iframe version 0.3.5</title>
+    <title>EmbarkAI Secure Wallet - iframe version 0.4.1</title>
 
     <!-- Styles will be injected by build process -->
     <style>

package/dist/iframe/main.js

@@ -2361,6 +2361,30 @@ var BackupManager = class {
     console.log("[iframe][BackupManager] \u2705 Backup data encrypted");
     return encrypted;
   }
+  /**
+   * Encrypt current keyshare as EnvelopeEncryptedShare (server/guardian format).
+   * Returns JSON string of the envelope.
+   */
+  async encryptEnvelopeData(userId, password) {
+    const data = this.getCurrentKeyshareBackupData(userId);
+    if (!data) {
+      throw new Error("No keyshare found for backup");
+    }
+    const { envelopeEncryptKeyshareWithPassword: envelopeEncryptKeyshareWithPassword2 } = await Promise.resolve().then(() => (init_crypto_utils(), crypto_utils_exports));
+    const envelope = await envelopeEncryptKeyshareWithPassword2(data, password);
+    return JSON.stringify(envelope);
+  }
+  /**
+   * Decrypt an EnvelopeEncryptedShare and restore keyshare to localStorage.
+   */
+  async decryptAndRestoreEnvelope(envelopeJson, password, userId) {
+    const { envelopeDecryptKeyshareWithPassword: envelopeDecryptKeyshareWithPassword2 } = await Promise.resolve().then(() => (init_crypto_utils(), crypto_utils_exports));
+    const envelope = JSON.parse(envelopeJson);
+    const backupData = await envelopeDecryptKeyshareWithPassword2(envelope, password);
+    localStorage.setItem(`tss.${userId}.keyshare`, backupData.keyshare);
+    localStorage.setItem(`tss.${userId}.sessionId`, backupData.sessionId);
+    localStorage.setItem(`tss.${userId}.ownerAddress`, backupData.ownerAddress);
+  }
   /**
    * Restore keyshare from local file backup
    */
@@ -3187,14 +3211,143 @@ var BinanceOnrampAPI = class {
   }
 };
 
+// src/iframe/lib/onramp/finchpay.ts
+var API_DOMAIN2 = "http://localhost:8000/api";
+var FinchPayRampAPI = class {
+  constructor(sendResponseFn) {
+    this.sendResponseFn = sendResponseFn;
+  }
+  async getCurrencies(accessToken) {
+    try {
+      const response = await fetch(`${API_DOMAIN2}/finchpay/currencies`, {
+        method: "GET",
+        headers: { "Content-Type": "application/json", ...accessToken && { Authorization: `Bearer ${accessToken}` } }
+      });
+      const data = await response.json();
+      if (!data.success) {
+        console.warn("[FINCHPAY] Failed to fetch currencies:", data);
+        throw new Error(`${data.code}: ${data.message}`);
+      }
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getLimits(payload, accessToken) {
+    const response = await fetch(`${API_DOMAIN2}/finchpay/limits`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...accessToken && { Authorization: `Bearer ${accessToken}` } },
+      body: JSON.stringify(payload)
+    });
+    const data = await response.json();
+    if (!data.success) {
+      console.warn("[FINCHPAY] Failed to fetch limits:", data);
+      throw new Error(`${data.code}: ${data.message}`);
+    }
+    return data;
+  }
+  async getLimitsSummary(payload, accessToken) {
+    const response = await fetch(`${API_DOMAIN2}/finchpay/limits/summary`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...accessToken && { Authorization: `Bearer ${accessToken}` } },
+      body: JSON.stringify(payload)
+    });
+    const data = await response.json();
+    if (!data.success) {
+      console.warn("[FINCHPAY] Failed to fetch limits summary:", data);
+      throw new Error(`${data.code}: ${data.message}`);
+    }
+    return data;
+  }
+  async getEstimates(payload, accessToken) {
+    const response = await fetch(`${API_DOMAIN2}/finchpay/estimates`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...accessToken && { Authorization: `Bearer ${accessToken}` } },
+      body: JSON.stringify(payload)
+    });
+    const data = await response.json();
+    if (!data.success) {
+      console.warn("[FINCHPAY] Failed to fetch estimates:", data);
+      throw new Error(`${data.code}: ${data.message}`);
+    }
+    return data;
+  }
+  async getTransactionStatus(transactionId, accessToken) {
+    try {
+      const response = await fetch(`${API_DOMAIN2}/finchpay/transaction/${transactionId}`, {
+        method: "GET",
+        headers: { "Content-Type": "application/json", ...accessToken && { Authorization: `Bearer ${accessToken}` } }
+      });
+      const data = await response.json();
+      if (!data.success) {
+        console.warn("[FINCHPAY] Failed to fetch transaction status:", data);
+        throw new Error(`${data.code}: ${data.message}`);
+      }
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getWidgetUrl(accessToken) {
+    try {
+      const response = await fetch(`${API_DOMAIN2}/finchpay/widget-url`, {
+        method: "GET",
+        headers: { "Content-Type": "application/json", ...accessToken && { Authorization: `Bearer ${accessToken}` } }
+      });
+      const data = await response.json();
+      if (!data.success) {
+        console.warn("[FINCHPAY] Failed to fetch widget URL:", data);
+        throw new Error(`${data.code}: ${data.message}`);
+      }
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  // IFRAME MESSAGING
+  async handleMessage(message, origin) {
+    const { type, messageId, data } = message;
+    const { accessToken } = message.data;
+    console.log("[FINCHPAY iframe]: Received message", type, message);
+    switch (type) {
+      case "FINCHPAY_GET_CURRENCIES_QUERY":
+        const isLumiaAvalableRes = await this.getCurrencies(accessToken);
+        this.sendResponseFn(messageId, isLumiaAvalableRes, origin);
+        break;
+      case "FINCHPAY_GET_LIMITS_QUERY":
+        const limitsResponse = await this.getLimits(data, accessToken);
+        this.sendResponseFn(messageId, limitsResponse, origin);
+        break;
+      case "FINCHPAY_GET_LIMITS_SUMMARY_QUERY":
+        const limitsSummaryResponse = await this.getLimitsSummary(data, accessToken);
+        this.sendResponseFn(messageId, limitsSummaryResponse, origin);
+        break;
+      case "FINCHPAY_GET_ESTIMATES_QUERY":
+        const paymentMethodsResponse = await this.getEstimates(data, accessToken);
+        this.sendResponseFn(messageId, paymentMethodsResponse, origin);
+        break;
+      case "FINCHPAY_GET_TRANSACTION_STATUS_QUERY":
+        const transactionStatusResponse = await this.getTransactionStatus(data.transactionId, accessToken);
+        this.sendResponseFn(messageId, transactionStatusResponse, origin);
+        break;
+      case "FINCHPAY_GET_WIDGET_URL_QUERY":
+        const widgetUrlResponse = await this.getWidgetUrl(accessToken);
+        this.sendResponseFn(messageId, widgetUrlResponse, origin);
+        break;
+      default:
+        throw new Error(`[FINCHPAY]: Unknown message type: ${type}`);
+    }
+  }
+};
+
 // src/iframe/lib/onramp/rampnow.ts
-var API_DOMAIN2 = "https://api.lumiapassport.com/on-ramp";
+var API_DOMAIN3 = "https://api.lumiapassport.com/on-ramp";
 var RampnowOnrampAPI = class {
   constructor(sendResponseFn) {
     this.sendResponseFn = sendResponseFn;
   }
   async getRampnowConfigQuery(accessToken) {
-    const response = await fetch(`${API_DOMAIN2}/api/rampnow/cfg`, {
+    const response = await fetch(`${API_DOMAIN3}/api/rampnow/cfg`, {
       method: "GET",
       headers: { ...accessToken && { Authorization: `Bearer ${accessToken}` } }
     });
@@ -3202,7 +3355,7 @@ var RampnowOnrampAPI = class {
     return data;
   }
   async getRampOrderQuoteQuery(payload, accessToken) {
-    const response = await fetch(`${API_DOMAIN2}/api/rampnow/quote`, {
+    const response = await fetch(`${API_DOMAIN3}/api/rampnow/quote`, {
       method: "POST",
       headers: { "Content-Type": "application/json", ...accessToken && { Authorization: `Bearer ${accessToken}` } },
       body: JSON.stringify(payload)
@@ -3662,6 +3815,8 @@ var SecureMessenger = class {
       "CLEAR_AUTHORIZATIONS",
       "CREATE_BACKUP",
       "ENCRYPT_BACKUP_DATA",
+      "ENCRYPT_ENVELOPE_DATA",
+      "DECRYPT_AND_RESTORE_ENVELOPE",
       "RESTORE_BACKUP",
       "RESTORE_FROM_FILE",
       "GET_BACKUP_STATUS",
@@ -3672,7 +3827,7 @@ var SecureMessenger = class {
       "TRUSTED_APP_REMOVED",
       "TOKEN_REFRESHED"
     ];
-    const validTypeGroups = ["BINANCE_", "RAMPNOW_"];
+    const validTypeGroups = ["BINANCE_", "RAMPNOW_", "FINCHPAY_"];
     const isTypeValid = validTypes.includes(message.type);
     const isGroupTypeValid = validTypeGroups.some((prefix) => message.type.startsWith(prefix));
     if (!message.type || !isTypeValid && !isGroupTypeValid) return false;
@@ -4439,7 +4594,7 @@ var SigningManager = class extends TokenRefreshApiClient {
 };
 
 // src/iframe/main.ts
-var IFRAME_VERSION = "0.3.5";
+var IFRAME_VERSION = "0.4.1";
 var IframeWallet = class {
   constructor() {
     console.log("=".repeat(60));
@@ -4454,6 +4609,7 @@ var IframeWallet = class {
     this.trustedApps = new TrustedAppsManager();
     this.optedOutApps = new OptedOutAppsManager();
     this.backupManager = new BackupManager();
+    this.finchpay = new FinchPayRampAPI(this.messenger.sendResponse.bind(this.messenger));
     this.binance = new BinanceOnrampAPI(this.messenger.sendResponse.bind(this.messenger));
     this.rampnow = new RampnowOnrampAPI(this.messenger.sendResponse.bind(this.messenger));
   }
@@ -4481,6 +4637,9 @@ var IframeWallet = class {
     const { type, messageId, projectId } = message;
     try {
       switch (true) {
+        case type.startsWith("FINCHPAY_"):
+          await this.finchpay.handleMessage(message, origin);
+          break;
         case type.startsWith("BINANCE_"):
           await this.binance.handleMessage(message, origin);
           break;
@@ -4538,6 +4697,12 @@ var IframeWallet = class {
         case type === "ENCRYPT_BACKUP_DATA":
           await this.handleEncryptBackupData(message, origin);
           break;
+        case type === "ENCRYPT_ENVELOPE_DATA":
+          await this.handleEncryptEnvelopeData(message, origin);
+          break;
+        case type === "DECRYPT_AND_RESTORE_ENVELOPE":
+          await this.handleDecryptAndRestoreEnvelope(message, origin);
+          break;
         default:
           throw new Error(`Unknown message type: ${type}`);
       }
@@ -5092,6 +5257,56 @@ var IframeWallet = class {
       this.messenger.sendError(messageId, error.message || "Encryption failed", origin);
     }
   }
+  async handleEncryptEnvelopeData(message, origin) {
+    const { userId, password } = message.data;
+    const { messageId } = message;
+    if (!userId) {
+      this.messenger.sendError(messageId, "userId is required", origin);
+      return;
+    }
+    try {
+      const envelopeJson = await this.backupManager.encryptEnvelopeData(userId, password);
+      this.messenger.sendResponse(
+        messageId,
+        {
+          type: "IFRAME_MSG_ENVELOPE_ENCRYPTED",
+          envelopeJson
+        },
+        origin
+      );
+    } catch (error) {
+      this.messenger.sendError(messageId, error.message || "Envelope encryption failed", origin);
+    }
+  }
+  async handleDecryptAndRestoreEnvelope(message, origin) {
+    const { userId, envelopeJson, password } = message.data;
+    const { messageId } = message;
+    if (!userId || !envelopeJson) {
+      this.messenger.sendError(messageId, "userId and envelopeJson are required", origin);
+      return;
+    }
+    try {
+      await this.backupManager.decryptAndRestoreEnvelope(envelopeJson, password, userId);
+      this.messenger.sendResponse(
+        messageId,
+        {
+          type: "IFRAME_MSG_ENVELOPE_RESTORED",
+          result: { success: true, timestamp: Date.now() }
+        },
+        origin
+      );
+      this.sendWalletReadyStatus(userId, origin);
+    } catch (error) {
+      this.messenger.sendResponse(
+        messageId,
+        {
+          type: "IFRAME_MSG_ENVELOPE_RESTORED",
+          result: { success: false, timestamp: Date.now(), error: error.message }
+        },
+        origin
+      );
+    }
+  }
   displayReadyIndicator() {
     const app = document.getElementById("app");
     if (!app) return;