Merge pull request #97 from cruxprotocol/feature/shift-to-infunction-init-calls

Init call transferred to constructor as a promise

Author: mascot6699

README.md

@@ -29,7 +29,7 @@ To initialize the sdk, you need to minimally pass a javascript object with follo
 
 `**Note:** Cruxprotocol JS SDK is case insensetive for cryptocurrency symbols and will always output lowercase symbols.`
 
-Example below shows how to a cruxClient instance. Note that all [SDK Operation](#sdk-operation) can oly be run after `.init()` is called.   
+Example below shows how to a cruxClient instance. These are the [SDK Operation](#sdk-operation) exposed.   
 ```javascript
 import crypto from "crypto";
 
@@ -45,12 +45,6 @@ let cruxClientOptions = {
 }
 
 let cruxClient = new CruxClient(cruxClientOptions);
-cruxClient.init()
-.then(() => {
-    console.log('CruxClient initialized');
-}).catch((err) => {
-    console.log('CruxClient error', err);
-})
 ```
 That's it! now you can use the cruxClient object to perform operations defined in [SDK Operation](#sdk-operation).
 ```javascript
@@ -64,7 +58,6 @@ Wallet clients are encouraged to surface the respective `ERROR_CODE` of the `Cru
 Refer [error-handling.md](https://github.com/cruxprotocol/js-sdk/blob/master/error-handling.md) for more information on Error handling.
 
 
-
 ### SDK Operation
 
 1. ##### isCruxIDAvailable(cruxID<onlySubdomain>)
@@ -76,7 +69,7 @@ Refer [error-handling.md](https://github.com/cruxprotocol/js-sdk/blob/master/err
 2. ##### getAssetMap()
     - Description: Get Wallet's asset map with currency symbols as the keys and asset object as the value.
     - Params: None
-    - Returns: [IResolvedClientAssetMapping](#iresolvedclientassetmapping) which has symbols and asset objects.
+    - Returns: Promise resolving to [IResolvedClientAssetMapping](#iresolvedclientassetmapping) which has symbols and asset objects.
 
 3. ##### registerCruxID(cruxID<onlySubdomain>)
     - Description: Reserves/registers the cruxID for the user. The user can link any blockchain address to his CruxID immediately after registration using [putAddressMap](#putaddressmap).
@@ -315,4 +308,4 @@ Running the above command will build a [demo page](https://localhost:1234), here
 
 ### How can I contribute?
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) file.
+See [CONTRIBUTING.md](CONTRIBUTING.md) file.

src/index.ts

@@ -165,6 +165,7 @@ export class CruxClient {
     protected _nameService?: nameService.NameService;
     protected _payIDClaim?: PayIDClaim;
     protected _configService?: configurationService.ConfigurationService;
+    private initPromise: Promise<void>;
 
     constructor(options: ICruxPayPeerOptions) {
         this._options = Object.assign({}, options);
@@ -184,46 +185,13 @@ export class CruxClient {
         cacheStorage = this._storage;
 
         log.info(`Config mode:`, config.CONFIG_MODE);
-        log.info(`CruxPayPeer Initialised`);
+        log.info(`CruxPayClient: constructor called`);
+        this.initPromise = this._init();
     }
 
     public init = async (): Promise<void> => {
-        await this._setupConfigService();
-        if (!this._configService) {
-            throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.ClientNotInitialized);
-        }
-        if (await this._hasPayIDClaimStored()) {
-            log.debug("using the stored payIDClaim");
-            const payIDClaim = (await this._storage.getJSON("payIDClaim") as ICruxPayClaim);
-            // log.debug(`Local payIDClaim:`, payIDClaim)
-
-            // if a keyPair is provided, add a validation check on the cruxID stored
-            if (this._keyPair) {
-                const registeredCruxID = await getCruxIDByAddress(this.walletClientName, this._keyPair.address, this._configService.getBnsNodes(), this._configService.getSubdomainRegistrar());
-                if (registeredCruxID) {
-                    CruxClient.validateCruxIDByWallet(this.walletClientName, registeredCruxID);
-                    if (registeredCruxID !== payIDClaim.virtualAddress) {
-                        throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.KeyPairMismatch);
-                    }
-                } else {
-                    throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.KeyPairMismatch);
-                }
-            }
-            this._setPayIDClaim(new PayIDClaim(payIDClaim, { getEncryptionKey: this._getEncryptionKey }));
-        } else if (this._keyPair) {
-            log.debug("using the keyPair provided");
-            const registeredCruxID = await getCruxIDByAddress(this.walletClientName, this._keyPair.address, this._configService.getBnsNodes(), this._configService.getSubdomainRegistrar());
-            if (registeredCruxID) {
-                CruxClient.validateCruxIDByWallet(this.walletClientName, registeredCruxID);
-                const payIDClaim = {identitySecrets: {identityKeyPair: this._keyPair}, virtualAddress: registeredCruxID || undefined};
-                this._setPayIDClaim(new PayIDClaim(payIDClaim, { getEncryptionKey: this._getEncryptionKey }));
-            }
-        }
-
-        await this._initializeNameService().then(() => this._restoreIdentity());
-
-        log.info(`CruxPayPeer: Done init`);
-    }
+        return await this.initPromise;
+    }   // For backward compatibility
 
     public hasPayIDClaim = (): boolean =>  {
         return Boolean(this._payIDClaim);
@@ -234,6 +202,7 @@ export class CruxClient {
     }
 
     public updatePassword = async (oldEncryptionKey: string, newEncryptionKey: string): Promise<boolean> => {
+        await this.initPromise;
         try {
             if (await this._hasPayIDClaimStored()) {
                 await (this._payIDClaim as PayIDClaim).decrypt(oldEncryptionKey);
@@ -253,41 +222,44 @@ export class CruxClient {
         }
     }
 
-    public isCruxIDAvailable = (cruxIDSubdomain: string): Promise<boolean> => {
+    public isCruxIDAvailable = async (cruxIDSubdomain: string): Promise<boolean> => {
+        await this.initPromise;
         try {
-            identityUtils.validateSubdomain(cruxIDSubdomain);
-            return (this._nameService as nameService.NameService).getNameAvailability(cruxIDSubdomain);
-        } catch (err) {
-            throw errors.CruxClientError.fromError(err);
-        }
+                identityUtils.validateSubdomain(cruxIDSubdomain);
+                return (this._nameService as nameService.NameService).getNameAvailability(cruxIDSubdomain);
+            } catch (err) {
+                throw errors.CruxClientError.fromError(err);
+            }
     }
 
     public resolveCurrencyAddressForCruxID = async (fullCruxID: string, walletCurrencySymbol: string): Promise<IAddress> => {
+        await this.initPromise;
         try {
-            if (!(this._configService && this._nameService)) {
-                throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.ClientNotInitialized);
-            }
-            walletCurrencySymbol = walletCurrencySymbol.toLowerCase();
-            let correspondingAssetId: string = "";
-            correspondingAssetId = await this._translateSymbolToAssetId(walletCurrencySymbol);
-            if (!correspondingAssetId) {
-                throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.AssetIDNotAvailable);
-            }
+                if (!(this._configService && this._nameService)) {
+                    throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.ClientNotInitialized);
+                }
+                walletCurrencySymbol = walletCurrencySymbol.toLowerCase();
+                let correspondingAssetId: string = "";
+                correspondingAssetId = await this._translateSymbolToAssetId(walletCurrencySymbol);
+                if (!correspondingAssetId) {
+                    throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.AssetIDNotAvailable);
+                }
 
-            const addressMap = await this._nameService.getAddressMapping(fullCruxID);
-            log.debug(`Address map: `, addressMap);
-            if (!addressMap[correspondingAssetId]) {
-                throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.AddressNotAvailable);
+                const addressMap = await this._nameService.getAddressMapping(fullCruxID);
+                log.debug(`Address map: `, addressMap);
+                if (!addressMap[correspondingAssetId]) {
+                    throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.AddressNotAvailable);
+                }
+                const address: IAddress = addressMap[correspondingAssetId] || addressMap[correspondingAssetId.toLowerCase()];
+                log.debug(`Address:`, address);
+                return address;
+            } catch (err) {
+                throw errors.CruxClientError.fromError(err);
             }
-            const address: IAddress = addressMap[correspondingAssetId] || addressMap[correspondingAssetId.toLowerCase()];
-            log.debug(`Address:`, address);
-            return address;
-        } catch (err) {
-            throw errors.CruxClientError.fromError(err);
-        }
     }
 
     public getCruxIDState = async (): Promise<ICruxIDState> => {
+        await this.initPromise;
         try {
             const fullCruxID = this.hasPayIDClaim() ? this.getPayIDClaim().virtualAddress : undefined;
             if (!fullCruxID) {
@@ -311,90 +283,90 @@ export class CruxClient {
 
     public registerCruxID = async (cruxIDSubdomain: string): Promise<void> => {
         // TODO: add isCruxIDAvailable check before
+        await this.initPromise;
         try {
-            // Subdomain validation
-            identityUtils.validateSubdomain(cruxIDSubdomain);
+                // Subdomain validation
+                identityUtils.validateSubdomain(cruxIDSubdomain);
 
-            // Validate if the subdomain is available
-            if (!(await this.isCruxIDAvailable(cruxIDSubdomain))) {
-                throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.CruxIDUnavailable, cruxIDSubdomain);
-            }
+                // Validate if the subdomain is available
+                if (!(await this.isCruxIDAvailable(cruxIDSubdomain))) {
+                    throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.CruxIDUnavailable, cruxIDSubdomain);
+                }
 
-            // Generating the identityClaim
-            if (this._payIDClaim) {
-                if (this._payIDClaim.virtualAddress) {
-                    // Do not allow multiple registrations using same payIDClaim
-                    throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.ExistingCruxIDFound, this._payIDClaim.virtualAddress);
+                // Generating the identityClaim
+                if (this._payIDClaim) {
+                    if (this._payIDClaim.virtualAddress) {
+                        // Do not allow multiple registrations using same payIDClaim
+                        throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.ExistingCruxIDFound, this._payIDClaim.virtualAddress);
+                    }
+                    await (this._payIDClaim as PayIDClaim).decrypt();
                 }
-                await (this._payIDClaim as PayIDClaim).decrypt();
-            }
 
-            let identityClaim: nameService.IIdentityClaim;
-            if (this._payIDClaim) {
-                identityClaim = {secrets: this._payIDClaim.identitySecrets};
-            } else if (this._keyPair) {
-                identityClaim = {secrets: {identityKeyPair: this._keyPair}};
-            } else {
-                identityClaim = await (this._nameService as nameService.NameService).generateIdentity(this._storage, await this._getEncryptionKey());
-            }
+                let identityClaim: nameService.IIdentityClaim;
+                if (this._payIDClaim) {
+                    identityClaim = {secrets: this._payIDClaim.identitySecrets};
+                } else if (this._keyPair) {
+                    identityClaim = {secrets: {identityKeyPair: this._keyPair}};
+                } else {
+                    identityClaim = await (this._nameService as nameService.NameService).generateIdentity(this._storage, await this._getEncryptionKey());
+                }
 
-            const registeredPublicID = await (this._nameService as nameService.NameService).registerName(identityClaim, cruxIDSubdomain);
+                const registeredPublicID = await (this._nameService as nameService.NameService).registerName(identityClaim, cruxIDSubdomain);
 
-            // Setup the payIDClaim locally
-            this._setPayIDClaim(new PayIDClaim({virtualAddress: registeredPublicID, identitySecrets: identityClaim.secrets}, { getEncryptionKey: this._getEncryptionKey }));
-            // await this._payIDClaim.setPasscode(passcode)
-            await (this._payIDClaim as PayIDClaim).encrypt();
-            await (this._payIDClaim as PayIDClaim).save(this._storage);
-            return;
-        } catch (err) {
-            throw errors.CruxClientError.fromError(err);
-        }
+                // Setup the payIDClaim locally
+                this._setPayIDClaim(new PayIDClaim({virtualAddress: registeredPublicID, identitySecrets: identityClaim.secrets}, { getEncryptionKey: this._getEncryptionKey }));
+                // await this._payIDClaim.setPasscode(passcode)
+                await (this._payIDClaim as PayIDClaim).encrypt();
+                await (this._payIDClaim as PayIDClaim).save(this._storage);
+                return;
+            } catch (err) {
+                throw errors.CruxClientError.fromError(err);
+            }
     }
 
     public putAddressMap = async (newAddressMap: IAddressMapping): Promise<{success: IPutAddressMapSuccess, failures: IPutAddressMapFailures}> => {
+        await this.initPromise;
         try {
-            const {assetAddressMap, success, failures} = await this._getAssetAddressMapFromCurrencyAddressMap(newAddressMap);
-            await (this._payIDClaim as PayIDClaim).decrypt();
-            await (this._nameService as nameService.NameService).putAddressMapping({secrets: (this._payIDClaim as PayIDClaim).identitySecrets}, assetAddressMap);
-            await (this._payIDClaim as PayIDClaim).encrypt();
-            return {success, failures};
-        } catch (err) {
-            throw errors.CruxClientError.fromError(err);
-        }
+                const {assetAddressMap, success, failures} = await this._getAssetAddressMapFromCurrencyAddressMap(newAddressMap);
+                await (this._payIDClaim as PayIDClaim).decrypt();
+                await (this._nameService as nameService.NameService).putAddressMapping({secrets: (this._payIDClaim as PayIDClaim).identitySecrets}, assetAddressMap);
+                await (this._payIDClaim as PayIDClaim).encrypt();
+                return {success, failures};
+            } catch (err) {
+                throw errors.CruxClientError.fromError(err);
+            }
     }
 
     public getAddressMap = async (): Promise<IAddressMapping> => {
+        await this.initPromise;
         try {
-            const currencyAddressMap: IAddressMapping = {};
-            if (this._payIDClaim && this._payIDClaim.virtualAddress && this._configService) {
-                const userAssetIdToAddressMap = await (this._nameService as nameService.NameService).getAddressMapping(this._payIDClaim.virtualAddress);
+                const currencyAddressMap: IAddressMapping = {};
+                if (this._payIDClaim && this._payIDClaim.virtualAddress && this._configService) {
+                    const userAssetIdToAddressMap = await (this._nameService as nameService.NameService).getAddressMapping(this._payIDClaim.virtualAddress);
 
-                for (const assetId of Object.keys(userAssetIdToAddressMap)) {
-                    currencyAddressMap[(await (this._translateAssetIdToSymbol(assetId)))] = userAssetIdToAddressMap[assetId];
+                    for (const assetId of Object.keys(userAssetIdToAddressMap)) {
+                        currencyAddressMap[(await (this._translateAssetIdToSymbol(assetId)))] = userAssetIdToAddressMap[assetId];
+                    }
+                    return currencyAddressMap;
+                } else {
+                    return {};
                 }
-                return currencyAddressMap;
-
-            } else {
-                return {};
-            }
-        } catch (err) {
-            if (err.errorCode && err.errorCode === errors.PackageErrorCode.GaiaEmptyResponse) {
-                return {};
+            } catch (err) {
+                if (err.errorCode && err.errorCode === errors.PackageErrorCode.GaiaEmptyResponse) {
+                    return {};
+                }
+                throw errors.CruxClientError.fromError(err);
             }
-            throw errors.CruxClientError.fromError(err);
-        }
     }
 
-    public getAssetMap = (): configurationService.IResolvedClientAssetMap => {
+    public getAssetMap = async (): Promise<configurationService.IResolvedClientAssetMap> => {
+        await this.initPromise;
         try {
-            if (this._configService) {
+                // @ts-ignore
                 return this._configService.resolvedClientAssetMap as configurationService.IResolvedClientAssetMap;
-            } else {
-                throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.ClientNotInitialized);
+            } catch (err) {
+                throw errors.CruxClientError.fromError(err);
             }
-        } catch (err) {
-            throw errors.CruxClientError.fromError(err);
-        }
     }
 
     public getAssetMapping = () => this.getAssetMap;    // For backward compatibility
@@ -404,6 +376,44 @@ export class CruxClient {
         delete this._keyPair;
     }
 
+    private _init = async (): Promise<void> => {
+        await this._setupConfigService();
+        if (!this._configService) {
+            throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.ClientNotInitialized);
+        }
+        if (await this._hasPayIDClaimStored()) {
+            log.debug("using the stored payIDClaim");
+            const payIDClaim = (await this._storage.getJSON("payIDClaim") as ICruxPayClaim);
+            // log.debug(`Local payIDClaim:`, payIDClaim)
+
+            // if a keyPair is provided, add a validation check on the cruxID stored
+            if (this._keyPair) {
+                const registeredCruxID = await getCruxIDByAddress(this.walletClientName, this._keyPair.address, this._configService.getBnsNodes(), this._configService.getSubdomainRegistrar());
+                if (registeredCruxID) {
+                    CruxClient.validateCruxIDByWallet(this.walletClientName, registeredCruxID);
+                    if (registeredCruxID !== payIDClaim.virtualAddress) {
+                        throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.KeyPairMismatch);
+                    }
+                } else {
+                    throw errors.ErrorHelper.getPackageError(errors.PackageErrorCode.KeyPairMismatch);
+                }
+            }
+            this._setPayIDClaim(new PayIDClaim(payIDClaim, { getEncryptionKey: this._getEncryptionKey }));
+        } else if (this._keyPair) {
+            log.debug("using the keyPair provided");
+            const registeredCruxID = await getCruxIDByAddress(this.walletClientName, this._keyPair.address, this._configService.getBnsNodes(), this._configService.getSubdomainRegistrar());
+            if (registeredCruxID) {
+                CruxClient.validateCruxIDByWallet(this.walletClientName, registeredCruxID);
+                const payIDClaim = {identitySecrets: {identityKeyPair: this._keyPair}, virtualAddress: registeredCruxID || undefined};
+                this._setPayIDClaim(new PayIDClaim(payIDClaim, { getEncryptionKey: this._getEncryptionKey }));
+            }
+        }
+
+        await this._initializeNameService().then(() => this._restoreIdentity());
+
+        log.info(`CruxPayClient: _init complete`);
+    }
+
     private _getIDStatus = async (): Promise<nameService.CruxIDRegistrationStatus> => {
         await (this._payIDClaim as PayIDClaim).decrypt();
         const result = await (this._nameService as nameService.NameService).getRegistrationStatus({secrets: (this._payIDClaim as PayIDClaim).identitySecrets});