@dashevo/dapi-client 0.22.0-dev.5 → 0.22.0-dev.7.alpha.2

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;

package/lib/BlockHeadersProvider/createBlockHeadersProviderFromOptions.js

@@ -0,0 +1,77 @@
+const networks = require('@dashevo/dashcore-lib/lib/networks');
+const DAPIClientError = require('../errors/DAPIClientError');
+const BlockHeadersProvider = require('./BlockHeadersProvider');
+
+const validateNumber = (value, name, min = NaN, max = NaN) => {
+  if (typeof value !== 'number') {
+    throw new DAPIClientError(`'${name}' is not a number`);
+  }
+
+  if (!Number.isNaN(min) && value < min) {
+    throw new DAPIClientError(`'${name}' can not be less than ${min}`);
+  }
+
+  if (!Number.isNaN(max) && value > min) {
+    throw new DAPIClientError(`'${name}' can not be more than ${max}`);
+  }
+};
+
+/**
+ * @typedef {createBlockHeadersProviderFromOptions}
+ * @param {DAPIClientOptions} options
+ * @param {CoreMethodsFacade} coreMethods
+ * @returns {BlockHeadersProvider}
+ */
+function createBlockHeadersProviderFromOptions(options, coreMethods) {
+  let blockHeadersProvider;
+  if (options.blockHeadersProvider) {
+    if (options.blockHeadersProviderOptions) {
+      throw new DAPIClientError("Can't use 'blockHeadersProviderOptions' with 'blockHeadersProvider' option");
+    }
+
+    blockHeadersProvider = options.blockHeadersProvider;
+  }
+
+  if (options.blockHeadersProviderOptions) {
+    const blockHeadersProviderOptions = {
+      ...BlockHeadersProvider.defaultOptions,
+      ...options.blockHeadersProviderOptions,
+    };
+
+    const {
+      network,
+      autoStart,
+      maxParallelStreams,
+      targetBatchSize,
+      fromBlockHeight,
+      maxRetries,
+    } = blockHeadersProviderOptions;
+
+    if (network && !networks.get(network)) {
+      throw new DAPIClientError(`Invalid network '${options.network}'`);
+    }
+
+    if (typeof autoStart !== 'boolean') {
+      throw new DAPIClientError('\'autoStart\' option must have boolean type');
+    }
+
+    validateNumber(maxParallelStreams, 'maxParallelStreams', 1);
+    validateNumber(targetBatchSize, 'targetBatchSize', 1);
+    validateNumber(fromBlockHeight, 'fromBlockHeight', 1);
+    validateNumber(maxRetries, 'maxRetries', 0);
+
+    blockHeadersProvider = new BlockHeadersProvider(
+      blockHeadersProviderOptions,
+    );
+  }
+
+  if (!blockHeadersProvider) {
+    blockHeadersProvider = new BlockHeadersProvider();
+  }
+
+  blockHeadersProvider.setCoreMethods(coreMethods);
+
+  return blockHeadersProvider;
+}
+
+module.exports = createBlockHeadersProviderFromOptions;

package/lib/BlockHeadersProvider/interfaces/BlockHeadersReaderInterface.js

@@ -0,0 +1,25 @@
+/**
+ * @interface BlockHeadersReader
+ */
+
+/**
+ * @private
+ * @function
+ * @async
+ * @name BlockHeadersReader#createBatchFetcher
+ * @returns {(function(*, *): Promise<void>)|*}
+ */
+
+/**
+ * @function
+ * @async
+ * @name BlockHeadersReader#subscribeToNew
+ * @returns {Promise<Stream>}
+ */
+
+/**
+ * @function
+ * @async
+ * @name BlockHeadersReader#readHistorical
+ * @returns {Promise<void>}
+ */

package/lib/DAPIClient.js

@@ -1,3 +1,5 @@
+const EventEmitter = require('events');
+
 const GrpcTransport = require('./transport/GrpcTransport/GrpcTransport');
 const JsonRpcTransport = require('./transport/JsonRpcTransport/JsonRpcTransport');
 
@@ -9,15 +11,25 @@ const requestJsonRpc = require('./transport/JsonRpcTransport/requestJsonRpc');
 const createGrpcTransportError = require('./transport/GrpcTransport/createGrpcTransportError');
 const createJsonTransportError = require('./transport/JsonRpcTransport/createJsonTransportError');
 
