@dynamic-labs-wallet/browser 0.0.1

package/index.esm.d.ts

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

package/index.esm.js

@@ -0,0 +1,537 @@
+import { SigningAlgorithm, RELAY_API_URL, getMPCChainConfig, MPC_CONFIG, ThresholdSignatureScheme, DynamicApiClient } from '@dynamic-labs-wallet/core';
+export * from '@dynamic-labs-wallet/core';
+import { BIP340, Ed25519, Ecdsa, MessageHash } from '@dynamic-labs-wallet/lib-mpc-web';
+export { BIP340, BIP340InitKeygenResult, BIP340KeygenResult, Ecdsa, EcdsaInitKeygenResult, EcdsaKeygenResult, EcdsaPublicKey, EcdsaSignature, Ed25519, Ed25519InitKeygenResult, Ed25519KeygenResult, MessageHash } from '@dynamic-labs-wallet/lib-mpc-web';
+
+const getMPCSignatureScheme = ({ signingAlgorithm, baseRelayUrl = RELAY_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 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 }) {
+        // Initilize keygen, create room, and create the wallet account on the server
+        const data = await this.apiClient.createWalletAccount({
+            chainName,
+            clientPrimaryKeygenId,
+            clientSecondaryKeygenId
+        });
+        return data;
+    }
+    async clientInitializeKeyGen({ chainName }) {
+        // Get the mpc signer
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        // 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: RELAY_API_URL
+        });
+        const chainConfig = getMPCChainConfig(chainName);
+        let publicKey;
+        if (mpcSigner instanceof Ecdsa) {
+            publicKey = await mpcSigner.derivePubkey(keyShare != null ? keyShare : this.clientKeyshare, new Uint32Array(chainConfig.derivationPath));
+        } else if (mpcSigner instanceof Ed25519) {
+            publicKey = await mpcSigner.derivePubkey(keyShare != null ? keyShare : this.clientKeyshare, new Uint32Array(chainConfig.derivationPath));
+        }
+        return publicKey;
+    }
+    async clientKeyGen({ chainName, roomId, serverKeygenId, clientPrimaryKeygenInitResult, clientSecondaryKeygenInitResult }) {
+        // Get the chain config and the mpc signer
+        const chainConfig = getMPCChainConfig(chainName);
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        // All parties receive the keygenIds from all OTHER parties
+        const clientPrimaryKeygenId = clientPrimaryKeygenInitResult.keygenId;
+        const clientSecondaryKeygenId = clientSecondaryKeygenInitResult.keygenId;
+        const clientPrimaryKeygenIds = [
+            serverKeygenId,
+            clientSecondaryKeygenId
+        ];
+        const clientSecondaryKeygenIds = [
+            serverKeygenId,
+            clientPrimaryKeygenId
+        ];
+        // Get the MPC config for the threshold signature scheme
+        const mpcConfig = MPC_CONFIG[ThresholdSignatureScheme.TWO_OF_THREE];
+        // 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;
+        this.clientKeyshare = clientPrimaryKeygenResult;
+        // 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 Ecdsa) {
+            rawPublicKey = await mpcSigner.derivePubkey(clientPrimaryKeygenResult, derivationPath);
+        } else if (mpcSigner instanceof Ed25519) {
+            rawPublicKey = await mpcSigner.derivePubkey(clientPrimaryKeygenResult, derivationPath);
+        } else if (mpcSigner instanceof BIP340) {
+            rawPublicKey = await mpcSigner.deriveTweakPubkey(clientPrimaryKeygenResult, derivationPath);
+        }
+        return {
+            rawPublicKey,
+            primaryKeygenResult: clientPrimaryKeygenResult,
+            secondaryKeygenResult: clientSecondaryKeygenResult
+        };
+    }
+    async keyGen({ chainName }) {
+        try {
+            const { clientPrimaryKeygenInitResult, clientSecondaryKeygenInitResult } = await this.clientInitializeKeyGen({
+                chainName
+            });
+            const data = await this.serverInitializeKeyGen({
+                chainName,
+                clientPrimaryKeygenId: clientPrimaryKeygenInitResult.keygenId,
+                clientSecondaryKeygenId: clientSecondaryKeygenInitResult.keygenId
+            });
+            const { rawPublicKey, primaryKeygenResult, secondaryKeygenResult } = await this.clientKeyGen({
+                chainName,
+                roomId: data.roomId,
+                serverKeygenId: data.serverKeygenId,
+                clientPrimaryKeygenInitResult,
+                clientSecondaryKeygenInitResult
+            });
+            return {
+                rawPublicKey,
+                primaryKeygenResult,
+                secondaryKeygenResult
+            };
+        } catch (error) {
+            console.error('Error creating wallet account', error);
+            throw new Error('Error creating wallet account');
+        }
+    }
+    async serverSign({ messageToSign }) {
+        // Create the room and sign the message
+        const data = await this.apiClient.signMessage({
+            messageToSign
+        });
+        return data;
+    }
+    async clientSign({ chainName, messageToSign, roomId }) {
+        // Get the chain config and the mpc signer
+        const chainConfig = getMPCChainConfig(chainName);
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        const formattedMessage = mpcSigner instanceof Ecdsa ? MessageHash.sha256(messageToSign) : new TextEncoder().encode(messageToSign);
+        const signature = await mpcSigner.sign(roomId, this.clientKeyshare, formattedMessage, derivationPath);
+        return signature;
+    }
+    async sign({ chainName, messageToSign }) {
+        // Perform the server sign
+        const data = await this.serverSign({
+            messageToSign
+        });
+        // Perform the client sign and return the signature
+        const signature = await this.clientSign({
+            chainName,
+            messageToSign,
+            roomId: data.roomId
+        });
+        return signature;
+    }
+    async refreshWalletAccountShares({ chainName, clientPrimaryKeyshare, clientSecondaryKeyshare }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        // Create the room and refresh the shares
+        const data = await this.apiClient.refreshWalletAccountShares();
+        const roomId = data.roomId;
+        const keygenResults = await Promise.all([
+            mpcSigner.refresh(roomId, clientPrimaryKeyshare),
+            mpcSigner.refresh(roomId, clientSecondaryKeyshare)
+        ]);
+        this.clientKeyshare = keygenResults[0];
+        return keygenResults;
+    }
+    async serverReshareRemainingParty({ clientPrimaryKeygenId, clientSecondaryKeygenId }) {
+        const data = await this.apiClient.reshareRemainingParty({
+            clientPrimaryKeygenId,
+            clientSecondaryKeygenId
+        });
+        return data;
+    }
+    async getKeygenId({ chainName, clientKeyshare }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        const exportId = await mpcSigner.exportID(clientKeyshare);
+        return exportId;
+    }
+    async reshareRemainingParty({ chainName, clientKeyshare }) {
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        // Initialize the new party
+        const newPartyInitKeygen = await mpcSigner.initKeygen();
+        const newPartyInitKeygenId = newPartyInitKeygen.keygenId;
+        const clientKeygenId = await this.getKeygenId({
+            chainName,
+            clientKeyshare
+        });
+        // Create the room and reshare the server share
+        const data = await this.serverReshareRemainingParty({
+            clientPrimaryKeygenId: newPartyInitKeygenId,
+            clientSecondaryKeygenId: clientKeygenId
+        });
+        const roomId = data.roomId;
+        // Get the MPC config for the threshold signature scheme
+        const mpcConfig = MPC_CONFIG[ThresholdSignatureScheme.TWO_OF_THREE];
+        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, clientKeyshare, clientSecondaryKeygenIds)
+        ]);
+        this.clientKeyshare = keygenResults[0];
+        return keygenResults;
+    }
+    async exportPrivateKey({ chainName, clientKeyshare }) {
+        const chainConfig = getMPCChainConfig(chainName);
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        const exportId = await this.getKeygenId({
+            chainName,
+            clientKeyshare
+        });
+        const data = await this.apiClient.exportKey({
+            exportId
+        });
+        const keyExportRaw = await mpcSigner.exportFullPrivateKey(data.roomId, clientKeyshare, exportId);
+        if (!keyExportRaw) {
+            throw new Error('Error exporting private key');
+        }
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        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 offlineExportPrivateKey({ chainName, keyShares }) {
+        const chainConfig = getMPCChainConfig(chainName);
+        const mpcSigner = getMPCSigner({
+            chainName,
+            baseRelayUrl: RELAY_API_URL
+        });
+        const keyExportRaw = await mpcSigner.offlineExportFullPrivateKey(keyShares);
+        if (!keyExportRaw) {
+            throw new Error('Error exporting private key');
+        }
+        const derivationPath = new Uint32Array(chainConfig.derivationPath);
+        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 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 storeEncryptedBackup({ keyShare, password }) {
+        const encryptedKeyShare = await this.encryptKeyShare({
+            keyShare,
+            password
+        });
+        const data = await this.apiClient.storeEncryptedBackup({
+            keyShare: encryptedKeyShare
+        });
+        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 recoverEncryptedBackup({ password } = {}) {
+        const data = await this.apiClient.recoverEncryptedBackup();
+        const decryptedKeyShare = await this.decryptKeyShare({
+            keyShare: data.keyShare,
+            password: password != null ? password : this.environmentId
+        });
+        this.restoreBackupShare({
+            keyShare: decryptedKeyShare
+        });
+        return decryptedKeyShare;
+    }
+    restoreBackupShare({ keyShare }) {
+        this.clientKeyshare = keyShare;
+    }
+    async getClientShare() {
+        return this.clientKeyshare;
+    }
+    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;
+    }
+    constructor({ environmentId, authToken, baseApiUrl, clientKeyshare }){
+        this.environmentId = environmentId;
+        this.clientKeyshare = clientKeyshare;
+        this.apiClient = new DynamicApiClient({
+            environmentId,
+            authToken,
+            baseApiUrl
+        });
+    }
+}
+
+export { DynamicWalletClient, getMPCSignatureScheme, getMPCSigner };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@dynamic-labs-wallet/browser",
+  "version": "0.0.1",
+  "dependencies": {
+    "@dynamic-labs-wallet/core": "0.0.1",
+    "@dynamic-labs-wallet/lib-mpc-web": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "nx": {
+    "sourceRoot": "packages/browser/src",
+    "projectType": "library",
+    "name": "browser"
+  },
+  "main": "./index.esm.js",
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.esm.d.ts",
+      "import": "./index.esm.js",
+      "default": "./index.esm.js"
+    }
+  },
+  "type": "module"
+}

