Skip to main content

sui_rpc/client/ledger_streams/adapter/
event.rs

1use prost::bytes::Bytes;
2use tonic::Request;
3use tonic::codegen::BoxStream;
4
5use super::super::super::Client;
6use super::super::super::Result;
7use super::super::observability::LedgerStreamFamily;
8use super::super::types::EventStreamFrame;
9use super::BoundFields;
10use super::KeyGranularity;
11use super::LedgerFrame;
12use super::Progress;
13use super::RpcFuture;
14use super::SubscriptionAdapter;
15use super::parse_opaque_live_frame;
16use crate::proto::sui::rpc::v2::Event;
17use crate::proto::sui::rpc::v2::ListEventsRequest;
18use crate::proto::sui::rpc::v2::ListEventsResponse;
19use crate::proto::sui::rpc::v2::QueryEnd;
20use crate::proto::sui::rpc::v2::QueryOptions;
21use crate::proto::sui::rpc::v2::SubscribeEventsRequest;
22use crate::proto::sui::rpc::v2::SubscribeEventsResponse;
23use crate::proto::sui::rpc::v2::Watermark;
24
25pub(in crate::client::ledger_streams) struct EventAdapter;
26
27impl SubscriptionAdapter for EventAdapter {
28    const FAMILY: LedgerStreamFamily = LedgerStreamFamily::Event;
29    const GRANULARITY: KeyGranularity = KeyGranularity::Event;
30
31    type Item = Event;
32    type Cursor = Bytes;
33    type Output = EventStreamFrame;
34    type ListRequest = ListEventsRequest;
35    type ListResponse = ListEventsResponse;
36    type SubscribeRequest = SubscribeEventsRequest;
37    type SubscribeResponse = SubscribeEventsResponse;
38
39    fn options(request: &Self::ListRequest) -> Option<&QueryOptions> {
40        request.options.as_ref()
41    }
42
43    fn options_mut(request: &mut Self::ListRequest) -> &mut QueryOptions {
44        request.options.get_or_insert_with(QueryOptions::default)
45    }
46
47    fn start_checkpoint(request: &Self::ListRequest) -> Option<u64> {
48        request.start_checkpoint
49    }
50
51    fn end_checkpoint(request: &Self::ListRequest) -> Option<u64> {
52        request.end_checkpoint
53    }
54
55    fn set_start_fields(request: &mut Self::ListRequest, fields: BoundFields) {
56        request.start_checkpoint = Some(fields.checkpoint);
57        request.start_transaction_index = fields.transaction_index;
58        request.start_event_index = fields.event_index;
59    }
60
61    fn set_end_fields(request: &mut Self::ListRequest, fields: BoundFields) {
62        request.end_checkpoint = Some(fields.checkpoint);
63        request.end_transaction_index = fields.transaction_index;
64        request.end_event_index = fields.event_index;
65    }
66
67    fn cursor_bytes(cursor: &Self::Cursor) -> Option<Bytes> {
68        Some(cursor.clone())
69    }
70
71    fn list_cursor(cursor: Bytes) -> Self::Cursor {
72        cursor
73    }
74
75    fn extract_metadata(
76        response: &Self::ListResponse,
77    ) -> (bool, Option<&Watermark>, Option<&QueryEnd>) {
78        (
79            response.event.is_some(),
80            response.watermark.as_ref(),
81            response.end.as_ref(),
82        )
83    }
84
85    fn into_list_item(response: Self::ListResponse) -> Option<Self::Item> {
86        response.event
87    }
88
89    fn parse_live(
90        response: Self::SubscribeResponse,
91        _item_required: bool,
92    ) -> Result<LedgerFrame<Self::Item, Self::Cursor>> {
93        parse_opaque_live_frame(response.event, response.watermark, Self::GRANULARITY)
94    }
95
96    fn into_output(item: Option<Self::Item>, progress: Progress<Self::Cursor>) -> Self::Output {
97        EventStreamFrame {
98            event: item,
99            cursor: progress.cursor,
100            position: progress.position,
101            covered_checkpoint: progress.checkpoint,
102        }
103    }
104
105    fn dispatch_list(
106        mut client: Client,
107        request: Request<Self::ListRequest>,
108    ) -> RpcFuture<Self::ListResponse> {
109        Box::pin(async move {
110            let stream = client
111                .ledger_client()
112                .list_events(request)
113                .await?
114                .into_inner();
115            Ok(Box::pin(stream) as BoxStream<Self::ListResponse>)
116        })
117    }
118
119    fn dispatch_subscribe(
120        mut client: Client,
121        request: Request<Self::SubscribeRequest>,
122    ) -> RpcFuture<Self::SubscribeResponse> {
123        Box::pin(async move {
124            let stream = client
125                .subscription_client()
126                .subscribe_events(request)
127                .await?
128                .into_inner();
129            Ok(Box::pin(stream) as BoxStream<Self::SubscribeResponse>)
130        })
131    }
132}