Improved init funtion

- Only computeHost and passphrase are reqired as configs
- Added specific internal errors for config fields to help with usage

Author: RobinP122

src/interfaces/error.interfaces.ts

@@ -82,6 +82,9 @@ export enum IErrorInternal {
     InvalidDRUIDProvided = 'Invalid DRUID value provided',
     UnableToFilterIntercomData = 'Unable to filter intercom data',
     ClientNotInitialized = 'Client not initialized',
+    StorageNotInitialized = 'Storage host not initialized',
+    IntercomNotInitialized = 'Intercom host not initialized',
+    NotaryNotInitialized = 'Notary host not initialized',
     FetchBalanceResponseEmpty = 'Balance object is empty',
     NoDRUIDValues = 'DRUID values are null',
     AssetsIncompatible = 'Assets are incompatible',
@@ -91,7 +94,9 @@ export enum IErrorInternal {
     UnableToSignMessage = 'Unable to sign message',
     NoHostsProvided = 'No hosts provided',
     NoKeypairsProvided = 'No key-pairs provided',
-    UnknownError = 'Unknown Error',
+    NoPassPhraseProvided = 'No passphrase provided',
+    NoComputeHostProvided = 'No compute host provided',
+    UnknownError = 'Unknown Error'
 }
 
 // Custom `Result` wrapper with string error

src/interfaces/general.interfaces.ts

@@ -4,11 +4,11 @@
 
 // Config needed for initialization
 export type IClientConfig = {
-    computeHost?: string;
+    computeHost: string; /* Required */
     storageHost?: string;
     intercomHost?: string;
     notaryHost?: string;
-    passPhrase: string;
+    passPhrase: string; /* Required */
 };
 
 /* -------------------------------------------------------------------------- */

src/mgmt/key.mgmt.ts

@@ -75,6 +75,8 @@ export function generateSeed(): IResult<string> {
  * @param passphrase {string} - Passphrase as a string
  */
 export function getPassphraseBuffer(passphrase: string): IResult<Uint8Array> {
+    if (passphrase == undefined)
+        return err(IErrorInternal.NoPassPhraseProvided);
     try {
         const hash = sha3_256(passphrase);
         const val = truncateByBytesUTF8(hash, 32);

src/services/znt.service.ts

@@ -50,9 +50,9 @@ export class ABlockWallet {
     /* -------------------------------------------------------------------------- */
     /*                              Member Variables                              */
     /* -------------------------------------------------------------------------- */
-    private intercomHost: string | undefined;
     private computeHost: string | undefined;
     private storageHost: string | undefined;
+    private intercomHost: string | undefined;
     private notaryHost: string | undefined;
     private keyMgmt: mgmtClient | undefined;
     private computeRoutesPoW: Map<string, number> | undefined;
@@ -62,9 +62,9 @@ export class ABlockWallet {
     /*                                 Constructor                                */
     /* -------------------------------------------------------------------------- */
     constructor() {
-        this.intercomHost = undefined;
         this.computeHost = undefined;
         this.storageHost = undefined;
+        this.intercomHost = undefined;
         this.notaryHost = undefined;
         this.keyMgmt = undefined;
         this.computeRoutesPoW = undefined;
@@ -184,27 +184,31 @@ export class ABlockWallet {
      * Common network initialization (retrieval of PoW list for compute as well as storage)
      *
      * @private
-     * @param {IClientConfig} config - Additional configuration parameters
+     * @param {IClientConfig} config - Configuration parameters
      * @memberof ABlockWallet
      */
-    public async initNetwork(config: IClientConfig): Promise<IClientResponse> {
-        this.intercomHost = config.intercomHost;
+    private async initNetwork(config: IClientConfig): Promise<IClientResponse> {
         this.computeHost = config.computeHost;
         this.storageHost = config.storageHost;
+        this.intercomHost = config.intercomHost;
         this.notaryHost = config.notaryHost;
-        // Set routes proof-of-work requirements
+
+        if (this.computeHost == undefined)
+            return {
+                status: 'error',
+                reason: IErrorInternal.NoComputeHostProvided
+            } as IClientResponse;
 
         // Initialize routes proof-of-work for compute host
-        if (this.computeHost !== undefined) {
-            this.computeRoutesPoW = new Map();
-            const initComputeResult = await this.initNetworkForHost(
-                this.computeHost,
-                this.computeRoutesPoW,
-            );
-            if (initComputeResult.status == 'error') return initComputeResult;
-        }
+        this.computeRoutesPoW = new Map();
+        const initComputeResult = await this.initNetworkForHost(
+            this.computeHost,
+            this.computeRoutesPoW,
+        );
+        if (initComputeResult.status == 'error') return initComputeResult;
 
-        // Initialize routes proof-of-work for storage host
+
+        // Optional - Initialize routes proof-of-work for storage host
         if (this.storageHost !== undefined) {
             this.storageRoutesPoW = new Map();
             const initStorageResult = await this.initNetworkForHost(
@@ -215,10 +219,10 @@ export class ABlockWallet {
         }
 
         if (
-            this.storageHost === undefined &&
             this.computeHost === undefined &&
-            this.notaryHost === undefined &&
-            this.intercomHost === undefined
+            this.storageHost === undefined &&
+            this.intercomHost === undefined &&
+            this.notaryHost === undefined
         )
             return {
                 status: 'error',
@@ -237,16 +241,10 @@ export class ABlockWallet {
      * @param {IClientConfig} config - Additional configuration parameters
      * @memberof ABlockWallet
      */
-    public async initNetworkForHost(
-        host: string | undefined,
+    private async initNetworkForHost(
+        host: string,
         routesPow: Map<string, number>,
     ): Promise<IClientResponse> {
-        if (!host) {
-            return {
-                status: 'error',
-                reason: IErrorInternal.NoHostsProvided,
-            } as IClientResponse;
-        }
         // Set routes proof-of-work requirements
         const debugData = await this.getDebugData(host);
         if (debugData.status === 'error')
@@ -359,8 +357,10 @@ export class ABlockWallet {
      */
     public async fetchTransactions(transactionHashes: string[]): Promise<IClientResponse> {
         try {
-            if (!this.storageHost || !this.keyMgmt || !this.storageRoutesPoW)
+            if (!this.keyMgmt)
                 throw new Error(IErrorInternal.ClientNotInitialized);
+            if (!this.storageHost || !this.storageRoutesPoW) /* Storage is optional on wallet init, but must be initialized here */
+                throw new Error(IErrorInternal.StorageNotInitialized);
             const headers = this.getRequestIdAndNonceHeadersForRoute(
                 this.computeRoutesPoW,
                 IAPIRoute.FetchBalance,
@@ -509,8 +509,10 @@ export class ABlockWallet {
      */
     async getNotaryBurnAddress(): Promise<IClientResponse> {
         try {
-            if (!this.notaryHost || !this.keyMgmt)
+            if (!this.keyMgmt)
                 throw new Error(IErrorInternal.ClientNotInitialized);
+            if (!this.notaryHost)
+                throw new Error(IErrorInternal.NotaryNotInitialized);
             const headers = this.getRequestIdAndNonceHeadersForRoute(
                 new Map(),
                 IAPIRoute.GetNotaryBurnAddress,
@@ -554,8 +556,10 @@ export class ABlockWallet {
         signatures: IGenericKeyPair<string>,
     ): Promise<IClientResponse> {
         try {
-            if (!this.notaryHost || !this.keyMgmt)
+            if (!this.keyMgmt)
                 throw new Error(IErrorInternal.ClientNotInitialized);
+            if (!this.notaryHost)
+                throw new Error(IErrorInternal.NotaryNotInitialized);
             const headers = this.getRequestIdAndNonceHeadersForRoute(
                 new Map(),
                 IAPIRoute.GetNotarySignature,
@@ -684,8 +688,10 @@ export class ABlockWallet {
         receiveAddress: IKeypairEncrypted,
     ): Promise<IClientResponse> {
         try {
-            if (!this.computeHost || !this.intercomHost || !this.keyMgmt || !this.computeRoutesPoW)
+            if (!this.computeHost || !this.keyMgmt || !this.computeRoutesPoW)
                 throw new Error(IErrorInternal.ClientNotInitialized);
+            if (!this.intercomHost)
+                throw new Error(IErrorInternal.IntercomNotInitialized);
             const senderKeypair = throwIfErr(this.keyMgmt.decryptKeypair(receiveAddress));
             const [allAddresses, keyPairMap] = throwIfErr(
                 this.keyMgmt.getAllAddressesAndKeypairMap(allKeypairs),
@@ -829,8 +835,10 @@ export class ABlockWallet {
         allEncryptedTxs: ICreateTransactionEncrypted[],
     ): Promise<IClientResponse> {
         try {
-            if (!this.computeHost || !this.intercomHost || !this.keyMgmt || !this.computeRoutesPoW)
+            if (!this.computeHost || !this.keyMgmt || !this.computeRoutesPoW)
                 throw new Error(IErrorInternal.ClientNotInitialized);
+            if (!this.intercomHost)
+                throw new Error(IErrorInternal.IntercomNotInitialized);
 
             // Generate a key-pair map
             const [allAddresses, keyPairMap] = throwIfErr(
@@ -1229,8 +1237,10 @@ export class ABlockWallet {
         allKeypairs: IKeypairEncrypted[],
     ): Promise<IClientResponse> {
         try {
-            if (!this.computeHost || !this.intercomHost || !this.keyMgmt || !this.computeRoutesPoW)
+            if (!this.computeHost || !this.keyMgmt || !this.computeRoutesPoW)
                 throw new Error(IErrorInternal.ClientNotInitialized);
+            if (!this.intercomHost)
+                throw new Error(IErrorInternal.IntercomNotInitialized);
             const [allAddresses, keyPairMap] = throwIfErr(
                 this.keyMgmt.getAllAddressesAndKeypairMap(allKeypairs),
             );
@@ -1336,13 +1346,12 @@ export class ABlockWallet {
      * Get information regarding the PoW required for all routes
      *
      * @private
-     * @param {(string | undefined)} host - Host address to retrieve proof-of-work data from
+     * @param {(string)} host - Host address to retrieve proof-of-work data from
      * @return {*}  {Promise<IClientResponse>}
      * @memberof ABlockWallet
      */
-    private async getDebugData(host: string | undefined): Promise<IClientResponse> {
+    private async getDebugData(host: string): Promise<IClientResponse> {
         try {
-            if (!host) throw new Error(IErrorInternal.ClientNotInitialized);
             const routesPow =
                 host === this.computeHost ? this.computeRoutesPoW : this.storageRoutesPoW;
             const headers = this.getRequestIdAndNonceHeadersForRoute(