@dashevo/dapi-client 0.25.0-dev.8 → 0.25.0-pr.1545.2

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/getProtocolVersionUpgradeState/GetProtocolVersionUpgradeStateResponse.js

@@ -0,0 +1,56 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const VersionEntry = require('./VersionEntry');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetProtocolVersionUpgradeStateResponse 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 {GetProtocolVersionUpgradeStateResponse}
+   */
+  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 GetProtocolVersionUpgradeStateResponse(
+      versionEntries,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetProtocolVersionUpgradeStateResponse;

package/lib/methods/platform/getProtocolVersionUpgradeState/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/getProtocolVersionUpgradeState/getProtocolVersionUpgradeStateFactory.js

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

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

@@ -0,0 +1,56 @@
+const AbstractResponse = require('../response/AbstractResponse');
+const VersionSignal = require('./VersionSignal');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+class GetProtocolVersionUpgradeVoteStatusResponse 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 {GetProtocolVersionUpgradeVoteStatusResponse}
+   */
+  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 GetProtocolVersionUpgradeVoteStatusResponse(
+      versionSignals,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetProtocolVersionUpgradeVoteStatusResponse;

package/lib/methods/platform/getProtocolVersionUpgradeVoteStatus/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/getProtocolVersionUpgradeVoteStatus/getProtocolVersionUpgradeVoteStatusFactory.js

@@ -0,0 +1,72 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetProtocolVersionUpgradeVoteStatusRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetProtocolVersionUpgradeVoteStatusResponse = require('./GetProtocolVersionUpgradeVoteStatusResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getProtocolVersionUpgradeVoteStatus}
+ */
+function getProtocolVersionUpgradeVoteStatusFactory(grpcTransport) {
+  /**
+   * Fetch the version upgrade vote status
+   *
+   * @typedef {getProtocolVersionUpgradeVoteStatus}
+   * @param {string} startProTxHash
+   * @param {number} count
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetProtocolVersionUpgradeVoteStatusResponse>}
+   */
+  async function getProtocolVersionUpgradeVoteStatus(startProTxHash, count, options = {}) {
+    const {
+      GetProtocolVersionUpgradeVoteStatusRequestV0,
+    } = GetProtocolVersionUpgradeVoteStatusRequest;
+
+    // eslint-disable-next-line max-len
+    const getProtocolVersionUpgradeVoteStatusRequest = new GetProtocolVersionUpgradeVoteStatusRequest();
+
+    getProtocolVersionUpgradeVoteStatusRequest.setV0(
+      new GetProtocolVersionUpgradeVoteStatusRequestV0()
+        .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 getProtocolVersionUpgradeVoteStatusResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getProtocolVersionUpgradeVoteStatus',
+          getProtocolVersionUpgradeVoteStatusRequest,
+          options,
+        );
+
+        return GetProtocolVersionUpgradeVoteStatusResponse
+          .createFromProto(getProtocolVersionUpgradeVoteStatusResponse);
+      } 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 getProtocolVersionUpgradeVoteStatus;
+}
+
+module.exports = getProtocolVersionUpgradeVoteStatusFactory;

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/response/Proof.js

@@ -16,7 +16,7 @@ class Proof {
   /**
    * @returns {Buffer}
    */
-  getMerkleProof() {
+  getGrovedbProof() {
     return this.merkleProof;
   }
 
@@ -43,13 +43,13 @@ class Proof {
   }
 
   /**
-   * @param {Object} proofProto
+   * @param {object} proofProto
    *
    * @returns {Proof}
    */
   static createFromProto(proofProto) {
     return new Proof({
-      merkleProof: Buffer.from(proofProto.getMerkleProof()),
+      merkleProof: Buffer.from(proofProto.getGrovedbProof()),
       quorumHash: Buffer.from(proofProto.getQuorumHash()),
       signature: Buffer.from(proofProto.getSignature()),
       round: proofProto.getRound(),

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

@@ -24,17 +24,20 @@ function waitForStateTransitionResultFactory(grpcTransport) {
     // eslint-disable-next-line no-param-reassign
     options = {
       // Set default timeout
-      timeout: 60000,
+      timeout: 120000,
       prove: false,
       retry: 0,
       throwDeadlineExceeded: true,
       ...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/networkConfigs.js

@@ -1,143 +1,52 @@
 module.exports = {
   testnet: {
     seeds: [
-      'seed-1.testnet.networks.dash.org',
-      'seed-2.testnet.networks.dash.org',
-      'seed-3.testnet.networks.dash.org',
-      'seed-4.testnet.networks.dash.org',
-      'seed-5.testnet.networks.dash.org',
+      'seed-1.testnet.networks.dash.org:1443',
+      'seed-2.testnet.networks.dash.org:1443',
+      'seed-3.testnet.networks.dash.org:1443',
+      'seed-4.testnet.networks.dash.org:1443',
+      'seed-5.testnet.networks.dash.org:1443',
     ],
     network: 'testnet',
     // Since we don't have PoSe atm, 3rd party masternodes sometimes provide wrong data
     // that breaks test suite and application logic. Temporary solution is to hardcode
     // reliable DCG testnet masternodes to connect. Should be removed when PoSe is introduced.
     dapiAddressesWhiteList: [
-      '34.216.69.175',
-      '34.218.75.96',
-      '18.237.220.27',
-      '54.191.38.234',
-      '35.93.95.157',
-      '35.166.240.246',
-      '35.91.186.151',
-      '35.161.123.225',
-      '54.212.169.115',
-      '54.187.168.12',
-      '18.236.191.199',
-      '18.237.165.224',
-      '52.36.42.1',
-      '34.220.32.216',
-      '34.222.238.250',
-      '35.93.34.215',
-      '34.221.10.165',
-      '54.203.241.195',
-      '35.92.138.231',
-      '52.38.169.156',
-      '54.187.21.108',
-      '34.219.48.219',
-      '34.217.38.221',
-      '35.92.157.107',
-      '18.236.82.230',
-      '54.184.225.22',
-      '18.237.144.120',
-      '18.237.254.214',
-      '35.88.29.196',
-      '35.89.126.245',
-      '34.217.148.69',
-      '35.89.193.46',
-      '35.89.119.37',
-      '54.186.161.236',
-      '52.13.63.7',
-      '18.236.233.225',
-      '54.191.138.72',
-      '54.191.59.75',
-      '18.237.160.84',
-      '54.218.236.193',
-      '54.148.178.140',
-      '35.161.168.136',
-      '35.161.33.22',
-      '35.160.130.44',
-      '34.212.104.247',
-      '52.13.29.83',
-      '54.149.39.172',
-      '35.89.93.255',
-      '35.85.46.137',
-      '54.188.154.252',
-      '54.218.11.172',
-      '54.186.47.235',
-      '54.244.145.48',
-      '18.236.232.153',
-      '34.220.226.135',
-      '34.220.30.59',
-      '18.237.160.97',
-      '18.236.146.99',
-      '35.88.169.18',
-      '35.164.17.198',
-      '54.218.80.158',
-      '34.220.102.107',
-      '35.165.60.113',
-      '34.215.234.63',
-      '35.89.146.226',
-      '35.89.86.26',
-      '35.88.160.231',
-      '54.245.8.155',
-      '52.36.221.94',
-      '52.35.46.188',
-      '34.221.153.67',
-      '54.212.153.15',
-      '35.85.55.192',
-      '35.89.105.90',
-      '52.24.22.52',
-      '54.212.33.96',
-      '52.10.19.238',
-      '35.160.190.165',
-      '34.219.3.61',
-      '54.187.32.187',
-      '35.162.221.77',
-      '35.91.64.183',
-      '18.236.189.15',
-      '35.91.145.195',
-      '54.186.251.30',
-      '54.245.9.46',
-      '35.91.48.128',
-      '54.244.75.85',
-      '34.221.159.53',
-      '35.89.88.166',
-      '54.185.249.165',
-      '54.245.9.209',
-      '34.222.167.162',
-      '54.191.88.232',
-      '54.191.111.112',
-      '18.237.146.37',
-      '35.89.148.27',
-      '35.91.8.48',
-      '18.236.208.138',
-      '54.213.60.60',
-      '35.92.151.94',
-      '18.237.241.37',
-      '54.202.209.229',
-      '34.221.9.70',
-      '35.89.38.62',
-      '54.218.81.193',
-      '34.221.158.21',
-      '35.88.97.57',
-      '54.68.247.40',
-      '35.88.168.176',
-      '35.89.202.171',
-      '34.220.106.205',
-      '34.210.86.23',
-      '44.230.40.184',
+      '34.214.48.68:1443',
+      '35.166.18.166:1443',
+      '35.165.50.126:1443',
+      '52.42.202.128:1443',
+      '52.12.176.90:1443',
+      '44.233.44.95:1443',
+      '35.167.145.149:1443',
+      '52.34.144.50:1443',
+      '44.240.98.102:1443',
+      '54.201.32.131:1443',
+      '52.10.229.11:1443',
+      '52.13.132.146:1443',
+      '44.228.242.181:1443',
+      '35.82.197.197:1443',
+      '52.40.219.41:1443',
+      '44.239.39.153:1443',
+      '54.149.33.167:1443',
+      '35.164.23.245:1443',
+      '52.33.28.47:1443',
+      '52.43.86.231:1443',
+      '52.43.13.92:1443',
+      '35.163.144.230:1443',
+      '52.89.154.48:1443',
+      '52.24.124.162:1443',
+      '44.227.137.77:1443',
+      '35.85.21.179:1443',
+      '54.187.14.232:1443',
+      '54.68.235.201:1443',
+      '52.13.250.182:1443',
+      '35.82.49.196:1443',
+      '44.232.196.6:1443',
+      '54.189.164.39:1443',
+      '54.213.204.85:1443',
     ],
   },
-  evonet: {
-    seeds: [
-      'seed-1.evonet.networks.dash.org',
-      'seed-2.evonet.networks.dash.org',
-      'seed-3.evonet.networks.dash.org',
-      'seed-4.evonet.networks.dash.org',
-      'seed-5.evonet.networks.dash.org',
-    ],
-    network: 'evonet',
-  },
   local: {
     dapiAddresses: ['127.0.0.1'],
     network: 'regtest',

package/lib/test/bootstrap.js

@@ -1,15 +1,21 @@
 require('../../polyfills/fetch-polyfill');
+require('setimmediate');
 
 const { expect, use } = require('chai');
 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();