@dynamic-labs-wallet/browser 0.0.47 → 0.0.49

package/index.cjs.js

@@ -3,6 +3,7 @@
 var core = require('@dynamic-labs-wallet/core');
 var web = require('./internal/web');
 var logger$1 = require('@dynamic-labs/logger');
+var messageTransport = require('@dynamic-labs/message-transport');
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -184,7 +185,6 @@ const encryptData = async ({ data, password })=>{
             cipher: bytesToBase64(new Uint8Array(encryptedData))
         };
     } catch (error) {
-        console.error('Error encrypting data:', error);
         throw new Error('Error encrypting data');
     }
 };
@@ -208,7 +208,6 @@ const decryptData = async ({ data, password })=>{
         }, key, cipherBytes);
         return new TextDecoder().decode(decryptedData);
     } catch (error) {
-        console.error('Decryption error details:', error);
         throw new Error('Decryption failed');
     }
 };
@@ -305,7 +304,6 @@ const downloadFileFromGoogleDrive = async ({ accessToken, name })=>{
         // The client will handle validation of the structure
         return JSON.parse(fileRawData);
     } catch (error) {
-        console.error('Error parsing backup file:', error);
         return null;
     }
 };
@@ -379,17 +377,91 @@ const localStorageWriteTest = {
         }
     });
 
