@dashevo/dapi-client 0.23.0 → 0.24.0-dev.10

package/lib/BlockHeadersProvider/BlockHeadersProvider.js

@@ -205,6 +205,10 @@ class BlockHeadersProvider extends EventEmitter {
   headersHandler(headersData, reject) {
     const { headers, headHeight } = headersData;
 
+    // TODO: simulate headers rejection and debug
+    // BlockHeadersReader might not correctly set startBlockHeight
+    // which results in orphan chunks in SPV
+
     try {
       const headersAdded = this.spvChain.addHeaders(headers, headHeight);
 

package/lib/BlockHeadersProvider/BlockHeadersReader.js

@@ -86,7 +86,7 @@ class BlockHeadersReader extends EventEmitter {
   stopReadingHistorical() {
     while (this.historicalStreams.length) {
       const stream = this.historicalStreams.shift();
-      stream.cancel();
+      this.cancelStream(stream);
     }
   }
 
@@ -105,11 +105,20 @@ class BlockHeadersReader extends EventEmitter {
       throw new Error(`Invalid fromBlockHeight: ${fromBlockHeight}`);
     }
 
+    // We don't know yet whether we already have header at fromBlockHeight
     let lastKnownChainHeight = fromBlockHeight - 1;
 
     const stream = await this.createContinuousSyncStream(fromBlockHeight);
 
-    stream.on('data', (data) => {
+    const errorHandler = (e) => {
+      this.continuousSyncStream = null;
+      if (e.code === GrpcErrorCodes.CANCELLED) {
+        return;
+      }
+      this.emit(EVENTS.ERROR, e);
+    };
+
+    const dataHandler = (data) => {
       const blockHeadersResponse = data.getBlockHeaders();
 
       if (blockHeadersResponse) {
@@ -125,35 +134,42 @@ class BlockHeadersReader extends EventEmitter {
          *
          * @param e
          */
-        const rejectHeaders = (e) => {
-          stream.destroy(e);
+        const rejectHeaders = async (e) => {
+          // Don't use cancelStream there because it's going to unsubscribe from events
+          stream.cancel();
+          stream.retryOnError(e);
         };
+
         this.emit(EVENTS.BLOCK_HEADERS, {
           headers,
           headHeight: batchHeadHeight,
         }, rejectHeaders);
       }
-    });
+    };
 
-    stream.on('beforeReconnect', (updateArguments) => {
+    const beforeReconnectHandler = (updateArguments) => {
       updateArguments({
         fromBlockHeight: lastKnownChainHeight,
+        count: 0,
       });
 
       lastKnownChainHeight -= 1;
-    });
+    };
 
-    stream.on('error', (e) => {
+    const endHandler = () => {
       this.continuousSyncStream = null;
-      if (e.code === GrpcErrorCodes.CANCELLED) {
-        return;
-      }
-      this.emit(EVENTS.ERROR, e);
-    });
+    };
 
-    stream.on('end', () => {
-      this.continuousSyncStream = null;
-    });
+    stream.on('data', dataHandler);
+    stream.on('beforeReconnect', beforeReconnectHandler);
+    stream.on('error', errorHandler);
+    stream.on('end', endHandler);
+
+    stream.removeAllListeners = () => {
+      stream.removeListener('data', dataHandler);
+      stream.removeListener('end', endHandler);
+      stream.removeListener('beforeReconnect', beforeReconnectHandler);
+    };
 
     this.continuousSyncStream = stream;
     return stream;
@@ -161,11 +177,13 @@ class BlockHeadersReader extends EventEmitter {
 
   unsubscribeFromNew() {
     if (this.continuousSyncStream) {
-      this.continuousSyncStream.cancel();
+      this.cancelStream(this.continuousSyncStream);
       this.continuousSyncStream = null;
     }
   }
 
+  // TODO: refactor whole thing with ReconnectableStream that supports
+  // retry on error logic
   /**
    * A HOF that returns a function to subscribe to historical block headers and chain locks
    * and handles retry logic
@@ -189,37 +207,6 @@ class BlockHeadersReader extends EventEmitter {
 
       const stream = await this.createHistoricalSyncStream(fromBlockHeight, count);
 
-      const dataHandler = (data) => {
-        const blockHeaders = data.getBlockHeaders();
-
-        if (blockHeaders) {
-          const headersList = blockHeaders.getHeadersList()
-            .map((header) => new BlockHeader(Buffer.from(header)));
-
-          let rejected = false;
-
-          /**
-           * Kills stream in case of deliberate rejection from the outside
-           *
-           * @param e
-           */
-          const rejectHeaders = (e) => {
-            rejected = true;
-            stream.destroy(e);
-          };
-
-          const batchHeadHeight = fromBlockHeight + headersObtained;
-          this.emit(EVENTS.BLOCK_HEADERS, {
-            headers: headersList,
-            headHeight: batchHeadHeight,
-          }, rejectHeaders);
-
-          if (!rejected) {
-            headersObtained += headersList.length;
-          }
-        }
-      };
-
       const errorHandler = (streamError) => {
         if (streamError.code === GrpcErrorCodes.CANCELLED) {
           // TODO: consider reworking with COMMANDS instead
@@ -251,6 +238,40 @@ class BlockHeadersReader extends EventEmitter {
         }
       };
 
+      const dataHandler = (data) => {
+        const blockHeaders = data.getBlockHeaders();
+
+        if (blockHeaders) {
+          const headersList = blockHeaders.getHeadersList()
+            .map((header) => new BlockHeader(Buffer.from(header)));
+
+          let rejected = false;
+
+          /**
+           * Kills stream in case of deliberate rejection from the outside
+           *
+           * @param e
+           */
+          const rejectHeaders = (e) => {
+            rejected = true;
+            // Cancel stream and unsubscribe from all data events
+            // because they are going th be re-created in errorHandler
+            this.cancelStream(stream);
+            errorHandler(e);
+          };
+
+          const batchHeadHeight = fromBlockHeight + headersObtained;
+          this.emit(EVENTS.BLOCK_HEADERS, {
+            headers: headersList,
+            headHeight: batchHeadHeight,
+          }, rejectHeaders);
+
+          if (!rejected) {
+            headersObtained += headersList.length;
+          }
+        }
+      };
+
       const endHandler = () => {
         const index = this.historicalStreams.indexOf(stream);
         this.historicalStreams.splice(index, 1);
@@ -267,11 +288,22 @@ class BlockHeadersReader extends EventEmitter {
       stream.on('error', errorHandler);
       stream.on('end', endHandler);
 
+      stream.removeAllListeners = () => {
+        stream.removeListener('data', dataHandler);
+        stream.removeListener('end', endHandler);
+      };
+
       return stream;
     };
 
     return subscribeWithRetries;
   }
+
+  // eslint-disable-next-line class-methods-use-this
+  cancelStream(stream) {
+    stream.removeAllListeners();
+    stream.cancel();
+  }
 }
 
 BlockHeadersReader.EVENTS = EVENTS;

package/lib/dapiAddressProvider/DAPIAddress.js

@@ -10,13 +10,15 @@ class DAPIAddress {
     }
 
     if (typeof address === 'string') {
-      const [host, httpPort, grpcPort] = address.split(':');
+      const [host, httpPort, grpcPort, ssl] = address.split(':');
 
       // eslint-disable-next-line no-param-reassign
       address = {
         host,
         httpPort: httpPort ? parseInt(httpPort, 10) : DAPIAddress.DEFAULT_HTTP_PORT,
         grpcPort: grpcPort ? parseInt(grpcPort, 10) : DAPIAddress.DEFAULT_GRPC_PORT,
+        protocol: ssl === 'no-ssl' ? 'http' : DAPIAddress.DEFAULT_PROTOCOL,
+        allowSelfSignedCertificate: ssl === 'self-signed',
       };
     }
 
@@ -24,15 +26,26 @@ class DAPIAddress {
       throw new DAPIAddressHostMissingError();
     }
 
+    this.protocol = address.protocol || DAPIAddress.DEFAULT_PROTOCOL;
     this.host = address.host;
     this.httpPort = address.httpPort || DAPIAddress.DEFAULT_HTTP_PORT;
     this.grpcPort = address.grpcPort || DAPIAddress.DEFAULT_GRPC_PORT;
     this.proRegTxHash = address.proRegTxHash;
+    this.allowSelfSignedCertificate = address.allowSelfSignedCertificate || false;
 
     this.banCount = 0;
     this.banStartTime = undefined;
   }
 
+  /**
+   * Get protocol
+   *
+   * @returns {string}
+   */
+  getProtocol() {
+    return this.protocol;
+  }
+
   /**
    * Get host
    *
@@ -150,6 +163,13 @@ class DAPIAddress {
     return this.banCount > 0;
   }
 
+  /**
+   * @returns {boolean}
+   */
+  isSelfSignedCertificateAllowed() {
+    return this.allowSelfSignedCertificate;
+  }
+
   /**
    * Return DAPIAddress as plain object
    *
@@ -157,27 +177,32 @@ class DAPIAddress {
    */
   toJSON() {
     return {
+      protocol: this.getProtocol(),
       host: this.getHost(),
       httpPort: this.getHttpPort(),
       grpcPort: this.getGrpcPort(),
       proRegTxHash: this.getProRegTxHash(),
+      allowSelfSignedCertificate: this.isSelfSignedCertificateAllowed(),
     };
   }
 
   toString() {
-    return `${this.getHost()}:${this.getHttpPort()}:${this.getGrpcPort()}`;
+    return `${this.getProtocol()}://${this.getHost()}:${this.getHttpPort()}:${this.getGrpcPort()}`;
   }
 }
 
 DAPIAddress.DEFAULT_HTTP_PORT = 3000;
 DAPIAddress.DEFAULT_GRPC_PORT = 3010;
+DAPIAddress.DEFAULT_PROTOCOL = 'http';
 
 /**
  * @typedef {object} RawDAPIAddress
+ * @property {string} protocol
  * @property {string} host
  * @property {number} [httpPort=3000]
  * @property {number} [grpcPort=3010]
  * @property {string} [proRegTxHash]
+ * @property {bool} [selfSigned]
  */
 
 module.exports = DAPIAddress;

package/lib/dapiAddressProvider/ListDAPIAddressProvider.js

@@ -1,4 +1,4 @@
-const sample = require('lodash.sample');
+const sample = require('lodash/sample');
 const networks = require('@dashevo/dashcore-lib/lib/networks');
 
 class ListDAPIAddressProvider {
@@ -36,7 +36,9 @@ class ListDAPIAddressProvider {
     if (network && network.regtestEnabled) {
       const randomNodeIndex = Math.floor(Math.random() * liveAddresses.length);
 
+      liveAddress.protocol = 'https';
       liveAddress.host = '127.0.0.1';
+      liveAddress.allowSelfSignedCertificate = true;
       liveAddress.httpPort = 3000 + randomNodeIndex * 100;
       liveAddress.grpcPort = 3010 + randomNodeIndex * 100;
     }

package/lib/methods/platform/response/Metadata.js

@@ -1,12 +1,16 @@
 class Metadata {
   /**
-   * @param {object} properties
+   * @param {Object} properties
    * @param {number} properties.height - block height
    * @param {number} properties.coreChainLockedHeight - core chain locked height
+   * @param {number} properties.timeMs - block time
+   * @param {number} properties.protocolVersion - protocol version
    */
   constructor(properties) {
     this.height = properties.height;
     this.coreChainLockedHeight = properties.coreChainLockedHeight;
+    this.timeMs = properties.timeMs;
+    this.protocolVersion = properties.protocolVersion;
   }
 
   /**
@@ -26,6 +30,22 @@ class Metadata {
   getCoreChainLockedHeight() {
     return this.coreChainLockedHeight;
   }
+
+  /**
+   * Get block time
+   * @return {number}
+   */
+  getTimeMs() {
+    return this.timeMs;
+  }
+
+  /**
+   * Get protocol version
+   * @return {number}
+   */
+  getProtocolVersion() {
+    return this.protocolVersion;
+  }
 }
 
 module.exports = Metadata;

package/lib/methods/platform/response/Proof.js

@@ -2,13 +2,15 @@ class Proof {
   /**
    * @param {object} properties
    * @param {Buffer} properties.merkleProof
-   * @param {Buffer} properties.signatureLLMQHash
+   * @param {Buffer} properties.quorumHash
    * @param {Buffer} properties.signature
+   * @param {number} properties.round
    */
   constructor(properties) {
     this.merkleProof = properties.merkleProof;
-    this.signatureLLMQHash = properties.signatureLLMQHash;
+    this.quorumHash = properties.quorumHash;
     this.signature = properties.signature;
+    this.round = properties.round;
   }
 
   /**
@@ -21,8 +23,8 @@ class Proof {
   /**
    * @returns {Buffer}
    */
-  getSignatureLLMQHash() {
-    return this.signatureLLMQHash;
+  getQuorumHash() {
+    return this.quorumHash;
   }
 
   /**
@@ -32,6 +34,14 @@ class Proof {
     return this.signature;
   }
 
+  /**
+   *
+   * @returns {number}
+   */
+  getRound() {
+    return this.round;
+  }
+
   /**
    * @param {Object} proofProto
    *
@@ -40,8 +50,9 @@ class Proof {
   static createFromProto(proofProto) {
     return new Proof({
       merkleProof: Buffer.from(proofProto.getMerkleProof()),
-      signatureLLMQHash: Buffer.from(proofProto.getSignatureLlmqHash()),
+      quorumHash: Buffer.from(proofProto.getQuorumHash()),
       signature: Buffer.from(proofProto.getSignature()),
+      round: proofProto.getRound(),
     });
   }
 }

package/lib/test/fixtures/getMetadataFixture.js

@@ -1,10 +1,18 @@
 /**
- * @returns {{coreChainLockedHeight: number, height: number}}
+ * @returns {{
+ * coreChainLockedHeight: number,
+ * height: number,
+ * signature: Buffer,
+ * protocolVersion: number,
+ * timeMs: number,
+ * }}
  */
 function getMetadataFixture() {
   return {
     height: 10,
     coreChainLockedHeight: 42,
+    timeMs: new Date().getTime(),
+    protocolVersion: 1,
   };
 }
 

package/lib/test/fixtures/getProofFixture.js

@@ -2,14 +2,15 @@
  * @returns {{
  *   merkleProof: Buffer,
  *   signature: Buffer,
- *   signatureLLMQHash: Buffer
+ *   quorumHash: Buffer
  * }}
  */
 function getProofFixture() {
   return {
-    signatureLLMQHash: Buffer.from('AQEBAQEBAQEBAQEB', 'base64'),
+    quorumHash: Buffer.from('AQEBAQEBAQEBAQEB', 'base64'),
     signature: Buffer.from('AgICAgICAgICAgIC', 'base64'),
     merkleProof: Buffer.from('0100000001f0faf5f55674905a68eba1be2f946e667c1cb5010101', 'hex'),
+    round: 42,
   };
 }
 

package/lib/test/mocks/BlockHeadersWithChainLocksStreamMock.js

@@ -7,20 +7,12 @@ class BlockHeadersWithChainLocksStreamMock extends EventEmitter {
     sinon.spy(this, 'on');
     sinon.spy(this, 'removeListener');
     sinon.spy(this, 'emit');
-    sinon.spy(this, 'destroy');
     sinon.spy(this, 'removeAllListeners');
     sinon.spy(this, 'cancel');
 
     this.errored = false;
   }
 
-  destroy(e) {
-    this.emit('end');
-    if (e) {
-      this.emit('error', e);
-    }
-  }
-
   cancel() {
     if (!this.errored) {
       const err = new Error('CANCELED_ON_CLIENT');
@@ -48,6 +40,15 @@ class BlockHeadersWithChainLocksStreamMock extends EventEmitter {
       }),
     });
   }
+
+  errorHandler(e) {
+    this.emit('error', e);
+  }
+
+  end() {
+    this.emit('end');
+    this.removeAllListeners();
+  }
 }
 
 module.exports = BlockHeadersWithChainLocksStreamMock;

package/lib/transport/GrpcTransport/GrpcTransport.js

@@ -132,6 +132,7 @@ class GrpcTransport {
    * @returns {string}
    */
   makeGrpcUrlFromAddress(address) {
+    let protocol = address.getProtocol();
     let port = address.getHttpPort();
 
     // For NodeJS Client
@@ -139,9 +140,11 @@ class GrpcTransport {
       && process.versions != null
       && process.versions.node != null) {
       port = address.getGrpcPort();
-    }
 
-    const protocol = address.getHttpPort() === 443 ? 'https' : 'http';
+      if (address.isSelfSignedCertificateAllowed()) {
+        protocol = 'http';
+      }
+    }
 
     return `${protocol}://${address.getHost()}:${port}`;
   }

package/lib/transport/GrpcTransport/createGrpcTransportError.js

@@ -2,7 +2,7 @@ const cbor = require('cbor');
 
 const createConsensusError = require('@dashevo/dpp/lib/errors/consensus/createConsensusError');
 const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
-const { Metadata } = require('@grpc/grpc-js/build/src/metadata');
+const { parseMetadata } = require('@dashevo/dapi-grpc');
 
 const NotFoundError = require('./errors/NotFoundError');
 const TimeoutError = require('./errors/TimeoutError');
@@ -50,15 +50,7 @@ function createGrpcTransportError(grpcError, dapiAddress) {
 
   const message = grpcError.details || grpcError.message;
 
-  let metadata = {};
-
-  if (grpcError.metadata) {
-    // In cases of gRPC-Web client we get plain map instead of Metadata instance
-    metadata = grpcError.metadata;
-    if (grpcError.metadata instanceof Metadata) {
-      metadata = grpcError.metadata.getMap();
-    }
-  }
+  const metadata = parseMetadata(grpcError.metadata) || {};
 
   // Error data
   const driveErrorData = metadata['drive-error-data-bin'];

package/lib/transport/JsonRpcTransport/JsonRpcTransport.js

@@ -65,8 +65,10 @@ class JsonRpcTransport {
 
     try {
       const result = await this.requestJsonRpc(
+        address.getProtocol(),
         address.getHost(),
         address.getHttpPort(),
+        address.isSelfSignedCertificateAllowed(),
         method,
         params,
         requestOptions,

package/lib/transport/JsonRpcTransport/requestJsonRpc.js

@@ -1,20 +1,21 @@
 const axios = require('axios');
+const https = require('https');
 
 const JsonRpcError = require('./errors/JsonRpcError');
 const WrongHttpCodeError = require('./errors/WrongHttpCodeError');
 
 /**
  * @typedef {requestJsonRpc}
+ * @param {string} protocol
  * @param {string} host
  * @param {number} port
+ * @param {boolean} selfSigned
  * @param {string} method
  * @param {object} params
  * @param {object} [options]
  * @returns {Promise<*>}
  */
-async function requestJsonRpc(host, port, method, params, options = {}) {
-  const protocol = port === 443 ? 'https' : 'http';
-
+async function requestJsonRpc(protocol, host, port, selfSigned, method, params, options = {}) {
   const url = `${protocol}://${host}${port && port !== 443 ? `:${port}` : ''}`;
 
   const payload = {
@@ -30,8 +31,10 @@ async function requestJsonRpc(host, port, method, params, options = {}) {
   }
 
   const requestInfo = {
+    protocol,
     host,
     port,
+    selfSigned,
     method,
     params,
     options,
@@ -39,11 +42,23 @@ async function requestJsonRpc(host, port, method, params, options = {}) {
 
   let response;
 
+  const config = { timeout: options.timeout };
+  // For NodeJS Client
+  if (typeof process !== 'undefined'
+    && process.versions != null
+    && process.versions.node != null
+    && protocol === 'https'
+    && selfSigned) {
+    config.httpsAgent = new https.Agent({
+      rejectUnauthorized: false,
+    });
+  }
+
   try {
     response = await axios.post(
       url,
       payload,
-      { timeout: options.timeout },
+      config,
     );
   } catch (error) {
     if (error.response && error.response.status >= 500) {

package/lib/transport/ReconnectableStream.js

@@ -2,9 +2,18 @@ const EventEmitter = require('events');
 const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
 const wait = require('../utils/wait');
 
+/**
+ * @typedef ReconnectableStreamOptions
+ * @property {number} [autoReconnectInterval]
+ *    interval in MS to perform auto reconnect
+ * @property {number} [maxRetriesOnError]
+ *    maximum amount of retry attempts on error happens. If set to -1, retries are infinite
+ * @property {number} [retryOnErrorDelay]
+ *    delay in MS to perform retry after an error
+ */
 const defaultOptions = {
   // TODO: manage timeout according to the Nginx setting of the node
-  reconnectTimeoutDelay: 50000,
+  autoReconnectInterval: 50000,
   maxRetriesOnError: 10,
   retryOnErrorDelay: 1000,
 };
@@ -17,69 +26,121 @@ const EVENTS = {
 };
 
 /**
- * Stream that provides auto-reconnect functionality
+ * A wrapper around grpc-js/grpc-web streams that provides auto-reconnect
+ * and retry on error functionality
+ * - Auto reconnect is needed to not hang on one node for too long.
+ *   It happens within provided interval
+ * - Retry on error logic performs retry attempts until it reaches it's limit.
+ *   After reaching limit, ReconnectableStream emits an error.
  */
 class ReconnectableStream extends EventEmitter {
-  static create(fn, options) {
+  /**
+   * Helper that wraps stream creation function and performs auto connection
+   *
+   * @param {Function} createStreamFunction - function returning grpc-js/grpc-web stream
+   * @param {ReconnectableStreamOptions} options
+   * @returns {function(...[*]): Promise<ReconnectableStream>}
+   */
+  static create(createStreamFunction, options) {
     return async (...args) => {
-      const reconnectableStream = new ReconnectableStream(fn, options);
+      const reconnectableStream = new ReconnectableStream(createStreamFunction, options);
       await reconnectableStream.connect(...args);
       return reconnectableStream;
     };
   }
 
-  constructor(streamFunction, options = {}) {
+  /**
+   * @param {Function} createStream - function returning grpc-js/grpc-web stream
+   * @param {ReconnectableStreamOptions} options
+   */
+  constructor(createStream, options = {}) {
     super();
-    this.stream = null;
-    this.streamFunction = streamFunction;
-    this.reconnectTimeout = null;
 
     const opts = { ...defaultOptions, ...options };
-    this.reconnectTimeoutDelay = opts.reconnectTimeoutDelay;
-    this.maxRetriesOnError = opts.maxRetriesOnError;
+
+    /**
+     * Auto-reconnect interval in millisecond
+     * It is needed to automatically reconnect to another DAPI node
+     *
+     * @type {number}
+     */
+    this.autoReconnectInterval = opts.autoReconnectInterval;
     this.retryOnErrorDelay = opts.retryOnErrorDelay;
-    // Assign setTimeout and clearTimeout as class method for tests
-    this.setTimeout = (callback, delay) => setTimeout(callback, delay);
 
-    this.clearTimeout = (reference) => clearTimeout(reference);
+    /**
+     * Max amount of retries on error
+     */
+    this.maxRetriesOnError = opts.maxRetriesOnError;
 
     /**
-     * Stream function arguments
+     * Current amount of retries on error
+     * (Does not have effect if maxRetriesOnError === -1)
+     */
+    this.retriesOnError = 0;
+
+    /**
+     * createStream arguments
      */
     this.args = null;
+    /**
+     * grpc stream
+     */
+    this.stream = null;
+
+    /**
+     * Function to wrap around to handle interval reconnects and error retries
+     */
+    this.createStream = createStream;
+
+    /**
+     * Reference to setTimeout managed by autoReconnectInterval
+     */
+    this.reconnectTimeout = null;
+
+    // For mocks
+    this.setTimeout = (callback, delay) => setTimeout(callback, delay);
+    this.clearTimeout = (reference) => clearTimeout(reference);
 
     this.connect = this.connect.bind(this);
     this.reconnect = this.reconnect.bind(this);
     this.cancel = this.cancel.bind(this);
-    this.destroy = this.destroy.bind(this);
     this.errorHandler = this.errorHandler.bind(this);
     this.dataHandler = this.dataHandler.bind(this);
     this.endHandler = this.endHandler.bind(this);
     this.addListeners = this.addListeners.bind(this);
-
-    // Manages retry attempts when error happens
-    this.retriesOnError = 0;
   }
 
   async connect(...args) {
+    // Memorize current stream args (which can be altered by beforeReconnect logic)
     this.args = args;
-    this.stream = await this.streamFunction(...this.args);
+
+    // Create grpc stream
+    this.stream = await this.createStream(...this.args);
+
+    // Add event listeners
     this.addListeners();
 
-    if (this.reconnectTimeoutDelay > 0) {
-      this.reconnectTimeout = this.setTimeout(
-        this.reconnect,
-        this.reconnectTimeoutDelay,
-      );
+    if (this.autoReconnectInterval > 0) {
+      this.startAutoReconnect();
     }
   }
 
+  startAutoReconnect() {
+    if (this.reconnectTimeout) {
+      throw new Error('Auto reconnect timeout is already running.');
+    }
+    this.reconnectTimeout = this.setTimeout(
+      this.reconnect,
+      this.autoReconnectInterval,
+    );
+  }
+
   reconnect() {
     if (this.reconnectTimeout) {
       this.reconnectTimeout = null;
       this.stream.cancel();
 
-      let newArgs = this.args;
+      let newArgs = this.args || [];
       const updateArgs = (...args) => {
         newArgs = args;
       };
@@ -91,6 +152,10 @@ class ReconnectableStream extends EventEmitter {
   }
 
   /**
+   * Function that adds EventEmitter style listeners
+   * to the stream and also rewires stream cancel function
+   * in order to automatically unsubscribe from events
+   *
    * @private
    */
   addListeners() {
@@ -100,6 +165,10 @@ class ReconnectableStream extends EventEmitter {
 
     const { cancel } = this.stream;
 
+    // Rewire cancel function in order to
+    // unsubscribe from DATA and END events.
+    // We don't unsubscribe from ERROR event because it
+    // handles `CANCELLED_ON_CLIENT` error after calling .cancel() and must stay
     this.stream.cancel = () => {
       this.stream.removeListener(EVENTS.DATA, this.dataHandler);
       this.stream.removeListener(EVENTS.END, this.endHandler);
@@ -107,72 +176,107 @@ class ReconnectableStream extends EventEmitter {
     };
   }
 
+  /**
+   * stream.on('data') handler
+   *
+   * @param data
+   */
   dataHandler(data) {
     this.emit(EVENTS.DATA, data);
   }
 
   /**
+   * stream.on('end') handler
+   *
    * @private
    */
   endHandler() {
-    this.stopReconnectTimeout();
+    this.stopAutoReconnect();
     this.stream = null;
     this.emit(EVENTS.END);
   }
 
   /**
+   * stream.on('error') handler
+   *
    * @private
    * @param e
    */
   errorHandler(e) {
-    this.stream.removeListener(EVENTS.ERROR, this.errorHandler);
+    // In case of cancellation nothing has to happen.
+    // TODO: do we need to propagate GrpcErrorCodes.CANCELLED further?
     if (e.code === GrpcErrorCodes.CANCELLED) {
       return;
     }
-    this.stopReconnectTimeout();
 
-    if (
-      this.maxRetriesOnError === -1 // Infinite retries
-      || this.retriesOnError < this.maxRetriesOnError // Limited retries
-    ) {
-      let newArgs = this.args;
-      const updateArgs = (...args) => {
+    // Retry stream
+    this.retryOnError(e);
+  }
+
+  /**
+   * Manages retry logic
+   *
+   * @param e
+   */
+  retryOnError(e) {
+    // Stop reconnect timeout if there is one
+    this.stopAutoReconnect();
+
+    // Unsubscribe from events in case of the external call
+    this.stream.removeListener(EVENTS.END, this.endHandler);
+    this.stream.removeListener(EVENTS.DATA, this.dataHandler);
+
+    const canRetry = this.maxRetriesOnError === -1 // Infinite retries
+      || this.retriesOnError < this.maxRetriesOnError; // Or less than max limit
+
+    if (canRetry) {
+      // Handle 'beforeReconnect` logic
+      let newArgs = this.args || [];
+      const updateArgsBeforeReconnect = (...args) => {
         newArgs = args;
       };
 
-      this.emit(EVENTS.BEFORE_RECONNECT, updateArgs);
+      // Emit beforeReconnect event in case parent would want to alter arguments
+      this.emit(EVENTS.BEFORE_RECONNECT, updateArgsBeforeReconnect);
 
+      // Wait before reconnecting
       wait(this.retryOnErrorDelay)
-        .then(() => this.connect(...newArgs))
+        .then(() => this.connect(...newArgs))// Reconnect with new args
         .then(() => {
-          this.retriesOnError += 1;
+          this.retriesOnError += 1; // Increase amount of current retries
         })
         .catch((connectError) => {
-          this.emit(EVENTS.ERROR, connectError);
+          this.emit(EVENTS.ERROR, connectError); // Or emit error in case retry has failed
         });
     } else {
+      // Or simply emit error in case retry attempts were exhausted
       this.emit(EVENTS.ERROR, e);
     }
   }
 
   /**
+   * Stops auto reconnect timeout
+   *
    * @private
    */
-  stopReconnectTimeout() {
+  stopAutoReconnect() {
     if (this.reconnectTimeout) {
       this.clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
     }
   }
 
+  /**
+   * Cancels stream.
+   * Returns `stream.cancel()` to handle it from parent if needed.
+   * (grpc-js cancel() is asynchronous and grpc-web is synchronous)
+   *
+   * @returns {*}
+   */
   cancel() {
-    this.stopReconnectTimeout();
+    this.stopAutoReconnect();
     return this.stream.cancel();
   }
-
-  destroy(e) {
-    this.stream.destroy(e);
-  }
 }
 
 ReconnectableStream.EVENTS = EVENTS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "0.23.0",
+  "version": "0.24.0-dev.10",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/index.js",
   "contributors": [
@@ -26,16 +26,15 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "0.23.0",
-    "@dashevo/dash-spv": "0.23.0",
+    "@dashevo/dapi-grpc": "0.24.0-dev.10",
+    "@dashevo/dash-spv": "0.24.0-dev.10",
     "@dashevo/dashcore-lib": "~0.19.44",
-    "@dashevo/dpp": "0.23.0",
-    "@dashevo/grpc-common": "0.23.0",
-    "@grpc/grpc-js": "^1.3.7",
+    "@dashevo/dpp": "0.24.0-dev.10",
+    "@dashevo/grpc-common": "0.24.0-dev.10",
     "axios": "^0.27.2",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
-    "lodash.sample": "^4.2.1",
+    "lodash": "^4.17.21",
     "node-inspect-extracted": "^1.0.8",
     "wasm-x11-hash": "~0.0.2"
   },
@@ -55,6 +54,7 @@
     "eslint-plugin-import": "^2.24.2",
     "eslint-plugin-jsdoc": "^27.0.0",
     "events": "^3.3.0",
+    "google-protobuf": "^3.12.2",
     "karma": "^6.4.1",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",