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

package/lib/methods/core/getBestBlockHeightFactory.js

@@ -0,0 +1,34 @@
+const {
+  v0: {
+    GetBestBlockHeightRequest,
+    CorePromiseClient,
+  },
+} = require('@dashevo/dapi-grpc');
+
+/**
+ *
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getBestBlockHeight}
+ */
+function getBestBlockHeightFactory(grpcTransport) {
+  /**
+   * Returns block height of chain tip
+   * @typedef {getBestBlockHeight}
+   * @param {DAPIClientOptions} [options]
+   * @returns {Promise<string>}
+   */
+  async function getBestBlockHeight(options = {}) {
+    const response = await grpcTransport.request(
+      CorePromiseClient,
+      'getBestBlockHeight',
+      new GetBestBlockHeightRequest(),
+      options,
+    );
+
+    return response.getHeight();
+  }
+
+  return getBestBlockHeight;
+}
+
+module.exports = getBestBlockHeightFactory;

package/lib/methods/core/getBlockchainStatusFactory.js

@@ -0,0 +1,59 @@
+const {
+  v0: {
+    GetBlockchainStatusRequest,
+    GetBlockchainStatusResponse,
+    CorePromiseClient,
+  },
+} = require('@dashevo/dapi-grpc');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getBlockchainStatus}
+ */
+function getBlockchainStatusFactory(grpcTransport) {
+  /**
+   * Get Core chain status
+   * @typedef {getBlockchainStatus}
+   * @param {DAPIClientOptions} [options]
+   * @returns {Promise<object>}
+   */
+  async function getBlockchainStatus(options = {}) {
+    const getBlockchainStatusRequest = new GetBlockchainStatusRequest();
+
+    const response = await grpcTransport.request(
+      CorePromiseClient,
+      'getBlockchainStatus',
+      getBlockchainStatusRequest,
+      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());
+      }
+    }
+
+    // Respond with constant names instead of constant values
+
+    responseObject.status = Object.keys(GetBlockchainStatusResponse.Status)
+      .find((key) => GetBlockchainStatusResponse.Status[key] === responseObject.status);
+
+    return responseObject;
+  }
+
+  return getBlockchainStatus;
+}
+
+module.exports = getBlockchainStatusFactory;

package/lib/methods/core/getMasternodeStatusFactory.js

@@ -0,0 +1,45 @@
+const {
+  v0: {
+    GetMasternodeStatusRequest,
+    GetMasternodeStatusResponse,
+    CorePromiseClient,
+  },
+} = require('@dashevo/dapi-grpc');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getMasternodeStatus}
+ */
+function getMasternodeStatusFactory(grpcTransport) {
+  /**
+   * Get Core chain status
+   * @typedef {getMasternodeStatus}
+   * @param {DAPIClientOptions} [options]
+   * @returns {Promise<object>}
+   */
+  async function getMasternodeStatus(options = {}) {
+    const getMasternodeStatusRequest = new GetMasternodeStatusRequest();
+
+    const response = await grpcTransport.request(
+      CorePromiseClient,
+      'getMasternodeStatus',
+      getMasternodeStatusRequest,
+      options,
+    );
+
+    const responseObject = response.toObject();
+
+    // Respond with constant names instead of constant values
+
+    responseObject.status = Object.keys(GetMasternodeStatusResponse.Status)
+      .find((key) => GetMasternodeStatusResponse.Status[key] === responseObject.status);
+
+    responseObject.proTxHash = Buffer.from(responseObject.proTxHash, 'base64');
+
+    return responseObject;
+  }
+
+  return getMasternodeStatus;
+}
+
+module.exports = getMasternodeStatusFactory;

package/lib/methods/core/subscribeToMasternodeListFactory.js

@@ -0,0 +1,46 @@
+const {
+  v0: {
+    MasternodeListRequest,
+    CorePromiseClient,
+  },
+} = require('@dashevo/dapi-grpc');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {subscribeToMasternodeList}
+ */
+function subscribeToMasternodeListFactory(grpcTransport) {
+  /**
+   * @typedef {subscribeToMasternodeList}
+   * @param {DAPIClientOptions & subscribeToMasternodeListOptions} [options]
+   * @returns {
+   *    EventEmitter|!grpc.web.ClientReadableStream<!MasternodeListResponse>
+   * }
+   */
+  async function subscribeToMasternodeList(options = { }) {
+    // eslint-disable-next-line no-param-reassign
+    options = {
+      // Override global timeout option
+      // and timeout for this method by default
+      timeout: undefined,
+      ...options,
+    };
+
+    const request = new MasternodeListRequest();
+
+    return grpcTransport.request(
+      CorePromiseClient,
+      'subscribeToMasternodeList',
+      request,
+      options,
+    );
+  }
+
+  return subscribeToMasternodeList;
+}
+
+/**
+ * @typedef {object} subscribeToMasternodeListOptions
+ */
+
+module.exports = subscribeToMasternodeListFactory;

