1use std::str::FromStr;
6
7use async_graphql::{
8 connection::{Connection, CursorType, Edge},
9 *,
10};
11use diesel::{
12 OptionalExtension, QueryableByName,
13 sql_types::{BigInt as SqlBigInt, Nullable, Text},
14};
15use iota_indexer::types::OwnerType;
16use iota_sdk_types::TypeTag;
17use serde::{Deserialize, Serialize};
18
19use crate::{
20 consistency::Checkpointed,
21 data::{Db, DbConnection, QueryExecutor},
22 error::Error,
23 filter, query,
24 raw_query::RawQuery,
25 types::{
26 available_range::AvailableRange,
27 big_int::BigInt,
28 cursor::{self, Page, RawPaginated, ScanLimited, Target},
29 iota_address::IotaAddress,
30 move_type::MoveType,
31 uint53::UInt53,
32 },
33};
34
35#[derive(Clone, Debug, SimpleObject)]
37pub(crate) struct Balance {
38 pub(crate) coin_type: MoveType,
40 pub(crate) coin_object_count: Option<UInt53>,
42 pub(crate) total_balance: Option<BigInt>,
44}
45
46#[derive(QueryableByName)]
50pub struct StoredBalance {
51 #[diesel(sql_type = Nullable<Text>)]
52 pub balance: Option<String>,
53 #[diesel(sql_type = Nullable<SqlBigInt>)]
54 pub count: Option<i64>,
55 #[diesel(sql_type = Text)]
56 pub coin_type: String,
57}
58
59pub(crate) type Cursor = cursor::JsonCursor<BalanceCursor>;
60
61#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
65pub(crate) struct BalanceCursor {
66 #[serde(rename = "t")]
67 coin_type: String,
68 #[serde(rename = "c")]
70 checkpoint_viewed_at: UInt53,
71}
72
73impl Balance {
74 pub(crate) async fn query(
79 db: &Db,
80 address: IotaAddress,
81 coin_type: TypeTag,
82 checkpoint_viewed_at: u64,
83 ) -> Result<Option<Balance>, Error> {
84 let max_available_range = db.max_available_range;
85 let stored: Option<StoredBalance> = db
86 .execute_repeatable(move |conn| {
87 if !AvailableRange::is_checkpoint_in_backward_history_range(
88 conn,
89 checkpoint_viewed_at,
90 max_available_range,
91 )? {
92 return Ok::<_, diesel::result::Error>(None);
93 }
94
95 conn.result(move || {
96 balance_query(address, Some(coin_type.clone()), checkpoint_viewed_at)
97 .into_boxed()
98 })
99 .optional()
100 })
101 .await?;
102
103 stored.map(Balance::try_from).transpose()
104 }
105
106 pub(crate) async fn paginate(
110 db: &Db,
111 page: Page<Cursor>,
112 address: IotaAddress,
113 checkpoint_viewed_at: u64,
114 ) -> Result<Connection<String, Balance>, Error> {
115 let cursor_viewed_at = page.validate_cursor_consistency()?;
120 let checkpoint_viewed_at = cursor_viewed_at.unwrap_or(checkpoint_viewed_at);
121
122 let max_available_range = db.max_available_range;
123
124 let Some((prev, next, results)) = db
125 .execute_repeatable(move |conn| {
126 if !AvailableRange::is_checkpoint_in_backward_history_range(
127 conn,
128 checkpoint_viewed_at,
129 max_available_range,
130 )? {
131 return Ok::<_, diesel::result::Error>(None);
132 }
133
134 let result = page.paginate_raw_query::<StoredBalance>(
135 conn,
136 checkpoint_viewed_at,
137 balance_query(address, None, checkpoint_viewed_at),
138 )?;
139
140 Ok(Some(result))
141 })
142 .await?
143 else {
144 return Err(Error::Client(
145 "Requested data is outside the available range".to_string(),
146 ));
147 };
148
149 let mut conn = Connection::new(prev, next);
150 for stored in results {
151 let cursor = stored.cursor(checkpoint_viewed_at).encode_cursor();
152 let balance = Balance::try_from(stored)?;
153 conn.edges.push(Edge::new(cursor, balance));
154 }
155
156 Ok(conn)
157 }
158}
159
160impl RawPaginated<Cursor> for StoredBalance {
161 fn filter_ge(cursor: &Cursor, query: RawQuery) -> RawQuery {
162 filter!(query, "coin_type >= {}", cursor.coin_type.clone())
163 }
164
165 fn filter_le(cursor: &Cursor, query: RawQuery) -> RawQuery {
166 filter!(query, "coin_type <= {}", cursor.coin_type.clone())
167 }
168
169 fn order(asc: bool, query: RawQuery) -> RawQuery {
170 if asc {
171 return query.order_by("coin_type ASC");
172 }
173 query.order_by("coin_type DESC")
174 }
175}
176
177impl Target<Cursor> for StoredBalance {
178 fn cursor(&self, checkpoint_viewed_at: u64) -> Cursor {
179 Cursor::new(BalanceCursor {
180 coin_type: self.coin_type.clone(),
181 checkpoint_viewed_at: UInt53::new_unchecked(checkpoint_viewed_at),
182 })
183 }
184}
185
186impl Checkpointed for Cursor {
187 fn checkpoint_viewed_at(&self) -> u64 {
188 self.checkpoint_viewed_at.into()
189 }
190}
191
192impl ScanLimited for Cursor {}
193
194impl TryFrom<StoredBalance> for Balance {
195 type Error = Error;
196
197 fn try_from(s: StoredBalance) -> Result<Self, Error> {
198 let StoredBalance {
199 balance,
200 count,
201 coin_type,
202 } = s;
203 let total_balance = balance
204 .map(|b| BigInt::from_str(&b))
205 .transpose()
206 .map_err(|_| Error::Internal("Failed to read balance.".to_string()))?;
207
208 let coin_object_count = count.map(|c| UInt53::try_from(c as u64)).transpose()?;
209
210 let coin_type = TypeTag::from_str(&coin_type)
211 .map_err(|e| Error::Internal(format!("Failed to parse coin type: {e}")))?
212 .into();
213
214 Ok(Balance {
215 coin_type,
216 coin_object_count,
217 total_balance,
218 })
219 }
220}
221
222fn balance_query(
242 address: IotaAddress,
243 coin_type: Option<TypeTag>,
244 checkpoint_viewed_at: u64,
245) -> RawQuery {
246 let checkpoint_viewed_at = checkpoint_viewed_at as i64;
247
248 let checkpointed = filter(
249 query!("SELECT object_id, coin_balance, coin_type FROM checkpointed_objects"),
250 address,
251 coin_type.clone(),
252 );
253 let source_a = filter!(
256 query!(
257 "SELECT candidates.object_id, candidates.coin_balance, candidates.coin_type \
258 FROM ({}) candidates \
259 LEFT JOIN LATERAL (\
260 SELECT changed.superseded_at_checkpoint \
261 FROM objects_backward_history changed \
262 WHERE changed.object_id = candidates.object_id \
263 ORDER BY changed.object_version DESC \
264 LIMIT 1\
265 ) latest ON true",
266 checkpointed
267 ),
268 format!(
269 "(latest.superseded_at_checkpoint IS NULL \
270 OR latest.superseded_at_checkpoint <= {checkpoint_viewed_at})"
271 )
272 );
273
274 let candidate_ids = filter!(
278 filter(
279 query!("SELECT DISTINCT object_id FROM objects_backward_history"),
280 address,
281 coin_type.clone(),
282 ),
283 format!("superseded_at_checkpoint > {checkpoint_viewed_at}")
284 );
285 let (candidate_ids_sql, binds) = candidate_ids.finish();
286
287 let newest_superseded = format!(
290 "SELECT superseded.object_version \
291 FROM objects_backward_history superseded \
292 WHERE superseded.object_id = candidate_ids.object_id \
293 AND superseded.superseded_at_checkpoint <= {checkpoint_viewed_at} \
294 ORDER BY superseded.object_version DESC \
295 LIMIT 1"
296 );
297
298 let live_rows = RawQuery::new(
303 format!(
304 "SELECT object_id, coin_balance, coin_type, owner_id, owner_type \
305 FROM ( \
306 SELECT live.* \
307 FROM ({candidate_ids_sql}) candidate_ids \
308 CROSS JOIN LATERAL ( \
309 SELECT objects_backward_history.* \
310 FROM objects_backward_history \
311 WHERE objects_backward_history.object_id = candidate_ids.object_id \
312 AND objects_backward_history.object_version > COALESCE(({newest_superseded}), -1) \
313 ORDER BY objects_backward_history.object_version ASC \
314 LIMIT 1 \
315 ) live \
316 ) AS objects_backward_history"
317 ),
318 binds,
319 );
320
321 let source_b = query!(
325 "SELECT candidates.object_id, candidates.coin_balance, candidates.coin_type \
326 FROM ({}) candidates",
327 filter(live_rows, address, coin_type)
328 );
329
330 query!(
331 r#"SELECT
332 CAST(SUM(coin_balance) AS TEXT) as balance,
333 COUNT(*) as count,
334 coin_type
335 FROM (({}) UNION ALL ({})) candidates"#,
336 source_a,
337 source_b
338 )
339 .group_by("coin_type")
340}
341
342fn filter(mut query: RawQuery, owner: IotaAddress, coin_type: Option<TypeTag>) -> RawQuery {
345 query = filter!(
346 query,
347 format!(
348 "owner_id = '\\x{}'::bytea AND owner_type = {}",
349 hex::encode(owner.into_vec()),
350 OwnerType::Address as i16
351 )
352 );
353
354 if let Some(coin_type) = coin_type {
355 query = filter!(
361 query,
362 "coin_type = {}",
363 coin_type.to_canonical_string(true)
364 );
365 } else {
366 query = filter!(query, "coin_type IS NOT NULL");
367 };
368
369 query
370}