@dashevo/dapi-client 1.8.0 → 2.0.0-rc.1

package/lib/BlockHeadersProvider/BlockHeadersProvider.js

@@ -5,9 +5,10 @@ const BlockHeadersReader = require('./BlockHeadersReader');
 
 /**
  * @typedef {BlockHeadersProviderOptions} BlockHeadersProviderOptions
- * @property {string} [network=testnet]
+ * @property {string} [network='testnet'] network type
  * @property {number} [maxParallelStreams=5] max parallel streams to read historical block headers
  * @property {number} [targetBatchSize=100000] a target batch size per stream
+ * @property {number} [fromBlockHeight=1] a target batch size per stream
  * @property {number} [maxRetries=10] max amount of retries per stream connection
  */
 const defaultOptions = {
@@ -35,9 +36,9 @@ const STATES = {
 
 class BlockHeadersProvider extends EventEmitter {
   /**
-   * @param {BlockHeadersProviderOptions} options
-   * @param {Function} [createHistoricalSyncStream]
-   * @param {Function} [createContinuousSyncStream]
+   * @param {BlockHeadersProviderOptions} options for block headers
+   * @param {Function} [createHistoricalSyncStream] createHistoricalSyncStream
+   * @param {Function} [createContinuousSyncStream] createContinuousSyncStream
    */
   // TODO move options to as last param
   // eslint-disable-next-line default-param-last
@@ -60,7 +61,7 @@ class BlockHeadersProvider extends EventEmitter {
   }
 
   /**
-   * @param {BlockHeadersReader} blockHeadersReader
+   * @param {BlockHeadersReader} blockHeadersReader instance
    */
   setBlockHeadersReader(blockHeadersReader) {
     this.blockHeadersReader = blockHeadersReader;
@@ -68,7 +69,7 @@ class BlockHeadersProvider extends EventEmitter {
 
   /**
    *
-   * @param {SpvChain} spvChain
+   * @param {SpvChain} spvChain instance
    */
   setSpvChain(spvChain) {
     this.spvChain = spvChain;
@@ -104,8 +105,8 @@ class BlockHeadersProvider extends EventEmitter {
 
   /**
    * Initializes SPV chain with a list of headers and a known lastSyncedHeaderHeight
-   * @param headers
-   * @param firstHeaderHeight
+   * @param {BlockHeader[]} headers array of headers
+   * @param firstHeaderHeight {number} first block header height
    */
   async initializeChainWith(headers, firstHeaderHeight) {
     await SpvChain.wasmX11Ready();
@@ -122,7 +123,7 @@ class BlockHeadersProvider extends EventEmitter {
   /**
    * Checks whether spv chain has header at specified height and flushes chains if not
    * @private
-   * @param height
+   * @param {number} height block height
    */
   ensureChainRoot(height) {
     // Flush spv chain in case header at specified height was not found
@@ -134,8 +135,8 @@ class BlockHeadersProvider extends EventEmitter {
 
   /**
    * Reads historical block headers
-   * @param fromBlockHeight
-   * @param toBlockHeight
+   * @param {number} fromBlockHeight height block height
+   * @param {number} toBlockHeight height block height
    * @returns {Promise<void>}
    */
   async readHistorical(fromBlockHeight, toBlockHeight) {
@@ -196,8 +197,8 @@ class BlockHeadersProvider extends EventEmitter {
 
   /**
    * @private
-   * @param headersData
-   * @param reject
+   * @param {object} headersData object with header and headHeight
+   * @param {function} reject callback function
    */
   headersHandler(headersData, reject) {
     const { headers, headHeight } = headersData;

package/lib/SimplifiedMasternodeListProvider/createMasternodeListStreamFactory.js

@@ -11,11 +11,10 @@ const ReconnectableStream = require('../transport/ReconnectableStream');
 
 /**
  * Creates continues masternode list stream
- *
  * @param {createDAPIAddressProviderFromOptions} createDAPIAddressProviderFromOptions
  * @param {ListDAPIAddressProvider} listDAPIAddressProvider
- * @param {Object} options
- * @return {function(...[*]): Promise<ReconnectableStream>}
+ * @param {object} options
+ * @returns {function(...[*]): Promise<ReconnectableStream>}
  */
 function createMasternodeListStreamFactory(
   createDAPIAddressProviderFromOptions,

package/lib/methods/platform/getDataContractHistory/DataContractHistoryEntry.js

@@ -0,0 +1,26 @@
+class DataContractHistoryEntry {
+  /**
+   * @param {bigint} date - timestamp
+   * @param {Buffer} value - buffer value of the data contract
+   */
+  constructor(date, value) {
+    this.date = date;
+    this.value = value;
+  }
+
+  /**
+   * @returns {bigint} - date
+   */
+  getDate() {
+    return this.date;
+  }
+
+  /**
+   * @returns {Buffer} - raw binary value of the data contract
+   */
+  getValue() {
+    return this.value;
+  }
+}
+
+module.exports = DataContractHistoryEntry;

package/lib/methods/platform/getDataContractHistory/GetDataContractHistoryResponse.js

@@ -1,9 +1,10 @@
 const AbstractResponse = require('../response/AbstractResponse');
 const InvalidResponseError = require('../response/errors/InvalidResponseError');
+const DataContractHistoryEntry = require('./DataContractHistoryEntry');
 
 class GetDataContractHistoryResponse extends AbstractResponse {
   /**
-   * @param {object.<number, Buffer>} dataContractHistory
+   * @param {DataContractHistoryEntry[]} dataContractHistory
    * @param {Metadata} metadata
    * @param {Proof} [proof]
    */
@@ -14,7 +15,7 @@ class GetDataContractHistoryResponse extends AbstractResponse {
   }
 
   /**
-   * @returns {object.<number, Buffer>}
+   * @returns {DataContractHistoryEntry[]} array of data contract history entries
    */
   getDataContractHistory() {
     return this.dataContractHistory;
@@ -33,19 +34,12 @@ class GetDataContractHistoryResponse extends AbstractResponse {
       throw new InvalidResponseError('DataContract is not defined');
     }
 
-    const history = {};
-
-    if (dataContractHistory) {
-      const dataContractHistoryEntries = dataContractHistory.getDataContractEntriesList();
-
-      // eslint-disable-next-line no-restricted-syntax
-      for (const historyEntry of dataContractHistoryEntries) {
-        history[historyEntry.getDate()] = historyEntry.getValue();
-      }
-    }
-
     return new GetDataContractHistoryResponse(
-      history,
+      dataContractHistory ? dataContractHistory.getDataContractEntriesList()
+        .map((dataContractHistoryEntry) => new DataContractHistoryEntry(
+          BigInt(dataContractHistoryEntry.getDate()),
+          dataContractHistoryEntry.getValue(),
+        )) : null,
       metadata,
       proof,
     );

package/lib/methods/platform/getDataContractHistory/getDataContractHistoryFactory.js

@@ -18,7 +18,7 @@ function getDataContractHistoryFactory(grpcTransport) {
    * Fetch Data Contract by id
    * @typedef {getDataContractHistory}
    * @param {Buffer} contractId
-   * @param {number} [startAtMs]
+   * @param {bigint} [startAtMs]
    * @param {number} [limit]
    * @param {number} [offset]
    * @param {DAPIClientOptions & {prove: boolean}} [options]
@@ -26,7 +26,7 @@ function getDataContractHistoryFactory(grpcTransport) {
    */
   async function getDataContractHistory(
     contractId,
-    startAtMs = 0,
+    startAtMs = BigInt(0),
     limit = 10,
     offset = 0,
     options = {},
@@ -45,7 +45,7 @@ function getDataContractHistoryFactory(grpcTransport) {
     getDataContractHistoryRequest.setV0(
       new GetDataContractHistoryRequestV0()
         .setId(contractId)
-        .setStartAtMs(startAtMs)
+        .setStartAtMs(startAtMs.toString())
         .setLimit(new UInt32Value([limit]))
         .setOffset(new UInt32Value([offset]))
         .setProve(!!options.prove),

package/lib/methods/platform/getEpochsInfo/EpochInfo.js

@@ -2,9 +2,9 @@ class EpochInfo {
   /**
    *
    * @param {number} number
-   * @param {number} firstBlockHeight
+   * @param {bigint} firstBlockHeight
    * @param {number} firstCoreBlockHeight
-   * @param {number} startTime
+   * @param {bigint} startTime
    * @param {number} feeMultiplier
    */
   constructor(number, firstBlockHeight, firstCoreBlockHeight, startTime, feeMultiplier) {
@@ -23,7 +23,7 @@ class EpochInfo {
   }
 
   /**
-   * @returns {number}
+   * @returns {bigint}
    */
   getFirstBlockHeight() {
     return this.firstBlockHeight;
@@ -37,7 +37,7 @@ class EpochInfo {
   }
 
   /**
-   * @returns {number}
+   * @returns {bigint}
    */
   getStartTime() {
     return this.startTime;

package/lib/methods/platform/getEpochsInfo/GetEpochsInfoResponse.js

@@ -41,9 +41,9 @@ class GetEpochsInfoResponse extends AbstractResponse {
     if (epochsInfoList) {
       epochsInfo = epochsInfoList.map((epoch) => new EpochInfo(
         epoch.getNumber(),
-        epoch.getFirstBlockHeight(),
+        BigInt(epoch.getFirstBlockHeight()),
         epoch.getFirstCoreBlockHeight(),
-        epoch.getStartTime(),
+        BigInt(epoch.getStartTime()),
         epoch.getFeeMultiplier(),
       ));
     }

package/lib/methods/platform/getIdentityBalance/GetIdentityBalanceResponse.js

@@ -3,7 +3,7 @@ const InvalidResponseError = require('../response/errors/InvalidResponseError');
 
 class GetIdentityBalanceResponse extends AbstractResponse {
   /**
-   * @param {number} balance
+   * @param {bigint} balance
    * @param {Metadata} metadata
    * @param {Proof} [proof]
    */
@@ -14,7 +14,7 @@ class GetIdentityBalanceResponse extends AbstractResponse {
   }
 
   /**
-   * @returns {number}
+   * @returns {bigint}
    */
   getBalance() {
     return this.balance;
@@ -25,7 +25,7 @@ class GetIdentityBalanceResponse extends AbstractResponse {
    * @returns {GetIdentityBalanceResponse}
    */
   static createFromProto(proto) {
-    const balance = proto.getV0().getBalance();
+    const balance = BigInt(proto.getV0().getBalance());
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
     if ((balance === null || balance === undefined) && !proof) {

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

@@ -1,11 +1,11 @@
 const AbstractResponse = require('../response/AbstractResponse');
 const InvalidResponseError = require('../response/errors/InvalidResponseError');
 
-const IDENTITY_CONTRACT_NONCE_VALUE_FILTER = 0xFFFFFFFFFF;
+const IDENTITY_CONTRACT_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
 
 class GetIdentityContractNonceResponse extends AbstractResponse {
   /**
-   * @param {number} identityContractNonce
+   * @param {bigint} identityContractNonce
    * @param {Metadata} metadata
    * @param {Proof} [proof]
    */
@@ -16,7 +16,7 @@ class GetIdentityContractNonceResponse extends AbstractResponse {
   }
 
   /**
-   * @returns {number}
+   * @returns {bigint}
    */
   getIdentityContractNonce() {
     return this.identityContractNonce;
@@ -28,8 +28,8 @@ class GetIdentityContractNonceResponse extends AbstractResponse {
    */
   static createFromProto(proto) {
     // eslint-disable-next-line
-    const identityContractNonce = proto.getV0()
-      .getIdentityContractNonce() & IDENTITY_CONTRACT_NONCE_VALUE_FILTER;
+    const identityContractNonce = BigInt(proto.getV0()
+      .getIdentityContractNonce()) & IDENTITY_CONTRACT_NONCE_VALUE_FILTER;
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
       proto,
     );

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

@@ -4,10 +4,14 @@ const {
     GetIdentityKeysRequest,
     KeyRequestType,
     SpecificKeys,
+    AllKeys,
   },
 } = require('@dashevo/dapi-grpc');
+
 const { UInt32Value } = require('google-protobuf/google/protobuf/wrappers_pb');
 
+const { GetIdentityKeysRequestV0 } = GetIdentityKeysRequest;
+
 const GetIdentityKeysResponse = require('./GetIdentityKeysResponse');
 const InvalidResponseError = require('../response/errors/InvalidResponseError');
 
@@ -20,25 +24,30 @@ function getIdentityKeysFactory(grpcTransport) {
    * Fetch the version upgrade votes status
    * @typedef {getIdentityKeys}
    * @param {Buffer} identityId
-   * @param {number[]} keyIds
+   * @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);
     }
 
+    const getIdentityKeysRequest = new GetIdentityKeysRequest();
+    const requestType = new KeyRequestType();
+
+    if (keyIds) {
+      requestType.setSpecificKeys(new SpecificKeys().setKeyIdsList(keyIds));
+    } else {
+      requestType.setAllKeys(new AllKeys());
+    }
+
     getIdentityKeysRequest.setV0(
       new GetIdentityKeysRequestV0()
         .setIdentityId(identityId)
-        .setRequestType(new KeyRequestType()
-          .setSpecificKeys(new SpecificKeys().setKeyIdsList(keyIds)))
+        .setRequestType(requestType)
         .setLimit(new UInt32Value([limit]))
         .setProve(!!options.prove),
     );

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

@@ -1,11 +1,11 @@
 const AbstractResponse = require('../response/AbstractResponse');
 const InvalidResponseError = require('../response/errors/InvalidResponseError');
 
-const IDENTITY_NONCE_VALUE_FILTER = 0xFFFFFFFFFF;
+const IDENTITY_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
 
 class GetIdentityNonceResponse extends AbstractResponse {
   /**
-   * @param {number} identityNonce
+   * @param {bigint} identityNonce
    * @param {Metadata} metadata
    * @param {Proof} [proof]
    */
@@ -16,7 +16,7 @@ class GetIdentityNonceResponse extends AbstractResponse {
   }
 
   /**
-   * @returns {number}
+   * @returns {bigint}
    */
   getIdentityNonce() {
     return this.identityNonce;
@@ -28,8 +28,8 @@ class GetIdentityNonceResponse extends AbstractResponse {
    */
   static createFromProto(proto) {
     // eslint-disable-next-line
-    const identityNonce = proto.getV0()
-      .getIdentityNonce() & IDENTITY_NONCE_VALUE_FILTER;
+    const identityNonce = BigInt(proto.getV0()
+      .getIdentityNonce()) & IDENTITY_NONCE_VALUE_FILTER;
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
       proto,
     );

package/lib/methods/platform/getStatus/ChainStatus.js

@@ -0,0 +1,99 @@
+class ChainStatus {
+  /**
+   * @param {boolean} catchingUp - is node syncing?
+   * @param {string} latestBlockHash - latest block hash
+   * @param {string} latestAppHash - latest app hash
+   * @param {bigint} latestBlockHeight - latest block height
+   * @param {string} earliestBlockHash - earliest block hash
+   * @param {string} earliestAppHash - earliest app hash
+   * @param {bigint} earliestBlockHeight - earliest block height
+   * @param {bigint} maxPeerBlockHeight - max peer block height
+   * @param {number=} coreChainLockedHeight - core chain locked height
+   */
+  constructor(
+    catchingUp,
+    latestBlockHash,
+    latestAppHash,
+    latestBlockHeight,
+    earliestBlockHash,
+    earliestAppHash,
+    earliestBlockHeight,
+    maxPeerBlockHeight,
+    coreChainLockedHeight,
+  ) {
+    this.catchingUp = catchingUp;
+    this.latestBlockHash = latestBlockHash;
+    this.latestAppHash = latestAppHash;
+    this.latestBlockHeight = latestBlockHeight;
+    this.earliestBlockHash = earliestBlockHash;
+    this.earliestAppHash = earliestAppHash;
+    this.earliestBlockHeight = earliestBlockHeight;
+    this.maxPeerBlockHeight = maxPeerBlockHeight;
+    this.coreChainLockedHeight = coreChainLockedHeight || null;
+  }
+
+  /**
+   * @returns {boolean} returns true if node is currently syncing
+   */
+  isCatchingUp() {
+    return this.catchingUp;
+  }
+
+  /**
+   * @returns {string} latest block hash
+   */
+  getLatestBlockHash() {
+    return this.latestBlockHash;
+  }
+
+  /**
+   * @returns {string} latest app hash
+   */
+  getLatestAppHash() {
+    return this.latestAppHash;
+  }
+
+  /**
+   * @returns {bigint} latest block height
+   */
+  getLatestBlockHeight() {
+    return this.latestBlockHeight;
+  }
+
+  /**
+   * @returns {string} earliest block hash
+   */
+  getEarliestBlockHash() {
+    return this.earliestBlockHash;
+  }
+
+  /**
+   * @returns {string} earliest app hash
+   */
+  getEarliestAppHash() {
+    return this.earliestAppHash;
+  }
+
+  /**
+   * @returns {bigint} earliest block height
+   */
+  getEarliestBlockHeight() {
+    return this.earliestBlockHeight;
+  }
+
+  /**
+   * @returns {bigint} max peer block height
+   */
+  getMaxPeerBlockHeight() {
+    return this.maxPeerBlockHeight;
+  }
+
+  /**
+   * @returns {number|null} core chain locked height
+   */
+  getCoreChainLockedHeight() {
+    return this.coreChainLockedHeight;
+  }
+}
+
+module.exports = ChainStatus;

package/lib/methods/platform/getStatus/GetStatusResponse.js

@@ -0,0 +1,164 @@
+const VersionStatus = require('./VersionStatus');
+const NodeStatus = require('./NodeStatus');
+const ChainStatus = require('./ChainStatus');
+const TimeStatus = require('./TimeStatus');
+const StateSyncStatus = require('./StateSyncStatus');
+const NetworkStatus = require('./NetworkStatus');
+
+class GetStatusResponse {
+  /**
+   * @param {VersionStatus} version - status versions
+   * @param {NodeStatus} node - node status
+   * @param {ChainStatus} chain - chain status
+   * @param {NetworkStatus} network - network status
+   * @param {StateSyncStatus} stateSync - state sync status
+   * @param {TimeStatus} time - time status
+   */
+  constructor(version, node, chain, network, stateSync, time) {
+    this.version = version;
+    this.node = node;
+    this.chain = chain;
+    this.network = network;
+    this.stateSync = stateSync;
+    this.time = time;
+  }
+
+  /**
+   * @returns {VersionStatus} network versions status
+   */
+  getVersionStatus() {
+    return this.version;
+  }
+
+  /**
+   * @returns {NodeStatus} node info status
+   */
+  getNodeStatus() {
+    return this.node;
+  }
+
+  /**
+   * @returns {ChainStatus} chain status
+   */
+  getChainStatus() {
+    return this.chain;
+  }
+
+  /**
+   * @returns {NetworkStatus} network status
+   */
+  getNetworkStatus() {
+    return this.network;
+  }
+
+  /**
+   * @returns {StateSyncStatus} state sync status
+   */
+  getStateSyncStatus() {
+    return this.stateSync;
+  }
+
+  /**
+   * @returns {TimeStatus} time status
+   */
+  getTimeStatus() {
+    return this.time;
+  }
+
+  /**
+   * @param {GetStatusResponse} proto GRPC GetStatusResponse
+   * @returns {GetStatusResponse} JS DAPI Client GetStatusResponse
+   */
+  static createFromProto(proto) {
+    const v0 = proto.getV0();
+
+    const dapiVersion = v0.getVersion().getSoftware().getDapi();
+    const driveVersion = v0.getVersion().getSoftware().getDrive();
+    const tenderdashVersion = v0.getVersion().getSoftware().getTenderdash();
+    const tenderdashP2pProtocol = v0.getVersion().getProtocol().getTenderdash().getP2p();
+    const tenderdashBlockProtocol = v0.getVersion().getProtocol().getTenderdash().getBlock();
+    const driveCurrentProtocol = v0.getVersion().getProtocol().getDrive().getCurrent();
+    const driveLatestProtocol = v0.getVersion().getProtocol().getDrive().getLatest();
+
+    const version = new VersionStatus(
+      dapiVersion,
+      driveVersion,
+      tenderdashVersion,
+      tenderdashP2pProtocol,
+      tenderdashBlockProtocol,
+      driveCurrentProtocol,
+      driveLatestProtocol,
+    );
+
+    const nodeId = Buffer.from(v0.getNode().getId()).toString('hex');
+    const proTxHash = Buffer.from(v0.getNode().getProTxHash()).toString('hex');
+
+    const node = new NodeStatus(nodeId, proTxHash);
+
+    const catchingUp = v0.getChain().getCatchingUp();
+    const latestBlockHash = Buffer.from(v0.getChain().getLatestBlockHash()).toString('hex');
+    const latestAppHash = Buffer.from(v0.getChain().getLatestAppHash()).toString('hex');
+    const latestBlockHeight = BigInt(v0.getChain().getLatestBlockHeight());
+    const earliestBlockHash = Buffer.from(v0.getChain().getEarliestBlockHash()).toString('hex');
+    const earliestAppHash = Buffer.from(v0.getChain().getEarliestAppHash()).toString('hex');
+    const earliestBlockHeight = BigInt(v0.getChain().getEarliestBlockHeight());
+    const maxPeerBlockHeight = BigInt(v0.getChain().getMaxPeerBlockHeight());
+    const coreChainLockedHeight = v0.getChain().getCoreChainLockedHeight();
+
+    const chain = new ChainStatus(
+      catchingUp,
+      latestBlockHash,
+      latestAppHash,
+      latestBlockHeight,
+      earliestBlockHash,
+      earliestAppHash,
+      earliestBlockHeight,
+      maxPeerBlockHeight,
+      coreChainLockedHeight,
+    );
+
+    const chainId = v0.getNetwork().getChainId();
+    const peersCount = v0.getNetwork().getPeersCount();
+    const isListening = v0.getNetwork().getListening();
+
+    const network = new NetworkStatus(chainId, peersCount, isListening);
+
+    const totalSyncedTime = BigInt(v0.getStateSync().getTotalSyncedTime());
+    const remainingTime = BigInt(v0.getStateSync().getRemainingTime());
+    const totalSnapshots = v0.getStateSync().getTotalSnapshots();
+    const chunkProcessAverageTime = BigInt(v0.getStateSync().getChunkProcessAvgTime());
+    const snapshotHeight = BigInt(v0.getStateSync().getSnapshotHeight());
+    const snapshotChunksCount = BigInt(v0.getStateSync().getSnapshotChunksCount());
+    const backfilledBlocks = BigInt(v0.getStateSync().getBackfilledBlocks());
+    const backfillBlocksTotal = BigInt(v0.getStateSync().getBackfillBlocksTotal());
+
+    const stateSync = new StateSyncStatus(
+      totalSyncedTime,
+      remainingTime,
+      totalSnapshots,
+      chunkProcessAverageTime,
+      snapshotHeight,
+      snapshotChunksCount,
+      backfilledBlocks,
+      backfillBlocksTotal,
+    );
+
+    const local = BigInt(v0.getTime().getLocal());
+    const block = BigInt(v0.getTime().getBlock());
+    const genesis = BigInt(v0.getTime().getGenesis());
+    const epoch = v0.getTime().getEpoch();
+
+    const time = new TimeStatus(local, block, genesis, epoch);
+
+    return new GetStatusResponse(
+      version,
+      node,
+      chain,
+      network,
+      stateSync,
+      time,
+    );
+  }
+}
+
+module.exports = GetStatusResponse;

package/lib/methods/platform/getStatus/NetworkStatus.js

@@ -0,0 +1,35 @@
+class NetworkStatus {
+  /**
+   * @param {string} chainId - Chain id
+   * @param {number} peersCount - Peers count
+   * @param {boolean} listening - Is listening to P2P network
+   */
+  constructor(chainId, peersCount, listening) {
+    this.chainId = chainId;
+    this.peersCount = peersCount;
+    this.listening = listening;
+  }
+
+  /**
+   * @returns {string} chain id
+   */
+  getChainId() {
+    return this.chainId;
+  }
+
+  /**
+   * @returns {number} peers count
+   */
+  getPeersCount() {
+    return this.peersCount;
+  }
+
+  /**
+   * @returns {boolean} is listening to p2p
+   */
+  isListening() {
+    return this.listening;
+  }
+}
+
+module.exports = NetworkStatus;

package/lib/methods/platform/getStatus/NodeStatus.js

@@ -0,0 +1,26 @@
+class NodeStatus {
+  /**
+   * @param {string} nodeId - Node ID
+   * @param {string=} proTxHash - Node's proTxHash
+   */
+  constructor(nodeId, proTxHash) {
+    this.nodeId = nodeId;
+    this.proTxHash = proTxHash || null;
+  }
+
+  /**
+   * @returns {string} Node ID
+   */
+  getNodeId() {
+    return this.nodeId;
+  }
+
+  /**
+   * @returns {string} Pro Tx Hash
+   */
+  getProTxHash() {
+    return this.proTxHash;
+  }
+}
+
+module.exports = NodeStatus;

package/lib/methods/platform/getStatus/StateSyncStatus.js

@@ -0,0 +1,89 @@
+class StateSyncStatus {
+  /**
+   * @param {bigint} totalSyncedTime - Total synced time
+   * @param {bigint} remainingTime - Remaining time to sync
+   * @param {number} totalSnapshots - Total snapshots count
+   * @param {bigint} chunkProcessAverageTime - Chunk process average time
+   * @param {bigint} snapshotHeight - Snapshot height
+   * @param {bigint} snapshotChunksCount - Snapshot chunks count
+   * @param {bigint} backfilledBlocks - Backfilled blocks
+   * @param {bigint} backfillBlocksTotal - Backfilled blocks total count
+   */
+  constructor(
+    totalSyncedTime,
+    remainingTime,
+    totalSnapshots,
+    chunkProcessAverageTime,
+    snapshotHeight,
+    snapshotChunksCount,
+    backfilledBlocks,
+    backfillBlocksTotal,
+  ) {
+    this.totalSyncedTime = totalSyncedTime;
+    this.remainingTime = remainingTime;
+    this.totalSnapshots = totalSnapshots;
+    this.chunkProcessAverageTime = chunkProcessAverageTime;
+    this.snapshotHeight = snapshotHeight;
+    this.snapshotChunksCount = snapshotChunksCount;
+    this.backfilledBlocks = backfilledBlocks;
+    this.backfillBlocksTotal = backfillBlocksTotal;
+  }
+
+  /**
+   * @returns {bigint} Total synced time
+   */
+  getTotalSyncedTime() {
+    return this.totalSyncedTime;
+  }
+
+  /**
+   * @returns {bigint} Total synced time
+   */
+  getRemainingTime() {
+    return this.remainingTime;
+  }
+
+  /**
+   * @returns {number} Total snapshots count
+   */
+  getTotalSnapshots() {
+    return this.totalSnapshots;
+  }
+
+  /**
+   * @returns {bigint} Chunk process average time
+   */
+  getChunkProcessAverageTime() {
+    return this.chunkProcessAverageTime;
+  }
+
+  /**
+   * @returns {bigint} Chunk process average time
+   */
+  getSnapshotHeight() {
+    return this.snapshotHeight;
+  }
+
+  /**
+   * @returns {bigint} Chunk process average time
+   */
+  getSnapshotChunkCount() {
+    return this.snapshotChunksCount;
+  }
+
+  /**
+   * @returns {bigint} Backfilled blocks
+   */
+  getBackfilledBlocks() {
+    return this.backfilledBlocks;
+  }
+
+  /**
+   * @returns {bigint} Backfill blocks total
+   */
+  getBackfilledBlockTotal() {
+    return this.backfillBlocksTotal;
+  }
+}
+
+module.exports = StateSyncStatus;

package/lib/methods/platform/getStatus/TimeStatus.js

@@ -0,0 +1,49 @@
+class TimeStatus {
+  /**
+   * @param {bigint} local - Local system time
+   * @param {bigint=} block - Block time
+   * @param {bigint=} genesis - Genesis time
+   * @param {number=} epoch - Epoch number
+   */
+  constructor(
+    local,
+    block,
+    genesis,
+    epoch,
+  ) {
+    this.local = local;
+    this.block = typeof block === 'bigint' ? block : null;
+    this.genesis = typeof genesis === 'bigint' ? genesis : null;
+    this.epoch = epoch || null;
+  }
+
+  /**
+   * @returns {bigint} Local system time
+   */
+  getLocalTime() {
+    return this.local;
+  }
+
+  /**
+   * @returns {bigint|null} Block time
+   */
+  getBlockTime() {
+    return this.block;
+  }
+
+  /**
+   * @returns {bigint|null} Genesis time
+   */
+  getGenesisTime() {
+    return this.genesis;
+  }
+
+  /**
+   * @returns {number|null} Epoch number
+   */
+  getEpochNumber() {
+    return this.epoch;
+  }
+}
+
+module.exports = TimeStatus;

package/lib/methods/platform/getStatus/VersionStatus.js

@@ -0,0 +1,79 @@
+class VersionStatus {
+  /**
+   * @param {string} dapiVersion - DAPI version
+   * @param {string=} driveVersion - Drive ABCI version
+   * @param {string=} tenderdashVersion - Tenderdash version
+   * @param {number} tenderdashP2pProtocol - Tenderdash Protocol Version
+   * @param {number} tenderdashBlockProtocol - Tenderdash Block Version
+   * @param {number} driveCurrentProtocol - Current Dash Platform (Drive) protocol version
+   * @param {number} driveLatestProtocol - Next Dash Platform (Drive) protocol version
+   */
+  constructor(
+    dapiVersion,
+    driveVersion,
+    tenderdashVersion,
+    tenderdashP2pProtocol,
+    tenderdashBlockProtocol,
+    driveCurrentProtocol,
+    driveLatestProtocol,
+  ) {
+    this.dapiVersion = dapiVersion;
+    this.driveVersion = driveVersion || null;
+    this.tenderdashVersion = tenderdashVersion || null;
+    this.tenderdashP2pProtocol = tenderdashP2pProtocol;
+    this.tenderdashBlockProtocol = tenderdashBlockProtocol;
+    this.driveCurrentProtocol = driveCurrentProtocol;
+    this.driveLatestProtocol = driveLatestProtocol;
+  }
+
+  /**
+   * @returns {string|null} DAPI version
+   */
+  getDapiVersion() {
+    return this.dapiVersion;
+  }
+
+  /**
+   * @returns {string|null} Drive ABCI version
+   */
+  getDriveVersion() {
+    return this.driveVersion;
+  }
+
+  /**
+   * @returns {string|null} Tenderdash version
+   */
+  getTenderdashVersion() {
+    return this.tenderdashVersion;
+  }
+
+  /**
+   * @returns {number} Tenderdash P2P protocol
+   */
+  getTenderdashP2pProtocol() {
+    return this.tenderdashP2pProtocol;
+  }
+
+  /**
+   * @returns {number} Tenderdash Block protocol
+   */
+  getTenderdashBlockProtocol() {
+    return this.tenderdashBlockProtocol;
+  }
+
+  /**
+   * @returns {number} Drive Current Protocol
+   */
+  getDriveCurrentProtocol() {
+    return this.driveCurrentProtocol;
+  }
+
+  /**
+   * @returns {number} Drive Latest Protocol
+   */
+  getDriveLatestProtocol() {
+    return this.driveLatestProtocol;
+  }
+}
+
+module.exports = VersionStatus;

package/lib/methods/platform/getStatus/getStatusFactory.js

@@ -6,18 +6,18 @@ const {
 } = require('@dashevo/dapi-grpc');
 
 const InvalidResponseError = require('../response/errors/InvalidResponseError');
+const GetStatusResponse = require('./GetStatusResponse');
 
 /**
  * @param {GrpcTransport} grpcTransport
- * @returns {getIdentity}
+ * @returns {getStatus}
  */
 function getStatusFactory(grpcTransport) {
   /**
-   * Fetch the identity by id
-   * @typedef {getIdentity}
-   * @param {Buffer} id
+   * Fetch node status
+   * @typedef {getStatus}
    * @param {DAPIClientOptions & {prove: boolean}} [options]
-   * @returns {Promise<GetIdentityResponse>}
+   * @returns {Promise<GetStatusResponse>}
    */
   async function getStatus(options = {}) {
     const { GetStatusRequestV0 } = GetStatusRequest;
@@ -45,7 +45,7 @@ function getStatusFactory(grpcTransport) {
           throw new InvalidResponseError('GetStatusResponseV0 is not defined');
         }
 
-        return getStatusResponse.getV0().toObject();
+        return GetStatusResponse.createFromProto(getStatusResponse);
       } catch (e) {
         if (e instanceof InvalidResponseError) {
           lastError = e;

package/lib/methods/platform/getTotalCreditsInPlatform/GetTotalCreditsInPlatformResponse.js

@@ -3,7 +3,7 @@ const InvalidResponseError = require('../response/errors/InvalidResponseError');
 
 class GetTotalCreditsInPlatformResponse extends AbstractResponse {
   /**
-   * @param {number} totalCreditsInPlatform
+   * @param {bigint} totalCreditsInPlatform
    * @param {Metadata} metadata
    * @param {Proof} [proof]
    */
@@ -14,7 +14,7 @@ class GetTotalCreditsInPlatformResponse extends AbstractResponse {
   }
 
   /**
-   * @returns {number}
+   * @returns {bigint}
    */
   getTotalCreditsInPlatform() {
     return this.totalCreditsInPlatform;
@@ -26,7 +26,7 @@ class GetTotalCreditsInPlatformResponse extends AbstractResponse {
    */
   static createFromProto(proto) {
     // eslint-disable-next-line
-    const totalCreditsInPlatform = proto.getV0().getCredits();
+    const totalCreditsInPlatform = BigInt(proto.getV0().getCredits());
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
       proto,
     );

package/lib/methods/platform/response/AbstractResponse.js

@@ -50,7 +50,12 @@ class AbstractResponse {
     }
 
     return {
-      metadata: new Metadata(metadata.toObject()),
+      metadata: new Metadata({
+        height: metadata.getHeight(),
+        coreChainLockedHeight: metadata.getCoreChainLockedHeight(),
+        timeMs: metadata.getTimeMs(),
+        protocolVersion: metadata.getProtocolVersion(),
+      }),
       proof,
     };
   }

package/lib/methods/platform/response/Metadata.js

@@ -1,21 +1,21 @@
 class Metadata {
   /**
    * @param {object} properties
-   * @param {number} properties.height - block height
+   * @param {bigint|string} properties.height - block height
    * @param {number} properties.coreChainLockedHeight - core chain locked height
-   * @param {number} properties.timeMs - block time
+   * @param {bigint|string} properties.timeMs - block time
    * @param {number} properties.protocolVersion - protocol version
    */
   constructor(properties) {
-    this.height = properties.height;
+    this.height = BigInt(properties.height);
     this.coreChainLockedHeight = properties.coreChainLockedHeight;
-    this.timeMs = properties.timeMs;
+    this.timeMs = BigInt(properties.timeMs);
     this.protocolVersion = properties.protocolVersion;
   }
 
   /**
    * Get height
-   * @returns {number} - block height
+   * @returns {bigint} - block height
    */
   getHeight() {
     return this.height;
@@ -31,7 +31,7 @@ class Metadata {
 
   /**
    * Get block time
-   * @returns {number}
+   * @returns {bigint}
    */
   getTimeMs() {
     return this.timeMs;

package/lib/methods/platform/waitForStateTransitionResult/ErrorResult.js

@@ -2,7 +2,7 @@ class ErrorResult {
   /**
    * @param {number} code
    * @param {string} message
-   * @param {*} data
+   * @param {Buffer|undefined} data
    */
   constructor(code, message, data) {
     this.code = code;
@@ -25,7 +25,7 @@ class ErrorResult {
   }
 
   /**
-   * @returns {*}
+   * @returns {Buffer|undefined}
    */
   getData() {
     return this.data;

package/lib/methods/platform/waitForStateTransitionResult/WaitForStateTransitionResultResponse.js

@@ -1,5 +1,3 @@
-const cbor = require('cbor');
-
 const AbstractResponse = require('../response/AbstractResponse');
 const Metadata = require('../response/Metadata');
 const Proof = require('../response/Proof');
@@ -38,9 +36,9 @@ class WaitForStateTransitionResultResponse extends AbstractResponse {
 
     if (proto.getV0().getError()) {
       let data;
-      const rawData = proto.getV0().getError().getData();
-      if (rawData) {
-        data = cbor.decode(Buffer.from(rawData));
+
+      if (proto.getV0().getError().getData()) {
+        data = Buffer.from(proto.getV0().getError().getData());
       }
 
       error = new ErrorResult(

package/lib/test/fixtures/getMetadataFixture.js

@@ -1,17 +1,16 @@
 /**
  * @returns {{
- * coreChainLockedHeight: number,
- * height: number,
- * signature: Buffer,
+ * height: bigint,
+ * coreChainLockedHeight: string,
+ * timeMs: string,
  * protocolVersion: number,
- * timeMs: number,
  * }}
  */
 function getMetadataFixture() {
   return {
-    height: 10,
-    coreChainLockedHeight: 42,
-    timeMs: new Date().getTime(),
+    height: BigInt(10),
+    coreChainLockedHeight: '42',
+    timeMs: new Date().getTime().toString(),
     protocolVersion: 1,
   };
 }

package/lib/test/fixtures/getStatusFixture.js

@@ -0,0 +1,62 @@
+/**
+ *
+ */
+function getStatusFixture() {
+  return {
+    version: {
+      software: {
+        dapi: '1.8.0-rc.2',
+        drive: '1.8.0-rc.3',
+        tenderdash: '1.4.0',
+      },
+      protocol: {
+        tenderdash: {
+          p2p: 10,
+          block: 14,
+        },
+        drive: {
+          latest: 9,
+          current: 8,
+        },
+      },
+    },
+    node: {
+      id: new Uint8Array(Buffer.from('QbMI9zfKnjn2e1UxWJAxmKiMUW4=', 'base64')),
+      proTxHash: new Uint8Array(Buffer.from('s7V0hXG2D+mtEScV1qUXJdblpSqcOvX9NqFyTPUNhi8=', 'base64')),
+    },
+    chain: {
+      catchingUp: false,
+      latestBlockHash: new Uint8Array(Buffer.from('mVDwGtY2oJSaLLgv3WpLp2dFDyFEtqhD4z1gl2OJceY=', 'base64')),
+      latestAppHash: new Uint8Array(Buffer.from('jHgEBK8aZ74TUKcUGN58EFzUNvNsLboOgYe6eH/JetU=', 'base64')),
+      latestBlockHeight: '94461',
+      earliestBlockHash: new Uint8Array(Buffer.from('CPoCwn7AOQujAeT8fj1+rbNQyBk+PmKgk2iXBuOiC/o=', 'base64')),
+      earliestAppHash: new Uint8Array(Buffer.from('vwzLnKBxugGubmegwJD5eAPSbVbWddzVExeBy8rI7I8=', 'base64')),
+      earliestBlockHeight: '1',
+      maxPeerBlockHeight: '94461',
+      coreChainLockedHeight: 1187358,
+    },
+    network: {
+      chainId: 'dash-testnet-51',
+      peersCount: 96,
+      listening: true,
+    },
+    stateSync: {
+      totalSyncedTime: '2312323',
+      remainingTime: '1337',
+      totalSnapshots: 300,
+      chunkProcessAverageTime: '213123',
+      snapshotHeight: '10000',
+      snapshotChunksCount: '1000',
+      backfilledBlocks: '1400',
+      backfillBlocksTotal: '2000',
+    },
+    time: {
+      local: '1738336806994',
+      block: '1738336736273',
+      genesis: '0',
+      epoch: 4717,
+    },
+  };
+}
+
+module.exports = getStatusFixture;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "1.8.0",
+  "version": "2.0.0-rc.1",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/index.js",
   "contributors": [
@@ -26,11 +26,11 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "1.8.0",
+    "@dashevo/dapi-grpc": "2.0.0-rc.1",
     "@dashevo/dash-spv": "2.8.0",
     "@dashevo/dashcore-lib": "~0.22.0",
-    "@dashevo/grpc-common": "1.8.0",
-    "@dashevo/wasm-dpp": "1.8.0",
+    "@dashevo/grpc-common": "2.0.0-rc.1",
+    "@dashevo/wasm-dpp": "2.0.0-rc.1",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
     "google-protobuf": "^3.12.2",
@@ -41,7 +41,7 @@
     "winston": "^3.2.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.23.3",
+    "@babel/core": "^7.26.10",
     "assert-browserify": "^2.0.0",
     "babel-loader": "^9.1.3",
     "browserify-zlib": "^0.2.0",
@@ -64,7 +64,7 @@
     "karma-mocha": "^2.0.1",
     "karma-mocha-reporter": "^2.2.5",
     "karma-webpack": "^5.0.0",
-    "mocha": "^10.2.0",
+    "mocha": "^11.1.0",
     "nyc": "^15.1.0",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
@@ -82,7 +82,8 @@
   "files": [
     "docs",
     "lib",
-    "polyfills"
+    "polyfills",
+    "dist"
   ],
   "scripts": {
     "build:web": "webpack",