refactor(hermes): removed `impl Store`

hermes/src/api/rest/get_price_feed.rs

@@ -65,9 +65,8 @@ pub async fn get_price_feed(
 ) -> Result<Json<RpcPriceFeed>, RestError> {
     let price_id: PriceIdentifier = params.id.into();
 
-    let price_feeds_with_update_data = state
+    let price_feeds_with_update_data = crate::store::get_price_feeds_with_update_data(
-        .store
+        &state.store,
-        .get_price_feeds_with_update_data(
         vec![price_id],
         RequestTime::FirstAfter(params.publish_time),
     )

hermes/src/api/rest/get_vaa.rs

@@ -5,11 +5,14 @@ use {
             types::PriceIdInput,
         },
         doc_examples,
-        store::types::{
+        store::{
+            self,
+            types::{
                 RequestTime,
                 UnixTimestamp,
             },
         },
+    },
     anyhow::Result,
     axum::{
         extract::State,
@@ -72,9 +75,8 @@ pub async fn get_vaa(
 ) -> Result<Json<GetVaaResponse>, RestError> {
     let price_id: PriceIdentifier = params.id.into();
 
-    let price_feeds_with_update_data = state
+    let price_feeds_with_update_data = store::get_price_feeds_with_update_data(
-        .store
+        &state.store,
-        .get_price_feeds_with_update_data(
         vec![price_id],
         RequestTime::FirstAfter(params.publish_time),
     )

hermes/src/api/rest/get_vaa_ccip.rs

@@ -68,9 +68,11 @@ pub async fn get_vaa_ccip(
             .map_err(|_| RestError::InvalidCCIPInput)?,
     );
 
-    let price_feeds_with_update_data = state
+    let price_feeds_with_update_data = crate::store::get_price_feeds_with_update_data(
-        .store
+        &state.store,
-        .get_price_feeds_with_update_data(vec![price_id], RequestTime::FirstAfter(publish_time))
+        vec![price_id],
+        RequestTime::FirstAfter(publish_time),
+    )
     .await
     .map_err(|_| RestError::CcipUpdateDataNotFound)?;
 

hermes/src/api/rest/latest_price_feeds.rs

@@ -63,9 +63,11 @@ pub async fn latest_price_feeds(
     QsQuery(params): QsQuery<LatestPriceFeedsQueryParams>,
 ) -> Result<Json<Vec<RpcPriceFeed>>, RestError> {
     let price_ids: Vec<PriceIdentifier> = params.ids.into_iter().map(|id| id.into()).collect();
-    let price_feeds_with_update_data = state
+    let price_feeds_with_update_data = crate::store::get_price_feeds_with_update_data(
-        .store
+        &state.store,
-        .get_price_feeds_with_update_data(price_ids, RequestTime::Latest)
+        price_ids,
+        RequestTime::Latest,
+    )
     .await
     .map_err(|_| RestError::UpdateDataNotFound)?;
 

hermes/src/api/rest/latest_vaas.rs

@@ -58,9 +58,11 @@ pub async fn latest_vaas(
     QsQuery(params): QsQuery<LatestVaasQueryParams>,
 ) -> Result<Json<Vec<String>>, RestError> {
     let price_ids: Vec<PriceIdentifier> = params.ids.into_iter().map(|id| id.into()).collect();
-    let price_feeds_with_update_data = state
+    let price_feeds_with_update_data = crate::store::get_price_feeds_with_update_data(
-        .store
+        &state.store,
-        .get_price_feeds_with_update_data(price_ids, RequestTime::Latest)
+        price_ids,
+        RequestTime::Latest,
+    )
     .await
     .map_err(|_| RestError::UpdateDataNotFound)?;
 

hermes/src/api/rest/price_feed_ids.rs

@@ -24,9 +24,7 @@ use {
 pub async fn price_feed_ids(
     State(state): State<crate::api::State>,
 ) -> Result<Json<Vec<RpcPriceIdentifier>>, RestError> {
-    let price_feed_ids = state
+    let price_feed_ids = crate::store::get_price_feed_ids(&state.store)
-        .store
-        .get_price_feed_ids()
         .await
         .iter()
         .map(RpcPriceIdentifier::from)

hermes/src/api/rest/ready.rs

@@ -8,7 +8,7 @@ use axum::{
 };
 
 pub async fn ready(State(state): State<crate::api::State>) -> Response {
-    match state.store.is_ready().await {
+    match crate::store::is_ready(&state.store).await {
         true => (StatusCode::OK, "OK").into_response(),
         false => (StatusCode::SERVICE_UNAVAILABLE, "Service Unavailable").into_response(),
     }

hermes/src/api/ws.rs

@@ -149,9 +149,11 @@ impl Subscriber {
 
     async fn handle_price_feeds_update(&mut self) -> Result<()> {
         let price_feed_ids = self.price_feeds_with_config.keys().cloned().collect();
-        for update in self
+        for update in crate::store::get_price_feeds_with_update_data(
-            .store
+            &self.store,
-            .get_price_feeds_with_update_data(price_feed_ids, RequestTime::Latest)
+            price_feed_ids,
+            RequestTime::Latest,
+        )
         .await?
         .price_feeds
         {
@@ -231,7 +233,7 @@ impl Subscriber {
                 binary,
             }) => {
                 let price_ids: Vec<PriceIdentifier> = ids.into_iter().map(|id| id.into()).collect();
-                let available_price_ids = self.store.get_price_feed_ids().await;
+                let available_price_ids = crate::store::get_price_feed_ids(&self.store).await;
 
                 let not_found_price_ids: Vec<&PriceIdentifier> = price_ids
                     .iter()

hermes/src/network/p2p.rs

@@ -213,7 +213,7 @@ pub async fn spawn(opts: RunOptions, store: Arc<Store>) -> Result<()> {
 
             let store = store.clone();
             tokio::spawn(async move {
-                if let Err(e) = store.store_update(Update::Vaa(vaa)).await {
+                if let Err(e) = crate::store::store_update(&store, Update::Vaa(vaa)).await {
                     tracing::error!(error = ?e, "Failed to process VAA.");
                 }
             });

hermes/src/network/pythnet.rs

@@ -175,8 +175,10 @@ pub async fn run(store: Arc<Store>, pythnet_ws_endpoint: String) -> Result<()> {
                         if candidate.to_string() == update.value.pubkey {
                             let store = store.clone();
                             tokio::spawn(async move {
-                                if let Err(err) = store
+                                if let Err(err) = crate::store::store_update(
-                                    .store_update(Update::AccumulatorMessages(accumulator_messages))
+                                    &store,
+                                    Update::AccumulatorMessages(accumulator_messages),
+                                )
                                 .await
                                 {
                                     tracing::error!(error = ?err, "Failed to store accumulator messages.");
@@ -228,9 +230,7 @@ async fn fetch_existing_guardian_sets(
         "Retrieved Current GuardianSet.",
     );
 
-    store
+    crate::store::update_guardian_set(&store, bridge.guardian_set_index, current).await;
-        .update_guardian_set(bridge.guardian_set_index, current)
-        .await;
 
     // If there are more than one guardian set, we want to fetch the previous one as well as it
     // may still be in transition phase if a guardian upgrade has just occurred.
@@ -248,9 +248,7 @@ async fn fetch_existing_guardian_sets(
             "Retrieved Previous GuardianSet.",
         );
 
-        store
+        crate::store::update_guardian_set(&store, bridge.guardian_set_index - 1, previous).await;
-            .update_guardian_set(bridge.guardian_set_index - 1, previous)
-            .await;
     }
 
     Ok(())

hermes/src/store.rs

@@ -91,20 +91,17 @@ const OBSERVED_CACHE_SIZE: usize = 1000;
 const READINESS_STALENESS_THRESHOLD: Duration = Duration::from_secs(30);
 
 pub struct Store {
-    /// Storage is a short-lived cache of the state of all the updates
+    /// Storage is a short-lived cache of the state of all the updates that have been passed to the
-    /// that have been passed to the store.
+    /// store.
     pub storage:                  Storage,
     /// Sequence numbers of lately observed Vaas. Store uses this set
     /// to ignore the previously observed Vaas as a performance boost.
     pub observed_vaa_seqs:        RwLock<BTreeSet<u64>>,
-    /// Wormhole guardian sets. It is used to verify Vaas before using
+    /// Wormhole guardian sets. It is used to verify Vaas before using them.
-    /// them.
     pub guardian_set:             RwLock<BTreeMap<u32, GuardianSet>>,
-    /// The sender to the channel between Store and Api to notify
+    /// The sender to the channel between Store and Api to notify completed updates.
-    /// completed updates.
     pub update_tx:                Sender<()>,
-    /// Time of the last completed update. This is used for the health
+    /// Time of the last completed update. This is used for the health probes.
-    /// probes.
     pub last_completed_update_at: RwLock<Option<Instant>>,
     /// Benchmarks endpoint
     pub benchmarks_endpoint:      Option<Url>,
@@ -125,23 +122,23 @@ impl Store {
             benchmarks_endpoint,
         })
     }
+}
 
-    /// Stores the update data in the store
+/// Stores the update data in the store
-    #[tracing::instrument(skip(self, update))]
+#[tracing::instrument(skip(store, update))]
-    pub async fn store_update(&self, update: Update) -> Result<()> {
+pub async fn store_update(store: &Store, update: Update) -> Result<()> {
     // The slot that the update is originating from. It should be available
     // in all the updates.
     let slot = match update {
         Update::Vaa(update_vaa) => {
             // FIXME: Move to wormhole.rs
-                let vaa =
+            let vaa = serde_wormhole::from_slice::<Vaa<&serde_wormhole::RawMessage>>(&update_vaa)?;
-                    serde_wormhole::from_slice::<Vaa<&serde_wormhole::RawMessage>>(&update_vaa)?;
 
-                if self.observed_vaa_seqs.read().await.contains(&vaa.sequence) {
+            if store.observed_vaa_seqs.read().await.contains(&vaa.sequence) {
                 return Ok(()); // Ignore VAA if we have already seen it
             }
 
-                let vaa = verify_vaa(self, vaa).await;
+            let vaa = verify_vaa(store, vaa).await;
 
             let vaa = match vaa {
                 Ok(vaa) => vaa,
@@ -152,7 +149,7 @@ impl Store {
             };
 
             {
-                    let mut observed_vaa_seqs = self.observed_vaa_seqs.write().await;
+                let mut observed_vaa_seqs = store.observed_vaa_seqs.write().await;
                 if observed_vaa_seqs.contains(&vaa.sequence) {
                     return Ok(()); // Ignore VAA if we have already seen it
                 }
@@ -167,7 +164,7 @@ impl Store {
                     tracing::info!(slot = proof.slot, "Storing VAA Merkle Proof.");
 
                     store_wormhole_merkle_verified_message(
-                            self,
+                        store,
                         proof.clone(),
                         update_vaa.to_owned(),
                     )
@@ -182,15 +179,16 @@ impl Store {
             let slot = accumulator_messages.slot;
             tracing::info!(slot = slot, "Storing Accumulator Messages.");
 
-                self.storage
+            store
+                .storage
                 .store_accumulator_messages(accumulator_messages)
                 .await?;
             slot
         }
     };
 
-        let accumulator_messages = self.storage.fetch_accumulator_messages(slot).await?;
+    let accumulator_messages = store.storage.fetch_accumulator_messages(slot).await?;
-        let wormhole_merkle_state = self.storage.fetch_wormhole_merkle_state(slot).await?;
+    let wormhole_merkle_state = store.storage.fetch_wormhole_merkle_state(slot).await?;
 
     let (accumulator_messages, wormhole_merkle_state) =
         match (accumulator_messages, wormhole_merkle_state) {
@@ -204,30 +202,29 @@ impl Store {
 
     // Once the accumulator reaches a complete state for a specific slot
     // we can build the message states
-        self.build_message_states(accumulator_messages, wormhole_merkle_state)
+    build_message_states(store, accumulator_messages, wormhole_merkle_state).await?;
-            .await?;
 
-        self.update_tx.send(()).await?;
+    store.update_tx.send(()).await?;
 
-        self.last_completed_update_at
+    store
+        .last_completed_update_at
         .write()
         .await
         .replace(Instant::now());
 
     Ok(())
-    }
+}
 
-    #[tracing::instrument(skip(self, accumulator_messages, wormhole_merkle_state))]
+#[tracing::instrument(skip(store, accumulator_messages, wormhole_merkle_state))]
-    async fn build_message_states(
+async fn build_message_states(
-        &self,
+    store: &Store,
     accumulator_messages: AccumulatorMessages,
     wormhole_merkle_state: WormholeMerkleState,
-    ) -> Result<()> {
+) -> Result<()> {
     let wormhole_merkle_message_states_proofs =
         construct_message_states_proofs(&accumulator_messages, &wormhole_merkle_state)?;
 
-        let current_time: UnixTimestamp =
+    let current_time: UnixTimestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as _;
-            SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as _;
 
     let message_states = accumulator_messages
         .raw_messages
@@ -252,22 +249,22 @@ impl Store {
 
     tracing::info!(len = message_states.len(), "Storing Message States.");
 
-        self.storage.store_message_states(message_states).await?;
+    store.storage.store_message_states(message_states).await?;
 
     Ok(())
-    }
+}
 
-    pub async fn update_guardian_set(&self, id: u32, guardian_set: GuardianSet) {
+pub async fn update_guardian_set(store: &Store, id: u32, guardian_set: GuardianSet) {
-        let mut guardian_sets = self.guardian_set.write().await;
+    let mut guardian_sets = store.guardian_set.write().await;
     guardian_sets.insert(id, guardian_set);
-    }
+}
 
-    async fn get_price_feeds_with_update_data_from_storage(
+async fn get_price_feeds_with_update_data_from_storage(
-        &self,
+    store: &Store,
     price_ids: Vec<PriceIdentifier>,
     request_time: RequestTime,
-    ) -> Result<PriceFeedsWithUpdateData> {
+) -> Result<PriceFeedsWithUpdateData> {
-        let messages = self
+    let messages = store
         .storage
         .fetch_message_states(
             price_ids
@@ -317,21 +314,24 @@ impl Store {
         price_feeds,
         update_data,
     })
-    }
+}
 
-    pub async fn get_price_feeds_with_update_data(
+pub async fn get_price_feeds_with_update_data(
-        &self,
+    store: &Store,
     price_ids: Vec<PriceIdentifier>,
     request_time: RequestTime,
-    ) -> Result<PriceFeedsWithUpdateData> {
+) -> Result<PriceFeedsWithUpdateData> {
-        match self
+    match get_price_feeds_with_update_data_from_storage(
-            .get_price_feeds_with_update_data_from_storage(price_ids.clone(), request_time.clone())
+        store,
+        price_ids.clone(),
+        request_time.clone(),
+    )
     .await
     {
         Ok(price_feeds_with_update_data) => Ok(price_feeds_with_update_data),
         Err(e) => {
             if let RequestTime::FirstAfter(publish_time) = request_time {
-                    if let Some(endpoint) = &self.benchmarks_endpoint {
+                if let Some(endpoint) = &store.benchmarks_endpoint {
                     return benchmarks::get_price_feeds_with_update_data_from_benchmarks(
                         endpoint.clone(),
                         price_ids,
@@ -343,26 +343,26 @@ impl Store {
             Err(e)
         }
     }
-    }
+}
 
-    pub async fn get_price_feed_ids(&self) -> HashSet<PriceIdentifier> {
+pub async fn get_price_feed_ids(store: &Store) -> HashSet<PriceIdentifier> {
-        self.storage
+    store
+        .storage
         .message_state_keys()
         .await
         .iter()
         .map(|key| PriceIdentifier::new(key.feed_id))
         .collect()
-    }
+}
 
-    pub async fn is_ready(&self) -> bool {
+pub async fn is_ready(store: &Store) -> bool {
-        let last_completed_update_at = self.last_completed_update_at.read().await;
+    let last_completed_update_at = store.last_completed_update_at.read().await;
     match last_completed_update_at.as_ref() {
         Some(last_completed_update_at) => {
             last_completed_update_at.elapsed() < READINESS_STALENESS_THRESHOLD
         }
         None => false,
     }
-    }
 }
 
 #[cfg(test)]
@@ -478,8 +478,8 @@ mod test {
         let store = Store::new(update_tx, cache_size, None);
 
         // Add an initial guardian set with public key 0
-        store
+        update_guardian_set(
-            .update_guardian_set(
+            &store,
             0,
             GuardianSet {
                 keys: vec![[0; 20]],
@@ -491,7 +491,7 @@ mod test {
     }
 
     pub async fn store_multiple_concurrent_valid_updates(store: Arc<Store>, updates: Vec<Update>) {
-        let res = join_all(updates.into_iter().map(|u| store.store_update(u))).await;
+        let res = join_all(updates.into_iter().map(|u| store_update(&store, u))).await;
         // Check that all store_update calls succeeded
         assert!(res.into_iter().all(|r| r.is_ok()));
     }
@@ -514,14 +514,14 @@ mod test {
 
         // Check the price ids are stored correctly
         assert_eq!(
-            store.get_price_feed_ids().await,
+            get_price_feed_ids(&store).await,
             vec![PriceIdentifier::new([100; 32])].into_iter().collect()
         );
 
         // Check get_price_feeds_with_update_data retrieves the correct
         // price feed with correct update data.
-        let price_feeds_with_update_data = store
+        let price_feeds_with_update_data = get_price_feeds_with_update_data(
-            .get_price_feeds_with_update_data(
+            &store,
             vec![PriceIdentifier::new([100; 32])],
             RequestTime::Latest,
         )
@@ -640,8 +640,8 @@ mod test {
         MockClock::advance(Duration::from_secs(1));
 
         // Get the price feeds with update data
-        let price_feeds_with_update_data = store
+        let price_feeds_with_update_data = get_price_feeds_with_update_data(
-            .get_price_feeds_with_update_data(
+            &store,
             vec![PriceIdentifier::new([100; 32])],
             RequestTime::Latest,
         )
@@ -656,13 +656,13 @@ mod test {
         );
 
         // Check the store is ready
-        assert!(store.is_ready().await);
+        assert!(is_ready(&store).await);
 
         // Advance the clock to make the prices stale
         MockClock::advance_system_time(READINESS_STALENESS_THRESHOLD);
         MockClock::advance(READINESS_STALENESS_THRESHOLD);
         // Check the store is not ready
-        assert!(!store.is_ready().await);
+        assert!(!is_ready(&store).await);
     }
 
     /// Test that the store retains the latest slots upon cache eviction.
@@ -705,8 +705,8 @@ mod test {
 
         // Check the last 100 slots are retained
         for slot in 900..1000 {
-            let price_feeds_with_update_data = store
+            let price_feeds_with_update_data = get_price_feeds_with_update_data(
-                .get_price_feeds_with_update_data(
+                &store,
                 vec![
                     PriceIdentifier::new([100; 32]),
                     PriceIdentifier::new([200; 32]),
@@ -722,8 +722,8 @@ mod test {
 
         // Check nothing else is retained
         for slot in 0..900 {
-            assert!(store
+            assert!(get_price_feeds_with_update_data(
-                .get_price_feeds_with_update_data(
+                &store,
                 vec![
                     PriceIdentifier::new([100; 32]),
                     PriceIdentifier::new([200; 32]),