Switch programs activation to whole-set based gating

genesis-programs/src/lib.rs

@@ -13,8 +13,11 @@ use solana_runtime::{
     message_processor::{DEFAULT_COMPUTE_BUDGET, DEFAULT_MAX_INVOKE_DEPTH},
 };
 use solana_sdk::{
-    clock::Epoch, entrypoint_native::ProcessInstructionWithContext, genesis_config::OperatingMode,
-    inflation::Inflation, pubkey::Pubkey,
+    clock::Epoch,
+    entrypoint_native::{ErasedProcessInstructionWithContext, ProcessInstructionWithContext},
+    genesis_config::OperatingMode,
+    inflation::Inflation,
+    pubkey::Pubkey,
 };
 
 pub fn get_inflation(operating_mode: OperatingMode, epoch: Epoch) -> Option<Inflation> {
@@ -52,102 +55,111 @@ enum Program {
     BuiltinLoader((String, Pubkey, ProcessInstructionWithContext)),
 }
 
-fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Option<Vec<Program>> {
+impl std::fmt::Debug for Program {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        #[derive(Debug)]
+        enum Program {
+            Native((String, Pubkey)),
+            BuiltinLoader((String, Pubkey, String)),
+        }
+        let program = match self {
+            crate::Program::Native((string, pubkey)) => Program::Native((string.clone(), *pubkey)),
+            crate::Program::BuiltinLoader((string, pubkey, instruction)) => {
+                let erased: ErasedProcessInstructionWithContext = *instruction;
+                Program::BuiltinLoader((string.clone(), *pubkey, format!("{:p}", erased)))
+            }
+        };
+        write!(f, "{:?}", program)
+    }
+}
+
+// given operating_mode and epoch, return the entire set of enabled programs
+fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Vec<Program> {
+    let mut programs = vec![];
+
     match operating_mode {
         OperatingMode::Development => {
-            if epoch == 0 {
-                // Programs used for testing
-                Some(vec![
-                    Program::BuiltinLoader(solana_bpf_loader_program!()),
-                    Program::BuiltinLoader(solana_bpf_loader_deprecated_program!()),
-                    Program::Native(solana_vest_program!()),
-                    Program::Native(solana_budget_program!()),
-                    Program::Native(solana_exchange_program!()),
-                ])
-            } else if epoch == std::u64::MAX {
-                // The epoch of std::u64::MAX is a placeholder and is expected
-                // to be reduced in a future network update.
-                Some(vec![Program::BuiltinLoader(solana_bpf_loader_program!())])
-            } else {
-                None
-            }
+            // Programs used for testing
+            programs.extend(vec![
+                Program::BuiltinLoader(solana_bpf_loader_program!()),
+                Program::BuiltinLoader(solana_bpf_loader_deprecated_program!()),
+                Program::Native(solana_vest_program!()),
+                Program::Native(solana_budget_program!()),
+                Program::Native(solana_exchange_program!()),
+            ]);
         }
-        OperatingMode::Stable => {
-            if epoch == std::u64::MAX {
+        OperatingMode::Preview => {
+            // tds enabled async cluster restart with smart contract being enabled
+            // at slot 2196960 (midway epoch 17) with v1.0.1 on Mar 1, 2020
+            if epoch >= 17 {
+                programs.extend(vec![Program::BuiltinLoader(
+                    solana_bpf_loader_deprecated_program!(),
+                )]);
+            }
+            #[allow(clippy::absurd_extreme_comparisons)]
+            if epoch >= std::u64::MAX {
                 // The epoch of std::u64::MAX is a placeholder and is expected
                 // to be reduced in a future network update.
-                Some(vec![
+                programs.extend(vec![
                     Program::BuiltinLoader(solana_bpf_loader_program!()),
                     Program::Native(solana_vest_program!()),
                 ])
-            } else {
-                None
             }
         }
-        OperatingMode::Preview => {
-            if epoch == std::u64::MAX {
+        OperatingMode::Stable => {
+            if epoch >= 34 {
+                programs.extend(vec![Program::BuiltinLoader(
+                    solana_bpf_loader_deprecated_program!(),
+                )]);
+            }
+            #[allow(clippy::absurd_extreme_comparisons)]
+            if epoch >= std::u64::MAX {
                 // The epoch of std::u64::MAX is a placeholder and is expected
                 // to be reduced in a future network update.
-                Some(vec![
+                programs.extend(vec![
                     Program::BuiltinLoader(solana_bpf_loader_program!()),
                     Program::Native(solana_vest_program!()),
-                ])
-            } else {
-                None
+                ]);
             }
         }
-    }
+    };
+
+    programs
 }
 
-pub fn get_native_programs(
-    operating_mode: OperatingMode,
-    epoch: Epoch,
-) -> Option<Vec<(String, Pubkey)>> {
-    match get_programs(operating_mode, epoch) {
-        Some(programs) => {
-            let mut native_programs = vec![];
-            for program in programs {
-                if let Program::Native((string, key)) = program {
-                    native_programs.push((string, key));
-                }
-            }
-            Some(native_programs)
+pub fn get_native_programs(operating_mode: OperatingMode, epoch: Epoch) -> Vec<(String, Pubkey)> {
+    let mut native_programs = vec![];
+    for program in get_programs(operating_mode, epoch) {
+        if let Program::Native((string, key)) = program {
+            native_programs.push((string, key));
         }
-        None => None,
     }
+    native_programs
 }
 
 pub fn get_entered_epoch_callback(operating_mode: OperatingMode) -> EnteredEpochCallback {
     Box::new(move |bank: &mut Bank| {
+        // Be careful to add arbitrary logic here; this should be idempotent and can be called
+        // at arbitrary point in an epoch not only epoch boundaries.
+        // This is because this closure need to be executed immediately after snapshot restoration,
+        // in addition to usual epoch boundaries
+        // In other words, this callback initializes some skip(serde) fields, regardless
+        // frozen or not
+
         if let Some(inflation) = get_inflation(operating_mode, bank.epoch()) {
             info!("Entering new epoch with inflation {:?}", inflation);
             bank.set_inflation(inflation);
         }
-        if let Some(programs) = get_programs(operating_mode, bank.epoch()) {
-            for program in programs {
-                match program {
-                    Program::Native((name, program_id)) => {
-                        bank.add_native_program(&name, &program_id);
-                    }
-                    Program::BuiltinLoader((
-                        name,
-                        program_id,
-                        process_instruction_with_context,
-                    )) => {
-                        bank.add_builtin_loader(
-                            &name,
-                            program_id,
-                            process_instruction_with_context,
-                        );
-                    }
+        for program in get_programs(operating_mode, bank.epoch()) {
+            match program {
+                Program::Native((name, program_id)) => {
+                    bank.add_native_program(&name, &program_id);
+                }
+                Program::BuiltinLoader((name, program_id, process_instruction_with_context)) => {
+                    bank.add_builtin_loader(&name, program_id, process_instruction_with_context);
                 }
             }
         }
-        if OperatingMode::Stable == operating_mode {
-            bank.set_cross_program_support(bank.epoch() >= 63);
-        } else {
-            bank.set_cross_program_support(true);
-        }
 
         bank.set_max_invoke_depth(DEFAULT_MAX_INVOKE_DEPTH);
         bank.set_compute_budget(DEFAULT_COMPUTE_BUDGET);
@@ -162,7 +174,7 @@ mod tests {
     #[test]
     fn test_id_uniqueness() {
         let mut unique = HashSet::new();
-        let programs = get_programs(OperatingMode::Development, 0).unwrap();
+        let programs = get_programs(OperatingMode::Development, 0);
         for program in programs {
             match program {
                 Program::Native((name, id)) => assert!(unique.insert((name, id))),
@@ -182,22 +194,14 @@ mod tests {
 
     #[test]
     fn test_development_programs() {
-        assert_eq!(
-            get_programs(OperatingMode::Development, 0).unwrap().len(),
-            5
-        );
-        assert!(get_programs(OperatingMode::Development, 1).is_none());
+        assert_eq!(get_programs(OperatingMode::Development, 0).len(), 5);
+        assert_eq!(get_programs(OperatingMode::Development, 1).len(), 5);
     }
 
     #[test]
     fn test_native_development_programs() {
-        assert_eq!(
-            get_native_programs(OperatingMode::Development, 0)
-                .unwrap()
-                .len(),
-            3
-        );
-        assert!(get_native_programs(OperatingMode::Development, 1).is_none());
+        assert_eq!(get_native_programs(OperatingMode::Development, 0).len(), 3);
+        assert_eq!(get_native_programs(OperatingMode::Development, 1).len(), 3);
     }
 
     #[test]
@@ -215,7 +219,7 @@ mod tests {
 
     #[test]
     fn test_softlaunch_programs() {
-        assert!(get_programs(OperatingMode::Stable, 1).is_none());
-        assert!(get_programs(OperatingMode::Stable, std::u64::MAX).is_some());
+        assert!(get_programs(OperatingMode::Stable, 1).is_empty());
+        assert!(!get_programs(OperatingMode::Stable, std::u64::MAX).is_empty());
     }
 }

genesis/src/main.rs

@@ -468,7 +468,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     );
 
     let native_instruction_processors =
-        solana_genesis_programs::get_native_programs(operating_mode, 0).unwrap_or_else(Vec::new);
+        solana_genesis_programs::get_native_programs(operating_mode, 0);
     let inflation = solana_genesis_programs::get_inflation(operating_mode, 0).unwrap();
 
     let mut genesis_config = GenesisConfig {