@dashevo/dapi-grpc 0.25.22 → 1.0.0-beta.2

package/clients/core/v0/web/core_pb_service.d.ts

@@ -4,13 +4,22 @@
 import * as core_pb from "./core_pb";
 import {grpc} from "@improbable-eng/grpc-web";
 
-type CoregetStatus = {
+type CoregetBlockchainStatus = {
   readonly methodName: string;
   readonly service: typeof Core;
   readonly requestStream: false;
   readonly responseStream: false;
-  readonly requestType: typeof core_pb.GetStatusRequest;
-  readonly responseType: typeof core_pb.GetStatusResponse;
+  readonly requestType: typeof core_pb.GetBlockchainStatusRequest;
+  readonly responseType: typeof core_pb.GetBlockchainStatusResponse;
+};
+
+type CoregetMasternodeStatus = {
+  readonly methodName: string;
+  readonly service: typeof Core;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof core_pb.GetMasternodeStatusRequest;
+  readonly responseType: typeof core_pb.GetMasternodeStatusResponse;
 };
 
 type CoregetBlock = {
@@ -22,6 +31,15 @@ type CoregetBlock = {
   readonly responseType: typeof core_pb.GetBlockResponse;
 };
 
+type CoregetBestBlockHeight = {
+  readonly methodName: string;
+  readonly service: typeof Core;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof core_pb.GetBestBlockHeightRequest;
+  readonly responseType: typeof core_pb.GetBestBlockHeightResponse;
+};
+
 type CorebroadcastTransaction = {
   readonly methodName: string;
   readonly service: typeof Core;
@@ -67,15 +85,27 @@ type CoresubscribeToTransactionsWithProofs = {
   readonly responseType: typeof core_pb.TransactionsWithProofsResponse;
 };
 
+type CoresubscribeToMasternodeList = {
+  readonly methodName: string;
+  readonly service: typeof Core;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof core_pb.MasternodeListRequest;
+  readonly responseType: typeof core_pb.MasternodeListResponse;
+};
+
 export class Core {
   static readonly serviceName: string;
-  static readonly getStatus: CoregetStatus;
+  static readonly getBlockchainStatus: CoregetBlockchainStatus;
+  static readonly getMasternodeStatus: CoregetMasternodeStatus;
   static readonly getBlock: CoregetBlock;
+  static readonly getBestBlockHeight: CoregetBestBlockHeight;
   static readonly broadcastTransaction: CorebroadcastTransaction;
   static readonly getTransaction: CoregetTransaction;
   static readonly getEstimatedTransactionFee: CoregetEstimatedTransactionFee;
   static readonly subscribeToBlockHeadersWithChainLocks: CoresubscribeToBlockHeadersWithChainLocks;
   static readonly subscribeToTransactionsWithProofs: CoresubscribeToTransactionsWithProofs;
+  static readonly subscribeToMasternodeList: CoresubscribeToMasternodeList;
 }
 
 export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
@@ -110,14 +140,23 @@ export class CoreClient {
   readonly serviceHost: string;
 
   constructor(serviceHost: string, options?: grpc.RpcOptions);
-  getStatus(
-    requestMessage: core_pb.GetStatusRequest,
+  getBlockchainStatus(
+    requestMessage: core_pb.GetBlockchainStatusRequest,
     metadata: grpc.Metadata,
-    callback: (error: ServiceError|null, responseMessage: core_pb.GetStatusResponse|null) => void
+    callback: (error: ServiceError|null, responseMessage: core_pb.GetBlockchainStatusResponse|null) => void
   ): UnaryResponse;
-  getStatus(
-    requestMessage: core_pb.GetStatusRequest,
-    callback: (error: ServiceError|null, responseMessage: core_pb.GetStatusResponse|null) => void
+  getBlockchainStatus(
+    requestMessage: core_pb.GetBlockchainStatusRequest,
+    callback: (error: ServiceError|null, responseMessage: core_pb.GetBlockchainStatusResponse|null) => void
+  ): UnaryResponse;
+  getMasternodeStatus(
+    requestMessage: core_pb.GetMasternodeStatusRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: core_pb.GetMasternodeStatusResponse|null) => void
+  ): UnaryResponse;
+  getMasternodeStatus(
+    requestMessage: core_pb.GetMasternodeStatusRequest,
+    callback: (error: ServiceError|null, responseMessage: core_pb.GetMasternodeStatusResponse|null) => void
   ): UnaryResponse;
   getBlock(
     requestMessage: core_pb.GetBlockRequest,
@@ -128,6 +167,15 @@ export class CoreClient {
     requestMessage: core_pb.GetBlockRequest,
     callback: (error: ServiceError|null, responseMessage: core_pb.GetBlockResponse|null) => void
   ): UnaryResponse;
+  getBestBlockHeight(
+    requestMessage: core_pb.GetBestBlockHeightRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: core_pb.GetBestBlockHeightResponse|null) => void
+  ): UnaryResponse;
+  getBestBlockHeight(
+    requestMessage: core_pb.GetBestBlockHeightRequest,
+    callback: (error: ServiceError|null, responseMessage: core_pb.GetBestBlockHeightResponse|null) => void
+  ): UnaryResponse;
   broadcastTransaction(
     requestMessage: core_pb.BroadcastTransactionRequest,
     metadata: grpc.Metadata,
@@ -157,5 +205,6 @@ export class CoreClient {
   ): UnaryResponse;
   subscribeToBlockHeadersWithChainLocks(requestMessage: core_pb.BlockHeadersWithChainLocksRequest, metadata?: grpc.Metadata): ResponseStream<core_pb.BlockHeadersWithChainLocksResponse>;
   subscribeToTransactionsWithProofs(requestMessage: core_pb.TransactionsWithProofsRequest, metadata?: grpc.Metadata): ResponseStream<core_pb.TransactionsWithProofsResponse>;
+  subscribeToMasternodeList(requestMessage: core_pb.MasternodeListRequest, metadata?: grpc.Metadata): ResponseStream<core_pb.MasternodeListResponse>;
 }
 

package/clients/core/v0/web/core_pb_service.js

@@ -10,13 +10,22 @@ var Core = (function () {
   return Core;
 }());
 
-Core.getStatus = {
-  methodName: "getStatus",
+Core.getBlockchainStatus = {
+  methodName: "getBlockchainStatus",
   service: Core,
   requestStream: false,
   responseStream: false,
-  requestType: core_pb.GetStatusRequest,
-  responseType: core_pb.GetStatusResponse
+  requestType: core_pb.GetBlockchainStatusRequest,
+  responseType: core_pb.GetBlockchainStatusResponse
+};
+
+Core.getMasternodeStatus = {
+  methodName: "getMasternodeStatus",
+  service: Core,
+  requestStream: false,
+  responseStream: false,
+  requestType: core_pb.GetMasternodeStatusRequest,
+  responseType: core_pb.GetMasternodeStatusResponse
 };
 
 Core.getBlock = {
@@ -28,6 +37,15 @@ Core.getBlock = {
   responseType: core_pb.GetBlockResponse
 };
 
+Core.getBestBlockHeight = {
+  methodName: "getBestBlockHeight",
+  service: Core,
+  requestStream: false,
+  responseStream: false,
+  requestType: core_pb.GetBestBlockHeightRequest,
+  responseType: core_pb.GetBestBlockHeightResponse
+};
+
 Core.broadcastTransaction = {
   methodName: "broadcastTransaction",
   service: Core,
@@ -73,6 +91,15 @@ Core.subscribeToTransactionsWithProofs = {
   responseType: core_pb.TransactionsWithProofsResponse
 };
 
+Core.subscribeToMasternodeList = {
+  methodName: "subscribeToMasternodeList",
+  service: Core,
+  requestStream: false,
+  responseStream: true,
+  requestType: core_pb.MasternodeListRequest,
+  responseType: core_pb.MasternodeListResponse
+};
+
 exports.Core = Core;
 
 function CoreClient(serviceHost, options) {
@@ -80,11 +107,42 @@ function CoreClient(serviceHost, options) {
   this.options = options || {};
 }
 
-CoreClient.prototype.getStatus = function getStatus(requestMessage, metadata, callback) {
+CoreClient.prototype.getBlockchainStatus = function getBlockchainStatus(requestMessage, metadata, callback) {
   if (arguments.length === 2) {
     callback = arguments[1];
   }
-  var client = grpc.unary(Core.getStatus, {
+  var client = grpc.unary(Core.getBlockchainStatus, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+CoreClient.prototype.getMasternodeStatus = function getMasternodeStatus(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Core.getMasternodeStatus, {
     request: requestMessage,
     host: this.serviceHost,
     metadata: metadata,
@@ -142,6 +200,37 @@ CoreClient.prototype.getBlock = function getBlock(requestMessage, metadata, call
   };
 };
 
+CoreClient.prototype.getBestBlockHeight = function getBestBlockHeight(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Core.getBestBlockHeight, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
 CoreClient.prototype.broadcastTransaction = function broadcastTransaction(requestMessage, metadata, callback) {
   if (arguments.length === 2) {
     callback = arguments[1];
@@ -313,5 +402,44 @@ CoreClient.prototype.subscribeToTransactionsWithProofs = function subscribeToTra
   };
 };
 
+CoreClient.prototype.subscribeToMasternodeList = function subscribeToMasternodeList(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(Core.subscribeToMasternodeList, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
 exports.CoreClient = CoreClient;
 

package/clients/platform/v0/nodejs/PlatformPromiseClient.js

@@ -28,14 +28,16 @@ const {
             BroadcastStateTransitionResponse: PBJSBroadcastStateTransitionResponse,
             GetIdentityRequest: PBJSGetIdentityRequest,
             GetIdentityResponse: PBJSGetIdentityResponse,
+            GetIdentitiesContractKeysRequest: PBJSGetIdentitiesContractKeysRequest,
+            GetIdentitiesContractKeysResponse: PBJSGetIdentitiesContractKeysResponse,
             GetDataContractRequest: PBJSGetDataContractRequest,
             GetDataContractResponse: PBJSGetDataContractResponse,
             GetDataContractHistoryRequest: PBJSGetDataContractHistoryRequest,
             GetDataContractHistoryResponse: PBJSGetDataContractHistoryResponse,
             GetDocumentsRequest: PBJSGetDocumentsRequest,
             GetDocumentsResponse: PBJSGetDocumentsResponse,
-            GetIdentitiesByPublicKeyHashesRequest: PBJSGetIdentitiesByPublicKeyHashesRequest,
-            GetIdentitiesByPublicKeyHashesResponse: PBJSGetIdentitiesByPublicKeyHashesResponse,
+            GetIdentityByPublicKeyHashRequest: PBJSGetIdentityByPublicKeyHashRequest,
+            GetIdentityByPublicKeyHashResponse: PBJSGetIdentityByPublicKeyHashResponse,
             WaitForStateTransitionResultRequest: PBJSWaitForStateTransitionResultRequest,
             WaitForStateTransitionResultResponse: PBJSWaitForStateTransitionResultResponse,
             GetConsensusParamsRequest: PBJSGetConsensusParamsRequest,
@@ -48,6 +50,14 @@ const {
               PBJSGetProtocolVersionUpgradeVoteStatusResponse,
             GetProtocolVersionUpgradeStateRequest: PBJSGetProtocolVersionUpgradeStateRequest,
             GetProtocolVersionUpgradeStateResponse: PBJSGetProtocolVersionUpgradeStateResponse,
+            GetProofsRequest: PBJSGetProofsRequest,
+            GetProofsResponse: PBJSGetProofsResponse,
+            GetIdentityContractNonceRequest: PBJSGetIdentityContractNonceRequest,
+            GetIdentityContractNonceResponse: PBJSGetIdentityContractNonceResponse,
+            GetIdentityNonceRequest: PBJSGetIdentityNonceRequest,
+            GetIdentityNonceResponse: PBJSGetIdentityNonceResponse,
+            GetIdentityKeysRequest: PBJSGetIdentityKeysRequest,
+            GetIdentityKeysResponse: PBJSGetIdentityKeysResponse,
           },
         },
       },
@@ -58,15 +68,20 @@ const {
 const {
   BroadcastStateTransitionResponse: ProtocBroadcastStateTransitionResponse,
   GetIdentityResponse: ProtocGetIdentityResponse,
+  GetIdentitiesContractKeysResponse: ProtocGetIdentitiesContractKeysResponse,
   GetDataContractResponse: ProtocGetDataContractResponse,
   GetDataContractHistoryResponse: ProtocGetDataContractHistoryResponse,
   GetDocumentsResponse: ProtocGetDocumentsResponse,
-  GetIdentitiesByPublicKeyHashesResponse: ProtocGetIdentitiesByPublicKeyHashesResponse,
+  GetIdentityByPublicKeyHashResponse: ProtocGetIdentityByPublicKeyHashResponse,
   WaitForStateTransitionResultResponse: ProtocWaitForStateTransitionResultResponse,
   GetConsensusParamsResponse: ProtocGetConsensusParamsResponse,
   GetEpochsInfoResponse: ProtocGetEpochsInfoResponse,
   GetProtocolVersionUpgradeVoteStatusResponse: ProtocGetProtocolVersionUpgradeVoteStatusResponse,
   GetProtocolVersionUpgradeStateResponse: ProtocGetProtocolVersionUpgradeStateResponse,
+  GetProofsResponse: ProtocGetProofsResponse,
+  GetIdentityContractNonceResponse: ProtocGetIdentityContractNonceResponse,
+  GetIdentityNonceResponse: ProtocGetIdentityNonceResponse,
+  GetIdentityKeysResponse: ProtocGetIdentityKeysResponse,
 } = require('./platform_protoc');
 
 const getPlatformDefinition = require('../../../../lib/getPlatformDefinition');
@@ -101,6 +116,10 @@ class PlatformPromiseClient {
       this.client.getIdentity.bind(this.client),
     );
 
+    this.client.getIdentitiesContractKeys = promisify(
+      this.client.getIdentitiesContractKeys.bind(this.client),
+    );
+
     this.client.getDataContract = promisify(
       this.client.getDataContract.bind(this.client),
     );
@@ -113,8 +132,8 @@ class PlatformPromiseClient {
       this.client.getDocuments.bind(this.client),
     );
 
-    this.client.getIdentitiesByPublicKeyHashes = promisify(
-      this.client.getIdentitiesByPublicKeyHashes.bind(this.client),
+    this.client.getIdentityByPublicKeyHash = promisify(
+      this.client.getIdentityByPublicKeyHash.bind(this.client),
     );
 
     this.client.waitForStateTransitionResult = promisify(
@@ -137,6 +156,22 @@ class PlatformPromiseClient {
       this.client.getProtocolVersionUpgradeState.bind(this.client),
     );
 
+    this.client.getProofs = promisify(
+      this.client.getProofs.bind(this.client),
+    );
+
+    this.client.getIdentityContractNonce = promisify(
+      this.client.getIdentityContractNonce.bind(this.client),
+    );
+
+    this.client.getIdentityNonce = promisify(
+      this.client.getIdentityNonce.bind(this.client),
+    );
+
+    this.client.getIdentityKeys = promisify(
+      this.client.getIdentityKeys.bind(this.client),
+    );
+
     this.protocolVersion = undefined;
   }
 
@@ -202,6 +237,40 @@ class PlatformPromiseClient {
     );
   }
 
+  /**
+   * @param {!GetIdentitiesContractKeysRequest} getIdentitiesContractKeysRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @returns {Promise<!GetIdentitiesContractKeysResponse>}
+   */
+  getIdentitiesContractKeys(
+    getIdentitiesContractKeysRequest,
+    metadata = {},
+    options = {},
+  ) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+    return this.client.getIdentitiesContractKeys(
+      getIdentitiesContractKeysRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetIdentitiesContractKeysResponse,
+              PBJSGetIdentitiesContractKeysResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetIdentitiesContractKeysRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
   /**
    *
    * @param {!GetDataContractRequest} getDataContractRequest
@@ -299,13 +368,13 @@ class PlatformPromiseClient {
   }
 
   /**
-   * @param {!GetIdentitiesByPublicKeyHashesRequest} getIdentitiesByPublicKeyHashesRequest
+   * @param {!GetIdentityByPublicKeyHashRequest} getIdentityByPublicKeyHashRequest
    * @param {?Object<string, string>} metadata
    * @param {CallOptions} [options={}]
-   * @returns {Promise<!GetIdentitiesByPublicKeyHashesResponse>}
+   * @returns {Promise<!GetIdentityByPublicKeyHashResponse>}
    */
-  getIdentitiesByPublicKeyHashes(
-    getIdentitiesByPublicKeyHashesRequest,
+  getIdentityByPublicKeyHash(
+    getIdentityByPublicKeyHashRequest,
     metadata = {},
     options = {},
   ) {
@@ -313,18 +382,18 @@ class PlatformPromiseClient {
       throw new Error('metadata must be an object');
     }
 
-    return this.client.getIdentitiesByPublicKeyHashes(
-      getIdentitiesByPublicKeyHashesRequest,
+    return this.client.getIdentityByPublicKeyHash(
+      getIdentityByPublicKeyHashRequest,
       convertObjectToMetadata(metadata),
       {
         interceptors: [
           jsonToProtobufInterceptorFactory(
             jsonToProtobufFactory(
-              ProtocGetIdentitiesByPublicKeyHashesResponse,
-              PBJSGetIdentitiesByPublicKeyHashesResponse,
+              ProtocGetIdentityByPublicKeyHashResponse,
+              PBJSGetIdentityByPublicKeyHashResponse,
             ),
             protobufToJsonFactory(
-              PBJSGetIdentitiesByPublicKeyHashesRequest,
+              PBJSGetIdentityByPublicKeyHashRequest,
             ),
           ),
         ],
@@ -496,6 +565,131 @@ class PlatformPromiseClient {
     );
   }
 
+  /**
+   *
+   * @param {!GetProofsRequest} request
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @returns {Promise<!GetProofsResponse>}
+   */
+  getProofs(request, metadata = {}, options = {}) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getProofs(
+      request,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetProofsResponse,
+              PBJSGetProofsResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetProofsRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
+  /**
+   * @param {!PBJSGetIdentityContractNonceRequest} getIdentityContractNonceRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @return {Promise<!GetIdentityContractNonceResponse>}
+   */
+  getIdentityContractNonce(
+    getIdentityContractNonceRequest,
+    metadata = {},
+    options = {},
+  ) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getIdentityContractNonce(
+      getIdentityContractNonceRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetIdentityContractNonceResponse,
+              PBJSGetIdentityContractNonceResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetIdentityContractNonceRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
+  getIdentityNonce(
+    getIdentityNonceRequest,
+    metadata = {},
+    options = {},
+  ) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getIdentityNonce(
+      getIdentityNonceRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetIdentityNonceResponse,
+              PBJSGetIdentityNonceResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetIdentityNonceRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
+  getIdentityKeys(
+    getIdentityKeysRequest,
+    metadata = {},
+    options = {},
+  ) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getIdentityKeys(
+      getIdentityKeysRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetIdentityKeysResponse,
+              PBJSGetIdentityKeysResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetIdentityKeysRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
   /**
    * @param {string} protocolVersion
    */