sui_rpc/client/ledger_streams/adapter/
transaction.rs1use 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}