@dashevo/dapi-client 0.21.7 → 0.22.0-dev.11

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/getIdentitiesByPublicKeyHashes/GetIdentitiesByPublicKeyHashesResponse.js

@@ -1,3 +1,5 @@
+const cbor = require('cbor');
+
 const AbstractResponse = require('../response/AbstractResponse');
 
 class GetIdentitiesByPublicKeyHashesResponse extends AbstractResponse {
@@ -13,7 +15,7 @@ class GetIdentitiesByPublicKeyHashesResponse extends AbstractResponse {
   }
 
   /**
-   * @returns {Buffer[]}
+   * @returns {Array<Buffer[]>}
    */
   getIdentities() {
     return this.identities;
@@ -27,8 +29,13 @@ class GetIdentitiesByPublicKeyHashesResponse extends AbstractResponse {
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
     return new GetIdentitiesByPublicKeyHashesResponse(
-      proto.getIdentitiesList()
-        .map((identity) => (identity.length > 0 ? Buffer.from(identity) : null)),
+      proto.getIdentitiesList().map((identitiesSerialized) => {
+        const identities = cbor.decode(identitiesSerialized);
+
+        return identities.map((identity) => (
+          (identity.length > 0 ? Buffer.from(identity) : null)
+        ));
+      }),
       metadata,
       proof,
     );

package/lib/methods/platform/getIdentityIdsByPublicKeyHashes/GetIdentityIdsByPublicKeyHashesResponse.js

@@ -1,3 +1,5 @@
+const cbor = require('cbor');
+
 const AbstractResponse = require('../response/AbstractResponse');
 
 class GetIdentityIdsByPublicKeyHashesResponse extends AbstractResponse {
@@ -13,7 +15,7 @@ class GetIdentityIdsByPublicKeyHashesResponse extends AbstractResponse {
   }
 
   /**
-   * @returns {Buffer[]}
+   * @returns {Array<Buffer[]>}
    */
   getIdentityIds() {
     return this.identityIds;
@@ -27,8 +29,13 @@ class GetIdentityIdsByPublicKeyHashesResponse extends AbstractResponse {
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
     return new GetIdentityIdsByPublicKeyHashesResponse(
-      proto.getIdentityIdsList()
-        .map((identityId) => (identityId.length > 0 ? Buffer.from(identityId) : null)),
+      proto.getIdentityIdsList().map((identityIdsSerialized) => {
+        const identityIds = cbor.decode(identityIdsSerialized);
+
+        return identityIds.map((identityId) => (
+          (identityId.length > 0 ? Buffer.from(identityId) : null)
+        ));
+      }),
       metadata,
       proof,
     );

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,
+      merkleProof: 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/lib/test/fixtures/getProofFixture.js

@@ -1,13 +1,7 @@
 /**
  * @returns {{
- *   rootTreeProof: Buffer,
+ *   merkleProof: Buffer,
  *   signature: Buffer,
- *   storeTreeProofs: {
- *      documentsProof: Buffer,
- *      publicKeyHashesToIdentityIdsProof: Buffer,
- *      dataContractsProof: Buffer,
- *      identitiesProof: Buffer
- *   },
  *   signatureLLMQHash: Buffer
  * }}
  */
@@ -15,13 +9,7 @@ function getProofFixture() {
   return {
     signatureLLMQHash: Buffer.from('AQEBAQEBAQEBAQEB', 'base64'),
     signature: Buffer.from('AgICAgICAgICAgIC', 'base64'),
-    rootTreeProof: Buffer.from('0100000001f0faf5f55674905a68eba1be2f946e667c1cb5010101', 'hex'),
-    storeTreeProofs: {
-      publicKeyHashesToIdentityIdsProof: Buffer.from('03046b657931060076616c75653103046b657932060076616c75653210', 'hex'),
-      identitiesProof: Buffer.from('03046b657931060076616c75653103046b657932060076616c75653210', 'hex'),
-      documentsProof: Buffer.from('03046b657931060076616c75653103046b657932060076616c75653210', 'hex'),
-      dataContractsProof: Buffer.from('03046b657931060076616c75653103046b657932060076616c75653210', 'hex'),
-    },
+    merkleProof: Buffer.from('0100000001f0faf5f55674905a68eba1be2f946e667c1cb5010101', 'hex'),
   };
 }
 

package/package.json

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

package/docs/usage/application/applyStateTransition.md

@@ -1,11 +0,0 @@
-**Usage**: `async client.platform.applyStateTransition(stateTransition)`
-**Description**: Send State Transition to machine
-
-Parameters:
-
-| parameters             | type                                                 | required       | Description                                                                                             |
-|------------------------|------------------------------------------------------|----------------| ------------------------------------------------------------------------------------------------ |
-| **stateTransition**    | DataContractStateTransition/DocumentsStateTransition | yes            | A valid state transition |
-
-Returns : Promise<!ApplyStateTransitionResponse>
-

package/docs/usage/payment/getBestBlockHash.md

@@ -1,10 +0,0 @@
-**Usage**: `async client.core.getBestBlockHash()`
-**Description**: Returns block hash of chaintip
-
-Parameters:
-
-| parameters             | type               | required       | Description                                                                                             |
-|------------------------|--------------------|----------------| ------------------------------------------------------------------------------------------------ |
-
-Returns : Promise<string>
-