@dashevo/dapi-grpc 0.23.0-dev.9 → 0.23.1

package/clients/platform/v0/web/platform_pb_service.d.ts

@@ -0,0 +1,177 @@
+// package: org.dash.platform.dapi.v0
+// file: platform.proto
+
+import * as platform_pb from "./platform_pb";
+import {grpc} from "@improbable-eng/grpc-web";
+
+type PlatformbroadcastStateTransition = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.BroadcastStateTransitionRequest;
+  readonly responseType: typeof platform_pb.BroadcastStateTransitionResponse;
+};
+
+type PlatformgetIdentity = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.GetIdentityRequest;
+  readonly responseType: typeof platform_pb.GetIdentityResponse;
+};
+
+type PlatformgetDataContract = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.GetDataContractRequest;
+  readonly responseType: typeof platform_pb.GetDataContractResponse;
+};
+
+type PlatformgetDocuments = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.GetDocumentsRequest;
+  readonly responseType: typeof platform_pb.GetDocumentsResponse;
+};
+
+type PlatformgetIdentitiesByPublicKeyHashes = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.GetIdentitiesByPublicKeyHashesRequest;
+  readonly responseType: typeof platform_pb.GetIdentitiesByPublicKeyHashesResponse;
+};
+
+type PlatformwaitForStateTransitionResult = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.WaitForStateTransitionResultRequest;
+  readonly responseType: typeof platform_pb.WaitForStateTransitionResultResponse;
+};
+
+type PlatformgetConsensusParams = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.GetConsensusParamsRequest;
+  readonly responseType: typeof platform_pb.GetConsensusParamsResponse;
+};
+
+export class Platform {
+  static readonly serviceName: string;
+  static readonly broadcastStateTransition: PlatformbroadcastStateTransition;
+  static readonly getIdentity: PlatformgetIdentity;
+  static readonly getDataContract: PlatformgetDataContract;
+  static readonly getDocuments: PlatformgetDocuments;
+  static readonly getIdentitiesByPublicKeyHashes: PlatformgetIdentitiesByPublicKeyHashes;
+  static readonly waitForStateTransitionResult: PlatformwaitForStateTransitionResult;
+  static readonly getConsensusParams: PlatformgetConsensusParams;
+}
+
+export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
+export type Status = { details: string, code: number; metadata: grpc.Metadata }
+
+interface UnaryResponse {
+  cancel(): void;
+}
+interface ResponseStream<T> {
+  cancel(): void;
+  on(type: 'data', handler: (message: T) => void): ResponseStream<T>;
+  on(type: 'end', handler: (status?: Status) => void): ResponseStream<T>;
+  on(type: 'status', handler: (status: Status) => void): ResponseStream<T>;
+}
+interface RequestStream<T> {
+  write(message: T): RequestStream<T>;
+  end(): void;
+  cancel(): void;
+  on(type: 'end', handler: (status?: Status) => void): RequestStream<T>;
+  on(type: 'status', handler: (status: Status) => void): RequestStream<T>;
+}
+interface BidirectionalStream<ReqT, ResT> {
+  write(message: ReqT): BidirectionalStream<ReqT, ResT>;
+  end(): void;
+  cancel(): void;
+  on(type: 'data', handler: (message: ResT) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'end', handler: (status?: Status) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'status', handler: (status: Status) => void): BidirectionalStream<ReqT, ResT>;
+}
+
+export class PlatformClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  broadcastStateTransition(
+    requestMessage: platform_pb.BroadcastStateTransitionRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.BroadcastStateTransitionResponse|null) => void
+  ): UnaryResponse;
+  broadcastStateTransition(
+    requestMessage: platform_pb.BroadcastStateTransitionRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.BroadcastStateTransitionResponse|null) => void
+  ): UnaryResponse;
+  getIdentity(
+    requestMessage: platform_pb.GetIdentityRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentityResponse|null) => void
+  ): UnaryResponse;
+  getIdentity(
+    requestMessage: platform_pb.GetIdentityRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentityResponse|null) => void
+  ): UnaryResponse;
+  getDataContract(
+    requestMessage: platform_pb.GetDataContractRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetDataContractResponse|null) => void
+  ): UnaryResponse;
+  getDataContract(
+    requestMessage: platform_pb.GetDataContractRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetDataContractResponse|null) => void
+  ): UnaryResponse;
+  getDocuments(
+    requestMessage: platform_pb.GetDocumentsRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetDocumentsResponse|null) => void
+  ): UnaryResponse;
+  getDocuments(
+    requestMessage: platform_pb.GetDocumentsRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetDocumentsResponse|null) => void
+  ): UnaryResponse;
+  getIdentitiesByPublicKeyHashes(
+    requestMessage: platform_pb.GetIdentitiesByPublicKeyHashesRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentitiesByPublicKeyHashesResponse|null) => void
+  ): UnaryResponse;
+  getIdentitiesByPublicKeyHashes(
+    requestMessage: platform_pb.GetIdentitiesByPublicKeyHashesRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentitiesByPublicKeyHashesResponse|null) => void
+  ): UnaryResponse;
+  waitForStateTransitionResult(
+    requestMessage: platform_pb.WaitForStateTransitionResultRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.WaitForStateTransitionResultResponse|null) => void
+  ): UnaryResponse;
+  waitForStateTransitionResult(
+    requestMessage: platform_pb.WaitForStateTransitionResultRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.WaitForStateTransitionResultResponse|null) => void
+  ): UnaryResponse;
+  getConsensusParams(
+    requestMessage: platform_pb.GetConsensusParamsRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetConsensusParamsResponse|null) => void
+  ): UnaryResponse;
+  getConsensusParams(
+    requestMessage: platform_pb.GetConsensusParamsRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetConsensusParamsResponse|null) => void
+  ): UnaryResponse;
+}
+

