@dashevo/dapi-client 1.0.0-pr.1825.9 → 1.0.0-pr.1883.1

package/lib/methods/core/subscribeToTransactionsWithProofsFactory.js

@@ -29,7 +29,7 @@ function subscribeToTransactionsWithProofsFactory(grpcTransport) {
    *    EventEmitter|!grpc.web.ClientReadableStream<!TransactionsWithProofsResponse>
    * }
    */
-  async function subscribeToTransactionsWithProofs(bloomFilter, options = { }) {
+  async function subscribeToTransactionsWithProofs(bloomFilter, options = {}) {
     // eslint-disable-next-line no-param-reassign
     options = {
       count: 0,

package/lib/methods/platform/PlatformMethodsFacade.js

@@ -3,7 +3,8 @@ const getDataContractFactory = require('./getDataContract/getDataContractFactory
 const getDataContractHistoryFactory = require('./getDataContractHistory/getDataContractHistoryFactory');
 const getDocumentsFactory = require('./getDocuments/getDocumentsFactory');
 const getIdentityFactory = require('./getIdentity/getIdentityFactory');
-const getIdentitiesByPublicKeyHashesFactory = require('./getIdentitiesByPublicKeyHashes/getIdentitiesByPublicKeyHashesFactory');
+const getIdentityByPublicKeyHashFactory = require('./getIdentityByPublicKeyHash/getIdentityByPublicKeyHashFactory');
+const getIdentitiesContractKeysFactory = require('./getIdentitiesContractKeys/getIdentitiesContractKeysFactory');
 const waitForStateTransitionResultFactory = require('./waitForStateTransitionResult/waitForStateTransitionResultFactory');
 const getConsensusParamsFactory = require('./getConsensusParams/getConsensusParamsFactory');
 const getEpochsInfoFactory = require('./getEpochsInfo/getEpochsInfoFactory');
@@ -23,7 +24,8 @@ class PlatformMethodsFacade {
     this.getDataContractHistory = getDataContractHistoryFactory(grpcTransport);
     this.getDocuments = getDocumentsFactory(grpcTransport);
     this.getIdentity = getIdentityFactory(grpcTransport);
-    this.getIdentitiesByPublicKeyHashes = getIdentitiesByPublicKeyHashesFactory(grpcTransport);
+    this.getIdentityByPublicKeyHash = getIdentityByPublicKeyHashFactory(grpcTransport);
+    this.getIdentitiesContractKeys = getIdentitiesContractKeysFactory(grpcTransport);
     this.waitForStateTransitionResult = waitForStateTransitionResultFactory(grpcTransport);
     this.getConsensusParams = getConsensusParamsFactory(grpcTransport);
     this.getEpochsInfo = getEpochsInfoFactory(grpcTransport);

package/lib/methods/platform/getIdentitiesContractKeys/GetIdentitiesContractKeysResponse.js

@@ -0,0 +1,65 @@
+const { Identifier } = require('@dashevo/wasm-dpp');
+const AbstractResponse = require('../response/AbstractResponse');
+
+class GetIdentitiesContractKeysResponse extends AbstractResponse {
+  /**
+   * @param {object} identitiesKeys
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(identitiesKeys, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.identitiesKeys = identitiesKeys;
+  }
+
+  /**
+   * @returns {object}
+   */
+  getIdentitiesKeys() {
+    return this.identitiesKeys;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetIdentitiesContractKeysResponse}
+   */
+  static createFromProto(proto) {
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
+
+    const identitiesKeys = proto.getV0().getIdentitiesKeys();
+
+    let identitiesKeysMap = {};
+    if (identitiesKeys) {
+      const keysEntries = identitiesKeys.getEntriesList();
+
+      identitiesKeysMap = keysEntries.reduce((acc, entry) => {
+        const identityId = Identifier.from(Buffer.from(entry.getIdentityId())).toString();
+        if (!acc[identityId]) {
+          acc[identityId] = {};
+        }
+
+        entry.getKeysList().forEach((key) => {
+          const purpose = key.getPurpose();
+          if (!acc[identityId][purpose]) {
+            // eslint-disable-next-line no-param-reassign
+            acc[identityId][purpose] = [];
+          }
+
+          // eslint-disable-next-line no-param-reassign
+          acc[identityId][purpose] = acc[identityId][purpose].concat(key.getKeysBytesList());
+        }, {});
+
+        return acc;
+      }, {});
+    }
+
+    return new GetIdentitiesContractKeysResponse(
+      identitiesKeysMap,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetIdentitiesContractKeysResponse;

package/lib/methods/platform/getIdentitiesContractKeys/getIdentitiesContractKeysFactory.js

@@ -0,0 +1,93 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentitiesContractKeysRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+const { IdentityPublicKey } = require('@dashevo/wasm-dpp');
+
+const GetIdentitiesContractKeysResponse = require('./GetIdentitiesContractKeysResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentitiesContractKeys}
+ */
+function getIdentitiesContractKeysFactory(grpcTransport) {
+  /**
+   * Fetch the identities by public key hashes
+   * @typedef {getIdentitiesContractKeys}
+   * @param {Buffer[]} identitiesIds
+   * @param {Buffer} contractId
+   * @param {IdentityPublicKey.PURPOSES[]} keyPurposes
+   * @param {string | null} documentTypeName
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentitiesContractKeysResponse>}
+   */
+  async function getIdentitiesContractKeys(
+    identitiesIds,
+    contractId,
+    keyPurposes,
+    documentTypeName = null,
+    options = {},
+  ) {
+    const { GetIdentitiesContractKeysRequestV0 } = GetIdentitiesContractKeysRequest;
+    const getIdentitiesContractKeysRequest = new GetIdentitiesContractKeysRequest();
+
+    // eslint-disable-next-line no-param-reassign
+    identitiesIds = identitiesIds.map((id) => {
+      if (Buffer.isBuffer(id)) {
+        // eslint-disable-next-line no-param-reassign
+        id = Buffer.from(id);
+      }
+
+      return id;
+    });
+
+    if (Buffer.isBuffer(contractId)) {
+      // eslint-disable-next-line no-param-reassign
+      contractId = Buffer.from(contractId);
+    }
+
+    getIdentitiesContractKeysRequest.setV0(
+      new GetIdentitiesContractKeysRequestV0()
+        .setProve(!!options.prove)
+        .setIdentitiesIdsList(identitiesIds)
+        .setContractId(contractId)
+        .setPurposesList(keyPurposes)
+        .setDocumentTypeName(documentTypeName),
+    );
+
+    let lastError;
+
+    // TODO: simple retry before the dapi versioning is properly implemented
+    for (let i = 0; i < 3; i += 1) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const getIdentitiesContractKeysResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentitiesContractKeys',
+          getIdentitiesContractKeysRequest,
+          options,
+        );
+
+        return GetIdentitiesContractKeysResponse
+          .createFromProto(getIdentitiesContractKeysResponse);
+      } catch (e) {
+        if (e instanceof InvalidResponseError) {
+          lastError = e;
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    // If we made it past the cycle it means that the retry didn't work,
+    // and we're throwing the last error encountered
+    throw lastError;
+  }
+
+  return getIdentitiesContractKeys;
+}
+
+module.exports = getIdentitiesContractKeysFactory;

package/lib/methods/platform/getIdentityByPublicKeyHash/GetIdentityByPublicKeyHashResponse.js

@@ -0,0 +1,40 @@
+const AbstractResponse = require('../response/AbstractResponse');
+
+class GetIdentityByPublicKeyHashResponse extends AbstractResponse {
+  /**
+   * @param {Buffer} identities
+   * @param identity
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(identity, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.identity = identity;
+  }
+
+  /**
+   * @returns {Buffer[]}
+   */
+  getIdentity() {
+    return this.identity;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetIdentityByPublicKeyHashResponse}
+   */
+  static createFromProto(proto) {
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
+
+    const identity = proto.getV0().getIdentity();
+
+    return new GetIdentityByPublicKeyHashResponse(
+      Buffer.from(identity),
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetIdentityByPublicKeyHashResponse;

package/lib/methods/platform/getIdentityByPublicKeyHash/getIdentityByPublicKeyHashFactory.js

@@ -0,0 +1,64 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentityByPublicKeyHashRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetIdentityByPublicKeyHashResponse = require('./GetIdentityByPublicKeyHashResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentityByPublicKeyHash}
+ */
+function getIdentityByPublicKeyHashFactory(grpcTransport) {
+  /**
+   * Fetch the identity by public key hash
+   * @typedef {getIdentityByPublicKeyHash}
+   * @param {Buffer} publicKeyHash
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentityByPublicKeyHashResponse>}
+   */
+  async function getIdentityByPublicKeyHash(publicKeyHash, options = {}) {
+    const { GetIdentityByPublicKeyHashRequestV0 } = GetIdentityByPublicKeyHashRequest;
+    const getIdentityByPublicKeyHashRequest = new GetIdentityByPublicKeyHashRequest();
+    getIdentityByPublicKeyHashRequest.setV0(
+      new GetIdentityByPublicKeyHashRequestV0()
+        .setPublicKeyHash(publicKeyHash)
+        .setProve(!!options.prove),
+    );
+
+    let lastError;
+
+    // TODO: simple retry before the dapi versioning is properly implemented
+    for (let i = 0; i < 3; i += 1) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const getIdentityByPublicKeyHashResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentityByPublicKeyHash',
+          getIdentityByPublicKeyHashRequest,
+          options,
+        );
+
+        return GetIdentityByPublicKeyHashResponse
+          .createFromProto(getIdentityByPublicKeyHashResponse);
+      } catch (e) {
+        if (e instanceof InvalidResponseError) {
+          lastError = e;
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    // If we made it past the cycle it means that the retry didn't work,
+    // and we're throwing the last error encountered
+    throw lastError;
+  }
+
+  return getIdentityByPublicKeyHash;
+}
+
+module.exports = getIdentityByPublicKeyHashFactory;

package/lib/transport/GrpcTransport/GrpcTransport.js

@@ -1,3 +1,4 @@
+const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
 const logger = require('../../logger');
 
 const MaxRetriesReachedError = require('../errors/response/MaxRetriesReachedError');
@@ -81,7 +82,12 @@ class GrpcTransport {
     } catch (error) {
       this.lastUsedAddress = address;
 
-      this.logger.error(`GRPC Request ${method} to ${address.toString()} failed with error: ${error.message}`);
+      // Show NOT_FOUND errors only in debug mode
+      if (error.code !== GrpcErrorCodes.NOT_FOUND) {
+        this.logger.error(`GRPC Request ${method} to ${address.toString()} failed with error: ${error.message}`);
+      } else {
+        this.logger.debug(`GRPC Request ${method} to ${address.toString()} failed with error: ${error.message}`);
+      }
 
       // for unknown errors
       if (error.code === undefined) {

package/lib/transport/ReconnectableStream.js

@@ -12,8 +12,7 @@ const wait = require('../utils/wait');
  *    delay in MS to perform retry after an error
  */
 const defaultOptions = {
-  // TODO: manage timeout according to the Nginx setting of the node
-  autoReconnectInterval: 50000,
+  autoReconnectInterval: 600000,
   maxRetriesOnError: 10,
   retryOnErrorDelay: 1000,
 };
@@ -57,6 +56,8 @@ class ReconnectableStream extends EventEmitter {
 
     const opts = { ...defaultOptions, ...options };
 
+    this.logger = opts.logger || { debug: () => {} };
+
     /**
      * Auto-reconnect interval in millisecond
      * It is needed to automatically reconnect to another DAPI node
@@ -109,6 +110,8 @@ class ReconnectableStream extends EventEmitter {
   }
 
   async connect(...args) {
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug('[ReconnectableStream] Connecting to stream');
     // Memorize current stream args (which can be altered by beforeReconnect logic)
     this.args = args;
 
@@ -127,6 +130,8 @@ class ReconnectableStream extends EventEmitter {
     if (this.reconnectTimeout) {
       throw new Error('Auto reconnect timeout is already running.');
     }
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug('[ReconnectableStream] Setting reconnect timeout');
     this.reconnectTimeout = this.setTimeout(
       this.reconnect,
       this.autoReconnectInterval,
@@ -134,6 +139,8 @@ class ReconnectableStream extends EventEmitter {
   }
 
   reconnect() {
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug('[ReconnectableStream] Try reconnecting to stream');
     if (this.reconnectTimeout) {
       this.reconnectTimeout = null;
       this.stream.cancel();
@@ -146,6 +153,8 @@ class ReconnectableStream extends EventEmitter {
       this.emit(EVENTS.BEFORE_RECONNECT, updateArgs);
       this.connect(...newArgs)
         .catch((connectError) => this.emit(EVENTS.ERROR, connectError));
+      // eslint-disable-next-line no-unused-expressions
+      this.logger.debug('[ReconnectableStream] Reconnected to stream');
     }
   }
 
@@ -186,9 +195,13 @@ class ReconnectableStream extends EventEmitter {
    * @private
    */
   endHandler() {
-    this.stopAutoReconnect();
-    this.stream = null;
-    this.emit(EVENTS.END);
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug('[ReconnectableStream] End handler, stream exists:', !!this.stream);
+    if (this.stream) {
+      this.stopAutoReconnect();
+      this.stream = null;
+      this.emit(EVENTS.END);
+    }
   }
 
   /**
@@ -197,9 +210,21 @@ class ReconnectableStream extends EventEmitter {
    * @param e
    */
   errorHandler(e) {
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug(`[ReconnectableStream] Error in stream, code ${e.code}, e:`, e);
+
     // In case of cancellation nothing has to happen.
+    // Do not retry UNKNOWN error code - HACH for grpc-web that ignores following error that happens
+    // in a while after stream cancellation
+    // Error message:
+    // "Response closed without grpc-status (Headers only) {
+    //    [Error: Response closed without grpc-status (Headers only)]"
     // TODO: do we need to propagate GrpcErrorCodes.CANCELLED further?
-    if (e.code === GrpcErrorCodes.CANCELLED) {
+    if (e.code === GrpcErrorCodes.CANCELLED
+      || (e.code === GrpcErrorCodes.UNKNOWN && this.stream === null)
+    ) {
+      // e.code
+      this.logger.debug(`[ReconnectableStream] Returning from error handler without restart, error code ${e.code}, e:`);
       return;
     }
 
@@ -212,6 +237,8 @@ class ReconnectableStream extends EventEmitter {
    * @param e
    */
   retryOnError(e) {
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug('[ReconnectableStream] Error handler', e);
     // Stop reconnect timeout if there is one
     this.stopAutoReconnect();
 
@@ -252,9 +279,13 @@ class ReconnectableStream extends EventEmitter {
    * @private
    */
   stopAutoReconnect() {
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug('[ReconnectableStream] Stopping auto reconnect');
     if (this.reconnectTimeout) {
       this.clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
+      // eslint-disable-next-line no-unused-expressions
+      this.logger.debug('[ReconnectableStream] Stoped auto reconnect');
     }
   }
 
@@ -265,7 +296,18 @@ class ReconnectableStream extends EventEmitter {
    * @returns {*}
    */
   cancel() {
+    // eslint-disable-next-line no-unused-expressions
+    this.logger.debug('[ReconnectableStream] Canceling streams');
     this.stopAutoReconnect();
+    // Hack for browsers to properly unsubscribe from ERROR event.
+    // (It will continue propagating despite of calling cancel)
+    // Ref to unsubscribe from ERROR event
+    const { stream } = this;
+    setTimeout(() => {
+      stream.removeListener(EVENTS.ERROR, this.errorHandler);
+      // endHandler
+      this.stream = null;
+    }, 1000);
     return this.stream.cancel();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "1.0.0-pr.1825.9",
+  "version": "1.0.0-pr.1883.1",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/index.js",
   "contributors": [
@@ -26,11 +26,11 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "1.0.0-pr.1825.9",
-    "@dashevo/dash-spv": "1.0.0-pr.1825.9",
+    "@dashevo/dapi-grpc": "1.0.0-pr.1883.1",
+    "@dashevo/dash-spv": "1.0.0-pr.1883.1",
     "@dashevo/dashcore-lib": "~0.21.1",
-    "@dashevo/grpc-common": "1.0.0-pr.1825.9",
-    "@dashevo/wasm-dpp": "1.0.0-pr.1825.9",
+    "@dashevo/grpc-common": "1.0.0-pr.1883.1",
+    "@dashevo/wasm-dpp": "1.0.0-pr.1883.1",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
     "google-protobuf": "^3.12.2",
@@ -57,7 +57,7 @@
     "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-jsdoc": "^46.9.0",
     "events": "^3.3.0",
-    "karma": "^6.4.1",
+    "karma": "^6.4.3",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
     "karma-firefox-launcher": "^2.1.2",
@@ -92,7 +92,7 @@
     "test:integration": "mocha './test/integration/**/*.spec.js'",
     "test:node": "NODE_ENV=test mocha",
     "test:browsers": "karma start ./karma.conf.js --single-run",
-    "test:coverage": "NODE_ENV=test nyc --check-coverage --stmts=98 --branch=98 --funcs=98 --lines=95 yarn run mocha 'test/unit/**/*.spec.js' 'test/integration/**/*.spec.js'",
+    "test:coverage": "NODE_ENV=test nyc --check-coverage --stmts=98 --branch=98 --funcs=98 --lines=90 yarn run mocha 'test/unit/**/*.spec.js' 'test/integration/**/*.spec.js'",
     "prepublishOnly": "yarn run build:web"
   },
   "ultra": {

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

@@ -1,13 +0,0 @@
-**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/getMnListDiff.md

@@ -1,12 +0,0 @@
-**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/lib/methods/core/generateToAddressFactory.js

@@ -1,25 +0,0 @@
-/**
- * @param {JsonRpcTransport} jsonRpcTransport
- * @returns {generateToAddress}
- */
-function generateToAddressFactory(jsonRpcTransport) {
-  /**
-   * ONLY FOR TESTING PURPOSES WITH REGTEST. WILL NOT WORK ON TESTNET/LIVENET.
-   * @typedef {generateToAddress}
-   * @param {number} blocksNumber - Number of blocks to generate
-   * @param {string} address - The address that will receive the newly generated Dash
-   * @param {DAPIClientOptions} [options]
-   * @returns {Promise<string[]>} - block hashes
-   */
-  function generateToAddress(blocksNumber, address, options = {}) {
-    return jsonRpcTransport.request(
-      'generateToAddress',
-      { blocksNumber, address },
-      options,
-    );
-  }
-
-  return generateToAddress;
-}
-
-module.exports = generateToAddressFactory;

package/lib/methods/core/getMnListDiffFactory.js

@@ -1,21 +0,0 @@
-/**
- * @param {JsonRpcTransport} jsonRpcTransport
- * @returns {getMnListDiff}
- */
-function getMnListDiffFactory(jsonRpcTransport) {
-  /**
-   * Get deterministic masternodelist diff
-   * @typedef {getMnListDiff}
-   * @param {string} baseBlockHash - hash or height of start block
-   * @param {string} blockHash - hash or height of end block
-   * @param {DAPIClientOptions} [options]
-   * @returns {Promise<object>}
-   */
-  function getMnListDiff(baseBlockHash, blockHash, options = {}) {
-    return jsonRpcTransport.request('getMnListDiff', { baseBlockHash, blockHash }, options);
-  }
-
-  return getMnListDiff;
-}
-
-module.exports = getMnListDiffFactory;

package/lib/methods/platform/getIdentitiesByPublicKeyHashes/GetIdentitiesByPublicKeyHashesResponse.js

@@ -1,46 +0,0 @@
-const AbstractResponse = require('../response/AbstractResponse');
-
-class GetIdentitiesByPublicKeyHashesResponse extends AbstractResponse {
-  /**
-   * @param {Buffer[]} identities
-   * @param {Metadata} metadata
-   * @param {Proof} [proof]
-   */
-  constructor(identities, metadata, proof = undefined) {
-    super(metadata, proof);
-
-    this.identities = identities;
-  }
-
-  /**
-   * @returns {Buffer[]}
-   */
-  getIdentities() {
-    return this.identities;
-  }
-
-  /**
-   * @param proto
-   * @returns {GetIdentitiesByPublicKeyHashesResponse}
-   */
-  static createFromProto(proto) {
-    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
-
-    const identitiesList = proto.getV0().getIdentities();
-
-    return new GetIdentitiesByPublicKeyHashesResponse(
-      identitiesList !== undefined
-        ? identitiesList.getIdentityEntriesList()
-          .map((identity) => {
-            const value = identity.getValue();
-            // TODO: rework to return whole `identity.getValue()` instead of inner getValue()
-            return value && Buffer.from(value.getValue());
-          })
-        : [],
-      metadata,
-      proof,
-    );
-  }
-}
-
-module.exports = GetIdentitiesByPublicKeyHashesResponse;

package/lib/methods/platform/getIdentitiesByPublicKeyHashes/getIdentitiesByPublicKeyHashesFactory.js

@@ -1,65 +0,0 @@
-const {
-  v0: {
-    PlatformPromiseClient,
-    GetIdentitiesByPublicKeyHashesRequest,
-  },
-} = require('@dashevo/dapi-grpc');
-
-const GetIdentitiesByPublicKeyHashesResponse = require('./GetIdentitiesByPublicKeyHashesResponse');
-const InvalidResponseError = require('../response/errors/InvalidResponseError');
-
-/**
- * @param {GrpcTransport} grpcTransport
- * @returns {getIdentitiesByPublicKeyHashes}
- */
-function getIdentitiesByPublicKeyHashesFactory(grpcTransport) {
-  /**
-   * Fetch the identities by public key hashes
-   * @typedef {getIdentitiesByPublicKeyHashes}
-   * @param {Buffer[]} publicKeyHashes
-   * @param {DAPIClientOptions & {prove: boolean}} [options]
-   * @returns {Promise<GetIdentitiesByPublicKeyHashesResponse>}
-   */
-  async function getIdentitiesByPublicKeyHashes(publicKeyHashes, options = {}) {
-    const { GetIdentitiesByPublicKeyHashesRequestV0 } = GetIdentitiesByPublicKeyHashesRequest;
-    const getIdentitiesByPublicKeyHashesRequest = new GetIdentitiesByPublicKeyHashesRequest();
-    getIdentitiesByPublicKeyHashesRequest.setV0(
-      new GetIdentitiesByPublicKeyHashesRequestV0()
-        .setPublicKeyHashesList(
-          publicKeyHashes,
-        ).setProve(!!options.prove),
-    );
-
-    let lastError;
-
-    // TODO: simple retry before the dapi versioning is properly implemented
-    for (let i = 0; i < 3; i += 1) {
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        const getIdentitiesByPublicKeyHashesResponse = await grpcTransport.request(
-          PlatformPromiseClient,
-          'getIdentitiesByPublicKeyHashes',
-          getIdentitiesByPublicKeyHashesRequest,
-          options,
-        );
-
-        return GetIdentitiesByPublicKeyHashesResponse
-          .createFromProto(getIdentitiesByPublicKeyHashesResponse);
-      } catch (e) {
-        if (e instanceof InvalidResponseError) {
-          lastError = e;
-        } else {
-          throw e;
-        }
-      }
-    }
-
-    // If we made it past the cycle it means that the retry didn't work,
-    // and we're throwing the last error encountered
-    throw lastError;
-  }
-
-  return getIdentitiesByPublicKeyHashes;
-}
-
-module.exports = getIdentitiesByPublicKeyHashesFactory;