@dynamic-labs-wallet/browser 0.0.16 → 0.0.18

package/index.cjs.js

@@ -1,16 +1,28 @@
 'use strict';
 
 var core = require('@dynamic-labs-wallet/core');
-var libMpcWeb = require('@dynamic-labs-wallet/lib-mpc-web');
+var web = require('@internal/web');
+var logger$1 = require('@dynamic-labs/logger');
+
+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 = core.MPC_RELAY_PROD_API_URL })=>{
     switch(signingAlgorithm){
         case core.SigningAlgorithm.ECDSA:
-            return new libMpcWeb.Ecdsa(baseRelayUrl);
+            return new web.Ecdsa(baseRelayUrl);
         case core.SigningAlgorithm.ED25519:
-            return new libMpcWeb.Ed25519(baseRelayUrl);
+            return new web.Ed25519(baseRelayUrl);
         case core.SigningAlgorithm.BIP340:
-            return new libMpcWeb.BIP340(baseRelayUrl);
+            return new web.BIP340(baseRelayUrl);
         default:
             throw new Error(`Unsupported signing algorithm: ${signingAlgorithm}`);
     }
@@ -24,17 +36,6 @@ const getMPCSigner = ({ chainName, baseRelayUrl })=>{
     return signatureScheme;
 };
 
-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 bytesToBase64 = (arr)=>{
     return btoa(Array.from(arr, (b)=>String.fromCharCode(b)).join(''));
 };
@@ -48,6 +49,7 @@ const base64ToBytes = (base64)=>{
 const ensureBase64Padding = (str)=>{
     return str.padEnd(Math.ceil(str.length / 4) * 4, '=');
 };
+const isBrowser = ()=>typeof window !== 'undefined';
 
 const getKey = async ({ password, salt })=>{
     const passwordBytes = stringToBytes(password);
@@ -190,9 +192,108 @@ const downloadFileFromGoogleDrive = async ({ accessToken, name })=>{
     return fileRawData;
 };
 
+const DEFAULT_LOG_LEVEL = 'INFO';
+const STORAGE_KEY = 'dynamic-waas-wallet-client';
 const BACKUP_FILENAME = 'dynamicWalletSecretBackup.json';
 
+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;
+        }
+    });
+
+const logger = new logger$1.Logger('DynamicWaasWalletClient');
+
 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;
+    }
+    /**
+   * Client initialization logic
+   */ async _initialize() {
+        try {
+            const initializePromises = [];
+            initializePromises.push(this.restoreWallets());
+            await Promise.all(initializePromises);
+            return {
+                error: null
+            };
+        } catch (error) {
+            return {
+                error
+            };
+        }
+    }
     async serverInitializeKeyGen({ chainName, clientKeygenIds, thresholdSignatureScheme }) {
         // Initilize keygen, create room, and create the wallet account on the server
         const data = await this.apiClient.createWalletAccount({
@@ -219,9 +320,9 @@ class DynamicWalletClient {
         });
         const chainConfig = core.getMPCChainConfig(chainName);
         let publicKey;
-        if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+        if (mpcSigner instanceof web.Ecdsa) {
             publicKey = await mpcSigner.derivePubkey(keyShare, new Uint32Array(chainConfig.derivationPath));
-        } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+        } else if (mpcSigner instanceof web.Ed25519) {
             publicKey = await mpcSigner.derivePubkey(keyShare, new Uint32Array(chainConfig.derivationPath));
         }
         return publicKey;
@@ -280,7 +381,7 @@ class DynamicWalletClient {
                 clientKeyShares
             };
         } catch (error) {
-            console.error('Error creating wallet account', error);
+            this.logger.error('Error creating wallet account', error);
             throw new Error('Error creating wallet account');
         }
     }