package/clients/platform/v0/web/platform_pb_service.js

@@ -0,0 +1,301 @@
+// package: org.dash.platform.dapi.v0
+// file: platform.proto
+
+var platform_pb = require("./platform_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var Platform = (function () {
+  function Platform() {}
+  Platform.serviceName = "org.dash.platform.dapi.v0.Platform";
+  return Platform;
+}());
+
+Platform.broadcastStateTransition = {
+  methodName: "broadcastStateTransition",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.BroadcastStateTransitionRequest,
+  responseType: platform_pb.BroadcastStateTransitionResponse
+};
+
+Platform.getIdentity = {
+  methodName: "getIdentity",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.GetIdentityRequest,
+  responseType: platform_pb.GetIdentityResponse
+};
+
+Platform.getDataContract = {
+  methodName: "getDataContract",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.GetDataContractRequest,
+  responseType: platform_pb.GetDataContractResponse
+};
+
+Platform.getDocuments = {
+  methodName: "getDocuments",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.GetDocumentsRequest,
+  responseType: platform_pb.GetDocumentsResponse
+};
+
+Platform.getIdentitiesByPublicKeyHashes = {
+  methodName: "getIdentitiesByPublicKeyHashes",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.GetIdentitiesByPublicKeyHashesRequest,
+  responseType: platform_pb.GetIdentitiesByPublicKeyHashesResponse
+};
+
+Platform.waitForStateTransitionResult = {
+  methodName: "waitForStateTransitionResult",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.WaitForStateTransitionResultRequest,
+  responseType: platform_pb.WaitForStateTransitionResultResponse
+};
+
+Platform.getConsensusParams = {
+  methodName: "getConsensusParams",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.GetConsensusParamsRequest,
+  responseType: platform_pb.GetConsensusParamsResponse
+};
+
+exports.Platform = Platform;
+
+function PlatformClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+PlatformClient.prototype.broadcastStateTransition = function broadcastStateTransition(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.broadcastStateTransition, {
+    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();
+    }
+  };
+};
+
+PlatformClient.prototype.getIdentity = function getIdentity(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.getIdentity, {
+    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();
+    }
+  };
+};
+
+PlatformClient.prototype.getDataContract = function getDataContract(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.getDataContract, {
+    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();
+    }
+  };
+};
+
+PlatformClient.prototype.getDocuments = function getDocuments(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.getDocuments, {
+    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();
+    }
+  };
+};
+
+PlatformClient.prototype.getIdentitiesByPublicKeyHashes = function getIdentitiesByPublicKeyHashes(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.getIdentitiesByPublicKeyHashes, {
+    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();
+    }
+  };
+};
+
+PlatformClient.prototype.waitForStateTransitionResult = function waitForStateTransitionResult(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.waitForStateTransitionResult, {
+    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();
+    }
+  };
+};
+
+PlatformClient.prototype.getConsensusParams = function getConsensusParams(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.getConsensusParams, {
+    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();
+    }
+  };
+};
+
+exports.PlatformClient = PlatformClient;
+

package/lib/utils/parseMetadata.js

@@ -0,0 +1,27 @@
+const { Metadata: MetadataGrpcJS } = require('@grpc/grpc-js/build/src/metadata');
+const { grpc: { Metadata: MetadataGrpcWeb } } = require('@improbable-eng/grpc-web');
+
+/**
+ *
+ * @param {MetadataGrpcJS|MetadataGrpcWeb} metadata
+ * @return {{}|{[p: string]: string}}
+ */
+const parseMetadata = (metadata) => {
+  if (metadata instanceof MetadataGrpcJS) {
+    return metadata.getMap();
+  } if (metadata instanceof MetadataGrpcWeb) {
+    const parsedMetadata = {};
+    metadata.forEach((key, values) => {
+      // Mapping each key to the first value associated with it.
+      // This corresponds to the getMap() behaviour of the grpc-js Metadata class.
+      const [value] = values;
+      parsedMetadata[key] = value;
+    });
+
+    return parsedMetadata;
+  }
+
+  return metadata;
+};
+
+module.exports = parseMetadata;

