@dashevo/dapi-client 0.25.22 → 1.0.0-beta.1

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 votes 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 votes 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/methods/platform/getProtocolVersionUpgradeVoteStatus/GetProtocolVersionUpgradeVoteStatusResponse.js

@@ -32,7 +32,7 @@ class GetProtocolVersionUpgradeVoteStatusResponse extends AbstractResponse {
     );
 
     if (!versions && !proof) {
-      throw new InvalidResponseError('Version upgrade vote status is not defined');
+      throw new InvalidResponseError('Version upgrade votes status is not defined');
     }
 
     let versionSignals = [];

package/lib/methods/platform/getProtocolVersionUpgradeVoteStatus/getProtocolVersionUpgradeVoteStatusFactory.js

@@ -14,7 +14,7 @@ const InvalidResponseError = require('../response/errors/InvalidResponseError');
  */
 function getProtocolVersionUpgradeVoteStatusFactory(grpcTransport) {
   /**
-   * Fetch the version upgrade vote status
+   * Fetch the version upgrade votes status
    * @typedef {getProtocolVersionUpgradeVoteStatus}
    * @param {string} startProTxHash
    * @param {number} count

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/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/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": "0.25.22",
+  "version": "1.0.0-beta.1",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/index.js",
   "contributors": [
@@ -26,11 +26,11 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "0.25.22",
-    "@dashevo/dash-spv": "0.25.22",
-    "@dashevo/dashcore-lib": "~0.21.0",
-    "@dashevo/grpc-common": "0.25.22",
-    "@dashevo/wasm-dpp": "0.25.22",
+    "@dashevo/dapi-grpc": "1.0.0-beta.1",
+    "@dashevo/dash-spv": "1.0.0-beta.1",
+    "@dashevo/dashcore-lib": "~0.21.2",
+    "@dashevo/grpc-common": "1.0.0-beta.1",
+    "@dashevo/wasm-dpp": "1.0.0-beta.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/core/getStatusFactory.js

@@ -1,68 +0,0 @@
-const {
-  v0: {
-    GetStatusRequest,
-    GetStatusResponse,
-    CorePromiseClient,
-  },
-} = require('@dashevo/dapi-grpc');
-
-/**
- * @param {GrpcTransport} grpcTransport
- * @returns {getStatus}
- */
-function getStatusFactory(grpcTransport) {
-  /**
-   * Get Core chain status
-   * @typedef {getStatus}
-   * @param {DAPIClientOptions} [options]
-   * @returns {Promise<object>}
-   */
-  async function getStatus(options = {}) {
-    const getStatusRequest = new GetStatusRequest();
-
-    const response = await grpcTransport.request(
-      CorePromiseClient,
-      'getStatus',
-      getStatusRequest,
-      options,
-    );
-
-    const responseObject = response.toObject();
-
-    // Respond with Buffers instead of base64 for binary fields
-
-    if (response.getChain()) {
-      if (response.getChain().getBestBlockHash()) {
-        responseObject.chain.bestBlockHash = Buffer.from(response.getChain().getBestBlockHash());
-      }
-
-      if (response.getChain().getChainWork()) {
-        responseObject.chain.chainWork = Buffer.from(response.getChain().getChainWork());
-      }
-    }
-
-    if (response.getMasternode()) {
-      if (response.getMasternode().getProTxHash()) {
-        responseObject.masternode.proTxHash = Buffer.from(response.getMasternode().getProTxHash());
-      }
-    }
-
-    // Respond with constant names instead of constant values
-
-    responseObject.status = Object.keys(GetStatusResponse.Status)
-      .find((key) => GetStatusResponse.Status[key] === responseObject.status);
-
-    if (responseObject.masternode) {
-      responseObject.masternode.status = Object.keys(GetStatusResponse.Masternode.Status)
-        .find((key) => (
-          GetStatusResponse.Masternode.Status[key] === responseObject.masternode.status
-        ));
-    }
-
-    return responseObject;
-  }
-
-  return getStatus;
-}
-
-module.exports = getStatusFactory;

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;