@dashevo/dapi-client 0.21.8 → 0.22.0-dev.12

package/README.md

@@ -12,7 +12,7 @@ Platform via the decentralized API ([DAPI](https://github.com/dashevo/dapi))
 hosted on Dash masternodes.
 
  - `DAPI-Client` provides automatic server (masternode) discovery using either a default seed node or a user-supplied one
- - `DAPI-Client` maps to DAPI's [RPC](https://github.com/dashevo/dapi/tree/master/lib/rpcServer/commands) and [gRPC](https://github.com/dashevo/dapi/tree/master/lib/grpcServer/handlers) endpoints
+ - `DAPI-Client` maps to DAPI's [RPC](https://github.com/dashevo/platform/tree/master/packages/dapi/lib/rpcServer/commands) and [gRPC](https://github.com/dashevo/platform/tree/master/packages/dapi/lib/grpcServer/handlers) endpoints
 
 ## Table of Contents
 - [Install](#install)
@@ -101,12 +101,12 @@ client.core.getBestBlockHash(options).then((r) => {
 
 ## Documentation
 
-More extensive documentation available at https://dashevo.github.io/js-dapi-client/.
+More extensive documentation available at https://dashevo.github.io/platform/DAPI-Client/.
 
 
 ## Contributing
 
-Feel free to dive in! [Open an issue](https://github.com/dashevo/js-dapi-client/issues/new/choose) or submit PRs.
+Feel free to dive in! [Open an issue](https://github.com/dashevo/platform/issues/new/choose) or submit PRs.
 
 ## License
 

package/docs/_sidebar.md

@@ -1,18 +1,24 @@
 - Getting started
     - [Quick start](getting-started/quickstart.md)
 - Usage
-    - Application
-        - [`.applyStateTransition()`](usage/application/applyStateTransition.md)
-        - [`.getDataContract()`](usage/application/getDataContract.md)
-        - [`.getDocuments()`](usage/application/getDocuments.md)
-        - [`.getIdentity()`](usage/application/getIdentity.md)
-        - [`.getIdentityByFirstPublicKey()`](usage/application/getIdentityByFirstPublicKey.md)
-        - [`.getIdentityIdByFirstPublicKey()`](usage/application/getIdentityIdByFirstPublicKey.md)
-    - Payment
-        - [`.getBestBlockHash()`](usage/payment/getBestBlockHash.md)
-        - [`.getBlockHash()`](usage/payment/getBlockHash.md)
-        - [`.getUTXO()`](usage/payment/getUTXO.md)
-   - Utilities
-        - [`.getMnListDiff()`](usage/utils/getMnListDiff.md)
-        - [`.subscribeToTransactionsWithProofs()`](usage/utils/subscribeToTransactionsWithProofs.md)
+    - DAPIClient
+        - [new DAPIClient()](usage/application/DAPIClient.md)
+            - Core
+                - [.broadcastTransaction()](usage/application/core/broadcastTransaction.md)
+                - [.generateToAddress()](usage/application/core/generateToAddress.md)
+                - [.getBestBlockHash()](usage/application/core/getBestBlockHash.md)
+                - [.getBlockByHash()](usage/application/core/getBlockByHash.md)
+                - [.getBlockByHeight()](usage/application/core/getBlockByHeight.md)
+                - [.getBlockHash()](usage/application/core/getBlockHash.md)
+                - [.getMnListDiff()](usage/application/core/getMnListDiff.md)
+                - [.getStatus()](usage/application/core/getStatus.md)
+                - [.getTransaction()](usage/application/core/getTransaction.md)
+                - [.subscribeToTransactionsWithProofs()](usage/application/core/subscribeToTransactionsWithProofs.md)
+            - Platform 
+                - [.broadcastStateTransition()](usage/application/platform/broadcastStateTransition.md)
+                - [.getDataContract()](usage/application/platform/getDataContract.md)
+                - [.getDocuments()](usage/application/platform/getDocuments.md)
+                - [.getIdentityByFirstPublicKey()](usage/application/platform/getIdentityByFirstPublicKey.md)
+                - [.getIdentity()](usage/application/platform/getIdentity.md)
+                - [.getIdentityIdByFirstPublicKey()](usage/application/platform/getIdentityIdByFirstPublicKey.md)
 - [License](https://github.com/dashevo/dapi-client/blob/master/LICENSE)

package/docs/getting-started/quickstart.md

@@ -1,6 +1,6 @@
 # Quick start
 
-### ES5/ES6 via NPM
+## ES5/ES6 via NPM
 
 In order to use this library in Node, you will need to add it to your project as a dependency.
 
@@ -10,7 +10,7 @@ Having [NodeJS](https://nodejs.org/) installed, just type in your terminal :
 npm install @dashevo/dapi-client
 ```
 
-### CDN Standalone
+## CDN Standalone
 
 For browser usage, you can also directly rely on unpkg :
 
@@ -18,6 +18,8 @@ For browser usage, you can also directly rely on unpkg :
 <script src="https://unpkg.com/@dashevo/dapi-client"></script>
 ```
 
+You can see an [example usage here](https://github.com/dashevo/js-dapi-client/blob/master/examples/web/web.usage.html) 
+
 ## Initialization
 
 ```js

package/docs/usage/application/DAPIClient.md

@@ -0,0 +1,29 @@
+**Usage**: `new DAPIClient(options)`  
+**Description**: This method creates a new DAPIClient instance.
+
+Parameters:
+
+| parameters                                | type                | required[def value]         | Description                                                                                                                                                                    |
+|-------------------------------------------|---------------------|-----------------------------| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **options**                               | Object              |  |   |
+| **options.dapiAddressProvider**           | DAPIAddressProvider | no[ListDAPIAddressProvider] | Allow to override the default dapiAddressProvider (do not allow seeds or dapiAddresses params)  |
+| **options.seeds**                         | string[]            | no[seeds]                   | Allow to override default seeds (to connect to specific node) |
+| **options.network**                       | string|Network      | no[=evonet]                 | Allow to setup the network to be used (livenet, testnet, evonet,..) |
+| **options.timeout**                       | number              | no[=2000]                   | Used to specify the timeout time in milliseconds. |
+| **options.retries**                       | number              | no[=3]                      | Used to specify the number of retries before aborting and erroring a request. |
+| **options.baseBanTime**                   | number              | no[=6000]                   |  |
+
+Returns : DAPIClient instance.
+
+```js
+const DAPIClient = require('@dashevo/dapi-client');
+const client = new DAPIClient({
+  timeout: 5000,
+  retries: 3,
+  network: 'livenet'
+});
+```
+
+**Notes**: 
+- Accessing the SimplifiedMasternodeListDAPIAddressProvider (or its overwrote instance), can be accessed via `client.dapiAddressProvider`.  
+ 

package/docs/usage/application/core/broadcastTransaction.md

@@ -0,0 +1,15 @@
+**Usage**: `await client.core.broadcastTransaction(transaction)`  
+**Description**: Allow to broadcast a valid **signed** transaction to the network.
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **transaction**           | Buffer              | yes            | A valid Buffer representation of a transaction                                                   |
+| **options**               | Object              |                |                                                  |
+| **options.allowHighFees** | Boolean             | no[=false]     | As safety measure, "absurd" fees are rejected when considered to high. This allow to overwrite that comportement |
+| **options.bypassLimits**  | Boolean             | no[=false]     | Allow to bypass default transaction policy rules limitation |
+
+Returns : transactionId (string).
+
+N.B : The TransactionID provided is subject to [transaction malleability](https://dashcore.readme.io/docs/core-guide-transactions-transaction-malleability), and is not a source of truth (the transaction might be included in a block with a different txid).

package/docs/usage/application/core/generateToAddress.md

@@ -0,0 +1,13 @@
+**Usage**: `await client.core.generateToAddress(blockMumber, address, options)`  
+**Description**: Allow to broadcast a valid **signed** transaction to the network.
+**Notes**: Will only works on regtest.
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **blocksNumber**          | Number              | yes            | A number of block to see generated on the regtest network                                        |
+| **address**               | String              | yes            | The address that will receive the newly generated Dash                                           |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<string[]>} - a set of generated blockhashes.

package/docs/usage/application/core/getBestBlockHash.md

@@ -0,0 +1,10 @@
+**Usage**: `await client.core.getBestBlockHash(options)`  
+**Description**: Allow to fetch the best (highest/latest block hash) from the network
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<string>} - The best block hash

package/docs/usage/application/core/getBlockByHash.md

@@ -0,0 +1,11 @@
+**Usage**: `await client.core.getBlockByHash(hash, options)`  
+**Description**: Allow to fetch a specific block by its hash
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **hash**                  | String              | yes            | A valid block hash |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<null|Buffer>} - The specified bufferized block

package/docs/usage/application/core/getBlockByHeight.md

@@ -0,0 +1,11 @@
+**Usage**: `await client.core.getBlockByHeight(height, options)`  
+**Description**: Allow to fetch a specific block by its height
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **height**                | Number              | yes            | A valid block height |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<null|Buffer>} - The specified bufferized block

package/docs/usage/application/core/getBlockHash.md

@@ -0,0 +1,11 @@
+**Usage**: `await client.core.getBlockHash(height, options)`  
+**Description**: Allow to fetch a specific block hash from  its height
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **height**                | Number              | yes            | A valid block height |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<null|string>} - the corresponding block hash

package/docs/usage/application/core/getMnListDiff.md

@@ -0,0 +1,12 @@
+**Usage**: `await client.core.getMnListDiff(baseBlockHash, blockHash, options)`  
+**Description**: Allow to fetch a specific block hash from  its height
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **baseBlockHash**         | String              | yes            |  hash or height of start block |
+| **blockHash**             | String              | yes            |  hash or height of end block |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<object>} - The Masternode List Diff of the specified period

package/docs/usage/application/core/getStatus.md

@@ -0,0 +1,29 @@
+**Usage**: `await client.core.getStatus(options)`  
+**Description**: Allow to fetch a specific block hash from  its height
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<object>} - Status object
+
+```js
+const status = await client.core.getStatus()
+/**
+{
+  coreVersion: 150000,
+  protocolVersion: 70216,
+  blocks: 10630,
+  timeOffset: 0,
+  connections: 58,
+  proxy: '',
+  difficulty: 0.001745769130443678,
+  testnet: false,
+  relayFee: 0.00001,
+  errors: '',
+  network: 'testnet'
+}
+**/
+```

package/docs/usage/application/core/getTransaction.md

@@ -0,0 +1,11 @@
+**Usage**: `await client.core.getTransaction(id, options)`  
+**Description**: Allow to fetch a transaction by ID
+
+Parameters:
+
+| parameters                | type                | required       | Description                                                                                      |
+|---------------------------|---------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **id**                    | string              | yes            | A valid transaction id to fetch  |
+| **options**               | DAPIClientOptions   | no             |  |
+
+Returns : {Promise<null|Buffer>} - The bufferized transaction

package/docs/usage/application/platform/broadcastStateTransition.md

@@ -0,0 +1,11 @@
+**Usage**: `async client.platform.broadcastStateTransition(stateTransition, options)`
+**Description**: Send State Transition to machine
+
+Parameters:
+
+| parameters             | type              | required       | Description                                                                                      |
+|------------------------|-------------------|----------------| ------------------------------------------------------------------------------------------------ |
+| **stateTransition**    | Buffer            | yes            | A valid bufferized state transition |
+| **options**            | DAPIClientOptions | no             | A valid state transition |
+
+Returns : Promise<!BroadcastStateTransitionResponse>

package/docs/usage/utils/subscribeToTransactionsWithProofs.md

@@ -1,4 +1,4 @@
-**Usage**: `async client.core.subscribeToTransactionsWithProofs(bloomFilter, options = { count: 0 })`\
+**Usage**: `await client.core.subscribeToTransactionsWithProofs(bloomFilter, options = { count: 0 })`\
 **Description**: For any provided bloomfilter, it will return a ClientReadableStream streaming the transaction matching the filter.
 
 

package/lib/BlockHeadersProvider/BlockHeadersProvider.js

@@ -0,0 +1,121 @@
+const EventEmitter = require('events');
+const { SpvChain } = require('@dashevo/dash-spv');
+
+const BlockHeadersReader = require('./BlockHeadersReader');
+
+/**
+ * @typedef {BlockHeadersProviderOptions} BlockHeadersProviderOptions
+ * @property {string} [network=testnet]
+ * @property {number} [maxParallelStreams=5] max parallel streams to read historical block headers
+ * @property {number} [targetBatchSize=100000] a target batch size per stream
+ * @property {number} [maxRetries=10] max amount of retries per stream connection
+ * @property {number} [autoStart=false] auto start fetching verifying block headers
+ */
+const defaultOptions = {
+  network: 'testnet',
+  maxParallelStreams: 5,
+  targetBatchSize: 100000,
+  fromBlockHeight: 1,
+  maxRetries: 10,
+  autoStart: false,
+};
+
+const EVENTS = {
+  ERROR: 'error',
+};
+
+class BlockHeadersProvider extends EventEmitter {
+  /**
+   * @param {BlockHeadersProviderOptions} options
+   */
+  constructor(options = {}) {
+    super();
+    this.options = {
+      ...defaultOptions,
+      ...options,
+    };
+
+    this.spvChain = new SpvChain(this.options.network);
+    this.started = false;
+  }
+
+  /**
+   * @param {CoreMethodsFacade} coreMethods
+   */
+  setCoreMethods(coreMethods) {
+    this.coreMethods = coreMethods;
+  }
+
+  /**
+   * @param {BlockHeadersReader} blockHeadersReader
+   */
+  setBlockHeadersReader(blockHeadersReader) {
+    this.blockHeadersReader = blockHeadersReader;
+  }
+
+  /**
+   *
+   * @param spvChain
+   */
+  setSpvChain(spvChain) {
+    this.spvChain = spvChain;
+  }
+
+  async start() {
+    if (!this.coreMethods) {
+      throw new Error('Core methods have not been provided. Please use "setCoreMethods"');
+    }
+
+    if (this.started) {
+      throw new Error('BlockHeaderProvider has already been started');
+    }
+
+    const { chain: { blocksCount: bestBlockHeight } } = await this.coreMethods.getStatus();
+
+    if (!this.blockHeadersReader) {
+      this.blockHeadersReader = new BlockHeadersReader(
+        {
+          coreMethods: this.coreMethods,
+          maxParallelStreams: this.options.maxParallelStreams,
+          targetBatchSize: this.options.targetBatchSize,
+          maxRetries: this.options.maxRetries,
+        },
+      );
+    }
+
+    this.blockHeadersReader.on(BlockHeadersReader.EVENTS.ERROR, (e) => {
+      this.emit(EVENTS.ERROR, e);
+    });
+
+    this.blockHeadersReader.on(BlockHeadersReader.EVENTS.HISTORICAL_DATA_OBTAINED, () => {
+      this.blockHeadersReader.subscribeToNew(bestBlockHeight)
+        .catch((e) => {
+          this.emit(EVENTS.ERROR, e);
+        });
+    });
+
+    this.blockHeadersReader.on(BlockHeadersReader.EVENTS.BLOCK_HEADERS, (headers, reject) => {
+      try {
+        this.spvChain.addHeaders(headers.map((header) => Buffer.from(header)));
+      } catch (e) {
+        if (e.message === 'Some headers are invalid') {
+          reject(e);
+        } else {
+          this.emit(EVENTS.ERROR, e);
+        }
+      }
+    });
+
+    await this.blockHeadersReader.readHistorical(
+      this.options.fromBlockHeight,
+      bestBlockHeight - 1,
+    );
+
+    this.started = true;
+  }
+}
+
+BlockHeadersProvider.EVENTS = EVENTS;
+BlockHeadersProvider.defaultOptions = defaultOptions;
+
+module.exports = BlockHeadersProvider;

package/lib/BlockHeadersProvider/BlockHeadersReader.js

@@ -0,0 +1,229 @@
+const { EventEmitter } = require('events');
+
+const EVENTS = {
+  BLOCK_HEADERS: 'BLOCK_HEADERS',
+  HISTORICAL_DATA_OBTAINED: 'HISTORICAL_DATA_OBTAINED',
+  ERROR: 'error',
+};
+
+const COMMANDS = {
+  HANDLE_FINISHED_STREAM: 'HANDLE_FINISHED_STREAM',
+  HANDLE_STREAM_RETRY: 'HANDLE_STREAM_RETRY',
+  HANDLE_STREAM_ERROR: 'HANDLE_STREAM_ERROR',
+};
+
+/**
+ * @typedef BlockHeadersReaderOptions
+ * @property {CoreMethodsFacade} [coreMethods]
+ * @property {number} [maxParallelStreams]
+ * @property {number} [targetBatchSize]
+ * @property {number} [maxRetries]
+ */
+
+class BlockHeadersReader extends EventEmitter {
+  /**
+   * @param {BlockHeadersReaderOptions} options
+   */
+  constructor(options = {}) {
+    super();
+    this.coreMethods = options.coreMethods;
+    this.maxParallelStreams = options.maxParallelStreams;
+    this.targetBatchSize = options.targetBatchSize;
+    this.maxRetries = options.maxRetries;
+
+    /**
+     * Holds references to the historical streams
+     *
+     * @type {*[]}
+     */
+    this.historicalStreams = [];
+  }
+
+  /**
+   * Reads historical block heights using multiple streams
+   *
+   * @param {number} fromBlockHeight
+   * @param {number} toBlockHeight
+   * @returns {Promise<void>}
+   */
+  async readHistorical(fromBlockHeight, toBlockHeight) {
+    if (this.historicalStreams.length) {
+      throw new Error('Historical streams are already running');
+    }
+
+    const totalAmount = toBlockHeight - fromBlockHeight + 1;
+    if (totalAmount === 0) {
+      return;
+    }
+
+    if (totalAmount < 0) {
+      throw new Error(`Invalid total amount of headers to read: ${totalAmount}`);
+    }
+
+    // Resubscribe to the stream in case of error, and replace the stream in the array
+    this.on(COMMANDS.HANDLE_STREAM_RETRY, (oldStream, newStream) => {
+      const index = this.historicalStreams.indexOf(oldStream);
+      this.historicalStreams[index] = newStream;
+    });
+
+    // Remove stream from the array in case of error
+    this.on(COMMANDS.HANDLE_STREAM_ERROR, (stream, e) => {
+      const index = this.historicalStreams.indexOf(stream);
+      this.historicalStreams.splice(index, 1);
+      this.emit(EVENTS.ERROR, e);
+    });
+
+    // Remove finished stream from the array and emit HISTORICAL_DATA_OBTAINED event
+    this.on(COMMANDS.HANDLE_FINISHED_STREAM, (stream) => {
+      const index = this.historicalStreams.indexOf(stream);
+      this.historicalStreams.splice(index, 1);
+      if (this.historicalStreams.length === 0) {
+        this.emit(EVENTS.HISTORICAL_DATA_OBTAINED);
+      }
+    });
+
+    const numStreams = Math.min(
+      Math.max(Math.round(totalAmount / this.targetBatchSize), 1),
+      this.maxParallelStreams,
+    );
+
+    const actualBatchSize = Math.ceil(totalAmount / numStreams);
+    for (let batchIndex = 0; batchIndex < numStreams; batchIndex += 1) {
+      const startingHeight = (batchIndex * actualBatchSize) + 1;
+      const count = Math.min(actualBatchSize, toBlockHeight - startingHeight + 1);
+
+      const subscribeWithRetries = this.subscribeToHistoricalBatch(this.maxRetries);
+
+      // eslint-disable-next-line no-await-in-loop
+      const stream = await subscribeWithRetries(startingHeight, count);
+      this.historicalStreams.push(stream);
+    }
+  }
+
+  stopReadingHistorical() {
+    this.removeAllListeners(COMMANDS.HANDLE_STREAM_RETRY);
+    this.removeAllListeners(COMMANDS.HANDLE_STREAM_ERROR);
+    this.removeAllListeners(COMMANDS.HANDLE_FINISHED_STREAM);
+    this.historicalStreams.forEach((stream) => stream.destroy());
+    this.historicalStreams = [];
+  }
+
+  /**
+   * Subscribes to continuously arriving block headers
+   *
+   * @param {number} fromBlockHeight
+   * @returns {Promise<Stream>}
+   */
+  async subscribeToNew(fromBlockHeight) {
+    const stream = await this.coreMethods.subscribeToBlockHeadersWithChainLocks({
+      fromBlockHeight,
+    });
+
+    stream.on('data', (data) => {
+      const blockHeaders = data.getBlockHeaders();
+
+      if (blockHeaders) {
+        /**
+         * Kills stream in case of deliberate rejection from the outside
+         *
+         * @param e
+         */
+        const rejectHeaders = (e) => {
+          stream.destroy(e);
+        };
+
+        this.emit(EVENTS.BLOCK_HEADERS, blockHeaders.getHeadersList(), rejectHeaders);
+      }
+    });
+
+    stream.on('error', (e) => {
+      this.emit(EVENTS.ERROR, e);
+    });
+
+    return stream;
+  }
+
+  /**
+   * A HOF that returns a function to subscribe to historical block headers and chain locks
+   * and handles retry logic
+   *
+   * @private
+   * @param {number} [maxRetries=0] - maximum amount of retries
+   * @returns {function(*, *): Promise<Stream>}
+   */
+  subscribeToHistoricalBatch(maxRetries = 0) {
+    let currentRetries = 0;
+
+    /**
+     * Subscribes to the stream of historical data and handles retry logic
+     *
+     * @param {number} fromBlockHeight
+     * @param {number} count
+     * @returns {Promise<Stream>}
+     */
+    const subscribeWithRetries = async (fromBlockHeight, count) => {
+      let headersObtained = 0;
+
+      const stream = await this.coreMethods.subscribeToBlockHeadersWithChainLocks({
+        fromBlockHeight,
+        count,
+      });
+
+      stream.on('data', (data) => {
+        const blockHeaders = data.getBlockHeaders();
+
+        if (blockHeaders) {
+          const headersList = blockHeaders.getHeadersList();
+
+          let rejected = false;
+
+          /**
+           * Kills stream in case of deliberate rejection from the outside
+           *
+           * @param e
+           */
+          const rejectHeaders = (e) => {
+            rejected = true;
+            stream.destroy(e);
+          };
+
+          this.emit(EVENTS.BLOCK_HEADERS, headersList, rejectHeaders);
+
+          if (!rejected) {
+            headersObtained += headersList.length;
+          }
+        }
+      });
+
+      stream.on('error', (streamError) => {
+        if (currentRetries < maxRetries) {
+          const newFromBlockHeight = fromBlockHeight + headersObtained;
+          const newCount = count - headersObtained;
+
+          subscribeWithRetries(newFromBlockHeight, newCount)
+            .then((newStream) => {
+              currentRetries += 1;
+              this.emit(COMMANDS.HANDLE_STREAM_RETRY, stream, newStream);
+            }).catch((e) => {
+              this.emit(COMMANDS.HANDLE_STREAM_ERROR, stream, e);
+            });
+        } else {
+          this.emit(COMMANDS.HANDLE_STREAM_ERROR, stream, streamError);
+        }
+      });
+
+      stream.on('end', () => {
+        this.emit(COMMANDS.HANDLE_FINISHED_STREAM, stream);
+      });
+
+      return stream;
+    };
+
+    return subscribeWithRetries;
+  }
+}
+
+BlockHeadersReader.EVENTS = EVENTS;
+BlockHeadersReader.COMMANDS = COMMANDS;
+
+module.exports = BlockHeadersReader;