@dashevo/dapi-grpc 2.1.0-dev.7 → 2.1.0-pr.2716.1

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

@@ -427,6 +427,15 @@ type PlatformgetGroupActionSigners = {
   readonly responseType: typeof platform_pb.GetGroupActionSignersResponse;
 };
 
+type PlatformSubscribePlatformEvents = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: true;
+  readonly responseStream: true;
+  readonly requestType: typeof platform_pb.PlatformEventsCommand;
+  readonly responseType: typeof platform_pb.PlatformEventsResponse;
+};
+
 export class Platform {
   static readonly serviceName: string;
   static readonly broadcastStateTransition: PlatformbroadcastStateTransition;
@@ -476,6 +485,7 @@ export class Platform {
   static readonly getGroupInfos: PlatformgetGroupInfos;
   static readonly getGroupActions: PlatformgetGroupActions;
   static readonly getGroupActionSigners: PlatformgetGroupActionSigners;
+  static readonly SubscribePlatformEvents: PlatformSubscribePlatformEvents;
 }
 
 export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
@@ -933,5 +943,6 @@ export class PlatformClient {
     requestMessage: platform_pb.GetGroupActionSignersRequest,
     callback: (error: ServiceError|null, responseMessage: platform_pb.GetGroupActionSignersResponse|null) => void
   ): UnaryResponse;
+  subscribePlatformEvents(metadata?: grpc.Metadata): BidirectionalStream<platform_pb.PlatformEventsCommand, platform_pb.PlatformEventsResponse>;
 }
 

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

@@ -433,6 +433,15 @@ Platform.getGroupActionSigners = {
   responseType: platform_pb.GetGroupActionSignersResponse
 };
 
+Platform.SubscribePlatformEvents = {
+  methodName: "SubscribePlatformEvents",
+  service: Platform,
+  requestStream: true,
+  responseStream: true,
+  requestType: platform_pb.PlatformEventsCommand,
+  responseType: platform_pb.PlatformEventsResponse
+};
+
 exports.Platform = Platform;
 
 function PlatformClient(serviceHost, options) {
@@ -1897,5 +1906,50 @@ PlatformClient.prototype.getGroupActionSigners = function getGroupActionSigners(
   };
 };
 
