@dynamic-labs-wallet/browser 0.0.0-preview-120.0

package/index.esm.js

@@ -0,0 +1,1738 @@
+import { SigningAlgorithm, MPC_RELAY_PROD_API_URL, getMPCChainConfig, BackupLocation, getClientThreshold, MPC_CONFIG, getTSSConfig, WalletOperation, getReshareConfig, DynamicApiClient, ENVIRONMENT_ENUM, DYNAMIC_AUTH_DEV_BASE_API_URL, DYNAMIC_AUTH_PREPROD_BASE_API_URL, DYNAMIC_AUTH_PROD_BASE_API_URL, IFRAME_DOMAIN_MAP } from '@dynamic-labs-wallet/core';
+export * from '@dynamic-labs-wallet/core';
+import { BIP340, Ed25519, Ecdsa, MessageHash, EcdsaKeygenResult, Ed25519KeygenResult, BIP340KeygenResult } from './internal/web';
+export { BIP340, BIP340InitKeygenResult, BIP340KeygenResult, Ecdsa, EcdsaInitKeygenResult, EcdsaKeygenResult, EcdsaPublicKey, EcdsaSignature, Ed25519, Ed25519InitKeygenResult, Ed25519KeygenResult, MessageHash } from './internal/web';
+import { Logger } from '@dynamic-labs/logger';
+import { createRequestChannel, parseMessageTransportData, applyDefaultMessageOrigin, createMessageTransport } from '@dynamic-labs/message-transport';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+const getMPCSignatureScheme = ({ signingAlgorithm, baseRelayUrl = MPC_RELAY_PROD_API_URL })=>{
+    switch(signingAlgorithm){
+        case SigningAlgorithm.ECDSA:
+            return new Ecdsa(baseRelayUrl);
+        case SigningAlgorithm.ED25519:
+            return new Ed25519(baseRelayUrl);
+        case SigningAlgorithm.BIP340:
+            return new BIP340(baseRelayUrl);
+        default:
+            throw new Error(`Unsupported signing algorithm: ${signingAlgorithm}`);
+    }
+};
+const getMPCSigner = ({ chainName, baseRelayUrl })=>{
+    const chainConfig = getMPCChainConfig(chainName);
+    const signatureScheme = getMPCSignatureScheme({
+        signingAlgorithm: chainConfig.signingAlgorithm,
+        baseRelayUrl
+    });
+    return signatureScheme;
+};
+
+const DEFAULT_LOG_LEVEL = 'INFO';
+const STORAGE_KEY = 'dynamic-waas-wallet-client';
+const CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX = 'dynamicWalletKeyShareBackup';
+
+const logger = new Logger('DynamicWaasWalletClient');
+
+const bytesToBase64 = (arr)=>{
+    return btoa(Array.from(arr, (b)=>String.fromCharCode(b)).join(''));
+};
+const stringToBytes = (str)=>{
+    return new TextEncoder().encode(str);
+};
+const base64ToBytes = (base64)=>{
+    return new Uint8Array(Buffer.from(base64, 'base64'));
+};
+// Helper function to ensure proper base64 padding
+const ensureBase64Padding = (str)=>{
+    return str.padEnd(Math.ceil(str.length / 4) * 4, '=');
+};
+const isBrowser = ()=>typeof window !== 'undefined';
+const isHexString = (str)=>{
+    // Remove 0x prefix if present
+    const hex = str.startsWith('0x') ? str.slice(2) : str;
+    // Check if string contains only hex characters
+    return /^[0-9A-Fa-f]+$/.test(hex);
+};
+const getClientKeyShareExportFileName = ({ thresholdSignatureScheme, accountAddress })=>{
+    return `${CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX}-${thresholdSignatureScheme}-${accountAddress}.json`;
+};
+const getClientKeyShareBackupInfo = (params)=>{
+    var _params_walletProperties, _params_walletProperties_keyShares_;
+    const backups = {
+        [BackupLocation.DYNAMIC]: [],
+        [BackupLocation.GOOGLE_DRIVE]: [],
+        [BackupLocation.ICLOUD]: [],
+        [BackupLocation.USER]: [],
+        [BackupLocation.EXTERNAL]: []
+    };
+    if (!(params == null ? void 0 : (_params_walletProperties = params.walletProperties) == null ? void 0 : _params_walletProperties.keyShares)) {
+        return {
+            backups,
+            passwordEncrypted: false
+        };
+    }
+    params.walletProperties.keyShares.forEach((keyShare)=>{
+        if (backups[keyShare.backupLocation]) {
+            backups[keyShare.backupLocation].push(keyShare.id);
+        }
+    });
+    const passwordEncrypted = Boolean((_params_walletProperties_keyShares_ = params.walletProperties.keyShares[0]) == null ? void 0 : _params_walletProperties_keyShares_.passwordEncrypted);
+    return {
+        backups,
+        passwordEncrypted
+    };
+};
+/**
+ * Helper function to merge keyshares and remove duplicates based on pubkey and secretShare
+ * @param existingKeyShares - Array of existing keyshares
+ * @param newKeyShares - Array of new keyshares to merge
+ * @returns Array of merged unique keyshares
+ */ const mergeUniqueKeyShares = (existingKeyShares, newKeyShares)=>{
+    const uniqueKeyShares = newKeyShares.filter((newShare)=>!existingKeyShares.some((existingShare)=>{
+            if (!(newShare == null ? void 0 : newShare.pubkey) || !(existingShare == null ? void 0 : existingShare.pubkey)) return false;
+            return newShare.pubkey.toString() === existingShare.pubkey.toString() && newShare.secretShare === existingShare.secretShare;
+        }));
+    return [
+        ...existingKeyShares,
+        ...uniqueKeyShares
+    ];
+};
+const timeoutPromise = ({ timeInMs, activity = 'Ceremony' })=>{
+    return new Promise((_, reject)=>setTimeout(()=>reject(new Error(`${activity} did not complete in ${timeInMs}ms`)), timeInMs));
+};
+/**
+ * Generic helper function to retry a promise-based operations
+ *
+ * @param operation - The async operation to retry
+ * @param config - Configuration options for retry behavior
+ * @returns Promise with the operation result
+ * @throws Last error encountered after all retries are exhausted
+ */ async function retryPromise(operation, { maxAttempts = 5, retryInterval = 500, operationName = 'operation', logContext = {} } = {}) {
+    let attempts = 0;
+    while(attempts < maxAttempts){
+        try {
+            return await operation();
+        } catch (error) {
+            attempts++;
+            if (attempts === maxAttempts) {
+                logger.error(`Failed to execute ${operationName} after ${maxAttempts} attempts`, _extends({}, logContext, {
+                    error
+                }));
+                throw error;
+            }
+            await new Promise((resolve)=>setTimeout(resolve, retryInterval));
+        }
+    }
+    // TypeScript needs this even though it's unreachable
+    throw new Error('Unreachable code');
+}
+
+const PBKDF2_ALGORITHM = 'PBKDF2';
+const PBKDF2_ITERATIONS = 100000;
+const PBKDF2_HASH_ALGORITHM = 'SHA-256';
+const AES_GCM_ALGORITHM = 'AES-GCM';
+const AES_GCM_LENGTH = 256;
+const getKey = async ({ password, salt })=>{
+    const passwordBytes = stringToBytes(password);
+    const initialKey = await crypto.subtle.importKey('raw', passwordBytes, {
+        name: 'PBKDF2'
+    }, false, [
+        'deriveKey'
+    ]);
+    return crypto.subtle.deriveKey({
+        name: PBKDF2_ALGORITHM,
+        salt,
+        iterations: PBKDF2_ITERATIONS,
+        hash: PBKDF2_HASH_ALGORITHM
+    }, initialKey, {
+        name: AES_GCM_ALGORITHM,
+        length: AES_GCM_LENGTH
+    }, false, [
+        'encrypt',
+        'decrypt'
+    ]);
+};
+const encryptData = async ({ data, password })=>{
+    try {
+        // Generate a random salt and IV
+        const salt = crypto.getRandomValues(new Uint8Array(16));
+        const iv = crypto.getRandomValues(new Uint8Array(12)); // AES-GCM requires 12 bytes
+        const key = await getKey({
+            password,
+            salt
+        });
+        // Convert the input string to bytes
+        const dataBytes = new TextEncoder().encode(data);
+        // Encrypt the data
+        const encryptedData = await crypto.subtle.encrypt({
+            name: AES_GCM_ALGORITHM,
+            iv
+        }, key, dataBytes);
+        // Convert to base64 strings, ensure proper padding
+        return {
+            salt: bytesToBase64(salt),
+            iv: bytesToBase64(iv),
+            cipher: bytesToBase64(new Uint8Array(encryptedData))
+        };
+    } catch (error) {
+        throw new Error('Error encrypting data');
+    }
+};
+const decryptData = async ({ data, password })=>{
+    try {
+        const { salt, iv, cipher } = data;
+        // Ensure proper base64 padding for all values
+        const paddedSalt = ensureBase64Padding(salt);
+        const paddedIv = ensureBase64Padding(iv);
+        const paddedCipher = ensureBase64Padding(cipher);
+        const saltBytes = base64ToBytes(paddedSalt);
+        const ivBytes = base64ToBytes(paddedIv);
+        const cipherBytes = base64ToBytes(paddedCipher);
+        const key = await getKey({
+            password,
+            salt: saltBytes
+        });
+        const decryptedData = await crypto.subtle.decrypt({
+            name: AES_GCM_ALGORITHM,
+            iv: ivBytes
+        }, key, cipherBytes);
+        return new TextDecoder().decode(decryptedData);
+    } catch (error) {
+        throw new Error('Decryption failed');
+    }
+};
+
+const GOOGLE_DRIVE_UPLOAD_API = 'https://www.googleapis.com';
+const uploadFileToGoogleDriveAppStorage = async ({ accessToken, fileName, jsonData })=>{
+    return uploadFileToGoogleDrive({
+        accessToken,
+        fileName,
+        jsonData,
+        parents: [
+            'appDataFolder'
+        ]
+    });
+};
+const uploadFileToGoogleDrivePersonal = async ({ accessToken, fileName, jsonData })=>{
+    return uploadFileToGoogleDrive({
+        accessToken,
+        fileName,
+        jsonData,
+        parents: [
+            'root'
+        ]
+    });
+};
+const uploadFileToGoogleDrive = async ({ accessToken, fileName, jsonData, parents })=>{
+    const metadata = {
+        name: fileName,
+        mimeType: 'application/json',
+        parents
+    };
+    const form = new FormData();
+    form.append('metadata', new Blob([
+        JSON.stringify(metadata)
+    ], {
+        type: 'application/json'
+    }));
+    form.append('file', new Blob([
+        JSON.stringify(jsonData)
+    ], {
+        type: 'application/json'
+    }));
+    const response = await fetch(`${GOOGLE_DRIVE_UPLOAD_API}/upload/drive/v3/files?uploadType=multipart`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${accessToken}`
+        },
+        body: form
+    });
+    if (!response.ok) {
+        throw new Error('Error uploading file');
+    }
+    const result = await response.json();
+    return result; // Return file metadata, including file ID
+};
+const listFilesFromGoogleDrive = async ({ accessToken, name })=>{
+    // Step 1: List all files inside `appDataFolder` with the specified backup filename
+    const resp = await fetch(`${GOOGLE_DRIVE_UPLOAD_API}/drive/v3/files?q=${encodeURIComponent(`name='${name}'`)}&spaces=appDataFolder&orderBy=createdTime desc`, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`
+        }
+    });
+    const data = await resp.json();
+    // If no files found, return null
+    if (!data.files || data.files.length === 0) {
+        return null;
+    }
+    const files = data.files;
+    return files;
+};
+const downloadFileFromGoogleDrive = async ({ accessToken, name })=>{
+    const files = await listFilesFromGoogleDrive({
+        accessToken,
+        name
+    });
+    if (!files || files.length === 0) {
+        return null;
+    }
+    // Get the most recent file
+    const fileMetadata = files[0];
+    // Fetch the file data using the file ID
+    const fileRes = await fetch(`${GOOGLE_DRIVE_UPLOAD_API}/drive/v3/files/${fileMetadata.id}?alt=media`, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`
+        }
+    });
+    // Read the file's raw data
+    const fileRawData = await fileRes.text();
+    if (fileRawData.length === 0) {
+        return null;
+    }
+    try {
+        // Just parse and return the data without validation
+        // The client will handle validation of the structure
+        return JSON.parse(fileRawData);
+    } catch (error) {
+        return null;
+    }
+};
+
+const localStorageWriteTest = {
+    tested: false,
+    writable: false
+};
+/**
+ * Checks whether localStorage is supported on this browser.
+ */ const supportsLocalStorage = ()=>{
+    if (!isBrowser()) {
+        return false;
+    }
+    try {
+        if (typeof globalThis.localStorage !== 'object') {
+            return false;
+        }
+    } catch (e) {
+        // DOM exception when accessing `localStorage`
+        return false;
+    }
+    if (localStorageWriteTest.tested) {
+        return localStorageWriteTest.writable;
+    }
+    const randomKey = `lswt-${Math.random()}${Math.random()}`;
+    try {
+        globalThis.localStorage.setItem(randomKey, randomKey);
+        globalThis.localStorage.removeItem(randomKey);
+        localStorageWriteTest.tested = true;
+        localStorageWriteTest.writable = true;
+    } catch (e) {
+        // localStorage can't be written to
+        localStorageWriteTest.tested = true;
+        localStorageWriteTest.writable = false;
+    }
+    return localStorageWriteTest.writable;
+};
+/**
+ * Provides safe access to the globalThis.localStorage property.
+ */ const localStorageAdapter = {
+    getItem: (key)=>{
+        if (!supportsLocalStorage()) {
+            return null;
+        }
+        return globalThis.localStorage.getItem(key);
+    },
+    removeItem: (key)=>{
+        if (!supportsLocalStorage()) {
+            return;
+        }
+        globalThis.localStorage.removeItem(key);
+    },
+    setItem: (key, value)=>{
+        if (!supportsLocalStorage()) {
+            return;
+        }
+        globalThis.localStorage.setItem(key, value);
+    }
+};
+/**
+ * Returns a localStorage-like object that stores the key-value pairs in
+ * memory.
+ */ const memoryLocalStorageAdapter = (store = {})=>({
+        getItem: (key)=>store[key] || null,
+        removeItem: (key)=>{
+            delete store[key];
+        },
+        setItem: (key, value)=>{
+            store[key] = value;
+        }
+    });
+
+/**
+ * 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){
+        this.requestChannel = createRequestChannel(messageTransport);
+    }
+}
+
+const setupMessageTransportBridge = (messageTransport, iframe, iframeOrigin)=>{
+    if (!(iframe == null ? void 0 : iframe.contentWindow)) {
+        throw new Error('Iframe or contentWindow not available');
+    }
+    const logger = new Logger('debug');
+    messageTransport.on((message)=>{
+        // Forward the message to webview via postMessage
+        if (message.origin === 'host') {
+            var _iframe_contentWindow;
+            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') {
+            return;
+        }
+        if (typeof data !== 'object') {
+            return;
+        }
+        try {
+            const message = parseMessageTransportData(data);
+            messageTransport.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){
+        this.requestChannel = createRequestChannel(messageTransport);
+    }
+}
+
+class DynamicWalletClient {
+    async initialize() {
+        if (this.initializePromise) {
+            return await this.initializePromise;
+        }
+        this.logger.debug('Initializing Dynamic Waas Wallet SDK');
+        this.initializePromise = this._initialize();
+        const result = await this.initializePromise;
+        this.logger.debug('Dynamic Waas Wallet SDK initialized');
+        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 = applyDefaultMessageOrigin({
+                defaultOrigin: 'host',
+                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 = applyDefaultMessageOrigin({
+            defaultOrigin: 'host',
+            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 = [
+                this.restoreWallets(),
+                this.initializeIframeCommunication()
+            ];
+            await Promise.all(initializePromises);
+            return {
+                error: null
+            };
+        } catch (error) {
+            return {
+                error
+            };
+        }
+    }
+    async serverInitializeKeyGen({ chainName, clientKeygenIds, thresholdSignatureScheme, onError, onCeremonyComplete }) {
+        // Initialize keygen, create room, and create the wallet account on the server
+        const data = await this.apiClient.createWalletAccount({
+            chainName,
+            clientKeygenIds,
+            thresholdSignatureScheme,
+            onError,
+            onCeremonyComplete
+        });
+        return data;
+    }
+    async clientInitializeKeyGen({ chainName, thresholdSignatureScheme }) {
+        // Get the mpc signer
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const clientThreshold = getClientThreshold(thresholdSignatureScheme);
+        const keygenInitResults = await Promise.all(Array(clientThreshold).fill(null).map(()=>mpcSigner.initKeygen()));
+        return keygenInitResults;
+    }
+    async derivePublicKey({ chainName, keyShare, derivationPath }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        let publicKey;
+        if (mpcSigner instanceof Ecdsa) {
+            publicKey = await mpcSigner.derivePubkey(keyShare, derivationPath);
+        } else if (mpcSigner instanceof Ed25519) {
+            publicKey = await mpcSigner.derivePubkey(keyShare, derivationPath);
+        }
+        return publicKey;
+    }
+    async clientKeyGen({ chainName, roomId, serverKeygenIds, clientKeygenInitResults, thresholdSignatureScheme }) {
+        // Get the chain config and the mpc signer
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        // Get the MPC config for the threshold signature scheme
+        const mpcConfig = MPC_CONFIG[thresholdSignatureScheme];
+        // For each client keygen init result, create an array of other parties' keygenIds
+        const clientKeygenResults = await Promise.all(clientKeygenInitResults.map((currentInit)=>{
+            // Get all other client keygenIds (excluding current one)
+            const otherClientKeygenIds = clientKeygenInitResults.filter((init)=>init.keygenId !== currentInit.keygenId).map((init)=>init.keygenId);
+            // Combine server keygenIds with other client keygenIds
+            const allOtherKeygenIds = [
+                ...serverKeygenIds,
+                ...otherClientKeygenIds
+            ];
+            return mpcSigner.keygen(roomId, mpcConfig.numberOfParties, mpcConfig.threshold, currentInit, allOtherKeygenIds);
+        }));
+        // only need one client keygen result to derive the public key
+        const [clientKeygenResult] = clientKeygenResults;
+        const chainConfig = getMPCChainConfig(chainName);
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        const rawPublicKey = await this.derivePublicKey({
+            chainName,
+            keyShare: clientKeygenResult,
+            derivationPath
+        });
+        return {
+            rawPublicKey,
+            clientKeygenResults
+        };
+    }
+    async keyGen({ chainName, thresholdSignatureScheme, onError, onCeremonyComplete }) {
+        try {
+            const clientKeygenInitResults = await this.clientInitializeKeyGen({
+                chainName,
+                thresholdSignatureScheme
+            });
+            const clientKeygenIds = clientKeygenInitResults.map((result)=>result.keygenId);
+            const { roomId, serverKeygenIds } = await this.serverInitializeKeyGen({
+                chainName,
+                clientKeygenIds,
+                thresholdSignatureScheme,
+                onCeremonyComplete
+            });
+            const { rawPublicKey, clientKeygenResults: clientKeyShares } = await this.clientKeyGen({
+                chainName,
+                roomId,
+                serverKeygenIds,
+                clientKeygenInitResults,
+                thresholdSignatureScheme
+            });
+            return {
+                rawPublicKey,
+                clientKeyShares
+            };
+        } catch (error) {
+            this.logger.error('Error creating wallet account', error);
+            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 } = 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') {
+            message = '0x' + Buffer.from(message).toString('hex');
+        }
+        const data = await this.apiClient.signMessage({
+            walletId,
+            message
+        });
+        return data;
+    }
+    async clientSign({ chainName, message, roomId, keyShare, derivationPath }) {
+        try {
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            let formattedMessage;
+            //note: Ecdsa can also be used by bitcoin, but only keccak256 is used by ethereum
+            if (mpcSigner instanceof Ecdsa) {
+                formattedMessage = MessageHash.keccak256(message);
+            } else if (mpcSigner instanceof Ed25519) {
+                if (typeof message === 'string') {
+                    if (!isHexString(message)) {
+                        formattedMessage = Buffer.from(message).toString('hex');
+                    } else {
+                        formattedMessage = Buffer.from(message, 'hex');
+                    }
+                } else {
+                    formattedMessage = message;
+                }
+            } else if (mpcSigner instanceof BIP340 && typeof message === 'string') {
+                formattedMessage = new TextEncoder().encode(message);
+            } else {
+                throw new Error('Unsupported signer type');
+            }
+            const signature = await mpcSigner.sign(roomId, keyShare, formattedMessage, derivationPath);
+            return signature;
+        } catch (error) {
+            this.logger.error('Error in clientSign:', error);
+            throw error;
+        }
+    }
+    //todo: need to modify with imported flag
+    async sign({ accountAddress, message, chainName, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_MESSAGE
+        });
+        const wallet = await this.getWallet({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.SIGN_MESSAGE
+        });
+        // Perform the server sign
+        const data = await this.serverSign({
+            walletId: wallet.walletId,
+            message
+        });
+        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: clientKeyShares[0],
+            derivationPath
+        });
+        return signature;
+    }
+    async refreshWalletAccountShares({ accountAddress, chainName, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.REFRESH
+        });
+        const wallet = await this.getWallet({
+            accountAddress,
+            walletOperation: WalletOperation.NO_OPERATION,
+            password
+        });
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        // Create the room and refresh the shares
+        const data = await this.apiClient.refreshWalletAccountShares({
+            walletId: wallet.walletId
+        });
+        const roomId = data.roomId;
+        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], {
+            clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
+        });
+        await this.setClientKeySharesToLocalStorage({
+            accountAddress,
+            clientKeyShares: refreshResults,
+            overwriteOrMerge: 'overwrite'
+        });
+        await this.storeEncryptedBackupByWallet({
+            accountAddress,
+            password: password != null ? password : this.environmentId
+        });
+        return refreshResults;
+    }
+    async getExportId({ chainName, clientKeyShare }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const exportId = await mpcSigner.exportID(clientKeyShare);
+        return exportId;
+    }
+    /**
+   * Helper function to create client shares required to complete a reshare ceremony.
+   * @param {string} chainName - The chain to create shares for
+   * @param {WalletProperties} wallet - The wallet to reshare
+   * @param {ThresholdSignatureScheme} oldThresholdSignatureScheme - The current threshold signature scheme
+   * @param {ThresholdSignatureScheme} newThresholdSignatureScheme - The target threshold signature scheme
+   * @returns {Promise<{
+   *   newClientInitKeygenResults: ClientInitKeygenResult[],
+   *   newClientKeygenIds: string[],
+   *   existingClientKeygenIds: string[],
+   *   existingClientKeyShares: ClientKeyShare[]
+   * }>} Object containing new and existing client keygen results, IDs and shares
+   * @todo Support higher to lower reshare strategies
+   */ async reshareStrategy({ chainName, wallet, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        // Determine share counts based on threshold signature schemes
+        const { newClientShareCount, existingClientShareCount } = getReshareConfig({
+            oldThresholdSignatureScheme,
+            newThresholdSignatureScheme
+        });
+        // Create new client shares
+        const newClientInitKeygenResults = await Promise.all(Array.from({
+            length: newClientShareCount
+        }, ()=>mpcSigner.initKeygen()));
+        const newClientKeygenIds = newClientInitKeygenResults.map((result)=>result.keygenId);
+        // Get existing client shares
+        const existingClientKeyShares = (await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        })).slice(0, existingClientShareCount);
+        const existingClientKeygenIds = await Promise.all(existingClientKeyShares.map(async (keyShare)=>await this.getExportId({
+                chainName,
+                clientKeyShare: keyShare
+            })));
+        return {
+            newClientInitKeygenResults,
+            newClientKeygenIds,
+            existingClientKeygenIds,
+            existingClientKeyShares
+        };
+    }
+    async reshare({ chainName, accountAddress, oldThresholdSignatureScheme, newThresholdSignatureScheme, password = undefined }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.RESHARE
+        });
+        const { existingClientShareCount } = getReshareConfig({
+            oldThresholdSignatureScheme,
+            newThresholdSignatureScheme
+        });
+        const wallet = await this.getWallet({
+            accountAddress,
+            walletOperation: WalletOperation.NO_OPERATION,
+            shareCount: existingClientShareCount,
+            password
+        });
+        const { newClientInitKeygenResults, newClientKeygenIds, existingClientKeygenIds, existingClientKeyShares } = await this.reshareStrategy({
+            chainName,
+            accountAddress,
+            wallet,
+            oldThresholdSignatureScheme,
+            newThresholdSignatureScheme
+        });
+        const clientKeygenIds = [
+            ...newClientKeygenIds,
+            ...existingClientKeygenIds
+        ];
+        // Server to create the room and complete the server reshare logics
+        const data = await this.apiClient.reshare({
+            walletId: wallet.walletId,
+            clientKeygenIds: clientKeygenIds,
+            oldThresholdSignatureScheme,
+            newThresholdSignatureScheme
+        });
+        const { roomId, serverKeygenIds, newServerKeygenIds = [] } = data;
+        // Get the MPC config for the threshold signature scheme
+        const oldMpcConfig = MPC_CONFIG[oldThresholdSignatureScheme];
+        const newMpcConfig = MPC_CONFIG[newThresholdSignatureScheme];
+        const allPartyKeygenIds = [
+            ...clientKeygenIds,
+            ...serverKeygenIds,
+            ...newServerKeygenIds
+        ];
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const reshareResults = await Promise.all([
+            ...newClientInitKeygenResults.map((keygenResult)=>mpcSigner.reshareNewParty(roomId, oldMpcConfig.threshold, newMpcConfig.threshold, keygenResult, allPartyKeygenIds)),
+            ...existingClientKeyShares.map((keyShare)=>mpcSigner.reshareRemainingParty(roomId, newMpcConfig.threshold, keyShare, allPartyKeygenIds))
+        ]);
+        await this.setClientKeySharesToLocalStorage({
+            accountAddress,
+            clientKeyShares: reshareResults,
+            overwriteOrMerge: 'overwrite'
+        });
+        await this.storeEncryptedBackupByWallet({
+            accountAddress,
+            password
+        });
+        return reshareResults;
+    }
+    async exportKey({ accountAddress, chainName, password = undefined }) {
+        const wallet = await this.getWallet({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY
+        });
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        const exportId = await this.getExportId({
+            chainName,
+            clientKeyShare: clientKeyShares[0]
+        });
+        const data = await this.apiClient.exportKey({
+            walletId: wallet.walletId,
+            exportId
+        });
+        const keyExportRaw = await mpcSigner.exportFullPrivateKey(data.roomId, clientKeyShares[0], exportId);
+        if (!keyExportRaw) {
+            throw new Error('Error exporting private key');
+        }
+        const derivationPath = wallet.derivationPath && wallet.derivationPath != '' ? new Uint32Array(Object.values(JSON.parse(wallet.derivationPath))) : undefined;
+        let derivedPrivateKey;
+        if (mpcSigner instanceof Ecdsa) {
+            derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+        } else if (mpcSigner instanceof Ed25519) {
+            derivedPrivateKey = keyExportRaw;
+        } else if (mpcSigner instanceof BIP340) {
+            derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+        }
+        return {
+            derivedPrivateKey
+        };
+    }
+    async offlineExportKey({ chainName, keyShares, derivationPath }) {
+        try {
+            if (!keyShares || keyShares.length < 2) {
+                throw new Error(`Must provide at least min threshold of key shares`);
+            }
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            const walletKeyShares = keyShares.map((keyShare)=>{
+                return mpcSigner instanceof Ecdsa ? new EcdsaKeygenResult(keyShare.pubkey, keyShare.secretShare) : mpcSigner instanceof Ed25519 ? new Ed25519KeygenResult(keyShare.pubkey, keyShare.secretShare) : new BIP340KeygenResult(keyShare.pubkey, keyShare.secretShare);
+            });
+            const keyExportRaw = await mpcSigner.offlineExportFullPrivateKey(walletKeyShares);
+            if (!keyExportRaw) {
+                throw new Error('Error exporting private key: Export returned null');
+            }
+            const chainConfig = getMPCChainConfig(chainName);
+            const walletDerivationPath = !derivationPath ? undefined : new Uint32Array(chainConfig.derivationPath);
+            let derivedPrivateKey;
+            if (mpcSigner instanceof Ecdsa) {
+                derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, walletDerivationPath);
+            } else if (mpcSigner instanceof Ed25519) {
+                derivedPrivateKey = keyExportRaw;
+            } else if (mpcSigner instanceof BIP340) {
+                derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, walletDerivationPath);
+            }
+            const rawPublicKey = await this.derivePublicKey({
+                chainName,
+                keyShare: walletKeyShares[0],
+                derivationPath: walletDerivationPath
+            });
+            return {
+                derivedPrivateKey,
+                rawPublicKey
+            };
+        } catch (error) {
+            this.logger.error('Error in offlineExportKey:', error);
+            throw error;
+        }
+    }
+    async encryptKeyShare({ keyShare, password }) {
+        const serializedKeyShare = JSON.stringify(keyShare);
+        const encryptedKeyShare = await encryptData({
+            data: serializedKeyShare,
+            password: password != null ? password : this.environmentId
+        });
+        // stringify the encrypted key share, convert to base64, and store it
+        const serializedEncryptedKeyShare = Buffer.from(JSON.stringify(encryptedKeyShare)).toString('base64');
+        return serializedEncryptedKeyShare;
+    }
+    /**
+   * helper function to store encrypted backup by wallet from iframe local storage
+   */ async getClientKeySharesFromLocalStorage({ accountAddress }) {
+        var _this_iframeStorage;
+        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 [];
+        }
+    }
+    /**
+   * helper function to store encrypted backup by wallet from iframe local storage
+   */ async setClientKeySharesToLocalStorage({ accountAddress, clientKeyShares, overwriteOrMerge = 'merge' }) {
+        var _this_iframeStorage;
+        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
+   * in Dynamic's backend. If Google Drive backup is already configured for this wallet,
+   * it will also update the backup in Google Drive.
+   *
+   * The method performs the following steps:
+   * 1. Encrypts all client key shares with the provided password (or environment ID if no password)
+   * 2. Stores the encrypted key shares in Dynamic's backend
+   * 3. If Google Drive backup exists, updates the backup there as well
+   * 4. Updates the local wallet map with the new backup information
+   * 5. Persists the updated wallet map to storage
+   *
+   * @param {Object} params - The parameters for the backup operation
+   * @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 : await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        const encryptedKeyShares = await Promise.all(keySharesToBackup.map((keyShare)=>this.encryptKeyShare({
+                keyShare,
+                password
+            })));
+        if (!this.walletMap[accountAddress].walletId) {
+            throw new Error(`WalletId not found for accountAddress: ${accountAddress}`);
+        }
+        const data = await this.apiClient.storeEncryptedBackupByWallet({
+            walletId: this.walletMap[accountAddress].walletId,
+            encryptedKeyShares,
+            passwordEncrypted: Boolean(password) && password !== this.environmentId
+        });
+        const hasGoogleDriveBackup = this.walletMap[accountAddress].clientKeySharesBackupInfo.backups[BackupLocation.GOOGLE_DRIVE].length > 0;
+        if (hasGoogleDriveBackup) {
+            var _user_verifiedCredentials_find;
+            const user = await this.apiClient.getUser();
+            const oauthAccountId = user == null ? void 0 : (_user_verifiedCredentials_find = user.verifiedCredentials.find((credential)=>credential.oauthProvider === 'google')) == null ? void 0 : _user_verifiedCredentials_find.id;
+            const googleDriveKeyShareIds = await this.backupKeySharesToGoogleDrive({
+                accountAddress,
+                password,
+                oauthAccountId
+            });
+            data.keyShares.push({
+                backupLocation: BackupLocation.GOOGLE_DRIVE,
+                id: googleDriveKeyShareIds
+            });
+        }
+        const updatedBackupInfo = getClientKeyShareBackupInfo({
+            walletProperties: {
+                derivationPath: this.walletMap[accountAddress].derivationPath,
+                keyShares: data.keyShares,
+                thresholdSignatureScheme: this.walletMap[accountAddress].thresholdSignatureScheme
+            }
+        });
+        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+            clientKeySharesBackupInfo: updatedBackupInfo
+        });
+        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+        return data;
+    }
+    async storeEncryptedBackupByWalletWithRetry({ accountAddress, clientKeyShares, password }) {
+        await retryPromise(()=>this.storeEncryptedBackupByWallet({
+                accountAddress,
+                clientKeyShares,
+                password
+            }), {
+            operationName: 'store encrypted backup',
+            logContext: {
+                walletAddress: accountAddress,
+                keyShares: clientKeyShares == null ? void 0 : clientKeyShares.map((keyShare)=>this.encryptKeyShare({
+                        keyShare,
+                        password
+                    }))
+            }
+        });
+    }
+    async updatePassword({ accountAddress, existingPassword, newPassword }) {
+        await this.getWallet({
+            accountAddress,
+            password: existingPassword,
+            walletOperation: WalletOperation.REACH_ALL_PARTIES
+        });
+        await this.storeEncryptedBackupByWallet({
+            accountAddress,
+            password: newPassword
+        });
+    }
+    async decryptKeyShare({ keyShare, password }) {
+        const decodedKeyShare = JSON.parse(Buffer.from(keyShare, 'base64').toString());
+        const decryptedKeyShare = await decryptData({
+            data: decodedKeyShare,
+            password: password != null ? password : this.environmentId
+        });
+        const deserializedKeyShare = JSON.parse(decryptedKeyShare);
+        return deserializedKeyShare;
+    }
+    /**
+   * Helper function to determine keyshare recovery strategy for dynamic shares.
+   * For REFRESH operations, retrieves enough shares to meet the client threshold.
+   * For all other operations, retrieves just 1 share.
+   *
+   * @param clientKeyShareBackupInfo - Information about backed up key shares
+   * @param thresholdSignatureScheme - The signature scheme being used (2-of-2, 2-of-3, etc)
+   * @param walletOperation - The operation being performed (REFRESH, SIGN_MESSAGE, etc)
+   * @param shareCount - The number of shares to recover if specified for reshare operations
+   * @returns @shares: Object mapping backup locations to arrays of share IDs to recover
+   * @returns @requiredShareCount: The number of shares required to recover
+   */ recoverStrategy({ clientKeyShareBackupInfo, thresholdSignatureScheme, walletOperation, shareCount = undefined }) {
+        const { backups } = clientKeyShareBackupInfo;
+        const { clientThreshold } = MPC_CONFIG[thresholdSignatureScheme];
+        let requiredShareCount = walletOperation === WalletOperation.REFRESH || walletOperation === WalletOperation.REACH_ALL_PARTIES || walletOperation === WalletOperation.RESHARE ? clientThreshold : 1;
+        // Override requiredShareCount if shareCount is provided
+        if (shareCount !== undefined) {
+            requiredShareCount = shareCount;
+        }
+        const dynamicShares = backups[BackupLocation.DYNAMIC].slice(0, requiredShareCount);
+        return {
+            shares: {
+                [BackupLocation.DYNAMIC]: dynamicShares
+            },
+            requiredShareCount
+        };
+    }
+    async recoverEncryptedBackupByWallet({ accountAddress, password, walletOperation, shareCount = undefined, storeRecoveredShares = true }) {
+        const wallet = this.walletMap[accountAddress];
+        this.logger.debug(`recoverEncryptedBackupByWallet wallet: ${walletOperation}`, wallet);
+        const { shares } = this.recoverStrategy({
+            clientKeyShareBackupInfo: wallet.clientKeySharesBackupInfo,
+            thresholdSignatureScheme: wallet.thresholdSignatureScheme,
+            walletOperation,
+            shareCount
+        });
+        const { dynamic: dynamicKeyShareIds } = shares;
+        const data = await this.apiClient.recoverEncryptedBackupByWallet({
+            walletId: wallet.walletId,
+            keyShareIds: dynamicKeyShareIds
+        });
+        const dynamicKeyShares = data.keyShares.filter((keyShare)=>keyShare.encryptedAccountCredential !== null && keyShare.backupLocation === BackupLocation.DYNAMIC);
+        const decryptedKeyShares = await Promise.all(dynamicKeyShares.map((keyShare)=>this.decryptKeyShare({
+                keyShare: keyShare.encryptedAccountCredential,
+                password: password != null ? password : this.environmentId
+            })));
+        if (storeRecoveredShares) {
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares: decryptedKeyShares,
+                overwriteOrMerge: 'merge'
+            });
+            await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+        }
+        return decryptedKeyShares;
+    }
+    async restoreWallets() {
+        const wallets = await this.storage.getItem(this.storageKey);
+        if (!wallets) {
+            return;
+        }
+        this.walletMap = JSON.parse(wallets);
+    }
+    async backupKeySharesToGoogleDrive({ accountAddress, fileName, oauthAccountId, password }) {
+        await this.getWallet({
+            accountAddress,
+            walletOperation: WalletOperation.REACH_ALL_PARTIES,
+            password
+        });
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        if (clientKeyShares.length === 0) {
+            throw new Error('No key shares found');
+        }
+        const encryptedKeyShares = await Promise.all(clientKeyShares.map((keyShare)=>this.encryptKeyShare({
+                keyShare,
+                password
+            })));
+        const accessToken = await this.apiClient.getAccessToken({
+            oauthAccountId
+        });
+        const thresholdSignatureScheme = this.walletMap[accountAddress].thresholdSignatureScheme;
+        const suggestedFileName = getClientKeyShareExportFileName({
+            thresholdSignatureScheme,
+            accountAddress
+        });
+        const backupData = {
+            keyShares: encryptedKeyShares,
+            metadata: {
+                version: '1.0',
+                createdAt: new Date().toISOString(),
+                accountAddress,
+                thresholdSignatureScheme,
+                hasPassword: true,
+                encryption: {
+                    algorithm: AES_GCM_ALGORITHM,
+                    keyDerivation: PBKDF2_ALGORITHM,
+                    iterations: PBKDF2_ITERATIONS,
+                    hashAlgorithm: PBKDF2_HASH_ALGORITHM,
+                    algorithmLength: AES_GCM_LENGTH
+                },
+                shareCount: encryptedKeyShares.length
+            }
+        };
+        // TODO: handle errors
+        await Promise.all([
+            uploadFileToGoogleDriveAppStorage({
+                accessToken,
+                fileName: fileName != null ? fileName : suggestedFileName,
+                jsonData: backupData
+            }),
+            uploadFileToGoogleDrivePersonal({
+                accessToken,
+                fileName: fileName != null ? fileName : suggestedFileName,
+                jsonData: backupData
+            })
+        ]);
+        const data = await this.apiClient.markKeySharesAsBackedUpGoogleDrive({
+            walletId: this.walletMap[accountAddress].walletId
+        });
+        const ids = data.keyShares.map((keyShare)=>keyShare.id);
+        this.walletMap[accountAddress].clientKeySharesBackupInfo.backups[BackupLocation.GOOGLE_DRIVE] = ids;
+        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
+        return ids;
+    }
+    async restoreBackupFromGoogleDrive({ accountAddress, oauthAccountId, name, displayContainer, password }) {
+        await this.getWallet({
+            accountAddress
+        });
+        const accessToken = await this.apiClient.getAccessToken({
+            oauthAccountId
+        });
+        const thresholdSignatureScheme = this.walletMap[accountAddress].thresholdSignatureScheme;
+        const suggestedFileName = getClientKeyShareExportFileName({
+            thresholdSignatureScheme,
+            accountAddress
+        });
+        const backupData = await downloadFileFromGoogleDrive({
+            accessToken,
+            name: name != null ? name : suggestedFileName
+        });
+        if (!backupData) {
+            throw new Error('No backup file found');
+        }
+        // Validate the backup data structure
+        if (!backupData.keyShares || !backupData.metadata) {
+            throw new Error('Invalid backup format: missing keyShares or metadata');
+        }
+        const { keyShares } = backupData;
+        const decryptedKeyShares = await Promise.all(keyShares.map((keyShare)=>this.decryptKeyShare({
+                keyShare,
+                password
+            })));
+        await this.setClientKeySharesToLocalStorage({
+            accountAddress,
+            clientKeyShares: decryptedKeyShares,
+            overwriteOrMerge: 'merge'
+        });
+        // Display the client shares in the container via iframe
+        const { iframeDisplay } = await this.initializeIframeDisplayForContainer({
+            container: displayContainer
+        });
+        iframeDisplay.displayClientShares(accountAddress);
+        return decryptedKeyShares;
+    }
+    async exportClientKeyshares({ accountAddress, password }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.REACH_ALL_PARTIES
+        });
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        if (!accountAddress) {
+            throw new Error('Must provide an account address');
+        }
+        const derivationPath = this.walletMap[accountAddress].derivationPath;
+        const text = JSON.stringify({
+            keyShares: clientKeyShares,
+            derivationPath
+        });
+        const blob = new Blob([
+            text
+        ], {
+            type: 'text/plain'
+        });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX}-${accountAddress}.txt`;
+        a.click();
+    }
+    async getClientKeyShares({ accountAddress, password }) {
+        await this.getWallet({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.REACH_THRESHOLD
+        });
+        return this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+    }
+    /**
+   * 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 }) {
+        let keyshareCheck = false;
+        let walletCheck = false;
+        let thresholdSignatureSchemeCheck = false;
+        let derivationPathCheck = false;
+        // check if wallet exists
+        const existingWallet = this.walletMap[accountAddress];
+        if (existingWallet) {
+            walletCheck = true;
+        }
+        // check if threshold signature scheme exists
+        if (existingWallet == null ? void 0 : existingWallet.thresholdSignatureScheme) {
+            thresholdSignatureSchemeCheck = true;
+        }
+        // check if derivation path exists
+        if ((existingWallet == null ? void 0 : existingWallet.derivationPath) || (existingWallet == null ? void 0 : existingWallet.derivationPath) === '') {
+            derivationPathCheck = true;
+        }
+        // check if wallet already exists with sufficient keyshares
+        if (existingWallet) {
+            const { shares } = this.recoverStrategy({
+                clientKeyShareBackupInfo: existingWallet.clientKeySharesBackupInfo || {
+                    backups: getClientKeyShareBackupInfo()
+                },
+                thresholdSignatureScheme: existingWallet.thresholdSignatureScheme,
+                walletOperation,
+                shareCount
+            });
+            const { dynamic: requiredDynamicKeyShareIds = [] } = shares;
+            const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            if (requiredDynamicKeyShareIds.length <= ((clientKeyShares == null ? void 0 : clientKeyShares.length) || 0)) {
+                keyshareCheck = true;
+            }
+        }
+        return walletCheck && thresholdSignatureSchemeCheck && keyshareCheck && derivationPathCheck;
+    }
+    /**
+   * 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 }) {
+        await this.getWallet({
+            accountAddress,
+            password,
+            walletOperation
+        });
+        if (await this.requiresPasswordForOperation({
+            accountAddress,
+            walletOperation
+        }) && !password) {
+            throw new Error('Password is required for operation but not provided');
+        }
+        // silent return if no password is provided and operation does not require a password
+        if (!password) {
+            return;
+        }
+        const { backups } = await this.getWalletClientKeyShareBackupInfo({
+            accountAddress
+        });
+        const { dynamic: dynamicKeyShareIds = [] } = backups;
+        if (!dynamicKeyShareIds || dynamicKeyShareIds.length === 0) {
+            throw new Error('No dynamic key shares found');
+        }
+        try {
+            await this.recoverEncryptedBackupByWallet({
+                accountAddress,
+                password,
+                walletOperation,
+                shareCount: 1,
+                storeRecoveredShares: false
+            });
+        } catch (error) {
+            this.logger.error('Error in verifying password', error);
+            throw new Error('Incorrect password');
+        }
+    }
+    async isPasswordEncrypted({ accountAddress }) {
+        const clientKeySharesBackupInfo = await this.getWalletClientKeyShareBackupInfo({
+            accountAddress
+        });
+        return clientKeySharesBackupInfo == null ? void 0 : clientKeySharesBackupInfo.passwordEncrypted;
+    }
+    /**
+   * check if the operation requires a password
+   */ async requiresPasswordForOperation({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD }) {
+        const isEncrypted = await this.isPasswordEncrypted({
+            accountAddress
+        });
+        if (!isEncrypted) {
+            return false;
+        }
+        return this.requiresRestoreBackupSharesForOperation({
+            accountAddress,
+            walletOperation
+        });
+    }
+    /**
+   * check if the operation requires restoring backup shares
+   */ async requiresRestoreBackupSharesForOperation({ accountAddress, walletOperation = WalletOperation.REACH_THRESHOLD }) {
+        const clientKeySharesBackupInfo = await this.getWalletClientKeyShareBackupInfo({
+            accountAddress
+        });
+        const clientKeyShares = await this.getClientKeySharesFromLocalStorage({
+            accountAddress
+        });
+        if (walletOperation === WalletOperation.REACH_ALL_PARTIES || walletOperation === WalletOperation.REFRESH || walletOperation === WalletOperation.RESHARE) {
+            return true;
+        }
+        const { requiredShareCount } = this.recoverStrategy({
+            clientKeyShareBackupInfo: clientKeySharesBackupInfo,
+            thresholdSignatureScheme: this.walletMap[accountAddress].thresholdSignatureScheme,
+            walletOperation
+        });
+        if (clientKeyShares.length >= requiredShareCount) {
+            return false;
+        }
+        return true;
+    }
+    async getWalletClientKeyShareBackupInfo({ accountAddress }) {
+        var _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC, _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups, _this_walletMap_accountAddress_clientKeySharesBackupInfo, _this_walletMap_accountAddress, _user_verifiedCredentials;
+        // Return existing backup info if it exists
+        if (((_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo = _this_walletMap_accountAddress.clientKeySharesBackupInfo) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo_backups = _this_walletMap_accountAddress_clientKeySharesBackupInfo.backups) == null ? void 0 : (_this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC = _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups[BackupLocation.DYNAMIC]) == null ? void 0 : _this_walletMap_accountAddress_clientKeySharesBackupInfo_backups_BackupLocation_DYNAMIC.length) > 0) {
+            return this.walletMap[accountAddress].clientKeySharesBackupInfo;
+        }
+        // Get backup info from server
+        const user = await this.apiClient.getUser();
+        const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.find((vc)=>vc.address.toLowerCase() === accountAddress.toLowerCase());
+        return getClientKeyShareBackupInfo({
+            walletProperties: wallet == null ? void 0 : wallet.walletProperties
+        });
+    }
+    async getWallet({ accountAddress, walletOperation = WalletOperation.NO_OPERATION, shareCount = undefined, password = undefined }) {
+        var _user_verifiedCredentials;
+        const existingWalletCheck = await this.checkWalletFields({
+            accountAddress,
+            walletOperation,
+            shareCount
+        });
+        if (existingWalletCheck) {
+            this.logger.debug(`Wallet ${accountAddress} already exists`);
+            return this.walletMap[accountAddress];
+        }
+        // Fetch and restore wallet from server
+        const user = await this.apiClient.getUser();
+        const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.find((vc)=>vc.address.toLowerCase() === accountAddress.toLowerCase());
+        this.logger.debug('Restoring wallet', wallet);
+        const walletProperties = wallet.walletProperties;
+        this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+            walletId: wallet.id,
+            chainName: wallet.chainName,
+            accountAddress,
+            thresholdSignatureScheme: walletProperties.thresholdSignatureScheme,
+            derivationPath: walletProperties.derivationPath,
+            clientKeySharesBackupInfo: getClientKeyShareBackupInfo({
+                walletProperties
+            })
+        });
+        if (walletOperation !== WalletOperation.NO_OPERATION && await this.requiresRestoreBackupSharesForOperation({
+            accountAddress,
+            walletOperation
+        })) {
+            const decryptedKeyShares = await this.recoverEncryptedBackupByWallet({
+                accountAddress,
+                password: password != null ? password : this.environmentId,
+                walletOperation: walletOperation,
+                shareCount
+            });
+            const existingKeyShares = await this.getClientKeySharesFromLocalStorage({
+                accountAddress
+            });
+            await this.setClientKeySharesToLocalStorage({
+                accountAddress,
+                clientKeyShares: mergeUniqueKeyShares(existingKeyShares, decryptedKeyShares)
+            });
+            this.logger.debug('Recovered backup', decryptedKeyShares);
+        }
+        const walletCount = Object.keys(this.walletMap).length;
+        if (walletCount === 0) {
+            throw new Error('No wallets found');
+        }
+        // Return the only wallet if there's just one
+        if (walletCount === 1) {
+            return Object.values(this.walletMap)[0];
+        }
+        return this.walletMap[accountAddress];
+    }
+    async getWallets() {
+        var _user_verifiedCredentials;
+        const user = await this.apiClient.getUser();
+        const waasWallets = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.filter((vc)=>vc.walletName === 'dynamicwaas');
+        const wallets = waasWallets.map((vc)=>{
+            var _this_walletMap_vc_address, _vc_walletProperties;
+            var _this_walletMap_vc_address_derivationPath;
+            return {
+                walletId: vc.id,
+                chainName: vc.chain,
+                accountAddress: vc.address,
+                clientKeySharesBackupInfo: getClientKeyShareBackupInfo({
+                    walletProperties: vc.walletProperties || {}
+                }),
+                derivationPath: (_this_walletMap_vc_address_derivationPath = (_this_walletMap_vc_address = this.walletMap[vc.address]) == null ? void 0 : _this_walletMap_vc_address.derivationPath) != null ? _this_walletMap_vc_address_derivationPath : undefined,
+                thresholdSignatureScheme: (_vc_walletProperties = vc.walletProperties) == null ? void 0 : _vc_walletProperties.thresholdSignatureScheme
+            };
+        });
+        this.walletMap = wallets.reduce((acc, wallet)=>{
+            var _acc_accountAddress;
+            const accountAddress = wallet.accountAddress;
+            acc[wallet.accountAddress] = {
+                walletId: wallet.walletId,
+                chainName: wallet.chainName,
+                accountAddress: wallet.accountAddress,
+                clientKeySharesBackupInfo: wallet.clientKeySharesBackupInfo,
+                derivationPath: ((_acc_accountAddress = acc[accountAddress]) == null ? void 0 : _acc_accountAddress.derivationPath) || undefined,
+                thresholdSignatureScheme: wallet.thresholdSignatureScheme
+            };
+            return acc;
+        }, {});
+        return wallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+        this.initializePromise = null;
+        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.iframeLoadPromise = null;
+        this.environmentId = environmentId;
+        this.storageKey = `${STORAGE_KEY}-${storageKey != null ? storageKey : environmentId}`;
+        this.baseMPCRelayApiUrl = baseMPCRelayApiUrl;
+        this.apiClient = new DynamicApiClient({
+            environmentId,
+            authToken,
+            baseApiUrl
+        });
+        this.debug = Boolean(debug);
+        this.logger.setLogLevel(this.debug ? 'DEBUG' : DEFAULT_LOG_LEVEL);
+        // setup storage
+        if (supportsLocalStorage()) {
+            this.storage = localStorageAdapter;
+        } else {
+            this.memoryStorage = {};
+            this.storage = memoryLocalStorageAdapter(this.memoryStorage);
+        }
+        let environment;
+        switch(baseApiUrl){
+            case undefined:
+                environment = ENVIRONMENT_ENUM.production;
+                break;
+            case DYNAMIC_AUTH_PROD_BASE_API_URL:
+                environment = ENVIRONMENT_ENUM.production;
+                break;
+            case DYNAMIC_AUTH_PREPROD_BASE_API_URL:
+                environment = ENVIRONMENT_ENUM.preprod;
+                break;
+            case DYNAMIC_AUTH_DEV_BASE_API_URL:
+                environment = ENVIRONMENT_ENUM.development;
+                break;
+            default:
+                environment = ENVIRONMENT_ENUM.development;
+                break;
+        }
+        this.iframeDomain = IFRAME_DOMAIN_MAP[environment];
+        // Generate unique instanceId when client is created
+        this.instanceId = crypto.randomUUID();
+        // initialize the client
+        this.initialize();
+    }
+}
+
+export { DynamicWalletClient, base64ToBytes, bytesToBase64, ensureBase64Padding, getClientKeyShareBackupInfo, getClientKeyShareExportFileName, getMPCSignatureScheme, getMPCSigner, isBrowser, isHexString, mergeUniqueKeyShares, retryPromise, stringToBytes, timeoutPromise };