Skip to main content

sui_rpc/client/ledger_streams/adapter/
transaction.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::TransactionStreamFrame;
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::ExecutedTransaction;
17use crate::proto::sui::rpc::v2::ListTransactionsRequest;
18use crate::proto::sui::rpc::v2::ListTransactionsResponse;
19use crate::proto::sui::rpc::v2::QueryEnd;
20use crate::proto::sui::rpc::v2::QueryOptions;
21use crate::proto::sui::rpc::v2::SubscribeTransactionsRequest;
22use crate::proto::sui::rpc::v2::SubscribeTransactionsResponse;
23use crate::proto::sui::rpc::v2::Watermark;
24
25pub(in crate::client::ledger_streams) struct TransactionAdapter;
26
27impl SubscriptionAdapter for TransactionAdapter {
28    const FAMILY: LedgerStreamFamily = LedgerStreamFamily::Transaction;
29    const GRANULARITY: KeyGranularity = KeyGranularity::Transaction;
30
31    type Item = ExecutedTransaction;
32    type Cursor = Bytes;
33    type Output = TransactionStreamFrame;
34    type ListRequest = ListTransactionsRequest;
35    type ListResponse = ListTransactionsResponse;
36    type SubscribeRequest = SubscribeTransactionsRequest;
37    type SubscribeResponse = SubscribeTransactionsResponse;
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    }
59
60    fn set_end_fields(request: &mut Self::ListRequest, fields: BoundFields) {
61        request.end_checkpoint = Some(fields.checkpoint);
62        request.end_transaction_index = fields.transaction_index;
63    }
64
65    fn cursor_bytes(cursor: &Self::Cursor) -> Option<Bytes> {
66        Some(cursor.clone())
67    }
68
69    fn list_cursor(cursor: Bytes) -> Self::Cursor {
70        cursor
71    }
72
73    fn extract_metadata(
74        response: &Self::ListResponse,
75    ) -> (bool, Option<&Watermark>, Option<&QueryEnd>) {
76        (
77            response.transaction.is_some(),
78            response.watermark.as_ref(),
79            response.end.as_ref(),
80        )
81    }
82
83    fn into_list_item(response: Self::ListResponse) -> Option<Self::Item> {
84        response.transaction
85    }
86
87    fn parse_live(
88        response: Self::SubscribeResponse,
89        _item_required: bool,
90    ) -> Result<LedgerFrame<Self::Item, Self::Cursor>> {
91        parse_opaque_live_frame(response.transaction, response.watermark, Self::GRANULARITY)
92    }
93
94    fn into_output(item: Option<Self::Item>, progress: Progress<Self::Cursor>) -> Self::Output {
95        TransactionStreamFrame {
96            transaction: item,
97            cursor: progress.cursor,
98            position: progress.position,
99            covered_checkpoint: progress.checkpoint,
100        }
101    }
102
103    fn dispatch_list(
104        mut client: Client,
105        request: Request<Self::ListRequest>,
106    ) -> RpcFuture<Self::ListResponse> {
107        Box::pin(async move {
108            let stream = client
109                .ledger_client()
110                .list_transactions(request)
111                .await?
112                .into_inner();
113            Ok(Box::pin(stream) as BoxStream<Self::ListResponse>)
114        })
115    }
116
117    fn dispatch_subscribe(
118        mut client: Client,
119        request: Request<Self::SubscribeRequest>,
120    ) -> RpcFuture<Self::SubscribeResponse> {
121        Box::pin(async move {
122            let stream = client
123                .subscription_client()
124                .subscribe_transactions(request)
125                .await?
126                .into_inner();
127            Ok(Box::pin(stream) as BoxStream<Self::SubscribeResponse>)
128        })
129    }
130}