@dynamic-labs-wallet/browser 0.0.8 → 0.0.10

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,799 @@
+'use strict';
+
+var core = require('@dynamic-labs-wallet/core');
+var libMpcWeb = require('@dynamic-labs-wallet/lib-mpc-web');
+
+const getMPCSignatureScheme = ({ signingAlgorithm, baseRelayUrl = core.MPC_RELAY_PROD_API_URL })=>{
+    switch(signingAlgorithm){
+        case core.SigningAlgorithm.ECDSA:
+            return new libMpcWeb.Ecdsa(baseRelayUrl);
+        case core.SigningAlgorithm.ED25519:
+            return new libMpcWeb.Ed25519(baseRelayUrl);
+        case core.SigningAlgorithm.BIP340:
+            return new libMpcWeb.BIP340(baseRelayUrl);
+        default:
+            throw new Error(`Unsupported signing algorithm: ${signingAlgorithm}`);
+    }
+};
+const getMPCSigner = ({ chainName, baseRelayUrl })=>{
+    const chainConfig = core.getMPCChainConfig(chainName);
+    const signatureScheme = getMPCSignatureScheme({
+        signingAlgorithm: chainConfig.signingAlgorithm,
+        baseRelayUrl
+    });
+    return signatureScheme;
+};
+
+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 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',
+        salt,
+        iterations: 100000,
+        hash: 'SHA-256'
+    }, initialKey, {
+        name: 'AES-GCM',
+        length: 256
+    }, 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',
+            iv
+        }, key, dataBytes);
+        // Convert to base64 strings, ensure proper padding
+        return {
+            salt: bytesToBase64(salt),
+            iv: bytesToBase64(iv),
+            cipher: bytesToBase64(new Uint8Array(encryptedData))
+        };
+    } catch (error) {
+        console.error('Error encrypting data:', 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',
+            iv: ivBytes
+        }, key, cipherBytes);
+        return new TextDecoder().decode(decryptedData);
+    } catch (error) {
+        console.error('Decryption error details:', error);
+        throw new Error(`Decryption failed`);
+    }
+};
+
+const GOOGLE_DRIVE_UPLOAD_API = 'https://www.googleapis.com';
+const uploadFileToGoogleDrive = async ({ accessToken, fileName, jsonData })=>{
+    const metadata = {
+        name: fileName,
+        mimeType: 'application/json',
+        parents: [
+            'appDataFolder'
+        ]
+    };
+    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
+    });
+    // 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;
+    }
+    return fileRawData;
+};
+
+const BACKUP_FILENAME = 'dynamicWalletSecretBackup.json';
+
+class DynamicWalletClient {
+    async serverInitializeKeyGen({ chainName, clientPrimaryKeygenId, clientSecondaryKeygenId, thresholdSignatureScheme }) {
+        // Initilize keygen, create room, and create the wallet account on the server
+        const data = await this.apiClient.createWalletAccount({
+            chainName,
+            clientKeygenIds: [
+                clientPrimaryKeygenId,
+                clientSecondaryKeygenId
+            ],
+            thresholdSignatureScheme
+        });
+        return data;
+    }
+    async clientInitializeKeyGen({ chainName }) {
+        // Get the mpc signer
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        // Initialize the keygen for the primary client and the secondary client shares
+        const keygenInitResults = await Promise.all([
+            mpcSigner.initKeygen(),
+            mpcSigner.initKeygen()
+        ]);
+        const [clientPrimaryKeygenInitResult, clientSecondaryKeygenInitResult] = keygenInitResults;
+        return {
+            clientPrimaryKeygenInitResult,
+            clientSecondaryKeygenInitResult
+        };
+    }
+    async derivePublicKey({ chainName, keyShare }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const chainConfig = core.getMPCChainConfig(chainName);
+        let publicKey;
+        if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+            publicKey = await mpcSigner.derivePubkey(keyShare, new Uint32Array(chainConfig.derivationPath));
+        } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+            publicKey = await mpcSigner.derivePubkey(keyShare, new Uint32Array(chainConfig.derivationPath));
+        }
+        return publicKey;
+    }
+    async clientKeyGen({ chainName, roomId, serverKeygenIds, clientPrimaryKeygenInitResult, clientSecondaryKeygenInitResult, thresholdSignatureScheme }) {
+        // Get the chain config and the mpc signer
+        const chainConfig = core.getMPCChainConfig(chainName);
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        // All parties receive the keygenIds from all OTHER parties
+        const clientPrimaryKeygenId = clientPrimaryKeygenInitResult.keygenId;
+        const clientSecondaryKeygenId = clientSecondaryKeygenInitResult.keygenId;
+        const clientPrimaryKeygenIds = [
+            ...serverKeygenIds,
+            clientSecondaryKeygenId
+        ];
+        const clientSecondaryKeygenIds = [
+            ...serverKeygenIds,
+            clientPrimaryKeygenId
+        ];
+        // Get the MPC config for the threshold signature scheme
+        const mpcConfig = core.MPC_CONFIG[thresholdSignatureScheme];
+        // All parties join the keygen room
+        const keygenResults = await Promise.all([
+            mpcSigner.keygen(roomId, mpcConfig.numberOfParties, mpcConfig.threshold, clientPrimaryKeygenInitResult, clientPrimaryKeygenIds),
+            mpcSigner.keygen(roomId, mpcConfig.numberOfParties, mpcConfig.threshold, clientSecondaryKeygenInitResult, clientSecondaryKeygenIds)
+        ]);
+        const [clientPrimaryKeygenResult, clientSecondaryKeygenResult] = keygenResults;
+        // Pick the derivation path of the public key you want to sign for
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        // Get the public key for the derivation path
+        let rawPublicKey;
+        if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+            rawPublicKey = await mpcSigner.derivePubkey(clientPrimaryKeygenResult, derivationPath);
+        } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+            rawPublicKey = await mpcSigner.derivePubkey(clientPrimaryKeygenResult, derivationPath);
+        } else if (mpcSigner instanceof libMpcWeb.BIP340) {
+            rawPublicKey = await mpcSigner.deriveTweakPubkey(clientPrimaryKeygenResult, derivationPath);
+        }
+        return {
+            rawPublicKey,
+            primaryKeygenResult: clientPrimaryKeygenResult,
+            secondaryKeygenResult: clientSecondaryKeygenResult
+        };
+    }
+    async keyGen({ chainName, thresholdSignatureScheme }) {
+        try {
+            const { clientPrimaryKeygenInitResult, clientSecondaryKeygenInitResult } = await this.clientInitializeKeyGen({
+                chainName
+            });
+            const data = await this.serverInitializeKeyGen({
+                chainName,
+                clientPrimaryKeygenId: clientPrimaryKeygenInitResult.keygenId,
+                clientSecondaryKeygenId: clientSecondaryKeygenInitResult.keygenId,
+                thresholdSignatureScheme
+            });
+            const { rawPublicKey, primaryKeygenResult, secondaryKeygenResult } = await this.clientKeyGen({
+                chainName,
+                roomId: data.roomId,
+                serverKeygenIds: data.serverKeygenIds,
+                clientPrimaryKeygenInitResult,
+                clientSecondaryKeygenInitResult,
+                thresholdSignatureScheme
+            });
+            return {
+                rawPublicKey,
+                primaryKeygenResult,
+                secondaryKeygenResult
+            };
+        } catch (error) {
+            console.error('Error creating wallet account', error);
+            throw new Error('Error creating wallet account');
+        }
+    }
+    async serverSign({ walletId, message }) {
+        // Create the room and sign the message
+        const data = await this.apiClient.signMessage({
+            walletId,
+            message
+        });
+        return data;
+    }
+    async clientSign({ chainName, message, roomId, keyShare }) {
+        try {
+            const chainConfig = core.getMPCChainConfig(chainName);
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            const derivationPath = new Uint32Array(chainConfig.derivationPath);
+            let formattedMessage;
+            if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+                formattedMessage = libMpcWeb.MessageHash.sha256(message);
+            } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+                formattedMessage = new TextEncoder().encode(message);
+            } else if (mpcSigner instanceof libMpcWeb.BIP340) {
+                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) {
+            console.error('Error in clientSign:', error);
+            throw error;
+        }
+    }
+    async sign({ accountAddress, message, chainName }) {
+        const wallet = await this.getWallet({
+            accountAddress
+        });
+        // Perform the server sign
+        const data = await this.serverSign({
+            walletId: wallet.walletId,
+            message
+        });
+        // Perform the client sign and return the signature
+        const signature = await this.clientSign({
+            chainName,
+            message,
+            roomId: data.roomId,
+            keyShare: wallet.clientKeyShares[0]
+        });
+        return signature;
+    }
+    async refreshWalletAccountShares({ accountAddress }) {
+        const wallet = await this.getWallet({
+            accountAddress
+        });
+        const chainName = wallet.chainName;
+        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 keygenResults = await Promise.all([
+            mpcSigner.refresh(roomId, wallet.clientKeyShares[0]),
+            mpcSigner.refresh(roomId, wallet.clientKeyShares[1])
+        ]);
+        return keygenResults;
+    }
+    async serverReshareRemainingParty({ walletId, clientKeygenIds }) {
+        const data = await this.apiClient.reshareRemainingParty({
+            walletId,
+            clientKeygenIds
+        });
+        return data;
+    }
+    async getExportId({ chainName, clientKeyShare }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const exportId = await mpcSigner.exportID(clientKeyShare);
+        return exportId;
+    }
+    async reshareRemainingParty({ accountAddress, thresholdSignatureScheme }) {
+        const wallet = await this.getWallet({
+            accountAddress
+        });
+        const chainName = wallet.chainName;
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        // Initialize the new party
+        const newPartyInitKeygen = await mpcSigner.initKeygen();
+        const newPartyInitKeygenId = newPartyInitKeygen.keygenId;
+        const clientKeygenId = await this.getExportId({
+            chainName,
+            clientKeyShare: wallet.clientKeyShares[0]
+        });
+        // Create the room and reshare the server share
+        const data = await this.serverReshareRemainingParty({
+            walletId: wallet.walletId,
+            clientKeygenIds: [
+                newPartyInitKeygenId,
+                clientKeygenId
+            ]
+        });
+        const roomId = data.roomId;
+        // Get the MPC config for the threshold signature scheme
+        const mpcConfig = core.MPC_CONFIG[thresholdSignatureScheme];
+        const newClientPrimaryKeygenIds = [
+            data.serverKeygenId,
+            clientKeygenId
+        ];
+        const clientSecondaryKeygenIds = [
+            data.serverKeygenId,
+            newPartyInitKeygenId
+        ];
+        console.log('newClientPrimaryKeygenIds', newClientPrimaryKeygenIds);
+        console.log('clientSecondaryKeygenIds', clientSecondaryKeygenIds);
+        const keygenResults = await Promise.all([
+            mpcSigner.reshareNewParty(roomId, mpcConfig.threshold, mpcConfig.threshold, newPartyInitKeygen, newClientPrimaryKeygenIds),
+            mpcSigner.reshareRemainingParty(roomId, mpcConfig.threshold, wallet.clientKeyShares[1], clientSecondaryKeygenIds)
+        ]);
+        return keygenResults;
+    }
+    async exportKey({ accountAddress, chainName }) {
+        const wallet = await this.getWallet({
+            accountAddress
+        });
+        const chainConfig = core.getMPCChainConfig(chainName);
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        const exportId = await this.getExportId({
+            chainName,
+            clientKeyShare: wallet.clientKeyShares[0]
+        });
+        const data = await this.apiClient.exportKey({
+            walletId: wallet.walletId,
+            exportId
+        });
+        const keyExportRaw = await mpcSigner.exportFullPrivateKey(data.roomId, wallet.clientKeyShares[0], exportId);
+        if (!keyExportRaw) {
+            throw new Error('Error exporting private key');
+        }
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        let derivedPrivateKey;
+        if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+            derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+        } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+            derivedPrivateKey = keyExportRaw;
+        } else if (mpcSigner instanceof libMpcWeb.BIP340) {
+            derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+        }
+        return {
+            derivedPrivateKey
+        };
+    }
+    async offlineExportKey({ chainName, keyShares }) {
+        try {
+            if (!keyShares || keyShares.length !== 2) {
+                throw new Error('Must provide 2 key shares');
+            }
+            const mpcSigner = getMPCSigner({
+                chainName,
+                baseRelayUrl: this.baseMPCRelayApiUrl
+            });
+            const walletKeyShares = keyShares.map((keyShare)=>{
+                return mpcSigner instanceof libMpcWeb.Ecdsa ? new libMpcWeb.EcdsaKeygenResult(keyShare.pubkey, keyShare.secretShare) : mpcSigner instanceof libMpcWeb.Ed25519 ? new libMpcWeb.Ed25519KeygenResult(keyShare.pubkey, keyShare.secretShare) : new libMpcWeb.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 = core.getMPCChainConfig(chainName);
+            const derivationPath = new Uint32Array(chainConfig.derivationPath);
+            let derivedPrivateKey;
+            if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+                derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+            } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+                derivedPrivateKey = keyExportRaw;
+            } else if (mpcSigner instanceof libMpcWeb.BIP340) {
+                derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
+            }
+            return {
+                derivedPrivateKey
+            };
+        } catch (error) {
+            console.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;
+    }
+    async storeEncryptedBackupByWallet({ accountAddress, password }) {
+        await this.getWallet({
+            accountAddress
+        });
+        const encryptedKeyShares = await Promise.all(this.walletMap[accountAddress].clientKeyShares.map((keyShare)=>this.encryptKeyShare({
+                keyShare,
+                password
+            })));
+        const data = await this.apiClient.storeEncryptedBackupByWallet({
+            walletId: this.walletMap[accountAddress].walletId,
+            encryptedKeyShares,
+            passwordEncrypted: password ? true : false
+        });
+        return data;
+    }
+    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;
+    }
+    async recoverEncryptedBackupByWallet({ accountAddress, password, keyShareIds }) {
+        const data = await this.apiClient.recoverEncryptedBackupByWallet({
+            walletId: this.walletMap[accountAddress].walletId,
+            keyShareIds
+        });
+        const decryptedKeyShares = await Promise.all(data.keyShares.map((keyShare)=>this.decryptKeyShare({
+                keyShare: keyShare.encryptedAccountCredential,
+                password: password != null ? password : this.environmentId
+            })));
+        decryptedKeyShares.forEach((keyShare)=>{
+            this.restoreBackupShare({
+                walletId: this.walletMap[accountAddress].walletId,
+                accountAddress,
+                chainName: data.chainName,
+                keyShare,
+                thresholdSignatureScheme: data.thresholdSignatureScheme
+            });
+        });
+        return decryptedKeyShares;
+    }
+    restoreBackupShare({ walletId, accountAddress, chainName, keyShare, thresholdSignatureScheme }) {
+        var _this_walletMap_accountAddress;
+        this.walletMap[accountAddress] = {
+            walletId,
+            chainName,
+            accountAddress,
+            clientKeyShares: [
+                ...((_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? undefined : _this_walletMap_accountAddress.clientKeyShares) || [],
+                keyShare
+            ],
+            thresholdSignatureScheme
+        };
+    }
+    async backupFileToGoogleDrive({ oauthAccountId, fileName = BACKUP_FILENAME, jsonData, password }) {
+        const encryptedKeyShare = await this.encryptKeyShare({
+            keyShare: jsonData,
+            password
+        });
+        const accessToken = await this.apiClient.getAccessToken({
+            oauthAccountId
+        });
+        const uploadMetadata = await uploadFileToGoogleDrive({
+            accessToken,
+            fileName,
+            jsonData: encryptedKeyShare
+        });
+        return uploadMetadata;
+    }
+    async getBackupFileFromGoogleDrive({ oauthAccountId, name = BACKUP_FILENAME, password }) {
+        const accessToken = await this.apiClient.getAccessToken({
+            oauthAccountId
+        });
+        const file = await downloadFileFromGoogleDrive({
+            accessToken,
+            name
+        });
+        if (!file) {
+            return null;
+        }
+        const decryptedKeyShare = await this.decryptKeyShare({
+            keyShare: file,
+            password: password != null ? password : this.environmentId
+        });
+        return decryptedKeyShare;
+    }
+    async importRawPrivateKey({ chainName, privateKey, thresholdSignatureScheme }) {
+        const chainConfig = core.getMPCChainConfig(chainName);
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: this.baseMPCRelayApiUrl
+        });
+        // 1. 2 parties on the client side create keygenInit
+        const { clientPrimaryKeygenInitResult, clientSecondaryKeygenInitResult } = await this.clientInitializeKeyGen({
+            chainName
+        });
+        const clientSecondaryKeygenId = clientSecondaryKeygenInitResult.keygenId;
+        const clientPrimaryKeygenId = clientPrimaryKeygenInitResult.keygenId;
+        // 2. server to create a room for importing the private key
+        // server will do 3 things:
+        // --- 1. init keygen for the server as a party
+        // --- 2. open a room and return the roomId for the ceremony
+        // --- 3. join the room as a party for the 2/3 ceremony
+        const { roomId, serverKeygenIds } = await this.apiClient.importPrivateKey({
+            chainName,
+            clientKeygenIds: [
+                clientPrimaryKeygenId,
+                clientSecondaryKeygenId
+            ],
+            thresholdSignatureScheme
+        });
+        const { threshold } = core.getTSSConfig(thresholdSignatureScheme);
+        // prep
+        const importerKeygenIds = [
+            ...serverKeygenIds,
+            clientSecondaryKeygenId
+        ];
+        const recipientKeygenIds = [
+            ...serverKeygenIds,
+            clientPrimaryKeygenId
+        ];
+        // 3. Join the keygen room for the ceremony
+        const [clientPrimaryKeygenResult, clientSecondaryKeygenResult] = await Promise.all([
+            mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, clientPrimaryKeygenInitResult, importerKeygenIds),
+            mpcSigner.importPrivateKeyRecipient(roomId, threshold, clientSecondaryKeygenInitResult, recipientKeygenIds)
+        ]);
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        // Get the public key for the derivation path
+        let rawPublicKey;
+        if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+            rawPublicKey = await mpcSigner.derivePubkey(clientPrimaryKeygenResult, derivationPath);
+        } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+            rawPublicKey = await mpcSigner.derivePubkey(clientPrimaryKeygenResult, derivationPath);
+        } else if (mpcSigner instanceof libMpcWeb.BIP340) {
+            rawPublicKey = await mpcSigner.deriveTweakPubkey(clientPrimaryKeygenResult, derivationPath);
+        }
+        return {
+            rawPublicKey,
+            primaryKeygenResult: clientPrimaryKeygenResult,
+            secondaryKeygenResult: clientSecondaryKeygenResult
+        };
+    }
+    async exportClientKeyshares({ accountAddress }) {
+        const clientKeyshares = await this.getClientKeyshares({
+            accountAddress
+        });
+        const text = JSON.stringify(clientKeyshares);
+        const blob = new Blob([
+            text
+        ], {
+            type: 'text/plain'
+        });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = 'clientKeyshare.txt';
+        a.click();
+    }
+    async getClientKeyshares({ accountAddress }) {
+        const wallet = await this.getWallet({
+            accountAddress
+        });
+        return wallet.clientKeyShares;
+    }
+    async getWallet({ accountAddress }) {
+        if (accountAddress) {
+            if (this.walletMap[accountAddress] && this.walletMap[accountAddress].clientKeyShares.length > 0) {
+                return this.walletMap[accountAddress];
+            } else {
+                var _user_verifiedCredentials;
+                const user = await this.apiClient.getUser();
+                const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? undefined : _user_verifiedCredentials.find((vc)=>vc.address === accountAddress);
+                console.log('need to restore wallet', wallet);
+                const clientShares = wallet.walletProperties.keyShares.filter((ks)=>ks.backupLocation === 'dynamic');
+                console.log('clientShares', clientShares);
+                // restore backup
+                const decryptedKeyShares = await this.recoverEncryptedBackupByWallet({
+                    accountAddress,
+                    password: this.environmentId
+                });
+                //todo: check to see if their are other backups ie google drive, etc
+                console.log('recovery decryptedKeyShares', decryptedKeyShares);
+            }
+        }
+        const walletCount = Object.keys(this.walletMap).length;
+        // if there are no wallets, throw an error
+        if (walletCount === 0) {
+            throw new Error('No wallets found');
+        }
+        // if there is only one wallet, return it by default
+        if (walletCount === 1) {
+            return Object.values(this.walletMap)[0];
+        }
+        if (!accountAddress) {
+            throw new Error('Must provide an account address');
+        }
+        return this.walletMap[accountAddress];
+    }
+    async getWallets() {
+        var _user_verifiedCredentials;
+        const user = await this.apiClient.getUser();
+        const waasWallets = (_user_verifiedCredentials = user.verifiedCredentials) == null ? undefined : _user_verifiedCredentials.filter((vc)=>vc.walletName === 'dynamicwaas');
+        const wallets = waasWallets.map((vc)=>({
+                walletId: vc.id,
+                chainName: vc.chain,
+                accountAddress: vc.address
+            }));
+        this.walletMap = wallets.reduce((acc, wallet)=>{
+            acc[wallet.accountAddress] = {
+                walletId: wallet.walletId,
+                chainName: wallet.chainName,
+                accountAddress: wallet.accountAddress,
+                clientKeyShares: [],
+                thresholdSignatureScheme: undefined
+            };
+            return acc;
+        }, {});
+        return wallets;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl }){
+        this.walletMap = {} // todo: store in session storage
+        ;
+        this.environmentId = environmentId;
+        this.baseMPCRelayApiUrl = baseMPCRelayApiUrl;
+        this.apiClient = new core.DynamicApiClient({
+            environmentId,
+            authToken,
+            baseApiUrl
+        });
+        this.getWallets();
+    }
+}
+
+Object.defineProperty(exports, "BIP340", {
+  enumerable: true,
+  get: function () { return libMpcWeb.BIP340; }
+});
+Object.defineProperty(exports, "BIP340InitKeygenResult", {
+  enumerable: true,
+  get: function () { return libMpcWeb.BIP340InitKeygenResult; }
+});
+Object.defineProperty(exports, "BIP340KeygenResult", {
+  enumerable: true,
+  get: function () { return libMpcWeb.BIP340KeygenResult; }
+});
+Object.defineProperty(exports, "Ecdsa", {
+  enumerable: true,
+  get: function () { return libMpcWeb.Ecdsa; }
+});
+Object.defineProperty(exports, "EcdsaInitKeygenResult", {
+  enumerable: true,
+  get: function () { return libMpcWeb.EcdsaInitKeygenResult; }
+});
+Object.defineProperty(exports, "EcdsaKeygenResult", {
+  enumerable: true,
+  get: function () { return libMpcWeb.EcdsaKeygenResult; }
+});
+Object.defineProperty(exports, "EcdsaPublicKey", {
+  enumerable: true,
+  get: function () { return libMpcWeb.EcdsaPublicKey; }
+});
+Object.defineProperty(exports, "EcdsaSignature", {
+  enumerable: true,
+  get: function () { return libMpcWeb.EcdsaSignature; }
+});
+Object.defineProperty(exports, "Ed25519", {
+  enumerable: true,
+  get: function () { return libMpcWeb.Ed25519; }
+});
+Object.defineProperty(exports, "Ed25519InitKeygenResult", {
+  enumerable: true,
+  get: function () { return libMpcWeb.Ed25519InitKeygenResult; }
+});
+Object.defineProperty(exports, "Ed25519KeygenResult", {
+  enumerable: true,
+  get: function () { return libMpcWeb.Ed25519KeygenResult; }
+});
+Object.defineProperty(exports, "MessageHash", {
+  enumerable: true,
+  get: function () { return libMpcWeb.MessageHash; }
+});
+exports.DynamicWalletClient = DynamicWalletClient;
+exports.getMPCSignatureScheme = getMPCSignatureScheme;
+exports.getMPCSigner = getMPCSigner;
+Object.keys(core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return core[k]; }
+  });
+});

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dynamic-labs-wallet/browser",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "dependencies": {
-    "@dynamic-labs-wallet/core": "0.0.8",
-    "@dynamic-labs-wallet/lib-mpc-web": "0.0.8"
+    "@dynamic-labs-wallet/core": "0.0.10",
+    "@dynamic-labs-wallet/lib-mpc-web": "0.0.10"
   },
   "publishConfig": {
     "access": "restricted"
@@ -13,7 +13,8 @@
     "projectType": "library",
     "name": "browser"
   },
-  "main": "./index.esm.js",
+  "type": "module",
+  "main": "./index.cjs.js",
   "module": "./index.esm.js",
   "types": "./index.esm.d.ts",
   "exports": {
@@ -21,8 +22,8 @@
     ".": {
       "types": "./index.esm.d.ts",
       "import": "./index.esm.js",
-      "default": "./index.esm.js"
+      "require": "./index.cjs.js",
+      "default": "./index.cjs.js"
     }
-  },
-  "type": "module"
-}
+  }
+}