@@ -305,11 +406,11 @@ class DynamicWalletClient {
             const derivationPath = new Uint32Array(chainConfig.derivationPath);
             let formattedMessage;
             //note: Ecdsa can also be used by bitcoin, but only keccak256 is used by ethereum
-            if (mpcSigner instanceof libMpcWeb.Ecdsa) {
-                formattedMessage = libMpcWeb.MessageHash.keccak256(message);
-            } else if (mpcSigner instanceof libMpcWeb.Ed25519 && typeof message === 'string') {
+            if (mpcSigner instanceof web.Ecdsa) {
+                formattedMessage = web.MessageHash.keccak256(message);
+            } else if (mpcSigner instanceof web.Ed25519 && typeof message === 'string') {
                 formattedMessage = new TextEncoder().encode(message);
-            } else if (mpcSigner instanceof libMpcWeb.BIP340 && typeof message === 'string') {
+            } else if (mpcSigner instanceof web.BIP340 && typeof message === 'string') {
                 formattedMessage = new TextEncoder().encode(message);
             } else {
                 throw new Error('Unsupported signer type');
@@ -317,7 +418,7 @@ class DynamicWalletClient {
             const signature = await mpcSigner.sign(roomId, keyShare, formattedMessage, derivationPath);
             return signature;
         } catch (error) {
-            console.error('Error in clientSign:', error);
+            this.logger.error('Error in clientSign:', error);
             throw error;
         }
     }
@@ -325,6 +426,7 @@ class DynamicWalletClient {
         const wallet = await this.getWallet({
             accountAddress
         });
+        this.logger.debug('signing wallet', wallet);
         // Perform the server sign
         const data = await this.serverSign({
             walletId: wallet.walletId,
@@ -412,8 +514,8 @@ class DynamicWalletClient {
             data.serverKeygenId,
             newPartyInitKeygenId
         ];
-        console.log('newClientPrimaryKeygenIds', newClientPrimaryKeygenIds);
-        console.log('clientSecondaryKeygenIds', clientSecondaryKeygenIds);
+        this.logger.debug('newClientPrimaryKeygenIds', newClientPrimaryKeygenIds);
+        this.logger.debug('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)
@@ -443,11 +545,11 @@ class DynamicWalletClient {
         }
         const derivationPath = new Uint32Array(chainConfig.derivationPath);
         let derivedPrivateKey;
-        if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+        if (mpcSigner instanceof web.Ecdsa) {
             derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
-        } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+        } else if (mpcSigner instanceof web.Ed25519) {
             derivedPrivateKey = keyExportRaw;
-        } else if (mpcSigner instanceof libMpcWeb.BIP340) {
+        } else if (mpcSigner instanceof web.BIP340) {
             derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
         }
         return {
@@ -464,7 +566,7 @@ class DynamicWalletClient {
                 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);
+                return mpcSigner instanceof web.Ecdsa ? new web.EcdsaKeygenResult(keyShare.pubkey, keyShare.secretShare) : mpcSigner instanceof web.Ed25519 ? new web.Ed25519KeygenResult(keyShare.pubkey, keyShare.secretShare) : new web.BIP340KeygenResult(keyShare.pubkey, keyShare.secretShare);
             });
             const keyExportRaw = await mpcSigner.offlineExportFullPrivateKey(walletKeyShares);
             if (!keyExportRaw) {
@@ -473,11 +575,11 @@ class DynamicWalletClient {
             const chainConfig = core.getMPCChainConfig(chainName);
             const derivationPath = new Uint32Array(chainConfig.derivationPath);
             let derivedPrivateKey;
-            if (mpcSigner instanceof libMpcWeb.Ecdsa) {
+            if (mpcSigner instanceof web.Ecdsa) {
                 derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
-            } else if (mpcSigner instanceof libMpcWeb.Ed25519) {
+            } else if (mpcSigner instanceof web.Ed25519) {
                 derivedPrivateKey = keyExportRaw;
-            } else if (mpcSigner instanceof libMpcWeb.BIP340) {
+            } else if (mpcSigner instanceof web.BIP340) {
                 derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
             }
             return {
@@ -542,18 +644,27 @@ class DynamicWalletClient {
         });
         return decryptedKeyShares;
     }
-    restoreBackupShare({ walletId, accountAddress, chainName, keyShare, thresholdSignatureScheme }) {
+    async restoreWallets() {
+        const wallets = await this.storage.getItem(this.storageKey);
+        console.log('local storage wallets', wallets);
+        if (!wallets) {
+            return;
+        }
+        this.walletMap = JSON.parse(wallets);
+    }
+    async 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) || [],
+                ...((_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? void 0 : _this_walletMap_accountAddress.clientKeyShares) || [],
                 keyShare
             ],
             thresholdSignatureScheme
         };
+        await this.storage.setItem(this.storageKey, JSON.stringify(this.walletMap));
     }
     async backupFileToGoogleDrive({ oauthAccountId, fileName = BACKUP_FILENAME, jsonData, password }) {
         const encryptedKeyShare = await this.encryptKeyShare({
@@ -656,17 +767,18 @@ class DynamicWalletClient {
             } 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);
+                const wallet = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.find((vc)=>vc.address === accountAddress);
+                this.logger.debug('need to restore wallet', wallet);
                 console.log('need to restore wallet', wallet);
                 const clientShares = wallet.walletProperties.keyShares.filter((ks)=>ks.backupLocation === 'dynamic');
-                console.log('clientShares', clientShares);
+                this.logger.debug('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);
+                this.logger.debug('recovery decryptedKeyShares', decryptedKeyShares);
             }
         }
         const walletCount = Object.keys(this.walletMap).length;
@@ -686,7 +798,7 @@ class DynamicWalletClient {
     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 waasWallets = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.filter((vc)=>vc.walletName === 'dynamicwaas');
         const wallets = waasWallets.map((vc)=>({
                 walletId: vc.id,
                 chainName: vc.chain,
@@ -704,74 +816,88 @@ class DynamicWalletClient {
         }, {});
         return wallets;
     }
-    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl }){
+    constructor({ environmentId, authToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug }){
+        this.initializePromise = null;
+        this.logger = logger;
         this.walletMap = {} // todo: store in session storage
         ;
+        this.memoryStorage = null;
         this.environmentId = environmentId;
+        this.storageKey = `${STORAGE_KEY}-${storageKey != null ? storageKey : environmentId}`;
         this.baseMPCRelayApiUrl = baseMPCRelayApiUrl;
         this.apiClient = new core.DynamicApiClient({
             environmentId,
             authToken,
             baseApiUrl
         });
-        this.getWallets();
+        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);
+        }
+        // initialize the client
+        this.initialize();
     }
 }
 
 Object.defineProperty(exports, "BIP340", {
-  enumerable: true,
-  get: function () { return libMpcWeb.BIP340; }
+    enumerable: true,
+    get: function () { return web.BIP340; }
 });
 Object.defineProperty(exports, "BIP340InitKeygenResult", {
-  enumerable: true,
-  get: function () { return libMpcWeb.BIP340InitKeygenResult; }
+    enumerable: true,
+    get: function () { return web.BIP340InitKeygenResult; }
 });
 Object.defineProperty(exports, "BIP340KeygenResult", {
-  enumerable: true,
-  get: function () { return libMpcWeb.BIP340KeygenResult; }
+    enumerable: true,
+    get: function () { return web.BIP340KeygenResult; }
 });
 Object.defineProperty(exports, "Ecdsa", {
-  enumerable: true,
-  get: function () { return libMpcWeb.Ecdsa; }
+    enumerable: true,
+    get: function () { return web.Ecdsa; }
 });
 Object.defineProperty(exports, "EcdsaInitKeygenResult", {
-  enumerable: true,
-  get: function () { return libMpcWeb.EcdsaInitKeygenResult; }
+    enumerable: true,
+    get: function () { return web.EcdsaInitKeygenResult; }
 });
 Object.defineProperty(exports, "EcdsaKeygenResult", {
-  enumerable: true,
-  get: function () { return libMpcWeb.EcdsaKeygenResult; }
+    enumerable: true,
+    get: function () { return web.EcdsaKeygenResult; }
 });
 Object.defineProperty(exports, "EcdsaPublicKey", {
-  enumerable: true,
-  get: function () { return libMpcWeb.EcdsaPublicKey; }
+    enumerable: true,
+    get: function () { return web.EcdsaPublicKey; }
 });
 Object.defineProperty(exports, "EcdsaSignature", {
-  enumerable: true,
-  get: function () { return libMpcWeb.EcdsaSignature; }
+    enumerable: true,
+    get: function () { return web.EcdsaSignature; }
 });
 Object.defineProperty(exports, "Ed25519", {
-  enumerable: true,
-  get: function () { return libMpcWeb.Ed25519; }
+    enumerable: true,
+    get: function () { return web.Ed25519; }
 });
 Object.defineProperty(exports, "Ed25519InitKeygenResult", {
-  enumerable: true,
-  get: function () { return libMpcWeb.Ed25519InitKeygenResult; }
+    enumerable: true,
+    get: function () { return web.Ed25519InitKeygenResult; }
 });
 Object.defineProperty(exports, "Ed25519KeygenResult", {
-  enumerable: true,
-  get: function () { return libMpcWeb.Ed25519KeygenResult; }
+    enumerable: true,
+    get: function () { return web.Ed25519KeygenResult; }
 });
 Object.defineProperty(exports, "MessageHash", {
-  enumerable: true,
-  get: function () { return libMpcWeb.MessageHash; }
+    enumerable: true,
+    get: function () { return web.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]; }
-  });
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return core[k]; }
+    });
 });