💫 Lint & perf

Author: akhercha

pragma-node/src/constants/caches.rs

@@ -12,8 +12,8 @@ pub const PUBLISHERS_UDPATES_CACHE_TIME_TO_IDLE_IN_SECONDS: u64 = 5 * 60; // 5 m
 /// In pragma-node, every decimals are 18 but this is not the case for onchain entries.
 /// So we use this cache to fetch RPC results & store decimals for a specific `pair_id`
 /// for a given network.
-/// The values don't change often at all so we use 24 hours.
-pub const DECIMALS_TIME_TO_LIVE_IN_SECONDS: u64 = 86400; // 24 hours
+/// The values don't change often at all so we use 1 week.
+pub const DECIMALS_TIME_TO_LIVE_IN_SECONDS: u64 = 604_800; // 1 week
 
 /// Cache of the stored publishers in memory.
 /// This cache is used to retrieve the `Publisher` object from the database

pragma-node/src/handlers/mod.rs

@@ -111,7 +111,7 @@ pub struct GetEntryParams {
     pub entry_type: Option<EntryType>,
 
     /// Expiry date for future contracts in ISO 8601 format.
-    /// Only applicable when entry_type is "future".
+    /// Only applicable when `entry_type` is "future".
     ///
     /// # Example
     /// - `"2024-12-31"`: December 31, 2024 expiry

pragma-node/src/handlers/stream/stream_multi.rs

@@ -30,7 +30,7 @@ pub struct StreamEntryMultipairParams {
     /// Base parameters for entry requests including interval, aggregation mode, and routing options
     #[serde(flatten)]
     pub get_entry_params: GetEntryParams,
-    /// List of trading pairs to stream prices for (e.g. ["ETH/USD", "BTC/USD"])
+    /// List of trading pairs to stream prices for (e.g. `["ETH/USD", "BTC/USD"]`)
     #[serde(rename = "pairs[]")]
     #[param(example = json!(["ETH/USD", "BTC/USD"]))]
     pub pairs: Vec<String>,

pragma-node/src/handlers/subscribe_to_entry.rs

@@ -30,8 +30,7 @@ pub struct SignedPublisherPrice {
     #[schema(example = "0x534f4c55534400000000000000000000505241474d4100")]
     pub oracle_asset_id: String,
 
-    /// Price in StarkEx decimal format (not hex)
-    /// The price is scaled by 10^18
+    /// Price in `StarkEx` 18 decimals
     #[schema(example = "128065038090000000000")]
     pub oracle_price: String,
 
@@ -52,8 +51,7 @@ pub struct AssetOraclePrice {
     #[schema(example = "0x534f4c2d5553442d38000000000000")]
     pub global_asset_id: String,
 
-    /// Median price in `StarkEx` decimal format
-    /// The price is scaled by 10^18
+    /// Median price in `StarkEx` 18 decimals format
     #[schema(example = "128065038090000007168")]
     pub median_price: String,
 
@@ -67,7 +65,7 @@ pub struct AssetOraclePrice {
     pub signed_prices: Vec<SignedPublisherPrice>,
 }
 
-/// WebSocket response message for StarkEx price updates
+/// WebSocket response message for `StarkEx` price updates
 #[derive(Debug, Default, Serialize, Deserialize, ToResponse, ToSchema)]
 #[schema(example = json!({
     "oracle_prices": [{

pragma-node/src/infra/repositories/onchain_repository/mod.rs

@@ -139,6 +139,6 @@ pub const fn get_onchain_interval_specifier(
         Interval::TwoHours => Ok("2_hour"),
         Interval::OneDay => Ok("1_day"),
         Interval::OneWeek => Ok("1_week"),
-        _ => return Err(InfraError::UnsupportedOnchainInterval(interval)),
+        _ => Err(InfraError::UnsupportedOnchainInterval(interval)),
     }
 }

pragma-node/src/infra/repositories/onchain_repository/publisher.rs

@@ -265,27 +265,36 @@ pub async fn get_publishers_with_components(
     let updates =
         get_all_publishers_updates(pool, table_name, publisher_names, publishers_updates_cache)
             .await?;
-    let mut publishers_response = Vec::with_capacity(publishers.len());
 
-    for publisher in &publishers {
-        let Some(publisher_updates) = updates.get(&publisher.name) else {
-            continue;
-        };
-        if publisher_updates.daily_updates == 0 {
-            continue;
-        }
-        let publisher_with_components = get_publisher_with_components(
-            pool,
-            network,
-            table_name,
-            publisher,
-            publisher_updates,
-            decimals_cache,
-            rpc_clients,
-        )
-        .await?;
-        publishers_response.push(publisher_with_components);
-    }
+    // Create a vector of futures for each publisher that needs processing
+    let publisher_futures: Vec<_> = publishers
+        .iter()
+        .filter_map(|publisher| {
+            // Only process publishers with updates
+            let publisher_updates = updates.get(&publisher.name)?;
+            if publisher_updates.daily_updates == 0 {
+                return None;
+            }
+
+            let table_name = table_name.to_string();
+            let publisher_updates = publisher_updates.clone();
+            Some(async move {
+                get_publisher_with_components(
+                    pool,
+                    network,
+                    &table_name,
+                    publisher,
+                    &publisher_updates,
+                    decimals_cache,
+                    rpc_clients,
+                )
+                .await
+            })
+        })
+        .collect();
+
+    // Execute all publisher futures concurrently
+    let publishers_response = try_join_all(publisher_futures).await?;
 
     Ok(publishers_response)
 }