package/src/backup/encryption.d.ts

@@ -0,0 +1,17 @@
+export declare const encryptData: ({ data, password, }: {
+    data: string;
+    password: string;
+}) => Promise<{
+    salt: string;
+    iv: string;
+    cipher: string;
+}>;
+export declare const decryptData: ({ data, password, }: {
+    data: {
+        salt: string;
+        iv: string;
+        cipher: string;
+    };
+    password: string;
+}) => Promise<string>;
+//# sourceMappingURL=encryption.d.ts.map

package/src/backup/encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../../src/backup/encryption.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,WAAW,wBAGrB;IACD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;;;;EA4BA,CAAC;AAEF,eAAO,MAAM,WAAW,wBAGrB;IACD,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,QAAQ,EAAE,MAAM,CAAC;CAClB,oBA0BA,CAAC"}

package/src/backup/providers/googleDrive.d.ts

@@ -0,0 +1,14 @@
+export declare const uploadFileToGoogleDrive: ({ accessToken, fileName, jsonData, }: {
+    accessToken: string;
+    fileName: string;
+    jsonData: string;
+}) => Promise<any>;
+export declare const listFilesFromGoogleDrive: ({ accessToken, name, }: {
+    accessToken: string;
+    name: string;
+}) => Promise<any>;
+export declare const downloadFileFromGoogleDrive: ({ accessToken, name, }: {
+    accessToken: string;
+    name: string;
+}) => Promise<string | null>;
+//# sourceMappingURL=googleDrive.d.ts.map