-var WalletOperation = /*#__PURE__*/ function(WalletOperation) {
-    WalletOperation["REACH_THRESHOLD"] = "REACH_THRESHOLD";
-    WalletOperation["REACH_ALL_PARTIES"] = "REACH_ALL_PARTIES";
-    WalletOperation["SIGN_MESSAGE"] = "SIGN_MESSAGE";
-    WalletOperation["SIGN_TRANSACTION"] = "SIGN_TRANSACTION";
-    WalletOperation["REFRESH"] = "REFRESH";
-    WalletOperation["RESHARE"] = "RESHARE";
-    WalletOperation["EXPORT_PRIVATE_KEY"] = "EXPORT_PRIVATE_KEY";
-    WalletOperation["NO_OPERATION"] = "NO_OPERATION";
-    return WalletOperation;
-}({});
+/**
+ * StorageRequestChannelAdapter.getItem() sends a message within host domain
+ * the bridge on host will capture this request and forwards it to the iframe via contentWindow.postMessage()
+ */ class StorageRequestChannelAdapter {
+    async getItem(key) {
+        const item = await this.requestChannel.request('getItem', {
+            source: 'localStorage',
+            key
+        });
+        return item ? JSON.parse(item) : null;
+    }
+    async setItem(key, value) {
+        const stringifiedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+        return this.requestChannel.request('setItem', {
+            source: 'localStorage',
+            key,
+            data: stringifiedValue
+        });
+    }
+    async removeItem(key) {
+        return this.requestChannel.request('deleteItem', {
+            source: 'localStorage',
+            key
+        });
+    }
+    constructor(messageTransport$1){
+        this.requestChannel = messageTransport.createRequestChannel(messageTransport$1);
+    }
+}
+
+const setupMessageTransportBridge = (messageTransport$1, iframe, iframeOrigin)=>{
+    if (!(iframe == null ? void 0 : iframe.contentWindow)) {
+        throw new Error('Iframe or contentWindow not available');
+    }
+    const logger = new logger$1.Logger('debug');
+    messageTransport$1.on((message)=>{
+        // Forward the message to webview via postMessage
+        if (message.origin === 'host') {
+            var _iframe_contentWindow;
+            logger.debug(`[host bridge] host --> bridge --> iframe`, message);
+            iframe == null ? void 0 : (_iframe_contentWindow = iframe.contentWindow) == null ? void 0 : _iframe_contentWindow.postMessage(message, iframeOrigin);
+        }
+    });
+    const handleIncomingMessage = (message)=>{
+        const { data } = message;
+        if (!data) return;
+        if ((data == null ? void 0 : data.origin) !== 'webview') {
+            logger.debug(`skipped message: ${JSON.stringify(data)}: origin is not host`);
+            return;
+        }
+        if (typeof data !== 'object') {
+            logger.debug(`skipped message: ${JSON.stringify(data)}: data is not an object`);
+            return;
+        }
+        try {
+            const message = messageTransport.parseMessageTransportData(data);
+            logger.debug(`[host bridge] iframe --> bridge --> host`, message);
+            messageTransport$1.emit(message);
+        } catch (error) {
+            if (!(error instanceof SyntaxError)) {
+                logger.error('Error handling incoming message:', error);
+            }
+        }
+    };
+    /**
+   * Handle incoming message from android client
+   */ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    document.addEventListener('message', handleIncomingMessage);
+    /**
+   * Handle incoming message from iOS client
+   */ window.addEventListener('message', handleIncomingMessage);
+};
+
+class IframeDisplayChannelAdapter {
+    async displayClientShares(accountAddress) {
+        await this.requestChannel.request('displayClientShares', accountAddress);
+    }
+    async displayPrivateKey(accountAddress, privateKey) {
+        await this.requestChannel.request('displayPrivateKey', accountAddress, privateKey);
+    }
+    constructor(messageTransport$1){
+        this.requestChannel = messageTransport.createRequestChannel(messageTransport$1);
+    }
+}
 
 class DynamicWalletClient {
     async initialize() {
@@ -403,11 +475,196 @@ class DynamicWalletClient {
         return result;
     }
     /**
+   * Initializes the iframe display for a specific container.
+   *
+   * @param {HTMLElement} container - The container to which the iframe will be attached.
+   * @returns {Promise<{
+   *   iframe: HTMLIFrameElement;
+   *   iframeDisplay: IframeDisplayChannelAdapter;
+   *   cleanup: () => void;
+   * }>} A promise that resolves when the iframe is loaded.
+   */ async initializeIframeDisplayForContainer({ container }) {
+        try {
+            const iframe = await this.loadIframeForContainer(container);
+            const transport = messageTransport.applyDefaultMessageOrigin({
+                defaultOrigin: 'host',
+                messageTransport: messageTransport.createMessageTransport()
+            });
+            setupMessageTransportBridge(transport, iframe, this.iframeDomain);
+            const iframeDisplay = new IframeDisplayChannelAdapter(transport);
+            return {
+                iframe,
+                iframeDisplay,
+                cleanup: ()=>{
+                    container.removeChild(iframe);
+                }
+            };
+        } catch (error) {
+            this.logger.error('Error initializing iframe:', error);
+            throw error;
+        }
+    }
+    /**
+   * this is called on class construction time
+   * @returns {Promise<void>} that resolves when the iframe is loaded and the message transport and iframe storage are initialized
+   */ initializeIframeCommunication() {
+        if (!this.iframeLoadPromise) {
+            this.iframeLoadPromise = this.doInitializeIframeCommunication();
+        }
+        return this.iframeLoadPromise;
+    }
+    /**
+   * initialize the iframe communication by awaiting the iframe load promise
+   * and initializing the message transport and iframe storage after iframe is successfully loaded
+   */ async doInitializeIframeCommunication() {
+        try {
+            await this.loadIframe();
+            this.initializeMessageTransport();
+            this.initializeIframeStorage();
+        } catch (error) {
+            this.logger.error('Error initializing iframe:', error);
+            throw error;
+        }
+    }
+    /**
+   * create a promise to load an iframe
+   * @returns {Promise<void>} that resolves when the iframe is loaded
+   */ loadIframe() {
+        return new Promise((resolve, reject)=>{
+            const iframe = document.createElement('iframe');
+            const iframeTimeoutId = setTimeout(()=>{
+                reject(new Error('Iframe load timeout'));
+            }, 10000);
+            iframe.style.display = 'none';
+            iframe.setAttribute('title', 'Dynamic Wallet Iframe');
+            iframe.style.position = 'fixed';
+            iframe.style.top = '0';
+            iframe.style.left = '0';
+            iframe.style.width = '0';
+            iframe.style.height = '0';
+            iframe.style.border = 'none';
+            iframe.style.pointerEvents = 'none';
+            const params = new URLSearchParams({
+                instanceId: this.instanceId,
+                hostOrigin: window.location.origin
+            });
+            iframe.src = `${this.iframeDomain}/waas/${this.environmentId}?${params.toString()}`;
+            this.logger.debug('Creating iframe with src:', iframe.src);
+            document.body.appendChild(iframe);
+            iframe.onload = ()=>{
+                clearTimeout(iframeTimeoutId);
+                this.logger.debug('Iframe loaded successfully');
+                this.iframe = iframe;
+                resolve();
+            };
+            iframe.onerror = (error)=>{
+                clearTimeout(iframeTimeoutId);
+                this.logger.error('Iframe failed to load:', error);
+                reject(new Error('Failed to load iframe'));
+            };
+        });
+    }
+    /**
+   * Load an iframe for a specific container
+   * @param {HTMLElement} container - The container to which the iframe will be attached
+   * @returns {Promise<HTMLIFrameElement>} that resolves when the iframe is loaded
+   */ loadIframeForContainer(container) {
+        return new Promise((resolve, reject)=>{
+            const iframe = document.createElement('iframe');
+            const iframeTimeoutId = setTimeout(()=>{
+                reject(new Error('Iframe load timeout'));
+            }, 10000);
+            iframe.style.display = 'block';
+            iframe.style.width = '100%';
+            iframe.style.height = '100%';
+            iframe.setAttribute('title', 'Dynamic Wallet Storage');
+            iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
+            const params = new URLSearchParams({
+                instanceId: this.instanceId,
+                hostOrigin: window.location.origin
+            });
+            iframe.src = `${this.iframeDomain}/waas/${this.environmentId}?${params.toString()}`;
+            this.logger.debug('Creating iframe with src:', iframe.src);
+            // Add iframe to the provided container
+            container.appendChild(iframe);
+            iframe.onload = ()=>{
+                clearTimeout(iframeTimeoutId);
+                this.logger.debug('Iframe loaded successfully');
+                this.iframe = iframe;
+                resolve(iframe);
+            };
+            iframe.onerror = (error)=>{
+                clearTimeout(iframeTimeoutId);
+                this.logger.error('Iframe failed to load:', error);
+                reject(new Error('Failed to load iframe'));
+            };
+        });
+    }
+    /**
+   * initialize the message transport after iframe is successfully loaded
+   */ initializeMessageTransport() {
+        const transport = messageTransport.applyDefaultMessageOrigin({
+            defaultOrigin: 'host',
+            messageTransport: messageTransport.createMessageTransport()
+        });
+        this.messageTransport = transport;
+        if (!this.iframe) {
+            throw new Error('Iframe not available');
+        }
+        setupMessageTransportBridge(this.messageTransport, this.iframe, this.iframeDomain);
+    }
+    /**
+   * initialize the iframe storage after iframe is successfully loaded
+   */ initializeIframeStorage() {
+        if (!this.messageTransport) {
+            throw new Error('Message transport not initialized');
+        }
+        this.iframeStorage = new StorageRequestChannelAdapter(this.messageTransport);
+    }
+    /**
+   * Gets the initialized iframe instance. This method ensures the iframe is properly loaded and configured.
+   * The first call will initialize and await the iframe loading process.
+   * Subsequent calls will return the same iframe instance immediately.
+   *
+   * @throws {Error} If iframe initialization fails
+   * @throws {Error} If message transport initialization fails
+   * @throws {Error} If iframe storage initialization fails
+   * @returns {Promise<HTMLIFrameElement>} The initialized iframe element
+   */ async getIframe() {
+        await this.initializeIframeCommunication();
+        if (!this.iframe) {
+            throw new Error('Failed to initialize iframe');
+        }
+        if (!this.messageTransport) {
+            throw new Error('Failed to initialize message transport');
+        }
+        if (!this.iframeStorage) {
+            throw new Error('Failed to initialize iframe storage');
+        }
+        return this.iframe;
+    }
+    /**
+   * Gets the initialized iframe storage instance. This method ensures the iframe storage is properly configured.
+   * The first call will initialize and await the iframe communication process.
+   * Subsequent calls will return the same storage instance immediately.
+   *
+   * @throws {Error} If iframe storage initialization fails
+   * @returns {Promise<SupportedStorage>} The initialized iframe storage instance
+   */ async getIframeStorage() {
+        await this.initializeIframeCommunication();
+        if (!this.iframeStorage) {
+            throw new Error('Failed to initialize iframe storage');
+        }
+        return this.iframeStorage;
+    }
+    /**
    * Client initialization logic
    */ async _initialize() {
         try {
-            const initializePromises = [];
-            initializePromises.push(this.restoreWallets());
+            const initializePromises = [
+                this.restoreWallets(),
+                this.useIframeStorage && this.initializeIframeCommunication()
+            ];
             await Promise.all(initializePromises);
             return {
                 error: null
@@ -514,6 +771,52 @@ class DynamicWalletClient {
             throw new Error('Error creating wallet account');
         }
     }
+    async importRawPrivateKey({ chainName, privateKey, thresholdSignatureScheme, onError, onCeremonyComplete }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const clientKeygenInitResults = await this.clientInitializeKeyGen({
+            chainName,
+            thresholdSignatureScheme
+        });
+        const clientKeygenIds = clientKeygenInitResults.map((result)=>result.keygenId);
+        const { roomId, serverKeygenIds } = await this.apiClient.importPrivateKey({
+            chainName,
+            clientKeygenIds,
+            thresholdSignatureScheme,
+            onError,
+            onCeremonyComplete
+        });
+        const { threshold } = core.getTSSConfig(thresholdSignatureScheme);
+        const clientKeygenResults = await Promise.all(clientKeygenInitResults.map(async (currentInit, index)=>{
+            const otherClientKeygenIds = clientKeygenInitResults.filter((init)=>init.keygenId !== currentInit.keygenId).map((init)=>init.keygenId);
+            if (index === 0) {
+                const otherKeyGenIds = [
+                    ...serverKeygenIds,
+                    ...otherClientKeygenIds
+                ];
+                const importerKeygenResult = await mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, currentInit, otherKeyGenIds);
+                return importerKeygenResult;
+            } else {
+                const recipientKeygenResult = await mpcSigner.importPrivateKeyRecipient(roomId, threshold, currentInit, [
+                    ...serverKeygenIds,
+                    ...otherClientKeygenIds
+                ]);
+                return recipientKeygenResult;
+            }
+        }));
+        const [clientKeygenResult] = clientKeygenResults;
+        const rawPublicKey = await this.derivePublicKey({
+            chainName,
+            keyShare: clientKeygenResult,
+            derivationPath: undefined
+        });
+        return {
+            rawPublicKey,
+            clientKeyShares: clientKeygenResults
+        };
+    }
     async serverSign({ walletId, message }) {
         // Create the room and sign the message
         if (typeof message !== 'string') {
@@ -562,12 +865,12 @@ class DynamicWalletClient {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: WalletOperation.SIGN_MESSAGE
+            walletOperation: core.WalletOperation.SIGN_MESSAGE
         });
         const wallet = await this.getWallet({
             accountAddress,
             password,
-            walletOperation: WalletOperation.SIGN_MESSAGE
+            walletOperation: core.WalletOperation.SIGN_MESSAGE
         });
         // Perform the server sign
         const data = await this.serverSign({
@@ -576,11 +879,14 @@ class DynamicWalletClient {
         });
         const derivationPath = wallet.derivationPath && wallet.derivationPath != '' ? new Uint32Array(Object.values(JSON.parse(wallet.derivationPath))) : undefined;
         // Perform the client sign and return the signature
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
         const signature = await this.clientSign({
             chainName,
             message,
             roomId: data.roomId,
-            keyShare: wallet.clientKeyShares[0],
+            keyShare: clientKeyShares[0],
             derivationPath
         });
         return signature;
@@ -589,11 +895,11 @@ class DynamicWalletClient {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: WalletOperation.REFRESH
+            walletOperation: core.WalletOperation.REFRESH
         });
         const wallet = await this.getWallet({
             accountAddress,
-            walletOperation: WalletOperation.REFRESH,
+            walletOperation: core.WalletOperation.NO_OPERATION,
             password
         });
         const mpcSigner = getMPCSigner({
@@ -605,12 +911,18 @@ class DynamicWalletClient {
             walletId: wallet.walletId
         });
         const roomId = data.roomId;
-        const refreshResults = await Promise.all(wallet.clientKeyShares.map((clientKeyShare)=>mpcSigner.refresh(roomId, clientKeyShare)));
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        const refreshResults = await Promise.all(clientKeyShares.map((clientKeyShare)=>mpcSigner.refresh(roomId, clientKeyShare)));
         this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-            clientKeyShares: refreshResults,
             clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
         });
-        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+        await this.setClientKeySharesToLocalStorage({
+            accountAddress,
+            clientKeyShares: refreshResults,
+            overwriteOrMerge: 'overwrite'
+        });
         await this.storeEncryptedBackupByWallet({
             accountAddress,
             password: password != null ? password : this.environmentId
@@ -638,7 +950,7 @@ class DynamicWalletClient {
    *   existingClientKeyShares: ClientKeyShare[]
    * }>} Object containing new and existing client keygen results, IDs and shares
    * @todo Support higher to lower reshare strategies
-   */ async reshareStrategy({ chainName, wallet, oldThresholdSignatureScheme, newThresholdSignatureScheme }) {
+   */ async reshareStrategy({ chainName, wallet, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme }) {
         const mpcSigner = getMPCSigner({
             chainName,
             baseRelayUrl: this.baseMPCRelayApiUrl
@@ -654,7 +966,9 @@ class DynamicWalletClient {
         }, ()=>mpcSigner.initKeygen()));
         const newClientKeygenIds = newClientInitKeygenResults.map((result)=>result.keygenId);
         // Get existing client shares
-        const existingClientKeyShares = wallet.clientKeyShares.slice(0, existingClientShareCount);
+        const existingClientKeyShares = (await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        })).slice(0, existingClientShareCount);
         const existingClientKeygenIds = await Promise.all(existingClientKeyShares.map(async (keyShare)=>await this.getExportId({
                 chainName,
                 clientKeyShare: keyShare
@@ -670,7 +984,7 @@ class DynamicWalletClient {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: WalletOperation.RESHARE
+            walletOperation: core.WalletOperation.RESHARE
         });
         const { existingClientShareCount } = core.getReshareConfig({
             oldThresholdSignatureScheme,
@@ -678,12 +992,13 @@ class DynamicWalletClient {
         });
         const wallet = await this.getWallet({
             accountAddress,
-            walletOperation: WalletOperation.RESHARE,
+            walletOperation: core.WalletOperation.NO_OPERATION,
             shareCount: existingClientShareCount,
             password
         });
         const { newClientInitKeygenResults, newClientKeygenIds, existingClientKeygenIds, existingClientKeyShares } = await this.reshareStrategy({
             chainName,
+            accountAddress,
             wallet,
             oldThresholdSignatureScheme,
             newThresholdSignatureScheme
@@ -716,35 +1031,39 @@ class DynamicWalletClient {
             ...newClientInitKeygenResults.map((keygenResult)=>mpcSigner.reshareNewParty(roomId, oldMpcConfig.threshold, newMpcConfig.threshold, keygenResult, allPartyKeygenIds)),
             ...existingClientKeyShares.map((keyShare)=>mpcSigner.reshareRemainingParty(roomId, newMpcConfig.threshold, keyShare, allPartyKeygenIds))
         ]);
-        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-            clientKeyShares: reshareResults
+        await this.setClientKeySharesToLocalStorage({
+            accountAddress,
+            clientKeyShares: reshareResults,
+            overwriteOrMerge: 'overwrite'
         });
-        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
         await this.storeEncryptedBackupByWallet({
             accountAddress,
             password
         });
         return reshareResults;
     }
-    async exportKey({ accountAddress, chainName, password = undefined }) {
+    async exportKey({ accountAddress, displayContainer, chainName, password = undefined }) {
         const wallet = await this.getWallet({
             accountAddress,
             password,
-            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY
+            walletOperation: core.WalletOperation.EXPORT_PRIVATE_KEY
         });
         const mpcSigner = getMPCSigner({
             chainName,
             baseRelayUrl: this.baseMPCRelayApiUrl
         });
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
         const exportId = await this.getExportId({
             chainName,
-            clientKeyShare: wallet.clientKeyShares[0]
+            clientKeyShare: clientKeyShares[0]
         });
         const data = await this.apiClient.exportKey({
             walletId: wallet.walletId,
             exportId
         });
-        const keyExportRaw = await mpcSigner.exportFullPrivateKey(data.roomId, wallet.clientKeyShares[0], exportId);
+        const keyExportRaw = await mpcSigner.exportFullPrivateKey(data.roomId, clientKeyShares[0], exportId);
         if (!keyExportRaw) {
             throw new Error('Error exporting private key');
         }
@@ -787,11 +1106,17 @@ class DynamicWalletClient {
             } else if (mpcSigner instanceof web.BIP340) {
                 derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, walletDerivationPath);
             }
+            const rawPublicKey = await this.derivePublicKey({
+                chainName,
+                keyShare: walletKeyShares[0],
+                derivationPath: walletDerivationPath
+            });
             return {
-                derivedPrivateKey
+                derivedPrivateKey,
+                rawPublicKey
             };
         } catch (error) {
-            console.error('Error in offlineExportKey:', error);
+            this.logger.error('Error in offlineExportKey:', error);
             throw error;
         }
     }
@@ -806,6 +1131,47 @@ class DynamicWalletClient {
         return serializedEncryptedKeyShare;
     }
     /**
+   * temporary helper function to store encrypted backup by wallet based on `useIframeStorage` flag
+   * TODO: revise this to only use iframe storage when iframe is deployed
+   */ async getClientKeySharesFromLocalStorage({ accountAddress }) {
+        var _this_iframeStorage;
+        if (!this.useIframeStorage) {
+            return this.walletMap[accountAddress].clientKeyShares;
+        }
+        await this.initializeIframeCommunication();
+        const walletObject = await ((_this_iframeStorage = this.iframeStorage) == null ? void 0 : _this_iframeStorage.getItem(accountAddress));
+        if (!walletObject) {
+            this.logger.debug(`No item found in iframe local storage for accountAddress: ${accountAddress}`);
+            return [];
+        }
+        try {
+            return (walletObject == null ? void 0 : walletObject.clientKeyShares) || [];
+        } catch (error) {
+            this.logger.error(`Error parsing clientKeyShares: ${error} for accountAddress: ${accountAddress}`);
+            return [];
+        }
+    }
+    /**
+   * temporary helper function to store encrypted backup by wallet based on `useIframeStorage` flag
+   * TODO: revise this to only use iframe storage when iframe is deployed
+   */ async setClientKeySharesToLocalStorage({ accountAddress, clientKeyShares, overwriteOrMerge = 'merge' }) {
+        var _this_iframeStorage;
+        if (!this.useIframeStorage) {
+            var _this_walletMap_accountAddress;
+            this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress] || {}, {
+                clientKeyShares: overwriteOrMerge === 'overwrite' ? clientKeyShares : mergeUniqueKeyShares(((_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? void 0 : _this_walletMap_accountAddress.clientKeyShares) || [], clientKeyShares)
+            });
+            await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+            return;
+        }
+        await this.initializeIframeCommunication();
+        await ((_this_iframeStorage = this.iframeStorage) == null ? void 0 : _this_iframeStorage.setItem(accountAddress, {
+            clientKeyShares: overwriteOrMerge === 'overwrite' ? clientKeyShares : mergeUniqueKeyShares(await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            }), clientKeyShares)
+        }));
+    }
+    /**
    * Encrypts and stores wallet key shares as backups.
    *
    * This method encrypts all client key shares for a specific wallet and stores them
@@ -823,7 +1189,9 @@ class DynamicWalletClient {
    * @param {string} params.accountAddress - The account address of the wallet to backup
    * @param {string} [params.password] - Optional password for encrypting the key shares
    */ async storeEncryptedBackupByWallet({ accountAddress, clientKeyShares = undefined, password = undefined }) {
-        const keySharesToBackup = clientKeyShares != null ? clientKeyShares : this.walletMap[accountAddress].clientKeyShares;
+        const keySharesToBackup = clientKeyShares != null ? clientKeyShares : await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
         const encryptedKeyShares = await Promise.all(keySharesToBackup.map((keyShare)=>this.encryptKeyShare({
                 keyShare,
                 password
@@ -884,7 +1252,7 @@ class DynamicWalletClient {
         await this.getWallet({
             accountAddress,
             password: existingPassword,
-            walletOperation: WalletOperation.REACH_ALL_PARTIES
+            walletOperation: core.WalletOperation.REACH_ALL_PARTIES
         });
         await this.storeEncryptedBackupByWallet({
             accountAddress,
@@ -914,7 +1282,7 @@ class DynamicWalletClient {
    */ recoverStrategy({ clientKeyShareBackupInfo, thresholdSignatureScheme, walletOperation, shareCount = undefined }) {
         const { backups } = clientKeyShareBackupInfo;
         const { clientThreshold } = core.MPC_CONFIG[thresholdSignatureScheme];
-        let requiredShareCount = walletOperation === WalletOperation.REFRESH || walletOperation === WalletOperation.REACH_ALL_PARTIES || walletOperation === WalletOperation.RESHARE ? clientThreshold : 1;
+        let requiredShareCount = walletOperation === core.WalletOperation.REFRESH || walletOperation === core.WalletOperation.REACH_ALL_PARTIES || walletOperation === core.WalletOperation.RESHARE ? clientThreshold : 1;
         // Override requiredShareCount if shareCount is provided
         if (shareCount !== undefined) {
             requiredShareCount = shareCount;
@@ -947,8 +1315,10 @@ class DynamicWalletClient {
                 password: password != null ? password : this.environmentId
             })));
         if (storeRecoveredShares) {
-            this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-                clientKeyShares: mergeUniqueKeyShares(this.walletMap[accountAddress].clientKeyShares || [], decryptedKeyShares)
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares: decryptedKeyShares,
+                overwriteOrMerge: 'merge'
             });
             await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
         }
@@ -964,10 +1334,12 @@ class DynamicWalletClient {
     async backupKeySharesToGoogleDrive({ accountAddress, fileName, oauthAccountId, password }) {
         await this.getWallet({
             accountAddress,
-            walletOperation: WalletOperation.REACH_ALL_PARTIES,
+            walletOperation: core.WalletOperation.REACH_ALL_PARTIES,
             password
         });
-        const clientKeyShares = this.walletMap[accountAddress].clientKeyShares;
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
         if (clientKeyShares.length === 0) {
             throw new Error('No key shares found');
         }
@@ -1022,7 +1394,7 @@ class DynamicWalletClient {
         await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
         return ids;
     }
-    async restoreBackupFromGoogleDrive({ accountAddress, oauthAccountId, name, password }) {
+    async restoreBackupFromGoogleDrive({ accountAddress, oauthAccountId, name, displayContainer, password }) {
         await this.getWallet({
             accountAddress
         });
@@ -1050,71 +1422,27 @@ class DynamicWalletClient {
                 keyShare,
                 password
             })));
-        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
-            clientKeyShares: mergeUniqueKeyShares(this.walletMap[accountAddress].clientKeyShares || [], decryptedKeyShares)
+        await this.setClientKeySharesToLocalStorage({
+            accountAddress,
+            clientKeyShares: decryptedKeyShares,
+            overwriteOrMerge: 'merge'
         });
+        if (this.useIframeStorage) {
+            const { iframeDisplay } = await this.initializeIframeDisplayForContainer({
+                container: displayContainer
+            });
+            iframeDisplay.displayClientShares(accountAddress);
+        }
         return decryptedKeyShares;
     }
-    async importRawPrivateKey({ chainName, privateKey, thresholdSignatureScheme, onError, onCeremonyComplete }) {
-        const mpcSigner = getMPCSigner({
-            chainName,
-            baseRelayUrl: this.baseMPCRelayApiUrl
-        });
-        const clientKeygenInitResults = await this.clientInitializeKeyGen({
-            chainName,
-            thresholdSignatureScheme
-        });
-        const clientKeygenIds = clientKeygenInitResults.map((result)=>result.keygenId);
-        const { roomId, serverKeygenIds } = await this.apiClient.importPrivateKey({
-            chainName,
-            clientKeygenIds,
-            thresholdSignatureScheme,
-            onError,
-            onCeremonyComplete
-        });
-        const { threshold } = core.getTSSConfig(thresholdSignatureScheme);
-        const clientKeygenResults = await Promise.all(clientKeygenInitResults.map(async (currentInit, index)=>{
-            const otherClientKeygenIds = clientKeygenInitResults.filter((init)=>init.keygenId !== currentInit.keygenId).map((init)=>init.keygenId);
-            if (index === 0) {
-                const otherKeyGenIds = [
-                    ...serverKeygenIds,
-                    ...otherClientKeygenIds
-                ];
-                const importerKeygenResult = await mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, currentInit, otherKeyGenIds);
-                return importerKeygenResult;
-            } else {
-                const recipientKeygenResult = await mpcSigner.importPrivateKeyRecipient(roomId, threshold, currentInit, [
-                    ...serverKeygenIds,
-                    ...otherClientKeygenIds
-                ]);
-                return recipientKeygenResult;
-            }
-        }));
-        const [clientKeygenResult] = clientKeygenResults;
-        const rawPublicKey = await this.derivePublicKey({
-            chainName,
-            keyShare: clientKeygenResult,
-            derivationPath: undefined
-        });
-        return {
-            rawPublicKey,
-            clientKeyShares: clientKeygenResults
-        };
-    }
     async exportClientKeyshares({ accountAddress, password }) {
         await this.verifyPassword({
             accountAddress,
             password,
-            walletOperation: WalletOperation.REACH_ALL_PARTIES
-        });
-        await this.getWallet({
-            accountAddress,
-            walletOperation: WalletOperation.REACH_ALL_PARTIES,
-            password
+            walletOperation: core.WalletOperation.REACH_ALL_PARTIES
         });
-        const clientKeyShares = await this.getClientKeyShares({
-            accountAddress,
-            password
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
         });
         if (!accountAddress) {
             throw new Error('Must provide an account address');
@@ -1136,19 +1464,21 @@ class DynamicWalletClient {
         a.click();
     }
     async getClientKeyShares({ accountAddress, password }) {
-        const wallet = await this.getWallet({
+        await this.getWallet({
             accountAddress,
             password,
-            walletOperation: WalletOperation.REACH_THRESHOLD
+            walletOperation: core.WalletOperation.REACH_THRESHOLD
+        });
+        return this.getClientKeySharesFromLocalStorage({
+            accountAddress
         });
-        return wallet.clientKeyShares;
     }
     /**
    * Helper function to check if the required wallet fields are present and valid
    * @param accountAddress - The account address of the wallet to check
    * @param walletOperation - The wallet operation that determines required fields
    * @returns boolean indicating if wallet needs to be re-fetched and restored from server
-   */ async checkWalletFields({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD, shareCount }) {
+   */ async checkWalletFields({ accountAddress, walletOperation = core.WalletOperation.REACH_THRESHOLD, shareCount }) {
         let keyshareCheck = false;
         let walletCheck = false;
         let thresholdSignatureSchemeCheck = false;
@@ -1168,7 +1498,6 @@ class DynamicWalletClient {
         }
         // check if wallet already exists with sufficient keyshares
         if (existingWallet) {
-            var _existingWallet_clientKeyShares;
             const { shares } = this.recoverStrategy({
                 clientKeyShareBackupInfo: existingWallet.clientKeySharesBackupInfo || {
                     backups: getClientKeyShareBackupInfo()
@@ -1178,7 +1507,10 @@ class DynamicWalletClient {
                 shareCount
             });
             const { dynamic: requiredDynamicKeyShareIds = [] } = shares;
-            if (requiredDynamicKeyShareIds.length <= (((_existingWallet_clientKeyShares = existingWallet.clientKeyShares) == null ? void 0 : _existingWallet_clientKeyShares.length) || 0)) {
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            if (requiredDynamicKeyShareIds.length <= ((clientKeyShares == null ? void 0 : clientKeyShares.length) || 0)) {
                 keyshareCheck = true;
             }
         }
@@ -1188,7 +1520,7 @@ class DynamicWalletClient {
    * verifyPassword attempts to recover and decrypt a single client key share using the provided password.
    * If successful, the key share is encrypted with the new password. This method solely performs the recovery
    * and decryption without storing the restored key shares. If unsuccessful, it throws an error.
-   */ async verifyPassword({ accountAddress, password = undefined, walletOperation = WalletOperation.NO_OPERATION }) {
+   */ async verifyPassword({ accountAddress, password = undefined, walletOperation = core.WalletOperation.NO_OPERATION }) {
         await this.getWallet({
             accountAddress,
             password,
@@ -1232,7 +1564,7 @@ class DynamicWalletClient {
     }
     /**
    * check if the operation requires a password
-   */ async requiresPasswordForOperation({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD }) {
+   */ async requiresPasswordForOperation({ accountAddress, walletOperation = core.WalletOperation.REACH_THRESHOLD }) {
         const isEncrypted = await this.isPasswordEncrypted({
             accountAddress
         });
@@ -1246,12 +1578,14 @@ class DynamicWalletClient {
     }
     /**
    * check if the operation requires restoring backup shares
-   */ async requiresRestoreBackupSharesForOperation({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD }) {
+   */ async requiresRestoreBackupSharesForOperation({ accountAddress, walletOperation = core.WalletOperation.REACH_THRESHOLD }) {
         const clientKeySharesBackupInfo = await this.getWalletClientKeyShareBackupInfo({
             accountAddress
         });
-        const clientKeyShares = this.walletMap[accountAddress].clientKeyShares || [];
-        if (walletOperation === WalletOperation.REACH_ALL_PARTIES || walletOperation === WalletOperation.REFRESH || walletOperation === WalletOperation.RESHARE) {
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        if (walletOperation === core.WalletOperation.REACH_ALL_PARTIES || walletOperation === core.WalletOperation.REFRESH || walletOperation === core.WalletOperation.RESHARE) {
             return true;
         }
         const { requiredShareCount } = this.recoverStrategy({
@@ -1277,7 +1611,7 @@ class DynamicWalletClient {
             walletProperties: wallet == null ? void 0 : wallet.walletProperties
         });
     }
-    async getWallet({ accountAddress, walletOperation = WalletOperation.NO_OPERATION, shareCount = undefined, password = undefined }) {
+    async getWallet({ accountAddress, walletOperation = core.WalletOperation.NO_OPERATION, shareCount = undefined, password = undefined }) {
         var _user_verifiedCredentials;
         const existingWalletCheck = await this.checkWalletFields({
             accountAddress,
@@ -1303,7 +1637,7 @@ class DynamicWalletClient {
                 walletProperties
             })
         });
-        if (walletOperation !== WalletOperation.NO_OPERATION && await this.requiresRestoreBackupSharesForOperation({
+        if (walletOperation !== core.WalletOperation.NO_OPERATION && await this.requiresRestoreBackupSharesForOperation({
             accountAddress,
             walletOperation
         })) {
@@ -1313,6 +1647,12 @@ class DynamicWalletClient {
                 walletOperation: walletOperation,
                 shareCount
             });
+            if (this.useIframeStorage) {
+                var _this_iframeStorage;
+                (_this_iframeStorage = this.iframeStorage) == null ? void 0 : _this_iframeStorage.setItem(`${accountAddress}`, JSON.stringify({
+                    clientKeyShares: decryptedKeyShares
+                }));
+            }
             this.logger.debug('Recovered backup', decryptedKeyShares);
         }
         const walletCount = Object.keys(this.walletMap).length;
@@ -1345,13 +1685,13 @@ class DynamicWalletClient {
             };
         });
         this.walletMap = wallets.reduce((acc, wallet)=>{
-            var _acc_accountAddress;
+            var _acc_wallet_accountAddress, _acc_accountAddress;
             const accountAddress = wallet.accountAddress;
             acc[wallet.accountAddress] = {
                 walletId: wallet.walletId,
                 chainName: wallet.chainName,
                 accountAddress: wallet.accountAddress,
-                clientKeyShares: wallet.clientKeyShares || [],
+                clientKeyShares: ((_acc_wallet_accountAddress = acc[wallet.accountAddress]) == null ? void 0 : _acc_wallet_accountAddress.clientKeyShares) || [],
                 clientKeySharesBackupInfo: wallet.clientKeySharesBackupInfo,
                 derivationPath: ((_acc_accountAddress = acc[accountAddress]) == null ? void 0 : _acc_accountAddress.derivationPath) || undefined,
                 thresholdSignatureScheme: wallet.thresholdSignatureScheme
@@ -1365,7 +1705,14 @@ class DynamicWalletClient {
         this.logger = logger;
         this.walletMap = {} // todo: store in session storage
         ;
+        this.iframeStorage = null;
+        this.iframeDisplay = null;
         this.memoryStorage = null;
+        this.messageTransport = null;
+        this.iframe = null;
+        this.useIframeStorage = false // TODO: remove this when iframe is deployed
+        ;
+        this.iframeLoadPromise = null;
         this.environmentId = environmentId;
         this.storageKey = `${STORAGE_KEY}-${storageKey != null ? storageKey : environmentId}`;
         this.baseMPCRelayApiUrl = baseMPCRelayApiUrl;
@@ -1383,6 +1730,9 @@ class DynamicWalletClient {
             this.memoryStorage = {};
             this.storage = memoryLocalStorageAdapter(this.memoryStorage);
         }
+        this.iframeDomain = core.IFRAME_DOMAIN;
+        // Generate unique instanceId when client is created
+        this.instanceId = crypto.randomUUID();
         // initialize the client
         this.initialize();
     }
@@ -1437,7 +1787,6 @@ Object.defineProperty(exports, "MessageHash", {
     get: function () { return web.MessageHash; }
 });
 exports.DynamicWalletClient = DynamicWalletClient;
-exports.WalletOperation = WalletOperation;
 exports.base64ToBytes = base64ToBytes;
 exports.bytesToBase64 = bytesToBase64;
 exports.ensureBase64Padding = ensureBase64Padding;