package/lib/methods/core/subscribeToTransactionsWithProofsFactory.js

@@ -29,7 +29,7 @@ function subscribeToTransactionsWithProofsFactory(grpcTransport) {
    *    EventEmitter|!grpc.web.ClientReadableStream<!TransactionsWithProofsResponse>
    * }
    */
-  async function subscribeToTransactionsWithProofs(bloomFilter, options = { }) {
+  async function subscribeToTransactionsWithProofs(bloomFilter, options = {}) {
     // eslint-disable-next-line no-param-reassign
     options = {
       count: 0,

package/lib/methods/platform/PlatformMethodsFacade.js

@@ -3,12 +3,16 @@ const getDataContractFactory = require('./getDataContract/getDataContractFactory
 const getDataContractHistoryFactory = require('./getDataContractHistory/getDataContractHistoryFactory');
 const getDocumentsFactory = require('./getDocuments/getDocumentsFactory');
 const getIdentityFactory = require('./getIdentity/getIdentityFactory');
-const getIdentitiesByPublicKeyHashesFactory = require('./getIdentitiesByPublicKeyHashes/getIdentitiesByPublicKeyHashesFactory');
+const getIdentityByPublicKeyHashFactory = require('./getIdentityByPublicKeyHash/getIdentityByPublicKeyHashFactory');
+const getIdentitiesContractKeysFactory = require('./getIdentitiesContractKeys/getIdentitiesContractKeysFactory');
 const waitForStateTransitionResultFactory = require('./waitForStateTransitionResult/waitForStateTransitionResultFactory');
 const getConsensusParamsFactory = require('./getConsensusParams/getConsensusParamsFactory');
 const getEpochsInfoFactory = require('./getEpochsInfo/getEpochsInfoFactory');
 const getProtocolVersionUpgradeVoteStatusFactory = require('./getProtocolVersionUpgradeVoteStatus/getProtocolVersionUpgradeVoteStatusFactory');
 const getProtocolVersionUpgradeStateFactory = require('./getProtocolVersionUpgradeState/getProtocolVersionUpgradeStateFactory');
+const getIdentityContractNonceFactory = require('./getIdentityContractNonce/getIdentityContractNonceFactory');
+const getIdentityNonceFactory = require('./getIdentityNonce/getIdentityNonceFactory');
+const getIdentityKeysFactory = require('./getIdentityKeys/getIdentityKeysFactory');
 
 class PlatformMethodsFacade {
   /**
@@ -20,7 +24,8 @@ class PlatformMethodsFacade {
     this.getDataContractHistory = getDataContractHistoryFactory(grpcTransport);
     this.getDocuments = getDocumentsFactory(grpcTransport);
     this.getIdentity = getIdentityFactory(grpcTransport);
-    this.getIdentitiesByPublicKeyHashes = getIdentitiesByPublicKeyHashesFactory(grpcTransport);
+    this.getIdentityByPublicKeyHash = getIdentityByPublicKeyHashFactory(grpcTransport);
+    this.getIdentitiesContractKeys = getIdentitiesContractKeysFactory(grpcTransport);
     this.waitForStateTransitionResult = waitForStateTransitionResultFactory(grpcTransport);
     this.getConsensusParams = getConsensusParamsFactory(grpcTransport);
     this.getEpochsInfo = getEpochsInfoFactory(grpcTransport);
@@ -28,6 +33,9 @@ class PlatformMethodsFacade {
       grpcTransport,
     );
     this.getProtocolVersionUpgradeState = getProtocolVersionUpgradeStateFactory(grpcTransport);
+    this.getIdentityContractNonce = getIdentityContractNonceFactory(grpcTransport);
+    this.getIdentityNonce = getIdentityNonceFactory(grpcTransport);
+    this.getIdentityKeys = getIdentityKeysFactory(grpcTransport);
   }
 }
 

package/lib/methods/platform/getIdentitiesContractKeys/GetIdentitiesContractKeysResponse.js

@@ -0,0 +1,65 @@
+const { Identifier } = require('@dashevo/wasm-dpp');
+const AbstractResponse = require('../response/AbstractResponse');
+
+class GetIdentitiesContractKeysResponse extends AbstractResponse {
+  /**
+   * @param {object} identitiesKeys
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(identitiesKeys, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.identitiesKeys = identitiesKeys;
+  }
+
+  /**
+   * @returns {object}
+   */
+  getIdentitiesKeys() {
+    return this.identitiesKeys;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetIdentitiesContractKeysResponse}
+   */
+  static createFromProto(proto) {
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
+
+    const identitiesKeys = proto.getV0().getIdentitiesKeys();
+
+    let identitiesKeysMap = {};
+    if (identitiesKeys) {
+      const keysEntries = identitiesKeys.getEntriesList();
+
+      identitiesKeysMap = keysEntries.reduce((acc, entry) => {
+        const identityId = Identifier.from(Buffer.from(entry.getIdentityId())).toString();
+        if (!acc[identityId]) {
+          acc[identityId] = {};
+        }
+
+        entry.getKeysList().forEach((key) => {
+          const purpose = key.getPurpose();
+          if (!acc[identityId][purpose]) {
+            // eslint-disable-next-line no-param-reassign
+            acc[identityId][purpose] = [];
+          }
+
+          // eslint-disable-next-line no-param-reassign
+          acc[identityId][purpose] = acc[identityId][purpose].concat(key.getKeysBytesList());
+        }, {});
+
+        return acc;
+      }, {});
+    }
+
+    return new GetIdentitiesContractKeysResponse(
+      identitiesKeysMap,
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetIdentitiesContractKeysResponse;

package/lib/methods/platform/getIdentitiesContractKeys/getIdentitiesContractKeysFactory.js

@@ -0,0 +1,93 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentitiesContractKeysRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+const { IdentityPublicKey } = require('@dashevo/wasm-dpp');
+
+const GetIdentitiesContractKeysResponse = require('./GetIdentitiesContractKeysResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentitiesContractKeys}
+ */
+function getIdentitiesContractKeysFactory(grpcTransport) {
+  /**
+   * Fetch the identities by public key hashes
+   * @typedef {getIdentitiesContractKeys}
+   * @param {Buffer[]} identitiesIds
+   * @param {Buffer} contractId
+   * @param {IdentityPublicKey.PURPOSES[]} keyPurposes
+   * @param {string | null} documentTypeName
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentitiesContractKeysResponse>}
+   */
+  async function getIdentitiesContractKeys(
+    identitiesIds,
+    contractId,
+    keyPurposes,
+    documentTypeName = null,
+    options = {},
+  ) {
+    const { GetIdentitiesContractKeysRequestV0 } = GetIdentitiesContractKeysRequest;
+    const getIdentitiesContractKeysRequest = new GetIdentitiesContractKeysRequest();
+
+    // eslint-disable-next-line no-param-reassign
+    identitiesIds = identitiesIds.map((id) => {
+      if (Buffer.isBuffer(id)) {
+        // eslint-disable-next-line no-param-reassign
+        id = Buffer.from(id);
+      }
+
+      return id;
+    });
+
+    if (Buffer.isBuffer(contractId)) {
+      // eslint-disable-next-line no-param-reassign
+      contractId = Buffer.from(contractId);
+    }
+
+    getIdentitiesContractKeysRequest.setV0(
+      new GetIdentitiesContractKeysRequestV0()
+        .setProve(!!options.prove)
+        .setIdentitiesIdsList(identitiesIds)
+        .setContractId(contractId)
+        .setPurposesList(keyPurposes)
+        .setDocumentTypeName(documentTypeName),
+    );
+
+    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 getIdentitiesContractKeysResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentitiesContractKeys',
+          getIdentitiesContractKeysRequest,
+          options,
+        );
+
+        return GetIdentitiesContractKeysResponse
+          .createFromProto(getIdentitiesContractKeysResponse);
+      } 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 getIdentitiesContractKeys;
+}
+
+module.exports = getIdentitiesContractKeysFactory;

package/lib/methods/platform/getIdentityByPublicKeyHash/GetIdentityByPublicKeyHashResponse.js

@@ -0,0 +1,40 @@
+const AbstractResponse = require('../response/AbstractResponse');
+
+class GetIdentityByPublicKeyHashResponse extends AbstractResponse {
+  /**
+   * @param {Buffer} identities
+   * @param identity
+   * @param {Metadata} metadata
+   * @param {Proof} [proof]
+   */
+  constructor(identity, metadata, proof = undefined) {
+    super(metadata, proof);
+
+    this.identity = identity;
+  }
+
+  /**
+   * @returns {Buffer[]}
+   */
+  getIdentity() {
+    return this.identity;
+  }
+
+  /**
+   * @param proto
+   * @returns {GetIdentityByPublicKeyHashResponse}
+   */
+  static createFromProto(proto) {
+    const { metadata, proof } = AbstractResponse.createMetadataAndProofFromProto(proto);
+
+    const identity = proto.getV0().getIdentity();
+
+    return new GetIdentityByPublicKeyHashResponse(
+      Buffer.from(identity),
+      metadata,
+      proof,
+    );
+  }
+}
+
+module.exports = GetIdentityByPublicKeyHashResponse;

package/lib/methods/platform/getIdentityByPublicKeyHash/getIdentityByPublicKeyHashFactory.js

@@ -0,0 +1,64 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentityByPublicKeyHashRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetIdentityByPublicKeyHashResponse = require('./GetIdentityByPublicKeyHashResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentityByPublicKeyHash}
+ */
+function getIdentityByPublicKeyHashFactory(grpcTransport) {
+  /**
+   * Fetch the identity by public key hash
+   * @typedef {getIdentityByPublicKeyHash}
+   * @param {Buffer} publicKeyHash
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentityByPublicKeyHashResponse>}
+   */
+  async function getIdentityByPublicKeyHash(publicKeyHash, options = {}) {
+    const { GetIdentityByPublicKeyHashRequestV0 } = GetIdentityByPublicKeyHashRequest;
+    const getIdentityByPublicKeyHashRequest = new GetIdentityByPublicKeyHashRequest();
+    getIdentityByPublicKeyHashRequest.setV0(
+      new GetIdentityByPublicKeyHashRequestV0()
+        .setPublicKeyHash(publicKeyHash)
+        .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 getIdentityByPublicKeyHashResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentityByPublicKeyHash',
+          getIdentityByPublicKeyHashRequest,
+          options,
+        );
+
+        return GetIdentityByPublicKeyHashResponse
+          .createFromProto(getIdentityByPublicKeyHashResponse);
+      } 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 getIdentityByPublicKeyHash;
+}
+
+module.exports = getIdentityByPublicKeyHashFactory;

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

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

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

@@ -0,0 +1,81 @@
+const {
+  v0: {
+    PlatformPromiseClient,
+    GetIdentityContractNonceRequest,
+  },
+} = require('@dashevo/dapi-grpc');
+
+const GetIdentityContractNonceResponse = require('./GetIdentityContractNonceResponse');
+const InvalidResponseError = require('../response/errors/InvalidResponseError');
+
+/**
+ * @param {GrpcTransport} grpcTransport
+ * @returns {getIdentityContractNonce}
+ */
+function getIdentityContractNonceFactory(grpcTransport) {
+  /**
+   * Fetch the version upgrade votes status
+   * @typedef {getIdentityContractNonce}
+   * @param {Buffer} identityId
+   * @param {Buffer} contractId
+   * @param {DAPIClientOptions & {prove: boolean}} [options]
+   * @returns {Promise<GetIdentityContractNonceResponse>}
+   */
+  async function getIdentityContractNonce(identityId, contractId, options = {}) {
+    const {
+      GetIdentityContractNonceRequestV0,
+    } = GetIdentityContractNonceRequest;
+
+    // eslint-disable-next-line max-len
+    const getIdentityContractNonceRequest = new GetIdentityContractNonceRequest();
+
+    if (Buffer.isBuffer(identityId)) {
+      // eslint-disable-next-line no-param-reassign
+      identityId = Buffer.from(identityId);
+    }
+
+    if (Buffer.isBuffer(contractId)) {
+      // eslint-disable-next-line no-param-reassign
+      contractId = Buffer.from(contractId);
+    }
+
+    getIdentityContractNonceRequest.setV0(
+      new GetIdentityContractNonceRequestV0()
+        .setIdentityId(identityId)
+        .setContractId(contractId)
+        .setProve(!!options.prove),
+    );
+
+    let lastError;
+
+    // TODO: simple retry before the dapi versioning is properly implemented
+    for (let i = 0; i < 3; i += 1) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const getIdentityContractNonceResponse = await grpcTransport.request(
+          PlatformPromiseClient,
+          'getIdentityContractNonce',
+          getIdentityContractNonceRequest,
+          options,
+        );
+
+        return GetIdentityContractNonceResponse
+          .createFromProto(getIdentityContractNonceResponse);
+      } catch (e) {
+        if (e instanceof InvalidResponseError) {
+          lastError = e;
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    // If we made it past the cycle it means that the retry didn't work,
+    // and we're throwing the last error encountered
+    throw lastError;
+  }
+
+  return getIdentityContractNonce;
+}
+
+module.exports = getIdentityContractNonceFactory;

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

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