third

rs/sns/governance/api/src/ic_sns_governance.pb.v1.rs

@@ -2213,6 +2213,7 @@ pub mod upgrade_journal_entry {
     pub struct TargetVersionSet {
         pub old_target_version: Option<super::governance::Version>,
         pub new_target_version: Option<super::governance::Version>,
+        pub is_advanced_automatically: Option<bool>,
     }
     #[derive(
         candid::CandidType, candid::Deserialize, Debug, serde::Serialize, Clone, PartialEq,

rs/sns/governance/canister/governance.did

@@ -778,6 +778,7 @@ type UpgradeStepsReset = record {
 type TargetVersionSet = record {
   new_target_version : opt Version;
   old_target_version : opt Version;
+  is_advanced_automatically : opt bool;
 };
 
 type TargetVersionReset = record {

rs/sns/governance/canister/governance_test.did

@@ -792,6 +792,7 @@ type UpgradeStepsReset = record {
 type TargetVersionSet = record {
   new_target_version : opt Version;
   old_target_version : opt Version;
+  is_advanced_automatically : opt bool;
 };
 
 type TargetVersionReset = record {

rs/sns/governance/proto/ic_sns_governance/pb/v1/governance.proto

@@ -2234,6 +2234,7 @@ message UpgradeJournalEntry {
   message TargetVersionSet {
     optional Governance.Version old_target_version = 1;
     optional Governance.Version new_target_version = 2;
+    optional bool is_advanced_automatically = 3;
   }
 
   message TargetVersionReset {

rs/sns/governance/src/cached_upgrade_steps.rs

@@ -502,11 +502,13 @@ impl Governance {
             let new_target = upgrade_steps.last().clone();
 
             {
-                let new_target = Some(new_target.clone());
-                if self.proto.target_version != new_target {
+                let old_version = self.proto.target_version.clone().unwrap_or_default();
+                let new_target = new_target.clone();
+                if old_version != new_target {
                     self.push_to_upgrade_journal(upgrade_journal_entry::TargetVersionSet::new(
-                        self.proto.target_version.clone(),
+                        old_version,
                         new_target,
+                        true,
                     ));
                 }
             }

rs/sns/governance/src/gen/ic_sns_governance.pb.v1.rs

@@ -3526,6 +3526,8 @@ pub mod upgrade_journal_entry {
         pub old_target_version: ::core::option::Option<super::governance::Version>,
         #[prost(message, optional, tag = "2")]
         pub new_target_version: ::core::option::Option<super::governance::Version>,
+        #[prost(bool, optional, tag = "3")]
+        pub is_advanced_automatically: ::core::option::Option<bool>,
     }
     #[derive(
         candid::CandidType,

rs/sns/governance/src/governance.rs

@@ -3087,11 +3087,14 @@ impl Governance {
         let (_, target_version) = self
             .proto
             .validate_new_target_version(Some(new_target))
-            .map_err(|err| GovernanceError::new_with_message(ErrorType::InvalidProposal, err))?;
+            .map_err(|err: String| {
+                GovernanceError::new_with_message(ErrorType::InvalidProposal, err)
+            })?;
 
         self.push_to_upgrade_journal(upgrade_journal_entry::TargetVersionSet::new(
-            self.proto.target_version.clone(),
-            Some(target_version.clone()),
+            self.proto.target_version.clone().unwrap_or_default(),
+            target_version.clone(),
+            false,
         ));
 
         self.proto.target_version = Some(target_version);

rs/sns/governance/src/governance/advance_target_sns_version_tests.rs

@@ -926,6 +926,84 @@ fn get_or_reset_upgrade_steps_leads_to_should_refresh_cached_upgrade_steps() {
     assert!(gov.should_refresh_cached_upgrade_steps());
 }
 
+#[tokio::test]
+async fn test_refresh_cached_upgrade_steps_advances_target_version_automatically_is_required() {
+    let version_a = Version {
+        root_wasm_hash: vec![1, 2, 3],
+        governance_wasm_hash: vec![2, 3, 4],
+        ledger_wasm_hash: vec![3, 4, 5],
+        swap_wasm_hash: vec![4, 5, 6],
+        archive_wasm_hash: vec![5, 6, 7],
+        index_wasm_hash: vec![6, 7, 8],
+    };
+    let mut version_b = version_a.clone();
+    version_b.root_wasm_hash = vec![9, 9, 9];
+
+    // Smoke test.
+    assert_ne!(version_a, version_b);
+
+    let make_gov = || -> Governance {
+        let mut env = NativeEnvironment::new(Some(*TEST_GOVERNANCE_CANISTER_ID));
+        add_environment_mock_list_upgrade_steps_call(
+            &mut env,
+            vec![
+                SnsVersion::from(version_a.clone()),
+                SnsVersion::from(version_b.clone()),
+            ],
+        );
+        Governance::new(
+            GovernanceProto {
+                deployed_version: Some(version_a.clone()),
+                cached_upgrade_steps: None,
+                ..basic_governance_proto()
+            }
+            .try_into()
+            .unwrap(),
+            Box::new(env),
+            Box::new(DoNothingLedger {}),
+            Box::new(DoNothingLedger {}),
+            Box::new(FakeCmc::new()),
+        )
+    };
+
+    for (automatically_advance_target_version, expected_target_version) in [
+        (None, None),
+        (Some(false), None),
+        (Some(true), Some(version_b.clone())),
+    ] {
+        let mut gov = make_gov();
+
+        if let Some(parameters) = gov.proto.parameters.as_mut() {
+            parameters.automatically_advance_target_version = automatically_advance_target_version;
+        };
+
+        // Precondition
+        assert_eq!(gov.proto.cached_upgrade_steps, None);
+        assert_eq!(gov.proto.target_version, None);
+
+        // Run code under test and assert intermediate conditions.
+        let deployed_version = gov
+            .try_temporarily_lock_refresh_cached_upgrade_steps()
+            .unwrap();
+        gov.refresh_cached_upgrade_steps(deployed_version).await;
+
+        // Intermediate postcondition.
+        assert_eq!(
+            gov.proto
+                .cached_upgrade_steps
+                .clone()
+                .unwrap()
+                .upgrade_steps
+                .unwrap()
+                .versions,
+            vec![version_a.clone(), version_b.clone(),]
+        );
+
+        // Main postcondition.
+        assert_eq!(gov.proto.target_version, expected_target_version);
+    }
+}
+
 fn add_environment_mock_calls_for_initiate_upgrade(
     env: &mut NativeEnvironment,
     expected_wasm_hash_requested: Vec<u8>,

rs/sns/governance/src/pb/conversions.rs

@@ -3197,6 +3197,7 @@ impl From<pb::upgrade_journal_entry::TargetVersionSet>
         Self {
             old_target_version: item.old_target_version.map(|x| x.into()),
             new_target_version: item.new_target_version.map(|x| x.into()),
+            is_advanced_automatically: item.is_advanced_automatically,
         }
     }
 }
@@ -3207,6 +3208,7 @@ impl From<pb_api::upgrade_journal_entry::TargetVersionSet>
         Self {
             old_target_version: item.old_target_version.map(|x| x.into()),
             new_target_version: item.new_target_version.map(|x| x.into()),
+            is_advanced_automatically: item.is_advanced_automatically,
         }
     }
 }

rs/sns/governance/src/upgrade_journal.rs

@@ -27,10 +27,15 @@ impl upgrade_journal_entry::UpgradeStepsReset {
 
 impl upgrade_journal_entry::TargetVersionSet {
     /// Creates a new TargetVersionSet event with old and new versions
-    pub fn new(old_version: Option<Version>, new_version: Option<Version>) -> Self {
+    pub fn new(
+        old_version: Version,
+        new_version: Version,
+        is_advanced_automatically: bool,
+    ) -> Self {
         Self {
-            old_target_version: old_version,
-            new_target_version: new_version,
+            old_target_version: Some(old_version),
+            new_target_version: Some(new_version),
+            is_advanced_automatically: Some(is_advanced_automatically),
         }
     }
 }