@dashevo/dapi-client 0.24.0-dev.6 → 0.25.0-dev.2

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)
@@ -50,8 +50,7 @@ const DAPIClient = require('@dashevo/dapi-client');
 var client = new DAPIClient({
   seeds: [{
      host: 'seed-1.evonet.networks.dash.org',
-     httpPort: 3000,
-     grpcPort: 3010,
+     port: 443,
   }],
 });
 
@@ -71,8 +70,8 @@ const DAPIClient = require('@dashevo/dapi-client');
 
 var client = new DAPIClient({
   dapiAddresses: [
-    '127.0.0.1:3000:3010',
-    '127.0.0.2:3000:3010',
+    '127.0.0.1:443',
+    '127.0.0.2:443',
   ],
 });
 
@@ -106,7 +105,7 @@ More extensive documentation available at https://dashpay.github.io/platform/DAP
 
 ## 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,164 @@ 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;
+
+    // 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);
+
+      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;