chore: remove legacy struct from mpc node and tee context post contract upgrade (#4224)

Author: kevindeforth

Cargo.lock

@@ -4,6 +4,7 @@ use near_account_id::AccountId;
 use near_contract_transport::{BlockHeight, ObservedState};
 use near_contract_transport::{ViewArgs, ViewContract};
 use near_indexer::near_primitives::transaction::SignedTransaction;
+use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use thiserror::Error;
@@ -20,6 +21,7 @@ pub struct MockChainState {
 
 pub struct MockViewState {
     pub response: Result<ObservedState, MockError>,
+    pub responses_by_method: HashMap<String, Result<ObservedState, MockError>>,
     pub submitted: Vec<Call>,
 }
 
@@ -50,6 +52,15 @@ impl MockChainState {
         inner.response = value;
     }
 
+    pub fn set_view_response_for_method(
+        &self,
+        method_name: impl Into<String>,
+        value: Result<ObservedState, MockError>,
+    ) {
+        let mut inner = self.view_state.lock().unwrap();
+        inner.responses_by_method.insert(method_name.into(), value);
+    }
+
     /// Wait for the next view_contract call (polls submitted.len() every 10ms).
     pub async fn await_next_view_call(&self, max_wait_duration: Duration) -> Result<(), MockError> {
         tokio::time::timeout(max_wait_duration, self.read_notify.notified())
@@ -118,6 +129,7 @@ impl MockChainStateBuilder {
             sync_response: Arc::new(Mutex::new(self.sync_response)),
             view_state: Arc::new(Mutex::new(MockViewState {
                 response: self.view_response,
+                responses_by_method: HashMap::new(),
                 submitted: Vec::new(),
             })),
             read_notify: Arc::new(Notify::new()),
@@ -148,12 +160,16 @@ impl ViewContract for MockChainState {
         view_args: ViewArgs,
     ) -> Result<ObservedState, Self::Error> {
         let mut inner = self.view_state.lock().unwrap();
+        let response = inner
+            .responses_by_method
+            .get(&view_args.method_name)
+            .unwrap_or(&inner.response)
+            .clone();
         inner.submitted.push(Call {
             contract_id: contract_id.clone(),
             method_name: view_args.method_name,
             args: view_args.args,
         });
-        let response = inner.response.clone();
         drop(inner);
         self.read_notify.notify_waiters();
         response

crates/chain-gateway/src/mock.rs

@@ -5,7 +5,7 @@ use crate::{indexer::migrations::ContractMigrationInfo, migration_service::types
 use self::stats::IndexerStats;
 use anyhow::Context;
 use handler::ChainBlockUpdate;
-use mpc_primitives::hash::{LauncherDockerComposeHash, NodeImageHash};
+use mpc_primitives::hash::LauncherDockerComposeHash;
 use near_account_id::AccountId;
 use near_async::{
     messaging::CanSendAsync, multithread::MultithreadRuntimeHandle, tokio::TokioRuntimeHandle,
@@ -47,13 +47,7 @@ pub mod types;
 #[cfg(test)]
 pub mod fake;
 
-// TODO(#3751): drop this struct after upgrading the contract.
-#[derive(Debug, PartialEq, Deserialize)]
-#[serde(untagged)]
-enum AllowedDockerImageHashesResponse {
-    WithExpiry(Vec<dtos::AllowedMpcDockerImageHash>),
-    Legacy(Vec<NodeImageHash>),
-}
+type AllowedDockerImageHashesResponse = Vec<dtos::AllowedMpcDockerImageHash>;
 
 pub(crate) struct IndexerState {
     /// For querying blockchain state.
@@ -334,21 +328,10 @@ impl IndexerViewClient {
         &self,
         mpc_contract_id: AccountId,
     ) -> anyhow::Result<(u64, Vec<dtos::AllowedMpcDockerImageHash>)> {
-        let (block_height, response): (u64, AllowedDockerImageHashesResponse) = self
+        let (block_height, entries): (u64, AllowedDockerImageHashesResponse) = self
             .get_mpc_state(mpc_contract_id, ALLOWED_DOCKER_IMAGE_HASHES)
             .await?;
 
-        // TODO(#3751): drop this logic after upgrading the contract.
-        let entries = match response {
-            AllowedDockerImageHashesResponse::WithExpiry(entries) => entries,
-            AllowedDockerImageHashesResponse::Legacy(hashes) => hashes
-                .into_iter()
-                .map(|image_hash| dtos::AllowedMpcDockerImageHash {
-                    image_hash,
-                    expiry_timestamp_seconds: None,
-                })
-                .collect(),
-        };
         Ok((block_height, entries))
     }
     pub(crate) async fn get_mpc_allowed_launcher_compose_hashes(
@@ -592,42 +575,7 @@ pub struct IndexerAPI<TransactionSender> {
 #[cfg(test)]
 #[expect(non_snake_case)]
 mod tests {
-    use super::{
-        AllowedDockerImageHashesResponse, BlockHeight, REQUIRED_STABLE_POLLS, SyncProgress,
-    };
-    use assert_matches::assert_matches;
-    use mpc_primitives::hash::NodeImageHash;
-
-    #[test]
-    fn allowed_docker_image_hashes_response__should_deserialize_with_expiry_objects() {
-        let json = r#"[
-        { "image_hash": "1111111111111111111111111111111111111111111111111111111111111111", "expiry_timestamp_seconds": 42 },
-        { "image_hash": "2222222222222222222222222222222222222222222222222222222222222222", "expiry_timestamp_seconds": null }
-    ]"#;
-        let response: AllowedDockerImageHashesResponse = serde_json::from_str(json).unwrap();
-        assert_matches!(response, AllowedDockerImageHashesResponse::WithExpiry(entries) if entries.len() == 2);
-    }
-
-    #[test]
-    fn allowed_docker_image_hashes_response__should_deserialize_legacy_bare_hashes() {
-        // Given: the shape returned by contracts predating expiry reporting.
-        let json = r#"[
-            "1111111111111111111111111111111111111111111111111111111111111111",
-            "2222222222222222222222222222222222222222222222222222222222222222"
-        ]"#;
-
-        // When
-        let response: AllowedDockerImageHashesResponse = serde_json::from_str(json).unwrap();
-
-        // Then
-        assert_eq!(
-            response,
-            AllowedDockerImageHashesResponse::Legacy(vec![
-                NodeImageHash::from([0x11; 32]),
-                NodeImageHash::from([0x22; 32]),
-            ])
-        );
-    }
+    use super::{BlockHeight, REQUIRED_STABLE_POLLS, SyncProgress};
 
     fn first_caught_up_poll(samples: &[(bool, BlockHeight)]) -> Option<usize> {
         let mut progress = SyncProgress::default();

crates/node/src/indexer.rs

@@ -26,27 +26,19 @@ pub fn update_own_image_hash_gauges(
 /// - last value indicates expiry timestamp (-1 if no expiry timestamp is given,
 ///   0 if `current_image` is not allowed)
 ///
-/// Expects `allowed_images` to be newest-first, as returned by the contract view.
+/// Expects the newest allowed image to be the only one the contract reports without
+/// an expiry timestamp.
 fn infer_image_status(
     current_image: &NodeImageHash,
     allowed_images: &[AllowedMpcDockerImageHash],
 ) -> (bool, bool, i64) {
-    // TODO(#3751): simplify this function after updating the contract
-    let is_most_recent = allowed_images
-        .first()
-        .is_some_and(|newest| newest.image_hash == *current_image);
-
     match allowed_images
         .iter()
         .find(|entry| entry.image_hash == *current_image)
     {
         Some(entry) => match entry.expiry_timestamp_seconds {
-            Some(expires_at) => (
-                true,
-                is_most_recent,
-                i64::try_from(expires_at).unwrap_or(i64::MAX),
-            ),
-            None => (true, is_most_recent, NO_EXPIRY),
+            Some(expires_at) => (true, false, i64::try_from(expires_at).unwrap_or(i64::MAX)),
+            None => (true, true, NO_EXPIRY),
         },
         None => (false, false, 0),
     }

crates/node/src/tee/image_expiry_metrics.rs

@@ -11,7 +11,6 @@ near-contract-transport = { workspace = true }
 near-mpc-contract-interface = { workspace = true, features = ["client"] }
 
 near-account-id = { workspace = true }
-serde = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tokio-util = { workspace = true }