feat: wait for lnd on create call

This makes the `CreateNode` call wait briefly for all enabled lnd
clients to become available. If any lnd clients remain unavailable,
the call returns an error.

Closes #1252.

Author: sangaman

lib/grpc/getGrpcError.ts

@@ -64,6 +64,8 @@ const getGrpcError = (err: any) => {
     case p2pErrorCodes.RESPONSE_TIMEOUT:
       code = status.DEADLINE_EXCEEDED;
       break;
+    case swapErrorCodes.SWAP_CLIENT_WALLET_NOT_CREATED:
+      code = status.INTERNAL;
       break;
   }
 

lib/lndclient/LndClient.ts

@@ -320,6 +320,7 @@ class LndClient extends SwapClient {
         this.walletUnlocker = new WalletUnlockerClient(this.uri, this.credentials);
         await LndClient.waitForClientReady(this.walletUnlocker);
         await this.setStatus(ClientStatus.WaitingUnlock);
+        this.emit('locked');
 
         if (this.reconnectionTimer) {
           // we don't need scheduled attempts to retry the connection while waiting on the wallet
@@ -383,7 +384,7 @@ class LndClient extends SwapClient {
           }
         } else {
           await this.setStatus(ClientStatus.OutOfSync);
-          this.logger.warn(`lnd is out of sync with chain, retrying in ${LndClient.RECONNECT_TIMER} ms`);
+          this.logger.warn(`lnd is out of sync with chain, retrying in ${LndClient.RECONNECT_TIME_LIMIT} ms`);
         }
       } catch (err) {
         if (err.code === grpc.status.UNIMPLEMENTED) {
@@ -398,7 +399,7 @@ class LndClient extends SwapClient {
           }
         } else {
           const errStr = typeof(err) === 'string' ? err : JSON.stringify(err);
-          this.logger.error(`could not verify connection at ${this.uri}, error: ${errStr}, retrying in ${LndClient.RECONNECT_TIMER} ms`);
+          this.logger.error(`could not verify connection at ${this.uri}, error: ${errStr}, retrying in ${LndClient.RECONNECT_TIME_LIMIT} ms`);
           await this.disconnect();
         }
       }

lib/raidenclient/RaidenClient.ts

@@ -150,7 +150,7 @@ class RaidenClient extends SwapClient {
       await this.setStatus(ClientStatus.ConnectionVerified);
     } catch (err) {
       this.logger.error(
-        `could not verify connection to raiden at ${this.host}:${this.port}, retrying in ${RaidenClient.RECONNECT_TIMER} ms`,
+        `could not verify connection to raiden at ${this.host}:${this.port}, retrying in ${RaidenClient.RECONNECT_TIME_LIMIT} ms`,
         err,
       );
       await this.disconnect();

lib/service/InitService.ts

@@ -31,31 +31,29 @@ class InitService extends EventEmitter {
     }
 
     this.pendingCall = true;
+    // wait briefly for all lnd instances to be available
+    await this.swapClientManager.waitForLnd();
+
     const seed = await this.swapClientManager.genSeed();
     let initializedLndWallets: string[] | undefined;
     let initializedRaiden = false;
     let nodeKey: NodeKey;
 
-    if (seed) {
-      const seedBytes = typeof seed.encipheredSeed === 'string' ?
-        Buffer.from(seed.encipheredSeed, 'base64') :
-        Buffer.from(seed.encipheredSeed);
-      assert.equal(seedBytes.length, 33);
+    const seedBytes = typeof seed.encipheredSeed === 'string' ?
+      Buffer.from(seed.encipheredSeed, 'base64') :
+      Buffer.from(seed.encipheredSeed);
+    assert.equal(seedBytes.length, 33);
 
-      // the seed is 33 bytes, the first byte of which is the version
-      // so we use the remaining 32 bytes to generate our private key
-      // TODO: use seedutil tool to derive a child private key from deciphered seed key?
-      const privKey = Buffer.from(seedBytes.slice(1));
-      nodeKey = new NodeKey(privKey);
+    // the seed is 33 bytes, the first byte of which is the version
+    // so we use the remaining 32 bytes to generate our private key
+    // TODO: use seedutil tool to derive a child private key from deciphered seed key?
+    const privKey = Buffer.from(seedBytes.slice(1));
+    nodeKey = new NodeKey(privKey);
 
-      // use this seed to init any lnd wallets that are uninitialized
-      const initWalletResult = await this.swapClientManager.initWallets(password, seed.cipherSeedMnemonicList);
-      initializedLndWallets = initWalletResult.initializedLndWallets;
-      initializedRaiden = initWalletResult.initializedRaiden;
-    } else {
-      // we couldn't generate a seed externally, so we must create a nodekey from scratch
-      nodeKey = await NodeKey.generate();
-    }
+    // use this seed to init any lnd wallets that are uninitialized
+    const initWalletResult = await this.swapClientManager.initWallets(password, seed.cipherSeedMnemonicList);
+    initializedLndWallets = initWalletResult.initializedLndWallets;
+    initializedRaiden = initWalletResult.initializedRaiden;
 
     await nodeKey.toFile(this.nodeKeyPath, password);
     this.emit('nodekey', nodeKey);

lib/swaps/SwapClient.ts

@@ -49,10 +49,10 @@ abstract class SwapClient extends EventEmitter {
    */
   public abstract readonly finalLock: number;
   public abstract readonly type: SwapClientType;
+  /** Time in milliseconds between attempts to recheck connectivity to the client. */
+  public static readonly RECONNECT_TIME_LIMIT = 5000;
   protected status: ClientStatus = ClientStatus.NotInitialized;
   protected reconnectionTimer?: NodeJS.Timer;
-  /** Time in milliseconds between attempts to recheck connectivity to the client. */
-  protected static readonly RECONNECT_TIMER = 5000;
 
   private updateCapacityTimer?: NodeJS.Timer;
   /** The maximum amount of time we will wait for the connection to be verified during initialization. */
@@ -126,7 +126,7 @@ abstract class SwapClient extends EventEmitter {
               // if we were still not able to verify the connection, schedule another attempt
               this.reconnectionTimer.refresh();
             }
-          }, SwapClient.RECONNECT_TIMER);
+          }, SwapClient.RECONNECT_TIME_LIMIT);
         }
       }
     }