package/src/backup/providers/googleDrive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"googleDrive.d.ts","sourceRoot":"","sources":["../../../../src/backup/providers/googleDrive.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB,yCAIjC;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,iBAkCA,CAAC;AAEF,eAAO,MAAM,wBAAwB,2BAGlC;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,iBAsBA,CAAC;AAEF,eAAO,MAAM,2BAA2B,2BAGrC;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAsBxB,CAAC"}

package/src/client.d.ts

@@ -0,0 +1,118 @@
+import { EcdsaPublicKey, EcdsaKeygenResult, Ed25519KeygenResult, BIP340KeygenResult, EcdsaSignature } from '@dynamic-labs-wallet/lib-mpc-web';
+import { ClientInitKeygenResult, ClientKeyshare } from './mpc/types';
+export declare class DynamicWalletClient {
+    environmentId: string;
+    private apiClient;
+    private clientKeyshare?;
+    constructor({ environmentId, authToken, baseApiUrl, clientKeyshare, }: {
+        environmentId: string;
+        authToken: string;
+        baseApiUrl?: string;
+        clientKeyshare?: ClientKeyshare;
+    });
+    serverInitializeKeyGen({ chainName, clientPrimaryKeygenId, clientSecondaryKeygenId, }: {
+        chainName: string;
+        clientPrimaryKeygenId: string;
+        clientSecondaryKeygenId: string;
+    }): Promise<any>;
+    clientInitializeKeyGen({ chainName }: {
+        chainName: string;
+    }): Promise<{
+        clientPrimaryKeygenInitResult: import("@dynamic-labs-wallet/lib-mpc-web").BIP340InitKeygenResult;
+        clientSecondaryKeygenInitResult: import("@dynamic-labs-wallet/lib-mpc-web").BIP340InitKeygenResult;
+    }>;
+    derivePublicKey({ chainName, keyShare, }: {
+        chainName: string;
+        keyShare?: ClientKeyshare;
+    }): Promise<Uint8Array | EcdsaPublicKey | undefined>;
+    clientKeyGen({ chainName, roomId, serverKeygenId, clientPrimaryKeygenInitResult, clientSecondaryKeygenInitResult, }: {
+        chainName: string;
+        roomId: string;
+        serverKeygenId: string;
+        clientPrimaryKeygenInitResult: ClientInitKeygenResult;
+        clientSecondaryKeygenInitResult: ClientInitKeygenResult;
+    }): Promise<{
+        rawPublicKey: Uint8Array | EcdsaPublicKey | undefined;
+        primaryKeygenResult: EcdsaKeygenResult | BIP340KeygenResult;
+        secondaryKeygenResult: EcdsaKeygenResult | BIP340KeygenResult;
+    }>;
+    keyGen({ chainName }: {
+        chainName: string;
+    }): Promise<{
+        rawPublicKey: Uint8Array | EcdsaPublicKey | undefined;
+        primaryKeygenResult: EcdsaKeygenResult | BIP340KeygenResult;
+        secondaryKeygenResult: EcdsaKeygenResult | BIP340KeygenResult;
+    }>;
+    serverSign({ messageToSign }: {
+        messageToSign: string;
+    }): Promise<any>;
+    clientSign({ chainName, messageToSign, roomId, }: {
+        chainName: string;
+        messageToSign: string;
+        roomId: string;
+    }): Promise<Uint8Array | EcdsaSignature>;
+    sign({ chainName, messageToSign, }: {
+        chainName: string;
+        messageToSign: string;
+    }): Promise<Uint8Array | EcdsaSignature>;
+    refreshWalletAccountShares({ chainName, clientPrimaryKeyshare, clientSecondaryKeyshare, }: {
+        chainName: string;
+        clientPrimaryKeyshare: EcdsaKeygenResult | Ed25519KeygenResult | BIP340KeygenResult;
+        clientSecondaryKeyshare: EcdsaKeygenResult | Ed25519KeygenResult | BIP340KeygenResult;
+    }): Promise<[EcdsaKeygenResult | BIP340KeygenResult, EcdsaKeygenResult | BIP340KeygenResult]>;
+    serverReshareRemainingParty({ clientPrimaryKeygenId, clientSecondaryKeygenId, }: {
+        clientPrimaryKeygenId: string;
+        clientSecondaryKeygenId: string;
+    }): Promise<any>;
+    getKeygenId({ chainName, clientKeyshare, }: {
+        chainName: string;
+        clientKeyshare: EcdsaKeygenResult | Ed25519KeygenResult | BIP340KeygenResult;
+    }): Promise<string>;
+    reshareRemainingParty({ chainName, clientKeyshare, }: {
+        chainName: string;
+        clientKeyshare: EcdsaKeygenResult | Ed25519KeygenResult | BIP340KeygenResult;
+    }): Promise<[EcdsaKeygenResult | BIP340KeygenResult, EcdsaKeygenResult | BIP340KeygenResult]>;
+    exportPrivateKey({ chainName, clientKeyshare, }: {
+        chainName: string;
+        clientKeyshare: EcdsaKeygenResult | Ed25519KeygenResult | BIP340KeygenResult;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    offlineExportPrivateKey({ chainName, keyShares, }: {
+        chainName: string;
+        keyShares: (EcdsaKeygenResult | Ed25519KeygenResult | BIP340KeygenResult)[];
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    encryptKeyShare({ keyShare, password, }: {
+        keyShare: ClientKeyshare;
+        password?: string;
+    }): Promise<string>;
+    storeEncryptedBackup({ keyShare, password, }: {
+        keyShare: ClientKeyshare;
+        password?: string;
+    }): Promise<any>;
+    decryptKeyShare({ keyShare, password, }: {
+        keyShare: string;
+        password?: string;
+    }): Promise<any>;
+    recoverEncryptedBackup({ password }?: {
+        password?: string;
+    }): Promise<any>;
+    restoreBackupShare({ keyShare }: {
+        keyShare: ClientKeyshare;
+    }): void;
+    getClientShare(): Promise<ClientKeyshare | undefined>;
+    backupFileToGoogleDrive({ oauthAccountId, fileName, jsonData, password, }: {
+        oauthAccountId: string;
+        fileName?: string;
+        jsonData: EcdsaKeygenResult;
+        password?: string;
+    }): Promise<any>;
+    getBackupFileFromGoogleDrive({ oauthAccountId, name, password, }: {
+        oauthAccountId: string;
+        name?: string;
+        password?: string;
+    }): Promise<ClientKeyshare | null>;
+}
+//# sourceMappingURL=client.d.ts.map

package/src/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"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"}

package/src/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const BACKUP_FILENAME = "dynamicWalletSecretBackup.json";
+//# sourceMappingURL=constants.d.ts.map

package/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,mCAAmC,CAAC"}

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@dynamic-labs-wallet/core';
+export * from './mpc/index';
+export * from './client';
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAE1C,cAAc,aAAa,CAAC;AAE5B,cAAc,UAAU,CAAC"}

package/src/mpc/index.d.ts

@@ -0,0 +1,4 @@
+import { Ecdsa, Ed25519, BIP340, BIP340KeygenResult, EcdsaPublicKey, Ed25519KeygenResult, EcdsaKeygenResult, MessageHash, EcdsaInitKeygenResult, Ed25519InitKeygenResult, BIP340InitKeygenResult, EcdsaSignature } from '@dynamic-labs-wallet/lib-mpc-web';
+export { Ecdsa, Ed25519, BIP340, EcdsaPublicKey, EcdsaKeygenResult, Ed25519KeygenResult, BIP340KeygenResult, MessageHash, EcdsaInitKeygenResult, Ed25519InitKeygenResult, BIP340InitKeygenResult, EcdsaSignature, };
+export * from './mpc';
+//# sourceMappingURL=index.d.ts.map

package/src/mpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mpc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,OAAO,EACP,MAAM,EACN,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,WAAW,EACX,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,cAAc,EACf,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EACL,KAAK,EACL,OAAO,EACP,MAAM,EACN,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,cAAc,GACf,CAAC;AAEF,cAAc,OAAO,CAAC"}

package/src/mpc/mpc.d.ts

@@ -0,0 +1,11 @@
+import { SigningAlgorithm } from '@dynamic-labs-wallet/core';
+import { Ecdsa, Ed25519, BIP340 } from '@dynamic-labs-wallet/lib-mpc-web';
+export declare const getMPCSignatureScheme: ({ signingAlgorithm, baseRelayUrl, }: {
+    signingAlgorithm: SigningAlgorithm;
+    baseRelayUrl?: string;
+}) => Ecdsa | Ed25519 | BIP340;
+export declare const getMPCSigner: ({ chainName, baseRelayUrl, }: {
+    chainName: string;
+    baseRelayUrl?: string;
+}) => Ecdsa | Ed25519 | BIP340;
+//# sourceMappingURL=mpc.d.ts.map

package/src/mpc/mpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mpc.d.ts","sourceRoot":"","sources":["../../../src/mpc/mpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAEjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAE1E,eAAO,MAAM,qBAAqB,wCAG/B;IACD,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,6BAWA,CAAC;AAEF,eAAO,MAAM,YAAY,iCAGtB;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,6BAOA,CAAC"}

package/src/mpc/types.d.ts

@@ -0,0 +1,5 @@
+import type { BIP340InitKeygenResult, BIP340KeygenResult, Ed25519InitKeygenResult, EcdsaInitKeygenResult, EcdsaKeygenResult, Ed25519KeygenResult } from '@dynamic-labs-wallet/lib-mpc-web';
+export type ClientInitKeygenResult = EcdsaInitKeygenResult | Ed25519InitKeygenResult | BIP340InitKeygenResult;
+export type ClientKeyshare = EcdsaKeygenResult | Ed25519KeygenResult | BIP340KeygenResult;
+export type { Ecdsa, Ed25519, BIP340, EcdsaPublicKey, EcdsaKeygenResult, Ed25519KeygenResult, BIP340KeygenResult, MessageHash, EcdsaSignature, } from '@dynamic-labs-wallet/lib-mpc-web';
+//# sourceMappingURL=types.d.ts.map

package/src/mpc/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/mpc/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAE1C,MAAM,MAAM,sBAAsB,GAC9B,qBAAqB,GACrB,uBAAuB,GACvB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,cAAc,GACtB,iBAAiB,GACjB,mBAAmB,GACnB,kBAAkB,CAAC;AAGrB,YAAY,EACV,KAAK,EACL,OAAO,EACP,MAAM,EACN,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,cAAc,GACf,MAAM,kCAAkC,CAAC"}

package/src/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const bytesToBase64: (arr: Uint8Array) => string;
+export declare const stringToBytes: (str: string) => Uint8Array;
+export declare const base64ToBytes: (base64: string) => Uint8Array;
+export declare const ensureBase64Padding: (str: string) => string;
+//# sourceMappingURL=utils.d.ts.map

package/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,QAAS,UAAU,WAE5C,CAAC;AAEF,eAAO,MAAM,aAAa,QAAS,MAAM,eAExC,CAAC;AAEF,eAAO,MAAM,aAAa,WAAY,MAAM,eAE3C,CAAC;AAGF,eAAO,MAAM,mBAAmB,QAAS,MAAM,KAAG,MAEjD,CAAC"}