@dashevo/dapi-client 1.0.0-pr.1694.9 → 1.0.0-pr.1825.1

package/lib/methods/platform/PlatformMethodsFacade.js

@@ -9,6 +9,9 @@ const getConsensusParamsFactory = require('./getConsensusParams/getConsensusPara
 const getEpochsInfoFactory = require('./getEpochsInfo/getEpochsInfoFactory');
 const getProtocolVersionUpgradeVoteStatusFactory = require('./getProtocolVersionUpgradeVoteStatus/getProtocolVersionUpgradeVoteStatusFactory');
 const getProtocolVersionUpgradeStateFactory = require('./getProtocolVersionUpgradeState/getProtocolVersionUpgradeStateFactory');
+const getIdentityContractNonceFactory = require('./getIdentityContractNonce/getIdentityContractNonceFactory');
+const getIdentityNonceFactory = require('./getIdentityNonce/getIdentityNonceFactory');
+const getIdentityKeysFactory = require('./getIdentityKeys/getIdentityKeysFactory');
 
 class PlatformMethodsFacade {
   /**
@@ -28,6 +31,9 @@ class PlatformMethodsFacade {
       grpcTransport,
     );
     this.getProtocolVersionUpgradeState = getProtocolVersionUpgradeStateFactory(grpcTransport);
+    this.getIdentityContractNonce = getIdentityContractNonceFactory(grpcTransport);
+    this.getIdentityNonce = getIdentityNonceFactory(grpcTransport);
+    this.getIdentityKeys = getIdentityKeysFactory(grpcTransport);
   }
 }
 

package/lib/methods/platform/getIdentityContractNonce/GetIdentityContractNonceResponse.js

@@ -0,0 +1,49 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+const IDENTITY_CONTRACT_NONCE_VALUE_FILTER = 0xFFFFFFFFFF;
+
+class GetIdentityContractNonceResponse extends AbstractResponse {
+  /**
+   * @param {number} identityContractNonce
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(identityContractNonce, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.identityContractNonce = identityContractNonce;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getIdentityContractNonce() {
+    return this.identityContractNonce;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetIdentityContractNonceResponse}
+   */
+  static createFromProto(proto) {
+    // eslint-disable-next-line
+    const identityContractNonce = proto.getV0()
+      .getIdentityContractNonce() & IDENTITY_CONTRACT_NONCE_VALUE_FILTER;
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
+      proto,
+    );
+
+    if ((typeof identityContractNonce === 'undefined' || identityContractNonce === null) && !proof) {
+      throw new InvalidResponseError('Contract nonce data is not defined');
+    }
+
+    return new GetIdentityContractNonceResponse(
+      identityContractNonce,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetIdentityContractNonceResponse;

package/lib/methods/platform/getIdentityContractNonce/getIdentityContractNonceFactory.js

@@ -0,0 +1,81 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentityContractNonceRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetIdentityContractNonceResponse = require('./GetIdentityContractNonceResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentityContractNonce}
+ */
+function getIdentityContractNonceFactory(grpcTransport) {
+  /**
+   * Fetch the version upgrade vote status
+   * @typedef {getIdentityContractNonce}
+   * @param {Buffer} identityId
+   * @param {Buffer} contractId
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentityContractNonceResponse>}
+   */
+  async function getIdentityContractNonce(identityId, contractId, options = {}) {
+    const {
+      GetIdentityContractNonceRequestV0,
+    } = GetIdentityContractNonceRequest;
+
+    // eslint-disable-next-line max-len
+    const getIdentityContractNonceRequest = new GetIdentityContractNonceRequest();
+
+    if (Buffer.isBuffer(identityId)) {
+      // eslint-disable-next-line no-param-reassign
+      identityId = Buffer.from(identityId);
+    }
+
+    if (Buffer.isBuffer(contractId)) {
+      // eslint-disable-next-line no-param-reassign
+      contractId = Buffer.from(contractId);
+    }
+
+    getIdentityContractNonceRequest.setV0(
+      new GetIdentityContractNonceRequestV0()
+        .setIdentityId(identityId)
+        .setContractId(contractId)
+        .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 getIdentityContractNonceResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentityContractNonce',
+          getIdentityContractNonceRequest,
+          options,
+        );
+
+        return GetIdentityContractNonceResponse
+          .createFromProto(getIdentityContractNonceResponse);
+      } 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 getIdentityContractNonce;
+}
+
+module.exports = getIdentityContractNonceFactory;

package/lib/methods/platform/getIdentityKeys/GetIdentityKeysResponse.js

@@ -0,0 +1,52 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetIdentityKeysResponse extends AbstractResponse {
+  /**
+   * @param {number} identityKeys
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(identityKeys, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.identityKeys = identityKeys;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getIdentityKeys() {
+    return this.identityKeys;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetIdentityKeysResponse}
+   */
+  static createFromProto(proto) {
+    // eslint-disable-next-line
+    const keys = proto.getV0().getKeys();
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
+      proto,
+    );
+
+    let identityKeys = [];
+    if ((typeof keys === 'undefined' || keys === null) && !proof) {
+      throw new InvalidResponseError('Identity keys are not defined');
+    } else if (!proof) {
+      identityKeys = keys.getKeysBytesList();
+      if ((typeof identityKeys === 'undefined' || identityKeys === null) && !proof) {
+        throw new InvalidResponseError('Identity keys are not defined');
+      }
+    }
+
+    return new GetIdentityKeysResponse(
+      identityKeys,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetIdentityKeysResponse;

package/lib/methods/platform/getIdentityKeys/getIdentityKeysFactory.js

@@ -0,0 +1,78 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentityKeysRequest,
+    KeyRequestType,
+    SpecificKeys,
+  },
+} = require('@dashevo/dapi-grpc');
+const { UInt32Value } = require('google-protobuf/google/protobuf/wrappers_pb');
+
+const GetIdentityKeysResponse = require('./GetIdentityKeysResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentityKeys}
+ */
+function getIdentityKeysFactory(grpcTransport) {
+  /**
+   * Fetch the version upgrade vote status
+   * @typedef {getIdentityKeys}
+   * @param {Buffer} identityId
+   * @param {number[]} keyIds
+   * @param {number} limit
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentityKeysResponse>}
+   */
+  async function getIdentityKeys(identityId, keyIds, limit = 100, options = {}) {
+    const { GetIdentityKeysRequestV0 } = GetIdentityKeysRequest;
+    const getIdentityKeysRequest = new GetIdentityKeysRequest();
+
+    if (Buffer.isBuffer(identityId)) {
+      // eslint-disable-next-line no-param-reassign
+      identityId = Buffer.from(identityId);
+    }
+
+    getIdentityKeysRequest.setV0(
+      new GetIdentityKeysRequestV0()
+        .setIdentityId(identityId)
+        .setRequestType(new KeyRequestType()
+          .setSpecificKeys(new SpecificKeys().setKeyIdsList(keyIds)))
+        .setLimit(new UInt32Value([limit]))
+        .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 getIdentityKeysResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentityKeys',
+          getIdentityKeysRequest,
+          options,
+        );
+
+        return GetIdentityKeysResponse
+          .createFromProto(getIdentityKeysResponse);
+      } 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 getIdentityKeys;
+}
+
+module.exports = getIdentityKeysFactory;

package/lib/methods/platform/getIdentityNonce/GetIdentityNonceResponse.js

@@ -0,0 +1,49 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+const IDENTITY_NONCE_VALUE_FILTER = 0xFFFFFFFFFF;
+
+class GetIdentityNonceResponse extends AbstractResponse {
+  /**
+   * @param {number} identityNonce
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(identityNonce, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.identityNonce = identityNonce;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getIdentityNonce() {
+    return this.identityNonce;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetIdentityNonceResponse}
+   */
+  static createFromProto(proto) {
+    // eslint-disable-next-line
+    const identityNonce = proto.getV0()
+      .getIdentityNonce() & IDENTITY_NONCE_VALUE_FILTER;
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
+      proto,
+    );
+
+    if ((typeof identityNonce === 'undefined' || identityNonce === null) && !proof) {
+      throw new InvalidResponseError('Nonce data is not defined');
+    }
+
+    return new GetIdentityNonceResponse(
+      identityNonce,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetIdentityNonceResponse;

package/lib/methods/platform/getIdentityNonce/getIdentityNonceFactory.js

@@ -0,0 +1,74 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentityNonceRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetIdentityNonceResponse = require('./GetIdentityNonceResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentityNonce}
+ */
+function getIdentityNonceFactory(grpcTransport) {
+  /**
+   * Fetch the version upgrade vote status
+   * @typedef {getIdentityNonce}
+   * @param {Buffer} identityId
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentityNonceResponse>}
+   */
+  async function getIdentityNonce(identityId, options = {}) {
+    const {
+      GetIdentityNonceRequestV0,
+    } = GetIdentityNonceRequest;
+
+    // eslint-disable-next-line max-len
+    const getIdentityNonceRequest = new GetIdentityNonceRequest();
+
+    if (Buffer.isBuffer(identityId)) {
+      // eslint-disable-next-line no-param-reassign
+      identityId = Buffer.from(identityId);
+    }
+
+    getIdentityNonceRequest.setV0(
+      new GetIdentityNonceRequestV0()
+        .setIdentityId(identityId)
+        .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 getIdentityNonceResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentityNonce',
+          getIdentityNonceRequest,
+          options,
+        );
+
+        return GetIdentityNonceResponse
+          .createFromProto(getIdentityNonceResponse);
+      } 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 getIdentityNonce;
+}
+
+module.exports = getIdentityNonceFactory;

package/lib/transport/GrpcTransport/createGrpcTransportError.js

@@ -118,7 +118,7 @@ async function createGrpcTransportError(grpcError, dapiAddress) {
   }
 
   // DPP consensus errors
-  if (code >= 1000 && code < 5000) {
+  if (code >= 10000 && code < 50000) {
     const consensusError = deserializeConsensusError(data.serializedError || []);
 
     delete data.serializedError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "1.0.0-pr.1694.9",
+  "version": "1.0.0-pr.1825.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.1694.9",
-    "@dashevo/dash-spv": "1.0.0-pr.1694.9",
+    "@dashevo/dapi-grpc": "1.0.0-pr.1825.1",
+    "@dashevo/dash-spv": "1.0.0-pr.1825.1",
     "@dashevo/dashcore-lib": "~0.21.1",
-    "@dashevo/grpc-common": "1.0.0-pr.1694.9",
-    "@dashevo/wasm-dpp": "1.0.0-pr.1694.9",
+    "@dashevo/grpc-common": "1.0.0-pr.1825.1",
+    "@dashevo/wasm-dpp": "1.0.0-pr.1825.1",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
     "google-protobuf": "^3.12.2",