lib/swaps/SwapClientManager.ts

@@ -1,17 +1,18 @@
+import { EventEmitter } from 'events';
 import Config from '../Config';
-import SwapClient from './SwapClient';
+import { SwapClientType } from '../constants/enums';
+import { Models } from '../db/DB';
 import LndClient from '../lndclient/LndClient';
 import { LndInfo } from '../lndclient/types';
-import RaidenClient from '../raidenclient/RaidenClient';
 import { Loggers } from '../Logger';
 import { Currency } from '../orderbook/types';
-import { Models } from '../db/DB';
-import { SwapClientType } from '../constants/enums';
-import { EventEmitter } from 'events';
 import Peer from '../p2p/Peer';
-import { UnitConverter } from '../utils/UnitConverter';
+import RaidenClient from '../raidenclient/RaidenClient';
 import seedutil from '../utils/seedutil';
+import { UnitConverter } from '../utils/UnitConverter';
 import errors from './errors';
+import SwapClient, { ClientStatus } from './SwapClient';
+import lndErrors from '../lndclient/errors';
 
 export function isRaidenClient(swapClient: SwapClient): swapClient is RaidenClient {
   return (swapClient.type === SwapClientType.Raiden);
@@ -38,7 +39,7 @@ interface SwapClientManager {
 }
 
 class SwapClientManager extends EventEmitter {
-  /** A map between currencies and all swap clients */
+  /** A map between currencies and all enabled swap clients */
   public swapClients = new Map<string, SwapClient>();
   public raidenClient: RaidenClient;
   private walletPassword?: string;
@@ -105,24 +106,63 @@ class SwapClientManager extends EventEmitter {
     }
   }
 
+  /**
+   * Checks to make sure all enabled lnd instances are available and waits
+   * up to a short time for them to become available in case they are not.
+   * Throws an error if any lnd clients remain unreachable.
+   */
+  public waitForLnd = async () => {
+    const lndClients = this.getLndClientsMap().values();
+    const lndAvailablePromises: Promise<void>[] = [];
+    for (const lndClient of lndClients) {
+      lndAvailablePromises.push(new Promise<void>((resolve, reject) => {
+        if (lndClient.isDisconnected() || lndClient.isNotInitialized()) {
+          const onAvailable = () => {
+            clearTimeout(timer);
+            lndClient.removeListener('locked', onAvailable);
+            lndClient.removeListener('connectionVerified', onAvailable);
+            resolve();
+          };
+          lndClient.once('connectionVerified', onAvailable);
+          lndClient.once('locked', onAvailable);
+          const timer = setTimeout(() => {
+            lndClient.removeListener('connectionVerified', onAvailable);
+            lndClient.removeListener('locked', onAvailable);
+            reject(lndClient.currency);
+          }, SwapClient.RECONNECT_TIME_LIMIT);
+        } else {
+          resolve();
+        }
+      }));
+    }
+
+    try {
+      await Promise.all(lndAvailablePromises);
+    } catch (currency) {
+      throw lndErrors.UNAVAILABLE(currency, ClientStatus.Disconnected);
+    }
+  }
+
   /**
    * Generates a cryptographically random 24 word seed mnemonic from an lnd client.
    */
   public genSeed = async () => {
+    const lndClients = this.getLndClientsMap().values();
     // loop through swap clients until we find an lnd client awaiting unlock
-    for (const swapClient of this.swapClients.values()) {
-      if (isLndClient(swapClient) && swapClient.isWaitingUnlock()) {
+    for (const lndClient of lndClients) {
+      if (lndClient.isWaitingUnlock()) {
         try {
-          const seed = await swapClient.genSeed();
+          const seed = await lndClient.genSeed();
           return seed;
         } catch (err) {
-          swapClient.logger.error('could not generate seed', err);
+          lndClient.logger.error('could not generate seed', err);
         }
       }
     }
 
-    // TODO: use seedutil tool to generate a seed
-    return undefined;
+    // TODO: use seedutil tool to generate a seed instead of throwing error
+    // when we can't generate one with lnd
+    throw errors.SWAP_CLIENT_WALLET_NOT_CREATED('could not generate aezeed');
   }
 
   /**
@@ -131,18 +171,23 @@ class SwapClientManager extends EventEmitter {
   public initWallets = async (walletPassword: string, seedMnemonic: string[]) => {
     this.walletPassword = walletPassword;
 
-    // loop through swap clients to find locked lnd clients
+    // loop through swap clients to initialize locked lnd clients
+    const lndClients = this.getLndClientsMap().values();
     const initWalletPromises: Promise<any>[] = [];
     const initializedLndWallets: string[] = [];
     let initializedRaiden = false;
-    for (const swapClient of this.swapClients.values()) {
-      if (isLndClient(swapClient) && swapClient.isWaitingUnlock()) {
-        const initWalletPromise = swapClient.initWallet(walletPassword, seedMnemonic).then(() => {
-          initializedLndWallets.push(swapClient.currency);
-        }).catch((err) => {
-          swapClient.logger.debug(`could not initialize wallet: ${err.message}`);
-        });
-        initWalletPromises.push(initWalletPromise);
+
+    for (const lndClient of lndClients) {
+      if (isLndClient(lndClient)) {
+        if (lndClient.isWaitingUnlock()) {
+          const initWalletPromise = lndClient.initWallet(walletPassword, seedMnemonic).then(() => {
+            initializedLndWallets.push(lndClient.currency);
+          }).catch((err) => {
+            lndClient.logger.error(`could not initialize wallet: ${err.message}`);
+            throw errors.SWAP_CLIENT_WALLET_NOT_CREATED(`could not initialize lnd-${lndClient.currency}: ${err.message}`);
+          });
+          initWalletPromises.push(initWalletPromise);
+        }
       }
     }
 
@@ -154,8 +199,9 @@ class SwapClientManager extends EventEmitter {
       const keystorePromise = seedutil(seedMnemonic, '', keystorepath).then(() => {
         this.raidenClient.logger.info(`created raiden keystore with master seed and empty password in ${keystorepath}`);
         initializedRaiden = true;
-      }).catch(() => {
-        this.raidenClient.logger.warn('could not create keystore');
+      }).catch((err) => {
+        this.raidenClient.logger.error('could not create keystore');
+        throw errors.SWAP_CLIENT_WALLET_NOT_CREATED(`could not create keystore: ${err}`);
       });
       initWalletPromises.push(keystorePromise);
     }

lib/swaps/errors.ts

@@ -8,6 +8,7 @@ const errorCodes = {
   PAYMENT_ERROR: codesPrefix.concat('.4'),
   PAYMENT_REJECTED: codesPrefix.concat('.5'),
   INVALID_RESOLVE_REQUEST: codesPrefix.concat('.6'),
+  SWAP_CLIENT_WALLET_NOT_CREATED: codesPrefix.concat('.7'),
 };
 
 const errors = {
@@ -35,6 +36,10 @@ const errors = {
     message: `invalid resolve request for rHash ${rHash}: ${errorMessage}`,
     code: errorCodes.INVALID_RESOLVE_REQUEST,
   }),
+  SWAP_CLIENT_WALLET_NOT_CREATED: (message: string) => ({
+    message,
+    code: errorCodes.SWAP_CLIENT_WALLET_NOT_CREATED,
+  }),
 };
 
 export { errorCodes };