@dashevo/dapi-client 0.25.8 → 0.25.10

package/lib/methods/platform/PlatformMethodsFacade.js

@@ -6,6 +6,9 @@ const getIdentityFactory = require('./getIdentity/getIdentityFactory');
 const getIdentitiesByPublicKeyHashesFactory = require('./getIdentitiesByPublicKeyHashes/getIdentitiesByPublicKeyHashesFactory');
 const waitForStateTransitionResultFactory = require('./waitForStateTransitionResult/waitForStateTransitionResultFactory');
 const getConsensusParamsFactory = require('./getConsensusParams/getConsensusParamsFactory');
+const getEpochsInfoFactory = require('./getEpochsInfo/getEpochsInfoFactory');
+const getVersionUpgradeVoteStatusFactory = require('./getVersionUpgradeVoteStatus/getVersionUpgradeVoteStatusFactory');
+const getVersionUpgradeStateFactory = require('./getVersionUpgradeState/getVersionUpgradeStateFactory');
 
 class PlatformMethodsFacade {
   /**
@@ -20,6 +23,9 @@ class PlatformMethodsFacade {
     this.getIdentitiesByPublicKeyHashes = getIdentitiesByPublicKeyHashesFactory(grpcTransport);
     this.waitForStateTransitionResult = waitForStateTransitionResultFactory(grpcTransport);
     this.getConsensusParams = getConsensusParamsFactory(grpcTransport);
+    this.getEpochsInfo = getEpochsInfoFactory(grpcTransport);
+    this.getVersionUpgradeVoteStatus = getVersionUpgradeVoteStatusFactory(grpcTransport);
+    this.getVersionUpgradeState = getVersionUpgradeStateFactory(grpcTransport);
   }
 }
 

package/lib/methods/platform/getConsensusParams/getConsensusParamsFactory.js

@@ -7,6 +7,10 @@ const {
 const InvalidResponseError = require('../response/errors/InvalidResponseError');
 const GetConsensusParamsResponse = require('./getConsensusParamsResponse');
 
+const {
+  GetConsensusParamsRequestV0,
+} = GetConsensusParamsRequest;
+
 /**
  * @param {GrpcTransport} grpcTransport
  * @returns {getConsensusParams}
@@ -22,11 +26,15 @@ function getConsensusParamsFactory(grpcTransport) {
    */
   async function getConsensusParams(height = undefined, options = {}) {
     const getConsensusParamsRequest = new GetConsensusParamsRequest();
+    getConsensusParamsRequest.setV0(
+      new GetConsensusParamsRequestV0(),
+    );
+
     if (height !== undefined) {
-      getConsensusParamsRequest.setHeight(height);
+      getConsensusParamsRequest.getV0().setHeight(height);
     }
 
-    getConsensusParamsRequest.setProve(!!options.prove);
+    getConsensusParamsRequest.getV0().setProve(!!options.prove);
 
     let lastError;
 

package/lib/methods/platform/getConsensusParams/getConsensusParamsResponse.js

@@ -32,8 +32,8 @@ class GetConsensusParamsResponse {
    * @returns {GetConsensusParamsResponse}
    */
   static createFromProto(proto) {
-    const protoBlock = proto.getBlock();
-    const protoEvidence = proto.getEvidence();
+    const protoBlock = proto.getV0().getBlock();
+    const protoEvidence = proto.getV0().getEvidence();
 
     if (!protoBlock && !protoEvidence) {
       throw new InvalidResponseError('Consensus params are not defined');

package/lib/methods/platform/getDataContract/GetDataContractResponse.js

@@ -25,7 +25,7 @@ class GetDataContractResponse extends AbstractResponse {
    * @returns {GetDataContractResponse}
    */
   static createFromProto(proto) {
-    const dataContract = proto.getDataContract();
+    const dataContract = proto.getV0().getDataContract();
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
     if (!dataContract && !proof) {

package/lib/methods/platform/getDataContract/getDataContractFactory.js

@@ -22,6 +22,7 @@ function getDataContractFactory(grpcTransport) {
    * @returns {Promise<GetDataContractResponse>}
    */
   async function getDataContract(contractId, options = {}) {
+    const { GetDataContractRequestV0 } = GetDataContractRequest;
     const getDataContractRequest = new GetDataContractRequest();
 
     // need to convert objects inherited from Buffer to pure buffer as google protobuf
@@ -32,8 +33,11 @@ function getDataContractFactory(grpcTransport) {
       contractId = Buffer.from(contractId);
     }
 
-    getDataContractRequest.setId(contractId);
-    getDataContractRequest.setProve(!!options.prove);
+    getDataContractRequest.setV0(
+      new GetDataContractRequestV0()
+        .setId(contractId)
+        .setProve(!!options.prove),
+    );
 
     let lastError;
 

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

@@ -26,7 +26,7 @@ class GetDataContractHistoryResponse extends AbstractResponse {
    */
   static createFromProto(proto) {
     // History is something that we need to call a method to get a list of entries on
-    const dataContractHistory = proto.getDataContractHistory();
+    const dataContractHistory = proto.getV0().getDataContractHistory();
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
     if (!dataContractHistory && !proof) {

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

@@ -32,6 +32,7 @@ function getDataContractHistoryFactory(grpcTransport) {
     offset = 0,
     options = {},
   ) {
+    const { GetDataContractHistoryRequestV0 } = GetDataContractHistoryRequest;
     const getDataContractHistoryRequest = new GetDataContractHistoryRequest();
 
     // need to convert objects inherited from Buffer to pure buffer as google protobuf
@@ -42,11 +43,14 @@ function getDataContractHistoryFactory(grpcTransport) {
       contractId = Buffer.from(contractId);
     }
 
-    getDataContractHistoryRequest.setId(contractId);
-    getDataContractHistoryRequest.setStartAtMs(startAtMs);
-    getDataContractHistoryRequest.setLimit(new UInt32Value([limit]));
-    getDataContractHistoryRequest.setOffset(new UInt32Value([offset]));
-    getDataContractHistoryRequest.setProve(!!options.prove);
+    getDataContractHistoryRequest.setV0(
+      new GetDataContractHistoryRequestV0()
+        .setId(contractId)
+        .setStartAtMs(startAtMs)
+        .setLimit(new UInt32Value([limit]))
+        .setOffset(new UInt32Value([offset]))
+        .setProve(!!options.prove),
+    );
 
     let lastError;
 

package/lib/methods/platform/getDocuments/GetDocumentsResponse.js

@@ -26,7 +26,7 @@ class GetDocumentsResponse extends AbstractResponse {
   static createFromProto(proto) {
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
-    const documents = proto.getDocuments();
+    const documents = proto.getV0().getDocuments();
 
     return new GetDocumentsResponse(
       documents !== undefined

package/lib/methods/platform/getDocuments/getDocumentsFactory.js

@@ -43,6 +43,7 @@ function getDocumentsFactory(grpcTransport) {
       orderBySerialized = cbor.encode(orderBy);
     }
 
+    const { GetDocumentsRequestV0 } = GetDocumentsRequest;
     const getDocumentsRequest = new GetDocumentsRequest();
     // need to convert Identifier to pure buffer as google protobuf doesn't support extended buffers
     // https://github.com/protocolbuffers/protobuf/blob/master/js/binary/utils.js#L1049
@@ -55,14 +56,17 @@ function getDocumentsFactory(grpcTransport) {
       contractId = Buffer.from(contractId);
     }
 
-    getDocumentsRequest.setDataContractId(contractId);
-    getDocumentsRequest.setDocumentType(type);
-    getDocumentsRequest.setWhere(whereSerialized);
-    getDocumentsRequest.setOrderBy(orderBySerialized);
-    getDocumentsRequest.setLimit(limit);
-    getDocumentsRequest.setStartAfter(startAfter);
-    getDocumentsRequest.setStartAt(startAt);
-    getDocumentsRequest.setProve(!!options.prove);
+    getDocumentsRequest.setV0(
+      new GetDocumentsRequestV0()
+        .setDataContractId(contractId)
+        .setDocumentType(type)
+        .setWhere(whereSerialized)
+        .setOrderBy(orderBySerialized)
+        .setLimit(limit)
+        .setStartAfter(startAfter)
+        .setStartAt(startAt)
+        .setProve(!!options.prove),
+    );
 
     let lastError;
 

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

@@ -0,0 +1,54 @@
+class EpochInfo {
+  /**
+   *
+   * @param {number} number
+   * @param {number} firstBlockHeight
+   * @param {number} firstCoreBlockHeight
+   * @param {number} startTime
+   * @param {number} feeMultiplier
+   */
+  constructor(number, firstBlockHeight, firstCoreBlockHeight, startTime, feeMultiplier) {
+    this.number = number;
+    this.firstBlockHeight = firstBlockHeight;
+    this.firstCoreBlockHeight = firstCoreBlockHeight;
+    this.startTime = startTime;
+    this.feeMultiplier = feeMultiplier;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getNumber() {
+    return this.number;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getFirstBlockHeight() {
+    return this.firstBlockHeight;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getFirstCoreBlockHeight() {
+    return this.firstCoreBlockHeight;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getStartTime() {
+    return this.startTime;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getFeeMultiplier() {
+    return this.feeMultiplier;
+  }
+}
+
+module.exports = EpochInfo;

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

@@ -0,0 +1,59 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const EpochInfo = require('./EpochInfo');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetEpochsInfoResponse extends AbstractResponse {
+  /**
+   * @param {EpochInfo[]} epochsInfo
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(epochsInfo, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.epochsInfo = epochsInfo;
+  }
+
+  /**
+   * @returns {EpochInfo[]}
+   */
+  getEpochsInfo() {
+    return this.epochsInfo;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetEpochsInfoResponse}
+   */
+  static createFromProto(proto) {
+    const epochs = proto.getV0().getEpochs();
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
+      proto,
+    );
+
+    if (!epochs && !proof) {
+      throw new InvalidResponseError('Epochs are not defined');
+    }
+
+    let epochsInfo = [];
+
+    const epochsInfoList = epochs && epochs.getEpochInfosList();
+    if (epochsInfoList) {
+      epochsInfo = epochsInfoList.map((epoch) => new EpochInfo(
+        epoch.getNumber(),
+        epoch.getFirstBlockHeight(),
+        epoch.getFirstCoreBlockHeight(),
+        epoch.getStartTime(),
+        epoch.getFeeMultiplier(),
+      ));
+    }
+
+    return new GetEpochsInfoResponse(
+      epochsInfo,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetEpochsInfoResponse;

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

@@ -0,0 +1,69 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetEpochsInfoRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const { UInt32Value } = require('google-protobuf/google/protobuf/wrappers_pb');
+
+const GetEpochsInfoResponse = require('./GetEpochsInfoResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getEpochsInfo}
+ */
+function getEpochsInfoFactory(grpcTransport) {
+  /**
+   * Fetch the epoch info
+   *
+   * @typedef {getEpochsInfo}
+   * @param {number} startEpoch
+   * @param {number} count
+   * @param {DAPIClientOptions & {prove: boolean, ascending: boolean}} [options]
+   * @returns {Promise<GetEpochsInfoResponse>}
+   */
+  async function getEpochsInfo(startEpoch, count, options = {}) {
+    const { GetEpochsInfoRequestV0 } = GetEpochsInfoRequest;
+    const getEpochInfosRequest = new GetEpochsInfoRequest();
+    getEpochInfosRequest.setV0(
+      new GetEpochsInfoRequestV0()
+        .setStartEpoch(new UInt32Value([startEpoch]))
+        .setCount(count)
+        .setAscending(!!options.ascending)
+        .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 getEpochsInfoResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getEpochsInfo',
+          getEpochInfosRequest,
+          options,
+        );
+
+        return GetEpochsInfoResponse.createFromProto(getEpochsInfoResponse);
+      } 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 getEpochsInfo;
+}
+
+module.exports = getEpochsInfoFactory;

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

@@ -26,11 +26,17 @@ class GetIdentitiesByPublicKeyHashesResponse extends AbstractResponse {
   static createFromProto(proto) {
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
-    const identitiesList = proto.getIdentities();
+    const identitiesList = proto.getV0().getIdentities();
 
     return new GetIdentitiesByPublicKeyHashesResponse(
       identitiesList !== undefined
-        ? identitiesList.getIdentitiesList_asU8().map((identity) => Buffer.from(identity)) : [],
+        ? 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,
     );

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

@@ -22,11 +22,14 @@ function getIdentitiesByPublicKeyHashesFactory(grpcTransport) {
    * @returns {Promise<GetIdentitiesByPublicKeyHashesResponse>}
    */
   async function getIdentitiesByPublicKeyHashes(publicKeyHashes, options = {}) {
+    const { GetIdentitiesByPublicKeyHashesRequestV0 } = GetIdentitiesByPublicKeyHashesRequest;
     const getIdentitiesByPublicKeyHashesRequest = new GetIdentitiesByPublicKeyHashesRequest();
-    getIdentitiesByPublicKeyHashesRequest.setPublicKeyHashesList(
-      publicKeyHashes,
+    getIdentitiesByPublicKeyHashesRequest.setV0(
+      new GetIdentitiesByPublicKeyHashesRequestV0()
+        .setPublicKeyHashesList(
+          publicKeyHashes,
+        ).setProve(!!options.prove),
     );
-    getIdentitiesByPublicKeyHashesRequest.setProve(!!options.prove);
 
     let lastError;
 

package/lib/methods/platform/getIdentity/GetIdentityResponse.js

@@ -25,7 +25,7 @@ class GetIdentityResponse extends AbstractResponse {
    * @returns {GetIdentityResponse}
    */
   static createFromProto(proto) {
-    const identity = proto.getIdentity();
+    const identity = proto.getV0().getIdentity();
     const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
 
     if (!identity && !proof) {
@@ -33,7 +33,7 @@ class GetIdentityResponse extends AbstractResponse {
     }
 
     return new GetIdentityResponse(
-      Buffer.from(proto.getIdentity()),
+      Buffer.from(proto.getV0().getIdentity()),
       metadata,
       proof,
     );

package/lib/methods/platform/getIdentity/getIdentityFactory.js

@@ -22,6 +22,7 @@ function getIdentityFactory(grpcTransport) {
    * @returns {Promise<GetIdentityResponse>}
    */
   async function getIdentity(id, options = {}) {
+    const { GetIdentityRequestV0 } = GetIdentityRequest;
     const getIdentityRequest = new GetIdentityRequest();
     // need to convert objects inherited from Buffer to pure buffer as google protobuf
     // doesn't support extended buffers
@@ -31,8 +32,11 @@ function getIdentityFactory(grpcTransport) {
       id = Buffer.from(id);
     }
 
-    getIdentityRequest.setId(id);
-    getIdentityRequest.setProve(!!options.prove);
+    getIdentityRequest.setV0(
+      new GetIdentityRequestV0()
+        .setId(id)
+        .setProve(!!options.prove),
+    );
 
     let lastError;
 

package/lib/methods/platform/getVersionUpgradeState/GetVersionUpgradeStateResponse.js

@@ -0,0 +1,56 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const VersionEntry = require('./VersionEntry');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetVersionUpgradeStateResponse extends AbstractResponse {
+  /**
+   * @param {VersionEntry[]} versionEntries
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(versionEntries, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.versionEntries = versionEntries;
+  }
+
+  /**
+   * @returns {VersionEntry[]}
+   */
+  getVersionEntries() {
+    return this.versionEntries;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetVersionUpgradeStateResponse}
+   */
+  static createFromProto(proto) {
+    const versions = proto.getV0().getVersions();
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
+      proto,
+    );
+
+    if (!versions && !proof) {
+      throw new InvalidResponseError('Version upgrade state is not defined');
+    }
+
+    let versionEntries = [];
+
+    const versionsList = versions && versions.getVersionsList();
+    if (versionsList) {
+      versionEntries = versionsList.map((versionSignal) => new VersionEntry(
+        versionSignal.getVersionNumber(),
+        versionSignal.getVoteCount(),
+      ));
+    }
+
+    return new GetVersionUpgradeStateResponse(
+      versionEntries,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetVersionUpgradeStateResponse;

package/lib/methods/platform/getVersionUpgradeState/VersionEntry.js

@@ -0,0 +1,26 @@
+class VersionEntry {
+  /**
+   * @param {number} versionNumber
+   * @param {number} voteCount
+   */
+  constructor(versionNumber, voteCount) {
+    this.versionNumber = versionNumber;
+    this.voteCount = voteCount;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getVersionNumber() {
+    return this.versionNumber;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getVoteCount() {
+    return this.voteCount;
+  }
+}
+
+module.exports = VersionEntry;

package/lib/methods/platform/getVersionUpgradeState/getVersionUpgradeStateFactory.js

@@ -0,0 +1,63 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetVersionUpgradeStateRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetVersionUpgradeStateResponse = require('./GetVersionUpgradeStateResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getVersionUpgradeState}
+ */
+function getVersionUpgradeStateFactory(grpcTransport) {
+  /**
+   * Fetch the version upgrade state
+   *
+   * @typedef {getVersionUpgradeState}
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetVersionUpgradeStateResponse>}
+   */
+  async function getVersionUpgradeState(options = {}) {
+    const { GetVersionUpgradeStateRequestV0 } = GetVersionUpgradeStateRequest;
+    const getVersionUpgradeStateRequest = new GetVersionUpgradeStateRequest();
+    getVersionUpgradeStateRequest.setV0(
+      new GetVersionUpgradeStateRequestV0()
+        .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 getVersionUpgradeStateResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getVersionUpgradeState',
+          getVersionUpgradeStateRequest,
+          options,
+        );
+
+        return GetVersionUpgradeStateResponse
+          .createFromProto(getVersionUpgradeStateResponse);
+      } 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 getVersionUpgradeState;
+}
+
+module.exports = getVersionUpgradeStateFactory;

package/lib/methods/platform/getVersionUpgradeVoteStatus/GetVersionUpgradeVoteStatusResponse.js

@@ -0,0 +1,56 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const VersionSignal = require('./VersionSignal');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetVersionUpgradeVoteStatusResponse extends AbstractResponse {
+  /**
+   * @param {VersionSignal[]} versionSignals
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(versionSignals, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.versionSignals = versionSignals;
+  }
+
+  /**
+   * @returns {VersionSignal[]}
+   */
+  getVersionSignals() {
+    return this.versionSignals;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetVersionUpgradeVoteStatusResponse}
+   */
+  static createFromProto(proto) {
+    const versions = proto.getV0().getVersions();
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(
+      proto,
+    );
+
+    if (!versions && !proof) {
+      throw new InvalidResponseError('Version upgrade vote status is not defined');
+    }
+
+    let versionSignals = [];
+
+    const versionSignalsList = versions && versions.getVersionSignalsList();
+    if (versionSignalsList) {
+      versionSignals = versionSignalsList.map((versionSignal) => new VersionSignal(
+        Buffer.from(versionSignal.getProTxHash()).toString('hex'),
+        versionSignal.getVersion(),
+      ));
+    }
+
+    return new GetVersionUpgradeVoteStatusResponse(
+      versionSignals,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetVersionUpgradeVoteStatusResponse;

package/lib/methods/platform/getVersionUpgradeVoteStatus/VersionSignal.js

@@ -0,0 +1,26 @@
+class VersionSignal {
+  /**
+   * @param {string} proTxHash
+   * @param {number} version
+   */
+  constructor(proTxHash, version) {
+    this.proTxHash = proTxHash;
+    this.version = version;
+  }
+
+  /**
+   * @returns {string}
+   */
+  getProTxHash() {
+    return this.proTxHash;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getVersion() {
+    return this.version;
+  }
+}
+
+module.exports = VersionSignal;

package/lib/methods/platform/getVersionUpgradeVoteStatus/getVersionUpgradeVoteStatusFactory.js

@@ -0,0 +1,67 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetVersionUpgradeVoteStatusRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetVersionUpgradeVoteStatusResponse = require('./GetVersionUpgradeVoteStatusResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getVersionUpgradeVoteStatus}
+ */
+function getVersionUpgradeVoteStatusFactory(grpcTransport) {
+  /**
+   * Fetch the version upgrade vote status
+   *
+   * @typedef {getVersionUpgradeVoteStatus}
+   * @param {string} startProTxHash
+   * @param {number} count
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetVersionUpgradeVoteStatusResponse>}
+   */
+  async function getVersionUpgradeVoteStatus(startProTxHash, count, options = {}) {
+    const { GetVersionUpgradeVoteStatusRequestV0 } = GetVersionUpgradeVoteStatusRequest;
+    const getVersionUpgradeVoteStatusRequest = new GetVersionUpgradeVoteStatusRequest();
+    getVersionUpgradeVoteStatusRequest.setV0(
+      new GetVersionUpgradeVoteStatusRequestV0()
+        .setStartProTxHash(Buffer.from(startProTxHash, 'hex'))
+        .setCount(count)
+        .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 getVersionUpgradeVoteStatusResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getVersionUpgradeVoteStatus',
+          getVersionUpgradeVoteStatusRequest,
+          options,
+        );
+
+        return GetVersionUpgradeVoteStatusResponse
+          .createFromProto(getVersionUpgradeVoteStatusResponse);
+      } 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 getVersionUpgradeVoteStatus;
+}
+
+module.exports = getVersionUpgradeVoteStatusFactory;

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

@@ -37,13 +37,13 @@ class AbstractResponse {
    * @throws {InvalidResponseError}
    */
   static createMetadataAndProofFromProto(proto) {
-    const metadata = proto.getMetadata();
+    const metadata = proto.getV0().getMetadata();
 
     if (metadata === undefined) {
       throw new InvalidResponseError('Metadata is not defined');
     }
 
-    const rawProof = proto.getProof();
+    const rawProof = proto.getV0().getProof();
 
     let proof;
     if (rawProof) {

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

@@ -32,25 +32,26 @@ class WaitForStateTransitionResultResponse extends AbstractResponse {
     let error;
     let proof;
 
-    if (proto.getProof()) {
-      proof = Proof.createFromProto(proto.getProof());
+    if (proto.getV0().getProof()) {
+      proof = Proof.createFromProto(proto.getV0().getProof());
     }
 
-    if (proto.getError()) {
+    if (proto.getV0().getError()) {
       let data;
-      const rawData = proto.getError().getData();
+      const rawData = proto.getV0().getError().getData();
       if (rawData) {
         data = cbor.decode(Buffer.from(rawData));
       }
 
       error = new ErrorResult(
-        proto.getError().getCode(),
-        proto.getError().getMessage(),
+        proto.getV0().getError().getCode(),
+        proto.getV0().getError().getMessage(),
         data,
       );
     }
 
-    const metadata = proto.getMetadata() ? new Metadata(proto.getMetadata().toObject()) : null;
+    const metadata = proto.getV0().getMetadata()
+      ? new Metadata(proto.getV0().getMetadata().toObject()) : null;
 
     return new WaitForStateTransitionResultResponse(
       metadata,

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

@@ -31,10 +31,13 @@ function waitForStateTransitionResultFactory(grpcTransport) {
       ...options,
     };
 
+    const { WaitForStateTransitionResultRequestV0 } = WaitForStateTransitionResultRequest;
     const waitForStateTransitionResultRequest = new WaitForStateTransitionResultRequest();
-
-    waitForStateTransitionResultRequest.setStateTransitionHash(stateTransitionHash);
-    waitForStateTransitionResultRequest.setProve(options.prove);
+    waitForStateTransitionResultRequest.setV0(
+      new WaitForStateTransitionResultRequestV0()
+        .setStateTransitionHash(stateTransitionHash)
+        .setProve(options.prove),
+    );
 
     let lastError;
 

package/lib/test/bootstrap.js

@@ -6,11 +6,16 @@ const sinon = require('sinon');
 const sinonChai = require('sinon-chai');
 const dirtyChai = require('dirty-chai');
 const chaiAsPromised = require('chai-as-promised');
+const { default: loadDpp } = require('@dashevo/wasm-dpp');
 
 use(sinonChai);
 use(chaiAsPromised);
 use(dirtyChai);
 
+before(async () => {
+  await loadDpp();
+});
+
 beforeEach(function beforeEach() {
   if (!this.sinon) {
     this.sinon = sinon.createSandbox();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "0.25.8",
+  "version": "0.25.10",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/index.js",
   "contributors": [
@@ -26,12 +26,11 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "0.25.8",
-    "@dashevo/dash-spv": "0.25.8",
-    "@dashevo/dashcore-lib": "~0.20.9",
-    "@dashevo/dpp": "0.25.8",
-    "@dashevo/grpc-common": "0.25.8",
-    "@dashevo/wasm-dpp": "0.25.8",
+    "@dashevo/dapi-grpc": "0.25.10",
+    "@dashevo/dash-spv": "0.25.10",
+    "@dashevo/dashcore-lib": "~0.21.0",
+    "@dashevo/grpc-common": "0.25.10",
+    "@dashevo/wasm-dpp": "0.25.10",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
     "google-protobuf": "^3.12.2",