-class DAPIClient {
+const BlockHeadersProvider = require('./BlockHeadersProvider/BlockHeadersProvider');
+const createBlockHeadersProviderFromOptions = require('./BlockHeadersProvider/createBlockHeadersProviderFromOptions');
+
+const EVENTS = {
+  ERROR: 'error',
+};
+
+class DAPIClient extends EventEmitter {
   /**
    * @param {DAPIClientOptions} [options]
    */
   constructor(options = {}) {
+    super();
+
     this.options = {
       network: 'testnet',
       timeout: 10000,
       retries: 5,
+      blockHeadersProviderOptions: BlockHeadersProvider.defaultOptions,
       ...options,
     };
 
@@ -40,9 +52,30 @@ class DAPIClient {
 
     this.core = new CoreMethodsFacade(jsonRpcTransport, grpcTransport);
     this.platform = new PlatformMethodsFacade(grpcTransport);
+
+    this.initBlockHeadersProvider();
+  }
+
+  /**
+   * @private
+   */
+  initBlockHeadersProvider() {
+    this.blockHeadersProvider = createBlockHeadersProviderFromOptions(this.options, this.core);
+
+    this.blockHeadersProvider.on(BlockHeadersProvider.EVENTS.ERROR, (e) => {
+      this.emit(EVENTS.ERROR, e);
+    });
+
+    if (this.options.blockHeadersProviderOptions.autoStart) {
+      this.blockHeadersProvider.start().catch((e) => {
+        this.emit(EVENTS.ERROR, e);
+      });
+    }
   }
 }
 
+DAPIClient.EVENTS = EVENTS;
+
 /**
  * @typedef {DAPIClientOptions} DAPIClientOptions
  * @property {DAPIAddressProvider} [dapiAddressProvider]
@@ -54,6 +87,8 @@ class DAPIClient {
  * @property {number} [retries=3]
  * @property {number} [baseBanTime=60000]
  * @property {boolean} [throwDeadlineExceeded]
+ * @property {BlockHeadersProvider} [blockHeadersProvider]
+ * @property {BlockHeadersProviderOptions} [blockHeadersProviderOptions]
  */
 
 module.exports = DAPIClient;

package/lib/methods/core/CoreMethodsFacade.js

@@ -8,6 +8,7 @@ const getMnListDiffFactory = require('./getMnListDiffFactory');
 const getStatusFactory = require('./getStatusFactory');
 const getTransactionFactory = require('./getTransaction/getTransactionFactory');
 const subscribeToTransactionsWithProofsFactory = require('./subscribeToTransactionsWithProofsFactory');
+const subscribeToBlockHeadersWithChainLocksFactory = require('./subscribeToBlockHeadersWithChainLocksFactory');
 
 class CoreMethodsFacade {
   /**
@@ -27,6 +28,9 @@ class CoreMethodsFacade {
     this.subscribeToTransactionsWithProofs = subscribeToTransactionsWithProofsFactory(
       grpcTransport,
     );
+    this.subscribeToBlockHeadersWithChainLocks = subscribeToBlockHeadersWithChainLocksFactory(
+      grpcTransport,
+    );
   }
 }
 

package/lib/methods/core/subscribeToBlockHeadersWithChainLocksFactory.js

@@ -0,0 +1,69 @@
+const {
+  v0: {
+    BlockHeadersWithChainLocksRequest,
+    CorePromiseClient,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const DAPIClientError = require('../../errors/DAPIClientError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {subscribeToBlockHeadersWithChainLocks}
+ */
+function subscribeToBlockHeadersWithChainLocksFactory(grpcTransport) {
+  /**
+   * @typedef {subscribeToBlockHeadersWithChainLocks}
+   * @param {DAPIClientOptions & subscribeToBlockHeadersWithChainLocksOptions} [options]
+   * @returns {
+   *    EventEmitter|!grpc.web.ClientReadableStream<!BlockHeadersWithChainLocksResponse>
+   * }
+   */
+  async function subscribeToBlockHeadersWithChainLocks(options = { }) {
+    // eslint-disable-next-line no-param-reassign
+    options = {
+      count: 0,
+      // Override global timeout option
+      // and timeout for this method by default
+      timeout: undefined,
+      ...options,
+    };
+
+    if (options.fromBlockHeight === 0) {
+      throw new DAPIClientError('Invalid argument: minimum value for `fromBlockHeight` is 1');
+    }
+
+    const request = new BlockHeadersWithChainLocksRequest();
+
+    if (options.fromBlockHeight !== undefined) {
+      request.setFromBlockHeight(options.fromBlockHeight);
+    }
+
+    if (options.fromBlockHash) {
+      request.setFromBlockHash(
+        Buffer.from(options.fromBlockHash, 'hex'),
+      );
+    }
+
+    request.setCount(options.count);
+
+    return grpcTransport.request(
+      CorePromiseClient,
+      'subscribeToBlockHeadersWithChainLocks',
+      request,
+      options,
+    );
+  }
+
+  return subscribeToBlockHeadersWithChainLocks;
+}
+
+/**
+ * @typedef {object} subscribeToBlockHeadersWithChainLocksOptions
+ * @property {string} [fromBlockHash] - Specifies block hash to start syncing from
+ * @property {number} [fromBlockHeight] - Specifies block height to start syncing from
+ * @property {number} [count=0] - Number of blocks to sync,
+ *                                if set to 0 syncing is continuously sends new data as well
+ */
+
+module.exports = subscribeToBlockHeadersWithChainLocksFactory;

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

@@ -1,16 +1,12 @@
-const StoreTreeProofs = require('./StoreTreeProofs');
-
 class Proof {
   /**
    * @param {object} properties
-   * @param {Buffer} properties.rootTreeProof
-   * @param {StoreTreeProofs} properties.storeTreeProofs
+   * @param {Buffer} properties.merkleProof
    * @param {Buffer} properties.signatureLLMQHash
    * @param {Buffer} properties.signature
    */
   constructor(properties) {
-    this.rootTreeProof = properties.rootTreeProof;
-    this.storeTreeProofs = properties.storeTreeProofs;
+    this.merkleProof = properties.merkleProof;
     this.signatureLLMQHash = properties.signatureLLMQHash;
     this.signature = properties.signature;
   }
@@ -18,15 +14,8 @@ class Proof {
   /**
    * @returns {Buffer}
    */
-  getRootTreeProof() {
-    return this.rootTreeProof;
-  }
-
-  /**
-   * @returns {StoreTreeProofs}
-   */
-  getStoreTreeProofs() {
-    return this.storeTreeProofs;
+  getMerkleProof() {
+    return this.merkleProof;
   }
 
   /**
@@ -44,27 +33,13 @@ class Proof {
   }
 
   /**
-   * @param proofProto
+   * @param {Object} proofProto
    *
    * @returns {Proof}
    */
   static createFromProto(proofProto) {
-    const rawStoreProofs = proofProto.getStoreTreeProofs();
-
-    const storeTreeProofs = new StoreTreeProofs({
-      dataContractsProof: rawStoreProofs.getDataContractsProof()
-        ? Buffer.from(rawStoreProofs.getDataContractsProof()) : null,
-      publicKeyHashesToIdentityIdsProof: rawStoreProofs.getPublicKeyHashesToIdentityIdsProof()
-        ? Buffer.from(rawStoreProofs.getPublicKeyHashesToIdentityIdsProof()) : null,
-      identitiesProof: rawStoreProofs.getIdentitiesProof()
-        ? Buffer.from(rawStoreProofs.getIdentitiesProof()) : null,
-      documentsProof: rawStoreProofs.getDocumentsProof()
-        ? Buffer.from(rawStoreProofs.getDocumentsProof()) : null,
-    });
-
     return new Proof({
-      rootTreeProof: Buffer.from(proofProto.getRootTreeProof()),
-      storeTreeProofs,
+      merleProof: Buffer.from(proofProto.getMerkleProof()),
       signatureLLMQHash: Buffer.from(proofProto.getSignatureLlmqHash()),
       signature: Buffer.from(proofProto.getSignature()),
     });

package/lib/test/fixtures/getHeadersFixture.js

@@ -0,0 +1,215 @@
+const { BlockHeader } = require('@dashevo/dashcore-lib');
+
+const headers = [
+  {
+    version: 2,
+    prevHash: '00000bafbc94add76cb75e2ec92894837288a481e5c005f6563d91623bf8bc2c',
+    merkleRoot: 'b4fd581bc4bfe51a5a66d8b823bd6ee2b492f0ddc44cf7e820550714cedc117f',
+    time: 1398712771,
+    bits: '1e0fffff',
+    nonce: 31475,
+  },
+  {
+    version: 2,
+    prevHash: '0000047d24635e347be3aaaeb66c26be94901a2f962feccd4f95090191f208c1',
+    merkleRoot: '0d6d332e68eb8ecc66a5baaa95dc4b10c0b32841aed57dc99a5ae0b2f9e4294d',
+    time: 1398712772,
+    nonce: 6523,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000c6264fab4ba2d23990396f42a76aa4822f03cbc7634b79f4dfea36fccc2',
+    merkleRoot: '1cc711129405a328c58d1948e748c3b8f3d610e66d9901db88c42c5247829658',
+    time: 1398712774,
+    nonce: 53194,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '0000057d5c945acbe476bc17bbbaeb2fc1c1b18673e7582c48ac04af61f4d811',
+    merkleRoot: '7e6b1b1457308bf6ccb1e325c64607ba7dfac05e26c08887cd28f97d4d4ab3e2',
+    time: 1398712782,
+    nonce: 193159,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '000002258bd58bf4cdcde282abc030437c103dbb12d2a7dbc978d07bcf386b42',
+    merkleRoot: '4cf4f3b788e8dc847a9e0ff3b279340207c555a6bc0736f93e95dbdc2e3c2f16',
+    time: 1398712784,
+    nonce: 41103,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000b1406007f9148c4c173e2314437a315b79b5b79e73ed534a2e8b18a43fc',
+    merkleRoot: '99c25e1373c0a5277157b730624d110d04322ffaac49ac0c98cc2d01c80f4c4c',
+    time: 1398712787,
+    nonce: 62295,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000d93de4b31ec550d324876ee7c502a073911972d26c2c990b94d9d5b5a44',
+    merkleRoot: '769fc473dc8e5073e4fe3f69f0603972d3d72fbeb62a64de826c64e44260b3f3',
+    time: 1398712793,
+    nonce: 127755,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000154b50ded9d6298dc965e541cef117103c3376256185d0d70e92850853d',
+    merkleRoot: '8243e732675d2936bb27917844e714ff5e2012726e3f76e374e7f6236e78669e',
+    time: 1398712796,
+    nonce: 62099,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '0000089e53a33e48061fa4dbc0a52c40736c2eedddaf563ec25cfe406dd8a541',
+    merkleRoot: '243786d6706421ba9ebe9a0d153a5e79d9f781825dbbb0ed26ccc647f10984ee',
+    time: 1398712802,
+    nonce: 128139,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000e98a2b0b1505e3ed00dba28988cd81440de4ec48d817412c2178d332985',
+    merkleRoot: 'b158385f441d9299732ec264442d28b6009b8d24388ee7e23a6ce7e6051bfa31',
+    time: 1398712803,
+    nonce: 23451,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '000001128124cab4756edc387dce2b8762514916d953a4993971a40d78240978',
+    merkleRoot: '1f966cdf6ca90f211308554f90f33935cd8e25ab329ffedfa1066b00a581d5d5',
+    time: 1398712807,
+    nonce: 58648,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000ce430de949c85a145b02e33ebbaed3772dc8f3d668f66edc6852c24d002',
+    merkleRoot: '663360403b5fba9cd8744c3706f9660c7d3fee4e5a9ee98ce0ad5e5ad7824c1d',
+    time: 1398712821,
+    nonce: 312363,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000ac3a0c9df709260e41290d6902e5a4a073099f11fe8c1ce80aadc4bb331',
+    merkleRoot: 'c2ed22a3e6712b842359dfbb6f0a133ae122ffb601e4cf60e30b8c99f9438f4f',
+    time: 1398712821,
+    nonce: 8325,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000b526b34e733532d706c1f4cef93eefe707b87c2c3cb2978e1a84b97c501',
+    merkleRoot: '8994e231d4986bbea391d08f67ff9b6da758c86aa2fc9e9816f105462d18cf1b',
+    time: 1398712824,
+    nonce: 60659,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000799cc6963498a215e04402737fc1a08e696a91540756b0697f1ac7b23a8',
+    merkleRoot: 'f57a78dd55cb4530df55a8b7ba5aed632b1d3819950e78f90d1acdba5ac595d9',
+    time: 1398712825,
+    nonce: 18064,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000170cc708e9c3b491625dd8dc2d737730a738ebd349f2a770fb26944c04f',
+    merkleRoot: '5494a90a580a4f16ff80d2b0c7507d7a565415091d88abeaa752b517da92e06d',
+    time: 1398886700,
+    nonce: 1555411,
+    bits: '1e0fffff',
+  },
+  {
+    version: 2,
+    prevHash: '000000ab6ae22728c701e15a13dfa022c88f17a4e0fd71f073b0a720229de22b',
+    merkleRoot: '0c03f4a03f47046d1295207ca99cc9db6757a6e4ff313a359d1182cfb8431a84',
+    time: 1405697551,
+    nonce: 1491503,
+    bits: '1e0fffff',
+  },
+  {
+    version: 2,
+    confirmations: 86916,
+    prevHash: '00000541dfefddc46d4a7ef3873375db4a6f5b1c06a84b67346fb88e07f024d0',
+    merkleRoot: '2d6ad1b165c8b7dd4f038d8003d0229259db52e7e828d0d25af38c2f2f7e1990',
+    time: 1405697569,
+    nonce: 966245,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '000000d275d8dc93e7bf8c358463c97e12be9b2b17d4e64770aca7af8dcb93d8',
+    merkleRoot: 'e3552304f4c424ebe5bfc0911b1a3a6fcec15fe788acaf910f45238f16d522f7',
+    time: 1405697598,
+    nonce: 1661888,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '0000073a769b38812ca2e3a6d4958cab3f21ed3cf4cc80590be3db4b9cb17c8a',
+    merkleRoot: 'dd0e01125ffba80e7e7508d57da2725ccc648ed3ea3bac60ee19f81efcf8b934',
+    time: 1405697613,
+    nonce: 828461,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000816a46bd5ea15161c7864b76a263f890d60d4aad6b53cceb8c39ee6b153',
+    merkleRoot: '2847d5749c81f8c0b6b91a87a833532611feebb39a833d0e092ec7c8e141467e',
+    time: 1405697617,
+    nonce: 50599,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000976f999bcb32be3d5b7c2e684e8000d8566f22df2612f58b8574536addc',
+    merkleRoot: '78d7b2982419345c34391df68ff2d10c0475d5513a6b52f8caaae4f350af1eee',
+    time: 1405697628,
+    nonce: 613213,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000a4f6e00f23dde0b9197d5633b1637c0c22748adadda2d1a799b26115d0d',
+    merkleRoot: 'bc8af9a84bc94da13dd144c4e1bff2d8580d33f7613d2e4c9c504b4df5c6d9b4',
+    time: 1405697647,
+    nonce: 1050462,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000ad04d60ac3b1567b499c359b2f901be9826e358e071e5ffcb014d7e60ef',
+    merkleRoot: '3cbf4973f43b967773b06169246fbbc80258631280ea84165a1c269b3601943f',
+    time: 1405697671,
+    nonce: 1381148,
+    bits: '1e0ffff0',
+  },
+  {
+    version: 2,
+    prevHash: '00000df1e666a530efa28ac37c8cf8b80970c65aa69497fc4fbb3252d2e5f661',
+    merkleRoot: '4050c8893b1d882da44d15e481b30e145ed6fe29ffa51ac99dc0e206696aa6dc',
+    time: 1405697678,
+    nonce: 352597,
+    bits: '1e0ffff0',
+  },
+];
+
+/**
+ * @returns {BlockHeader[]}
+ */
+function getHeadersFixture() {
+  return headers
+    .map((header) => new BlockHeader({ ...header, bits: parseInt(header.bits, 16) }));
+}
+
+module.exports = getHeadersFixture;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "0.22.0-dev.5",
+  "version": "0.22.0-dev.7.alpha.2",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/DAPIClient.js",
   "contributors": [
@@ -26,10 +26,11 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "~0.22.0-dev.5",
-    "@dashevo/dashcore-lib": "~0.19.28",
-    "@dashevo/dpp": "~0.22.0-dev.5",
-    "@dashevo/grpc-common": "~0.22.0-dev.5",
+    "@dashevo/dapi-grpc": "~0.22.0-dev.7.alpha.2",
+    "@dashevo/dash-spv": "github:dashevo/dash-spv",
+    "@dashevo/dashcore-lib": "~0.19.30",
+    "@dashevo/dpp": "~0.22.0-dev.7.alpha.2",
+    "@dashevo/grpc-common": "~0.22.0-dev.7.alpha.2",
     "@grpc/grpc-js": "^1.3.7",
     "axios": "^0.21.1",
     "bs58": "^4.0.1",