event read api and refactor api server builder (MystenLabs#2831)

nigolov · Jun 29, 2022 · 317485a · 317485a
1 parent cae031c
commit 317485a
Show file tree

Hide file tree

Showing 11 changed files with 1,339 additions and 706 deletions.
diff --git a/crates/generate-json-rpc-spec/src/main.rs b/crates/generate-json-rpc-spec/src/main.rs
@@ -26,7 +26,8 @@ use sui_json_rpc::SuiRpcModule;
 use sui_json_rpc_api::rpc_types::{
     GetObjectDataResponse, SuiObjectInfo, TransactionEffectsResponse, TransactionResponse,
 };
-use sui_json_rpc_api::EventApiOpenRpc;
+use sui_json_rpc_api::EventReadApiOpenRpc;
+use sui_json_rpc_api::EventStreamingApiOpenRpc;
 use sui_json_rpc_api::RpcReadApiClient;
 use sui_json_rpc_api::RpcTransactionBuilderClient;
 use sui_json_rpc_api::TransactionBytes;
@@ -83,7 +84,8 @@ async fn main() {
     open_rpc.add_module(ReadApi::rpc_doc_module());
     open_rpc.add_module(FullNodeApi::rpc_doc_module());
     open_rpc.add_module(BcsApiImpl::rpc_doc_module());
-    open_rpc.add_module(EventApiOpenRpc::module_doc());
+    open_rpc.add_module(EventStreamingApiOpenRpc::module_doc());
+    open_rpc.add_module(EventReadApiOpenRpc::module_doc());
     open_rpc.add_module(GatewayWalletSyncApiImpl::rpc_doc_module());
 
     match options.action {

diff --git a/crates/sui-json-rpc-api/src/lib.rs b/crates/sui-json-rpc-api/src/lib.rs
@@ -245,7 +245,63 @@ impl TransactionBytes {
 
 #[open_rpc(namespace = "sui", tag = "Event Subscription")]
 #[rpc(server, client, namespace = "sui")]
-pub trait EventApi {
+pub trait EventStreamingApi {
     #[subscription(name = "subscribeEvent", item = SuiEventEnvelope)]
     fn subscribe_event(&self, filter: SuiEventFilter);
 }
+
+#[open_rpc(namespace = "sui", tag = "Event Read API")]
+#[rpc(server, client, namespace = "sui")]
+pub trait EventReadApi {
+    #[method(name = "getEventsByTransaction")]
+    async fn get_events_by_transaction(
+        &self,
+        digest: TransactionDigest,
+    ) -> RpcResult<Vec<SuiEventEnvelope>>;
+
+    #[method(name = "getEventsByModule")]
+    async fn get_events_by_module(
+        &self,
+        package: ObjectID,
+        module: String,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>>;
+
+    #[method(name = "getEventsByEventType")]
+    async fn get_events_by_event_type(
+        &self,
+        event_type: String,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>>;
+
+    #[method(name = "getEventsBySender")]
+    async fn get_events_by_sender(
+        &self,
+        sender: SuiAddress,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>>;
+
+    #[method(name = "getEventsByObject")]
+    async fn get_events_by_object(
+        &self,
+        object: ObjectID,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>>;
+
+    #[method(name = "getEventsByOwner")]
+    async fn get_events_by_owner(
+        &self,
+        owner: SuiAddress,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>>;
+}
diff --git a/crates/sui-json-rpc/src/event_api.rs b/crates/sui-json-rpc/src/event_api.rs
@@ -1,26 +1,30 @@
 // Copyright (c) 2022, Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
-
-use std::fmt::Display;
-use std::sync::Arc;
-
+use crate::SuiRpcModule;
+use async_trait::async_trait;
 use futures::{StreamExt, TryStream};
+use jsonrpsee::core::RpcResult;
 use jsonrpsee_core::error::SubscriptionClosed;
+use jsonrpsee_core::server::rpc_module::RpcModule;
 use jsonrpsee_core::server::rpc_module::{PendingSubscription, SubscriptionSink};
 use serde::Serialize;
-use tracing::warn;
-
+use std::fmt::Display;
+use std::sync::Arc;
 use sui_core::authority::AuthorityState;
 use sui_core::event_handler::EventHandler;
 use sui_json_rpc_api::rpc_types::{SuiEvent, SuiEventEnvelope, SuiEventFilter};
-use sui_json_rpc_api::EventApiServer;
+use sui_json_rpc_api::EventReadApiServer;
+use sui_json_rpc_api::EventStreamingApiServer;
+use sui_open_rpc::Module;
+use sui_types::base_types::{ObjectID, SuiAddress, TransactionDigest};
+use tracing::warn;
 
-pub struct EventApiImpl {
+pub struct EventStreamingApiImpl {
     state: Arc<AuthorityState>,
     event_handler: Arc<EventHandler>,
 }
 
-impl EventApiImpl {
+impl EventStreamingApiImpl {
     pub fn new(state: Arc<AuthorityState>, event_handler: Arc<EventHandler>) -> Self {
         Self {
             state,
@@ -29,7 +33,8 @@ impl EventApiImpl {
     }
 }
 
-impl EventApiServer for EventApiImpl {
+#[async_trait]
+impl EventStreamingApiServer for EventStreamingApiImpl {
     fn subscribe_event(&self, pending: PendingSubscription, filter: SuiEventFilter) {
         let filter = match filter.try_into() {
             Ok(filter) => filter,
@@ -77,3 +82,100 @@ where
         };
     });
 }
+
+impl SuiRpcModule for EventStreamingApiImpl {
+    fn rpc(self) -> RpcModule<Self> {
+        self.into_rpc()
+    }
+
+    fn rpc_doc_module() -> Module {
+        sui_json_rpc_api::EventStreamingApiOpenRpc::module_doc()
+    }
+}
+
+#[allow(unused)]
+pub struct EventReadApiImpl {
+    state: Arc<AuthorityState>,
+    event_handler: Arc<EventHandler>,
+}
+
+impl EventReadApiImpl {
+    pub fn new(state: Arc<AuthorityState>, event_handler: Arc<EventHandler>) -> Self {
+        Self {
+            state,
+            event_handler,
+        }
+    }
+}
+
+#[allow(unused)]
+#[async_trait]
+impl EventReadApiServer for EventReadApiImpl {
+    async fn get_events_by_transaction(
+        &self,
+        digest: TransactionDigest,
+    ) -> RpcResult<Vec<SuiEventEnvelope>> {
+        Ok(vec![])
+    }
+
+    async fn get_events_by_module(
+        &self,
+        package: ObjectID,
+        module: String,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>> {
+        Ok(vec![])
+    }
+
+    async fn get_events_by_event_type(
+        &self,
+        event_type: String,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>> {
+        Ok(vec![])
+    }
+
+    async fn get_events_by_sender(
+        &self,
+        sender: SuiAddress,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>> {
+        Ok(vec![])
+    }
+
+    async fn get_events_by_object(
+        &self,
+        object: ObjectID,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>> {
+        Ok(vec![])
+    }
+
+    async fn get_events_by_owner(
+        &self,
+        owner: SuiAddress,
+        count: u64,
+        start_time: u64,
+        end_time: u64,
+    ) -> RpcResult<Vec<SuiEventEnvelope>> {
+        Ok(vec![])
+    }
+}
+
+impl SuiRpcModule for EventReadApiImpl {
+    fn rpc(self) -> RpcModule<Self> {
+        self.into_rpc()
+    }
+
+    fn rpc_doc_module() -> Module {
+        sui_json_rpc_api::EventReadApiOpenRpc::module_doc()
+    }
+}