+PlatformClient.prototype.subscribePlatformEvents = function subscribePlatformEvents(metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.client(Platform.SubscribePlatformEvents, {
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport
+  });
+  client.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;
+  });
+  client.onMessage(function (message) {
+    listeners.data.forEach(function (handler) {
+      handler(message);
+    })
+  });
+  client.start(metadata);
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    write: function (requestMessage) {
+      client.send(requestMessage);
+      return this;
+    },
+    end: function () {
+      client.finishSend();
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
 exports.PlatformClient = PlatformClient;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-grpc",
-  "version": "2.1.0-dev.7",
+  "version": "2.1.0-pr.2716.1",
   "description": "DAPI GRPC definition file and generated clients",
   "browser": "browser.js",
   "main": "node.js",
@@ -45,7 +45,7 @@
   },
   "homepage": "https://github.com/dashevo/dapi-grpc#readme",
   "dependencies": {
-    "@dashevo/grpc-common": "2.1.0-dev.7",
+    "@dashevo/grpc-common": "2.1.0-pr.2716.1",
     "@dashevo/protobufjs": "6.10.5",
     "@grpc/grpc-js": "1.4.4",
     "@improbable-eng/grpc-web": "^0.15.0",

package/protos/platform/v0/platform.proto

@@ -6,6 +6,91 @@ package org.dash.platform.dapi.v0;
 
 import "google/protobuf/timestamp.proto";
 
+// Platform events streaming (v0)
+message PlatformEventsCommand {
+  message PlatformEventsCommandV0 {
+    oneof command {
+      AddSubscriptionV0 add = 1;
+      RemoveSubscriptionV0 remove = 2;
+    }
+  }
+  oneof version { PlatformEventsCommandV0 v0 = 1; }
+}
+
+message PlatformEventsResponse {
+  message PlatformEventsResponseV0 {
+    oneof response {
+      PlatformEventMessageV0 event = 1;
+      AckV0 ack = 2;
+      PlatformErrorV0 error = 3;
+    }
+  }
+  oneof version { PlatformEventsResponseV0 v0 = 1; }
+}
+
+message AddSubscriptionV0 {
+  string client_subscription_id = 1;
+  PlatformFilterV0 filter = 2;
+}
+
+message RemoveSubscriptionV0 { 
+  string client_subscription_id = 1; 
+}
+
+message AckV0 {
+  string client_subscription_id = 1;
+  string op = 2; // "add" | "remove"
+}
+
+message PlatformErrorV0 {
+  string client_subscription_id = 1;
+  uint32 code = 2;
+  string message = 3;
+}
+
+message PlatformEventMessageV0 {
+  string client_subscription_id = 1;
+  PlatformEventV0 event = 2;
+}
+
+// Initial placeholder filter and event to be refined during integration
+// Filter for StateTransitionResult events
+message StateTransitionResultFilter {
+  // When set, only match StateTransitionResult events for this tx hash.
+  optional bytes tx_hash = 1;
+}
+
+message PlatformFilterV0 {
+  oneof kind {
+    bool all = 1; // subscribe to all platform events
+    bool block_committed = 2; // subscribe to BlockCommitted events only
+    StateTransitionResultFilter state_transition_result = 3; // subscribe to StateTransitionResult events (optionally filtered by tx_hash)
+  }
+}
+
+message PlatformEventV0 {
+  message BlockMetadata {
+    uint64 height = 1 [ jstype = JS_STRING ];
+    uint64 time_ms = 2 [ jstype = JS_STRING ];
+    bytes block_id_hash = 3;
+  }
+
+  message BlockCommitted {
+    BlockMetadata meta = 1;
+    uint32 tx_count = 2;
+  }
+
+  message StateTransitionFinalized {
+    BlockMetadata meta = 1;
+    bytes tx_hash = 2;
+  }
+
+  oneof event {
+    BlockCommitted block_committed = 1;
+    StateTransitionFinalized state_transition_finalized = 2;
+  }
+}
+
 service Platform {
   rpc broadcastStateTransition(BroadcastStateTransitionRequest)
       returns (BroadcastStateTransitionResponse);
@@ -102,6 +187,10 @@ service Platform {
   rpc getGroupActions(GetGroupActionsRequest) returns (GetGroupActionsResponse);
   rpc getGroupActionSigners(GetGroupActionSignersRequest)
       returns (GetGroupActionSignersResponse);
+
+  // Bi-directional stream for multiplexed platform events subscriptions
+  rpc SubscribePlatformEvents(stream PlatformEventsCommand)
+      returns (stream PlatformEventsResponse);
 }
 
 // Proof message includes cryptographic proofs for validating responses

package/src/drive/client/org.dash.platform.dapi.v0.rs

@@ -1,4 +1,222 @@
 // This file is @generated by prost-build.
+/// Platform events streaming (v0)
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct PlatformEventsCommand {
+    #[prost(oneof = "platform_events_command::Version", tags = "1")]
+    pub version: ::core::option::Option<platform_events_command::Version>,
+}
+/// Nested message and enum types in `PlatformEventsCommand`.
+pub mod platform_events_command {
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(::dapi_grpc_macros::Mockable)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+    pub struct PlatformEventsCommandV0 {
+        #[prost(oneof = "platform_events_command_v0::Command", tags = "1, 2")]
+        pub command: ::core::option::Option<platform_events_command_v0::Command>,
+    }
+    /// Nested message and enum types in `PlatformEventsCommandV0`.
+    pub mod platform_events_command_v0 {
+        #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+        #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
+        pub enum Command {
+            #[prost(message, tag = "1")]
+            Add(super::super::AddSubscriptionV0),
+            #[prost(message, tag = "2")]
+            Remove(super::super::RemoveSubscriptionV0),
+        }
+    }
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(PlatformEventsCommandV0),
+    }
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct PlatformEventsResponse {
+    #[prost(oneof = "platform_events_response::Version", tags = "1")]
+    pub version: ::core::option::Option<platform_events_response::Version>,
+}
+/// Nested message and enum types in `PlatformEventsResponse`.
+pub mod platform_events_response {
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(::dapi_grpc_macros::Mockable)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+    pub struct PlatformEventsResponseV0 {
+        #[prost(oneof = "platform_events_response_v0::Response", tags = "1, 2, 3")]
+        pub response: ::core::option::Option<platform_events_response_v0::Response>,
+    }
+    /// Nested message and enum types in `PlatformEventsResponseV0`.
+    pub mod platform_events_response_v0 {
+        #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+        #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
+        pub enum Response {
+            #[prost(message, tag = "1")]
+            Event(super::super::PlatformEventMessageV0),
+            #[prost(message, tag = "2")]
+            Ack(super::super::AckV0),
+            #[prost(message, tag = "3")]
+            Error(super::super::PlatformErrorV0),
+        }
+    }
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(PlatformEventsResponseV0),
+    }
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct AddSubscriptionV0 {
+    #[prost(string, tag = "1")]
+    pub client_subscription_id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub filter: ::core::option::Option<PlatformFilterV0>,
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct RemoveSubscriptionV0 {
+    #[prost(string, tag = "1")]
+    pub client_subscription_id: ::prost::alloc::string::String,
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct AckV0 {
+    #[prost(string, tag = "1")]
+    pub client_subscription_id: ::prost::alloc::string::String,
+    /// "add" | "remove"
+    #[prost(string, tag = "2")]
+    pub op: ::prost::alloc::string::String,
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct PlatformErrorV0 {
+    #[prost(string, tag = "1")]
+    pub client_subscription_id: ::prost::alloc::string::String,
+    #[prost(uint32, tag = "2")]
+    pub code: u32,
+    #[prost(string, tag = "3")]
+    pub message: ::prost::alloc::string::String,
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct PlatformEventMessageV0 {
+    #[prost(string, tag = "1")]
+    pub client_subscription_id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub event: ::core::option::Option<PlatformEventV0>,
+}
+/// Initial placeholder filter and event to be refined during integration
+/// Filter for StateTransitionResult events
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct StateTransitionResultFilter {
+    /// When set, only match StateTransitionResult events for this tx hash.
+    #[prost(bytes = "vec", optional, tag = "1")]
+    pub tx_hash: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct PlatformFilterV0 {
+    #[prost(oneof = "platform_filter_v0::Kind", tags = "1, 2, 3")]
+    pub kind: ::core::option::Option<platform_filter_v0::Kind>,
+}
+/// Nested message and enum types in `PlatformFilterV0`.
+pub mod platform_filter_v0 {
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
+    pub enum Kind {
+        /// subscribe to all platform events
+        #[prost(bool, tag = "1")]
+        All(bool),
+        /// subscribe to BlockCommitted events only
+        #[prost(bool, tag = "2")]
+        BlockCommitted(bool),
+        /// subscribe to StateTransitionResult events (optionally filtered by tx_hash)
+        #[prost(message, tag = "3")]
+        StateTransitionResult(super::StateTransitionResultFilter),
+    }
+}
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+#[derive(::dapi_grpc_macros::Mockable)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct PlatformEventV0 {
+    #[prost(oneof = "platform_event_v0::Event", tags = "1, 2")]
+    pub event: ::core::option::Option<platform_event_v0::Event>,
+}
+/// Nested message and enum types in `PlatformEventV0`.
+pub mod platform_event_v0 {
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(::dapi_grpc_macros::Mockable)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+    pub struct BlockMetadata {
+        #[prost(uint64, tag = "1")]
+        pub height: u64,
+        #[prost(uint64, tag = "2")]
+        pub time_ms: u64,
+        #[prost(bytes = "vec", tag = "3")]
+        pub block_id_hash: ::prost::alloc::vec::Vec<u8>,
+    }
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(::dapi_grpc_macros::Mockable)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+    pub struct BlockCommitted {
+        #[prost(message, optional, tag = "1")]
+        pub meta: ::core::option::Option<BlockMetadata>,
+        #[prost(uint32, tag = "2")]
+        pub tx_count: u32,
+    }
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(::dapi_grpc_macros::Mockable)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+    pub struct StateTransitionFinalized {
+        #[prost(message, optional, tag = "1")]
+        pub meta: ::core::option::Option<BlockMetadata>,
+        #[prost(bytes = "vec", tag = "2")]
+        pub tx_hash: ::prost::alloc::vec::Vec<u8>,
+    }
+    #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
+    #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
+    pub enum Event {
+        #[prost(message, tag = "1")]
+        BlockCommitted(BlockCommitted),
+        #[prost(message, tag = "2")]
+        StateTransitionFinalized(StateTransitionFinalized),
+    }
+}
 /// Proof message includes cryptographic proofs for validating responses
 #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
@@ -7024,5 +7242,37 @@ pub mod platform_client {
                 );
             self.inner.unary(req, path, codec).await
         }
+        /// Bi-directional stream for multiplexed platform events subscriptions
+        pub async fn subscribe_platform_events(
+            &mut self,
+            request: impl tonic::IntoStreamingRequest<
+                Message = super::PlatformEventsCommand,
+            >,
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::PlatformEventsResponse>>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic_prost::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/org.dash.platform.dapi.v0.Platform/SubscribePlatformEvents",
+            );
+            let mut req = request.into_streaming_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "org.dash.platform.dapi.v0.Platform",
+                        "SubscribePlatformEvents",
+                    ),
+                );
+            self.inner.streaming(req, path, codec).await
+        }
     }
 }