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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "1.0.0-pr.1825.9",
+  "version": "1.0.0-pr.1902.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.1902.1",
+    "@dashevo/dash-spv": "1.0.0-pr.1902.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.1902.1",
+    "@dashevo/wasm-dpp": "1.0.0-pr.1902.1",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
     "google-protobuf": "^3.12.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=94.99 yarn run mocha 'test/unit/**/*.spec.js' 'test/integration/**/*.spec.js'",
     "prepublishOnly": "yarn run build:web"
   },
   "ultra": {

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;