package/node.js

@@ -1,3 +1,4 @@
+const { Metadata } = require('@grpc/grpc-js/build/src/metadata');
 const CorePromiseClient = require('./clients/core/v0/nodejs/CorePromiseClient');
 const PlatformPromiseClient = require('./clients/platform/v0/nodejs/PlatformPromiseClient');
 
@@ -6,6 +7,7 @@ const protocPlatformMessages = require('./clients/platform/v0/nodejs/platform_pr
 
 const getCoreDefinition = require('./lib/getCoreDefinition');
 const getPlatformDefinition = require('./lib/getPlatformDefinition');
+const parseMetadata = require('./lib/utils/parseMetadata');
 
 const {
   org: {
@@ -45,4 +47,6 @@ module.exports = {
     ...protocCoreMessages,
     ...protocPlatformMessages,
   },
+  parseMetadata,
+  Metadata,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-grpc",
-  "version": "0.23.0-dev.9",
+  "version": "0.23.1",
   "description": "DAPI GRPC definition file and generated clients",
   "browser": "browser.js",
   "main": "node.js",
@@ -33,11 +33,11 @@
   },
   "homepage": "https://github.com/dashevo/dapi-grpc#readme",
   "dependencies": {
-    "@dashevo/grpc-common": "~0.23.0-dev.9",
+    "@dashevo/grpc-common": "0.23.1",
     "@dashevo/protobufjs": "6.10.5",
     "@grpc/grpc-js": "^1.3.7",
+    "@improbable-eng/grpc-web": "^0.15.0",
     "google-protobuf": "^3.12.2",
-    "grpc-web": "1.2.1",
     "long": "^5.2.0"
   },
   "devDependencies": {

package/scripts/build.sh

@@ -18,8 +18,7 @@ PLATFORM_OBJ_C_OUT_PATH="$PLATFORM_CLIENTS_PATH/objective-c"
 CORE_PYTHON_OUT_PATH="$CORE_CLIENTS_PATH/python"
 PLATFORM_PYTHON_OUT_PATH="$PLATFORM_CLIENTS_PATH/python"
 
-GRPC_WEB_COMMON_IMAGE="strophy/grpc-web-common:1.3.2"
-PROTOC_IMAGE="strophy/protoc:3.3.2"
+PROTOC_IMAGE="rvolosatovs/protoc:4.0.0"
 
 #################################################
 # Generate JavaScript client for `Core` service #
@@ -30,10 +29,11 @@ rm -rf "$CORE_WEB_OUT_PATH/*"
 docker run -v "$CORE_PROTO_PATH:$CORE_PROTO_PATH" \
            -v "$CORE_WEB_OUT_PATH:$CORE_WEB_OUT_PATH" \
            --rm \
-           "$GRPC_WEB_COMMON_IMAGE" \
-           protoc -I="$CORE_PROTO_PATH" "core.proto" \
-                   --js_out="import_style=commonjs:$CORE_WEB_OUT_PATH" \
-                   --grpc-web_out="import_style=commonjs,mode=grpcwebtext:$CORE_WEB_OUT_PATH"
+           "$PROTOC_IMAGE" \
+           --js_out="import_style=commonjs:$CORE_WEB_OUT_PATH" \
+           --ts_out="service=grpc-web:$CORE_WEB_OUT_PATH" \
+           -I="$CORE_PROTO_PATH" \
+           "core.proto"
 
 # Clean node message classes
 
@@ -61,10 +61,11 @@ rm -rf "$PLATFORM_WEB_OUT_PATH/*"
 docker run -v "$PLATFORM_PROTO_PATH:$PLATFORM_PROTO_PATH" \
            -v "$PLATFORM_WEB_OUT_PATH:$PLATFORM_WEB_OUT_PATH" \
            --rm \
-           "$GRPC_WEB_COMMON_IMAGE" \
-           protoc -I="$PLATFORM_PROTO_PATH" "platform.proto" \
-                   --js_out="import_style=commonjs:$PLATFORM_WEB_OUT_PATH" \
-                   --grpc-web_out="import_style=commonjs,mode=grpcwebtext:$PLATFORM_WEB_OUT_PATH"
+           "$PROTOC_IMAGE" \
+           --js_out="import_style=commonjs:$PLATFORM_WEB_OUT_PATH" \
+           --ts_out="service=grpc-web:$PLATFORM_WEB_OUT_PATH" \
+           -I="$PLATFORM_PROTO_PATH" \
+           "platform.proto"
 
 # Clean node message classes