fix: correct timestamp unit mismatch in currentCapacity calculation (#929)

* fix: correct timestamp unit mismatch in currentCapacity calculation

* fix: use u64 for timestamp newtypes per review

Author: cosmir17

indexer-api/src/infra/storage/dust.rs

@@ -17,7 +17,7 @@ use crate::{
 };
 use fastrace::trace;
 use indexer_common::{
-    domain::{ByteVec, CardanoRewardAddress, LedgerVersion, ledger},
+    domain::{ByteVec, CardanoRewardAddress, LedgerVersion, TimestampMs, TimestampSecs, ledger},
     infra::sqlx::U128BeBytes,
 };
 use indoc::indoc;
@@ -78,31 +78,32 @@ impl DustStorage for Storage {
                     .fetch_optional(&*self.pool)
                     .await?;
 
-                if let Some((value, ctime)) = result {
+                if let Some((value, ctime_raw)) = result {
                     let value = u128::from(value);
                     night_balance = value;
 
                     // DUST generation rate = STAR * generation_decay_rate SPECK/second.
                     generation_rate = value.saturating_mul(generation_decay_rate);
 
-                    // Calculate current capacity based on elapsed time since creation.
+                    // dust_generation_info.ctime is in seconds (ledger convention).
+                    let ctime = TimestampSecs(ctime_raw as u64);
+
                     // Get current timestamp from latest block.
+                    // blocks.timestamp is in milliseconds (Substrate Timestamp pallet).
                     let current_time_query = indoc! {"
                         SELECT timestamp
                         FROM blocks
                         ORDER BY height DESC
                         LIMIT 1
                     "};
 
-                    let current_timestamp = sqlx::query_as::<_, (i64,)>(current_time_query)
+                    let now = sqlx::query_as::<_, (i64,)>(current_time_query)
                         .fetch_optional(&*self.pool)
                         .await?
-                        .map(|(t,)| t)
-                        .unwrap_or(ctime);
+                        .map(|(t,)| TimestampMs(t as u64))
+                        .unwrap_or(ctime.to_ms());
 
-                    // Calculate elapsed seconds since creation.
-                    // Convert from milliseconds to seconds.
-                    let elapsed_seconds = ((current_timestamp - ctime).max(0) as u128) / 1000;
+                    let elapsed_seconds = now.elapsed_seconds_since(ctime.to_ms());
 
                     // Maximum capacity (static cap) = STAR * night_dust_ratio.
                     max_capacity = value.saturating_mul(night_dust_ratio);
@@ -111,7 +112,7 @@ impl DustStorage for Storage {
                     // elapsed_seconds. Capped at max_capacity.
                     let generated_capacity = value
                         .saturating_mul(generation_decay_rate)
-                        .saturating_mul(elapsed_seconds);
+                        .saturating_mul(elapsed_seconds as u128);
                     current_capacity = generated_capacity.min(max_capacity);
                 }
             }

indexer-common/src/domain.rs

@@ -124,6 +124,30 @@ mod network_id_tests {
     }
 }
 
+/// A timestamp in milliseconds since the Unix epoch (Substrate Timestamp pallet convention).
+/// Use when working with values from the `blocks.timestamp` column.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TimestampMs(pub u64);
+
+/// A timestamp in seconds since the Unix epoch (ledger convention).
+/// Use when working with values from `dust_generation_info.ctime`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TimestampSecs(pub u64);
+
+impl TimestampSecs {
+    /// Convert to milliseconds.
+    pub fn to_ms(self) -> TimestampMs {
+        TimestampMs(self.0 * 1000)
+    }
+}
+
+impl TimestampMs {
+    /// Calculate elapsed seconds since an earlier timestamp.
+    pub fn elapsed_seconds_since(self, earlier: TimestampMs) -> u64 {
+        self.0.saturating_sub(earlier.0) / 1000
+    }
+}
+
 /// The outcome of applying a regular transaction to the ledger state along with extracted data.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct ApplyRegularTransactionOutcome {