@dashevo/dapi-client 0.23.0-dev.8 → 0.23.0

package/README.md

@@ -1,8 +1,8 @@
 # DAPI Client
 
 [![NPM Version](https://img.shields.io/npm/v/@dashevo/dapi-client)](https://www.npmjs.com/package/@dashevo/dapi-client)
-[![Build Status](https://github.com/dashevo/platform/actions/workflows/release.yml/badge.svg)](https://github.com/dashevo/platform/actions/workflows/release.yml)
-[![Release Date](https://img.shields.io/github/release-date/dashevo/platform)](https://github.com/dashevo/platform/releases/latest)
+[![Build Status](https://github.com/dashpay/platform/actions/workflows/release.yml/badge.svg)](https://github.com/dashpay/platform/actions/workflows/release.yml)
+[![Release Date](https://img.shields.io/github/release-date/dashpay/platform)](https://github.com/dashpay/platform/releases/latest)
 [![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen)](https://github.com/RichardLitt/standard-readme)
 
 Client library used to access Dash DAPI endpoints
@@ -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/platform/tree/master/packages/dapi/lib/rpcServer/commands) and [gRPC](https://github.com/dashevo/platform/tree/master/packages/dapi/lib/grpcServer/handlers) endpoints
+ - `DAPI-Client` maps to DAPI's [RPC](https://github.com/dashpay/platform/tree/master/packages/dapi/lib/rpcServer/commands) and [gRPC](https://github.com/dashpay/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/platform/DAPI-Client/.
+More extensive documentation available at https://dashpay.github.io/platform/DAPI-Client/.
 
 
 ## Contributing
 
-Feel free to dive in! [Open an issue](https://github.com/dashevo/platform/issues/new/choose) or submit PRs.
+Feel free to dive in! [Open an issue](https://github.com/dashpay/platform/issues/new/choose) or submit PRs.
 
 ## License
 

package/lib/BlockHeadersProvider/BlockHeadersProvider.js

@@ -1,5 +1,7 @@
 const EventEmitter = require('events');
-const { SpvChain } = require('@dashevo/dash-spv');
+const { configure: configureDashcore } = require('@dashevo/dashcore-lib');
+const X11 = require('wasm-x11-hash');
+const { SpvChain, SPVError } = require('@dashevo/dash-spv');
 
 const BlockHeadersReader = require('./BlockHeadersReader');
 
@@ -9,41 +11,53 @@ const BlockHeadersReader = require('./BlockHeadersReader');
  * @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,
+  maxParallelStreams: 10,
+  targetBatchSize: 50000,
   fromBlockHeight: 1,
   maxRetries: 10,
-  autoStart: false,
 };
 
 const EVENTS = {
   ERROR: 'error',
+  HISTORICAL_SYNC_STARTED: 'HISTORICAL_SYNC_STARTED',
+  CONTINUOUS_SYNC_STARTED: 'CONTINUOUS_SYNC_STARTED',
+  CHAIN_UPDATED: 'CHAIN_UPDATED',
+  HISTORICAL_DATA_OBTAINED: 'HISTORICAL_DATA_OBTAINED',
+  STOPPED: 'STOPPED',
+};
+
+const STATES = {
+  IDLE: 'IDLE',
+  HISTORICAL_SYNC: 'HISTORICAL_SYNC',
+  CONTINUOUS_SYNC: 'CONTINUOUS_SYNC',
 };
 
 class BlockHeadersProvider extends EventEmitter {
   /**
    * @param {BlockHeadersProviderOptions} options
+   * @param {Function} [createHistoricalSyncStream]
+   * @param {Function} [createContinuousSyncStream]
    */
-  constructor(options = {}) {
+  constructor(options = {}, createHistoricalSyncStream, createContinuousSyncStream) {
     super();
     this.options = {
       ...defaultOptions,
       ...options,
     };
 
-    this.spvChain = new SpvChain(this.options.network);
-    this.started = false;
-  }
+    this.spvChain = new SpvChain(this.options.network, 100);
 
-  /**
-   * @param {CoreMethodsFacade} coreMethods
-   */
-  setCoreMethods(coreMethods) {
-    this.coreMethods = coreMethods;
+    this.state = STATES.IDLE;
+    this.wasmX11Ready = false;
+
+    this.errorHandler = this.errorHandler.bind(this);
+    this.headersHandler = this.headersHandler.bind(this);
+    this.historicalDataObtainedHandler = this.historicalDataObtainedHandler.bind(this);
+    this.createHistoricalSyncStream = createHistoricalSyncStream;
+    this.createContinuousSyncStream = createContinuousSyncStream;
   }
 
   /**
@@ -55,23 +69,24 @@ class BlockHeadersProvider extends EventEmitter {
 
   /**
    *
-   * @param spvChain
+   * @param {SpvChain} 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');
+  /**
+   * @private
+   */
+  async init() {
+    if (!this.wasmX11Ready) {
+      const x11Hash = await X11();
+      configureDashcore({
+        x11hash: x11Hash,
+      });
+      this.wasmX11Ready = true;
     }
 
-    const { chain: { blocksCount: bestBlockHeight } } = await this.coreMethods.getStatus();
-
     if (!this.blockHeadersReader) {
       this.blockHeadersReader = new BlockHeadersReader(
         {
@@ -80,42 +95,160 @@ class BlockHeadersProvider extends EventEmitter {
           targetBatchSize: this.options.targetBatchSize,
           maxRetries: this.options.maxRetries,
         },
+        this.createHistoricalSyncStream,
+        this.createContinuousSyncStream,
       );
     }
 
-    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);
-        }
-      }
-    });
+    this.blockHeadersReader.on(BlockHeadersReader.EVENTS.BLOCK_HEADERS, this.headersHandler);
+    this.blockHeadersReader.on(BlockHeadersReader.EVENTS.ERROR, this.errorHandler);
+  }
+
+  destroyReader() {
+    this.removeReaderListeners();
+    this.blockHeadersReader = null;
+  }
+
+  /**
+   * Initializes SPV chain with a list of headers and a known lastSyncedHeaderHeight
+   *
+   * @param headers
+   * @param lastSyncedHeaderHeight
+   */
+  initializeWith(headers, lastSyncedHeaderHeight) {
+    const firstHeaderHeight = lastSyncedHeaderHeight - headers.length + 1;
+    this.spvChain.reset(firstHeaderHeight);
+    this.spvChain.addHeaders(headers, firstHeaderHeight);
+  }
+
+  /**
+   * Checks whether spv chain has header at specified height and flushes chains if not
+   *
+   * @private
+   * @param height
+   */
+  ensureChainRoot(height) {
+    // Flush spv chain in case header at specified height was not found
+    if (!this.spvChain.hashesByHeight.has(height - 1)) {
+      this.spvChain.reset(height);
+    }
+  }
+
+  /**
+   * Reads historical block headers
+   *
+   * @param fromBlockHeight
+   * @param toBlockHeight
+   * @returns {Promise<void>}
+   */
+  async readHistorical(fromBlockHeight, toBlockHeight) {
+    if (this.state !== STATES.IDLE) {
+      throw new Error(`BlockHeaderProvider can not read historical data while being in ${this.state} state.`);
+    }
+
+    await this.init();
+
+    this.ensureChainRoot(fromBlockHeight);
+
+    this.blockHeadersReader
+      .once(BlockHeadersReader.EVENTS.HISTORICAL_DATA_OBTAINED, this.historicalDataObtainedHandler);
 
     await this.blockHeadersReader.readHistorical(
-      this.options.fromBlockHeight,
-      bestBlockHeight - 1,
+      fromBlockHeight,
+      toBlockHeight,
     );
 
-    this.started = true;
+    this.state = STATES.HISTORICAL_SYNC;
+    this.emit(EVENTS.HISTORICAL_SYNC_STARTED);
+  }
+
+  async startContinuousSync(fromBlockHeight) {
+    if (this.state !== STATES.IDLE) {
+      throw new Error(`BlockHeaderProvider can not sync continuous data while being in ${this.state} state.`);
+    }
+
+    await this.init();
+    this.ensureChainRoot(fromBlockHeight);
+    await this.blockHeadersReader.subscribeToNew(fromBlockHeight);
+    this.state = STATES.CONTINUOUS_SYNC;
+    this.emit(EVENTS.CONTINUOUS_SYNC_STARTED);
+  }
+
+  async stop() {
+    if (this.state === STATES.IDLE) {
+      return;
+    }
+
+    if (this.state === STATES.HISTORICAL_SYNC) {
+      this.blockHeadersReader.stopReadingHistorical();
+    } else if (this.state === STATES.CONTINUOUS_SYNC) {
+      this.blockHeadersReader.unsubscribeFromNew();
+    }
+
+    this.destroyReader();
+
+    this.state = STATES.IDLE;
+
+    this.emit(EVENTS.STOPPED);
+  }
+
+  errorHandler(e) {
+    this.destroyReader();
+    this.emit(EVENTS.ERROR, e);
+  }
+
+  /**
+   * @private
+   * @param headersData
+   * @param reject
+   */
+  headersHandler(headersData, reject) {
+    const { headers, headHeight } = headersData;
+
+    try {
+      const headersAdded = this.spvChain.addHeaders(headers, headHeight);
+
+      if (headersAdded.length) {
+        // Calculate amount of removed headers in order to properly adjust head height
+        // TODO(spv): move this logic to SpvChain?
+        const difference = headers.length - headersAdded.length;
+        this.emit(EVENTS.CHAIN_UPDATED, headersAdded, headHeight + difference);
+      }
+    } catch (e) {
+      if (e instanceof SPVError) {
+        reject(e);
+      } else {
+        this.errorHandler(e);
+      }
+    }
+  }
+
+  historicalDataObtainedHandler() {
+    try {
+      this.spvChain.validate();
+      this.emit(EVENTS.HISTORICAL_DATA_OBTAINED);
+      this.removeReaderListeners();
+    } catch (e) {
+      this.errorHandler(e);
+    } finally {
+      this.state = STATES.IDLE;
+    }
+  }
+
+  removeReaderListeners() {
+    this.blockHeadersReader.removeListener(BlockHeadersReader.EVENTS.ERROR, this.errorHandler);
+    this.blockHeadersReader
+      .removeListener(BlockHeadersReader.EVENTS.BLOCK_HEADERS, this.headersHandler);
+    this.blockHeadersReader
+      .removeListener(
+        BlockHeadersReader.EVENTS.HISTORICAL_DATA_OBTAINED,
+        this.historicalDataObtainedHandler,
+      );
   }
 }
 
 BlockHeadersProvider.EVENTS = EVENTS;
-BlockHeadersProvider.defaultOptions = defaultOptions;
+BlockHeadersProvider.STATES = STATES;
+BlockHeadersProvider.defaultOptions = { ...defaultOptions };
 
 module.exports = BlockHeadersProvider;

package/lib/BlockHeadersProvider/BlockHeadersReader.js

@@ -1,4 +1,6 @@
 const { EventEmitter } = require('events');
+const { BlockHeader } = require('@dashevo/dashcore-lib');
+const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
 
 const EVENTS = {
   BLOCK_HEADERS: 'BLOCK_HEADERS',
@@ -6,15 +8,8 @@ const EVENTS = {
   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]
@@ -23,10 +18,13 @@ const COMMANDS = {
 class BlockHeadersReader extends EventEmitter {
   /**
    * @param {BlockHeadersReaderOptions} options
+   * @param createHistoricalSyncStream
+   * @param createContinuousSyncStream
    */
-  constructor(options = {}) {
+  constructor(options = {}, createHistoricalSyncStream, createContinuousSyncStream) {
     super();
-    this.coreMethods = options.coreMethods;
+    this.createHistoricalSyncStream = createHistoricalSyncStream;
+    this.createContinuousSyncStream = createContinuousSyncStream;
     this.maxParallelStreams = options.maxParallelStreams;
     this.targetBatchSize = options.targetBatchSize;
     this.maxRetries = options.maxRetries;
@@ -34,9 +32,16 @@ class BlockHeadersReader extends EventEmitter {
     /**
      * Holds references to the historical streams
      *
-     * @type {*[]}
+     * @type {Stream[]}
      */
     this.historicalStreams = [];
+
+    /**
+     * Holds reference to the continuous sync stream
+     *
+     * @type {Stream}
+     */
+    this.continuousSyncStream = null;
   }
 
   /**
@@ -48,52 +53,30 @@ class BlockHeadersReader extends EventEmitter {
    */
   async readHistorical(fromBlockHeight, toBlockHeight) {
     if (this.historicalStreams.length) {
-      throw new Error('Historical streams are already running');
+      throw new Error('Historical streams are already running. Please stop them first.');
     }
 
-    const totalAmount = toBlockHeight - fromBlockHeight + 1;
-    if (totalAmount === 0) {
-      return;
+    if (fromBlockHeight <= 0) {
+      throw new Error(`Invalid fromBlockHeight value: ${fromBlockHeight}`);
     }
 
-    if (totalAmount < 0) {
+    const totalAmount = toBlockHeight - fromBlockHeight + 1;
+    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 startingHeight = (batchIndex * actualBatchSize) + fromBlockHeight;
       const count = Math.min(actualBatchSize, toBlockHeight - startingHeight + 1);
 
-      const subscribeWithRetries = this.subscribeToHistoricalBatch(this.maxRetries);
-
+      const subscribeWithRetries = this.createSubscribeToHistoricalBatch(this.maxRetries);
       // eslint-disable-next-line no-await-in-loop
       const stream = await subscribeWithRetries(startingHeight, count);
       this.historicalStreams.push(stream);
@@ -101,28 +84,42 @@ class BlockHeadersReader extends EventEmitter {
   }
 
   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 = [];
+    while (this.historicalStreams.length) {
+      const stream = this.historicalStreams.shift();
+      stream.cancel();
+    }
   }
 
   /**
    * Subscribes to continuously arriving block headers
    *
    * @param {number} fromBlockHeight
-   * @returns {Promise<Stream>}
+   * @returns {Promise<ReconnectableStream>}
    */
   async subscribeToNew(fromBlockHeight) {
-    const stream = await this.coreMethods.subscribeToBlockHeadersWithChainLocks({
-      fromBlockHeight,
-    });
+    if (this.continuousSyncStream) {
+      throw new Error('Continuous sync has already been started');
+    }
+
+    if (typeof fromBlockHeight !== 'number' || fromBlockHeight < 1) {
+      throw new Error(`Invalid fromBlockHeight: ${fromBlockHeight}`);
+    }
+
+    let lastKnownChainHeight = fromBlockHeight - 1;
+
+    const stream = await this.createContinuousSyncStream(fromBlockHeight);
 
     stream.on('data', (data) => {
-      const blockHeaders = data.getBlockHeaders();
+      const blockHeadersResponse = data.getBlockHeaders();
+
+      if (blockHeadersResponse) {
+        const rawHeaders = blockHeadersResponse.getHeadersList();
+
+        const headers = rawHeaders.map((header) => new BlockHeader(Buffer.from(header)));
+
+        lastKnownChainHeight += headers.length;
+        const batchHeadHeight = lastKnownChainHeight - headers.length + 1;
 
-      if (blockHeaders) {
         /**
          * Kills stream in case of deliberate rejection from the outside
          *
@@ -131,18 +128,44 @@ class BlockHeadersReader extends EventEmitter {
         const rejectHeaders = (e) => {
           stream.destroy(e);
         };
-
-        this.emit(EVENTS.BLOCK_HEADERS, blockHeaders.getHeadersList(), rejectHeaders);
+        this.emit(EVENTS.BLOCK_HEADERS, {
+          headers,
+          headHeight: batchHeadHeight,
+        }, rejectHeaders);
       }
     });
 
+    stream.on('beforeReconnect', (updateArguments) => {
+      updateArguments({
+        fromBlockHeight: lastKnownChainHeight,
+      });
+
+      lastKnownChainHeight -= 1;
+    });
+
     stream.on('error', (e) => {
+      this.continuousSyncStream = null;
+      if (e.code === GrpcErrorCodes.CANCELLED) {
+        return;
+      }
       this.emit(EVENTS.ERROR, e);
     });
 
+    stream.on('end', () => {
+      this.continuousSyncStream = null;
+    });
+
+    this.continuousSyncStream = stream;
     return stream;
   }
 
+  unsubscribeFromNew() {
+    if (this.continuousSyncStream) {
+      this.continuousSyncStream.cancel();
+      this.continuousSyncStream = null;
+    }
+  }
+
   /**
    * A HOF that returns a function to subscribe to historical block headers and chain locks
    * and handles retry logic
@@ -151,7 +174,7 @@ class BlockHeadersReader extends EventEmitter {
    * @param {number} [maxRetries=0] - maximum amount of retries
    * @returns {function(*, *): Promise<Stream>}
    */
-  subscribeToHistoricalBatch(maxRetries = 0) {
+  createSubscribeToHistoricalBatch(maxRetries = 0) {
     let currentRetries = 0;
 
     /**
@@ -164,16 +187,14 @@ class BlockHeadersReader extends EventEmitter {
     const subscribeWithRetries = async (fromBlockHeight, count) => {
       let headersObtained = 0;
 
-      const stream = await this.coreMethods.subscribeToBlockHeadersWithChainLocks({
-        fromBlockHeight,
-        count,
-      });
+      const stream = await this.createHistoricalSyncStream(fromBlockHeight, count);
 
-      stream.on('data', (data) => {
+      const dataHandler = (data) => {
         const blockHeaders = data.getBlockHeaders();
 
         if (blockHeaders) {
-          const headersList = blockHeaders.getHeadersList();
+          const headersList = blockHeaders.getHeadersList()
+            .map((header) => new BlockHeader(Buffer.from(header)));
 
           let rejected = false;
 
@@ -187,34 +208,64 @@ class BlockHeadersReader extends EventEmitter {
             stream.destroy(e);
           };
 
-          this.emit(EVENTS.BLOCK_HEADERS, headersList, rejectHeaders);
+          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
+          // of producing a side effect that alters class state
+          const index = this.historicalStreams.indexOf(stream);
+          if (index >= 0) {
+            this.historicalStreams.splice(index, 1);
+          }
+          return;
+        }
 
-      stream.on('error', (streamError) => {
         if (currentRetries < maxRetries) {
           const newFromBlockHeight = fromBlockHeight + headersObtained;
           const newCount = count - headersObtained;
 
+          // TODO: do not retry in case newCount is zero
           subscribeWithRetries(newFromBlockHeight, newCount)
             .then((newStream) => {
+              const index = this.historicalStreams.indexOf(stream);
+              this.historicalStreams[index] = newStream;
               currentRetries += 1;
-              this.emit(COMMANDS.HANDLE_STREAM_RETRY, stream, newStream);
             }).catch((e) => {
-              this.emit(COMMANDS.HANDLE_STREAM_ERROR, stream, e);
+              this.stopReadingHistorical();
+              this.emit(EVENTS.ERROR, e);
             });
         } else {
-          this.emit(COMMANDS.HANDLE_STREAM_ERROR, stream, streamError);
+          this.stopReadingHistorical();
+          this.emit(EVENTS.ERROR, streamError);
         }
-      });
+      };
 
-      stream.on('end', () => {
-        this.emit(COMMANDS.HANDLE_FINISHED_STREAM, stream);
-      });
+      const endHandler = () => {
+        const index = this.historicalStreams.indexOf(stream);
+        this.historicalStreams.splice(index, 1);
+        if (this.historicalStreams.length === 0) {
+          this.emit(EVENTS.HISTORICAL_DATA_OBTAINED);
+        }
+      };
+
+      // TODO: consider reworking with "pasued" mode to
+      // control the data flow manually because SPV verification is
+      // resource intense and backpressure could be a problem
+      // also the whole thing severely affects UI responsiveness
+      stream.on('data', dataHandler);
+      stream.on('error', errorHandler);
+      stream.on('end', endHandler);
 
       return stream;
     };
@@ -224,6 +275,5 @@ class BlockHeadersReader extends EventEmitter {
 }
 
 BlockHeadersReader.EVENTS = EVENTS;
-BlockHeadersReader.COMMANDS = COMMANDS;
 
 module.exports = BlockHeadersReader;