Make default programs static (#9717)

Cargo.lock

@@ -4134,14 +4134,11 @@ dependencies = [
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "solana-bpf-loader-program 1.2.0",
  "solana-budget-program 1.2.0",
- "solana-config-program 1.2.0",
  "solana-exchange-program 1.2.0",
  "solana-runtime 1.2.0",
  "solana-sdk 1.2.0",
- "solana-stake-program 1.2.0",
  "solana-storage-program 1.2.0",
  "solana-vest-program 1.2.0",
- "solana-vote-program 1.2.0",
 ]
 
 [[package]]
@@ -4543,6 +4540,7 @@ dependencies = [
  "rayon 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.106 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.106 (registry+https://github.com/rust-lang/crates.io-index)",
+ "solana-config-program 1.2.0",
  "solana-logger 1.2.0",
  "solana-measure 1.2.0",
  "solana-metrics 1.2.0",

bench-exchange/tests/bench_exchange.rs

@@ -86,7 +86,7 @@ fn test_exchange_bank_client() {
     solana_logger::setup();
     let (genesis_config, identity) = create_genesis_config(100_000_000_000_000);
     let mut bank = Bank::new(&genesis_config);
-    bank.add_instruction_processor(id(), process_instruction);
+    bank.add_static_program("exchange_program", id(), process_instruction);
     let clients = vec![BankClient::new(bank)];
 
     let mut config = Config::default();

genesis-programs/Cargo.toml

@@ -12,14 +12,11 @@ edition = "2018"
 log = { version = "0.4.8" }
 solana-bpf-loader-program = { path = "../programs/bpf_loader", version = "1.2.0" }
 solana-budget-program = { path = "../programs/budget", version = "1.2.0" }
-solana-config-program = { path = "../programs/config", version = "1.2.0" }
 solana-exchange-program = { path = "../programs/exchange", version = "1.2.0" }
 solana-runtime = { path = "../runtime", version = "1.2.0" }
 solana-sdk = { path = "../sdk", version = "1.2.0" }
-solana-stake-program = { path = "../programs/stake", version = "1.2.0" }
 solana-storage-program = { path = "../programs/storage", version = "1.2.0" }
 solana-vest-program = { path = "../programs/vest", version = "1.2.0" }
-solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
 
 [lib]
 crate-type = ["lib"]

genesis-programs/src/lib.rs

@@ -1,6 +1,6 @@
 use solana_sdk::{
     clock::Epoch, genesis_config::OperatingMode, inflation::Inflation,
-    move_loader::solana_move_loader_program, pubkey::Pubkey, system_program::solana_system_program,
+    move_loader::solana_move_loader_program, pubkey::Pubkey,
 };
 
 #[macro_use]
@@ -8,17 +8,11 @@ extern crate solana_bpf_loader_program;
 #[macro_use]
 extern crate solana_budget_program;
 #[macro_use]
-extern crate solana_config_program;
-#[macro_use]
 extern crate solana_exchange_program;
 #[macro_use]
-extern crate solana_stake_program;
-#[macro_use]
 extern crate solana_storage_program;
 #[macro_use]
 extern crate solana_vest_program;
-#[macro_use]
-extern crate solana_vote_program;
 
 use log::*;
 use solana_runtime::bank::{Bank, EnteredEpochCallback};
@@ -56,12 +50,8 @@ pub fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Option<Vec<(
                 Some(vec![
                     // Enable all Stable programs
                     solana_bpf_loader_program!(),
-                    solana_config_program!(),
-                    solana_stake_program!(),
                     solana_storage_program!(),
-                    solana_system_program(),
                     solana_vest_program!(),
-                    solana_vote_program!(),
                     // Programs that are only available in Development mode
                     solana_budget_program!(),
                     solana_exchange_program!(),
@@ -72,14 +62,7 @@ pub fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Option<Vec<(
             }
         }
         OperatingMode::Stable => {
-            if epoch == 0 {
+            if epoch == std::u64::MAX - 1 {
-                Some(vec![
-                    solana_config_program!(),
-                    solana_stake_program!(),
-                    solana_system_program(),
-                    solana_vote_program!(),
-                ])
-            } else if epoch == std::u64::MAX - 1 {
                 // The epoch of std::u64::MAX - 1 is a placeholder and is expected to be reduced in
                 // a future hard fork.
                 Some(vec![solana_bpf_loader_program!()])
@@ -93,13 +76,7 @@ pub fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Option<Vec<(
         }
         OperatingMode::Preview => {
             if epoch == 0 {
-                Some(vec![
+                Some(vec![solana_bpf_loader_program!()])
-                    solana_config_program!(),
-                    solana_stake_program!(),
-                    solana_system_program(),
-                    solana_vote_program!(),
-                    solana_bpf_loader_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 hard fork.
@@ -124,7 +101,7 @@ pub fn get_entered_epoch_callback(operating_mode: OperatingMode) -> EnteredEpoch
         if let Some(new_programs) = get_programs(operating_mode, bank.epoch()) {
             for (name, program_id) in new_programs.iter() {
                 info!("Registering {} at {}", name, program_id);
-                bank.register_native_instruction_processor(name, program_id);
+                bank.add_native_program(name, program_id);
             }
         }
     })
@@ -155,7 +132,7 @@ mod tests {
     fn test_development_programs() {
         assert_eq!(
             get_programs(OperatingMode::Development, 0).unwrap().len(),
-            10
+            6
         );
         assert_eq!(get_programs(OperatingMode::Development, 1), None);
     }
@@ -175,15 +152,6 @@ mod tests {
 
     #[test]
     fn test_softlaunch_programs() {
-        assert_eq!(
-            get_programs(OperatingMode::Stable, 0),
-            Some(vec![
-                solana_config_program!(),
-                solana_stake_program!(),
-                solana_system_program(),
-                solana_vote_program!(),
-            ])
-        );
         assert_eq!(get_programs(OperatingMode::Stable, 1), None);
         assert!(get_programs(OperatingMode::Stable, std::u64::MAX - 1).is_some());
         assert!(get_programs(OperatingMode::Stable, std::u64::MAX).is_some());

genesis/src/main.rs

@@ -438,7 +438,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     );
 
     let native_instruction_processors =
-        solana_genesis_programs::get_programs(operating_mode, 0).unwrap();
+        solana_genesis_programs::get_programs(operating_mode, 0).unwrap_or_else(|| vec![]);
     let inflation = solana_genesis_programs::get_inflation(operating_mode, 0).unwrap();
 
     let mut genesis_config = GenesisConfig {

ledger/src/snapshot_utils.rs

@@ -652,8 +652,8 @@ where
                 stream.by_ref(),
                 &append_vecs_path,
             )?;
-
             bank.set_bank_rc(rc, bank::StatusCacheRc::default());
+            bank.finish_init();
             Ok(bank)
         },
     )?;

local-cluster/src/local_cluster.rs

@@ -169,9 +169,7 @@ impl LocalCluster {
             OperatingMode::Stable | OperatingMode::Preview => {
                 genesis_config.native_instruction_processors =
                     solana_genesis_programs::get_programs(genesis_config.operating_mode, 0)
-                        .unwrap()
+                        .unwrap_or_else(|| vec![])
-                        .into_iter()
-                        .collect()
             }
             OperatingMode::Development => {
                 genesis_config

programs/bpf/Cargo.lock

@@ -1988,6 +1988,7 @@ dependencies = [
  "rayon 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.106 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.106 (registry+https://github.com/rust-lang/crates.io-index)",
+ "solana-config-program 1.2.0",
  "solana-logger 1.2.0",
  "solana-measure 1.2.0",
  "solana-metrics 1.2.0",

programs/budget/src/budget_processor.rs

@@ -238,7 +238,7 @@ mod tests {
     fn create_bank(lamports: u64) -> (Bank, Keypair) {
         let (genesis_config, mint_keypair) = create_genesis_config(lamports);
         let mut bank = Bank::new(&genesis_config);
-        bank.add_instruction_processor(id(), process_instruction);
+        bank.add_static_program("budget_program", id(), process_instruction);
         (bank, mint_keypair)
     }
 

programs/config/Cargo.toml

@@ -18,7 +18,7 @@ solana-logger = { path = "../../logger", version = "1.2.0" }
 solana-sdk = { path = "../../sdk", version = "1.2.0" }
 
 [lib]
-crate-type = ["lib", "cdylib"]
+crate-type = ["lib"]
 name = "solana_config_program"
 
 [package.metadata.docs.rs]

programs/config/src/lib.rs

@@ -2,16 +2,11 @@ pub mod config_instruction;
 pub mod config_processor;
 pub mod date_instruction;
 
-use crate::config_processor::process_instruction;
 use bincode::{deserialize, serialize, serialized_size};
 use serde_derive::{Deserialize, Serialize};
 use solana_sdk::{account::Account, pubkey::Pubkey, short_vec};
 
-solana_sdk::declare_program!(
+solana_sdk::declare_id!("Config1111111111111111111111111111111111111");
-    "Config1111111111111111111111111111111111111",
-    solana_config_program,
-    process_instruction
-);
 
 pub trait ConfigState: serde::Serialize + Default {
     /// Maximum space that the serialized representation will require

programs/exchange/src/exchange_processor.rs

@@ -577,7 +577,7 @@ mod test {
     fn create_bank(lamports: u64) -> (Bank, Keypair) {
         let (genesis_config, mint_keypair) = create_genesis_config(lamports);
         let mut bank = Bank::new(&genesis_config);
-        bank.add_instruction_processor(id(), process_instruction);
+        bank.add_static_program("excahnge_program", id(), process_instruction);
         (bank, mint_keypair)
     }
 

programs/failure/tests/failure.rs

@@ -13,7 +13,7 @@ fn test_program_native_failure() {
     let (genesis_config, alice_keypair) = create_genesis_config(50);
     let program_id = Pubkey::new_rand();
     let bank = Bank::new(&genesis_config);
-    bank.register_native_instruction_processor("solana_failure_program", &program_id);
+    bank.add_native_program("solana_failure_program", &program_id);
 
     // Call user program
     let instruction = create_invoke_instruction(alice_keypair.pubkey(), program_id, &1u8);

programs/librapay/Cargo.lock

@@ -2483,6 +2483,7 @@ dependencies = [
  "rayon 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.106 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.106 (registry+https://github.com/rust-lang/crates.io-index)",
+ "solana-config-program 1.2.0",
  "solana-logger 1.2.0",
  "solana-measure 1.2.0",
  "solana-metrics 1.2.0",

programs/librapay/src/librapay_transaction.rs

@@ -156,10 +156,7 @@ mod tests {
         let (mut genesis_config, mint) = create_genesis_config(lamports);
         genesis_config.rent.lamports_per_byte_year = 0;
         let bank = Bank::new(&genesis_config);
-        bank.register_native_instruction_processor(
+        bank.add_native_program("solana_move_loader_program", &solana_sdk::move_loader::id());
-            "solana_move_loader_program",
-            &solana_sdk::move_loader::id(),
-        );
         let shared_bank = Arc::new(bank);
         let bank_client = BankClient::new_shared(&shared_bank);
         let genesis_pubkey = create_genesis(&mint, &bank_client, 1_000_000);

programs/ownable/src/ownable_processor.rs

@@ -71,7 +71,7 @@ mod tests {
     fn create_bank(lamports: u64) -> (Bank, Keypair) {
         let (genesis_config, mint_keypair) = create_genesis_config(lamports);
         let mut bank = Bank::new(&genesis_config);
-        bank.add_instruction_processor(crate::id(), process_instruction);
+        bank.add_static_program("ownable_program", crate::id(), process_instruction);
         (bank, mint_keypair)
     }
 

programs/stake/Cargo.toml

@@ -23,7 +23,7 @@ solana-config-program = { path = "../config", version = "1.2.0" }
 thiserror = "1.0"
 
 [lib]
-crate-type = ["lib", "cdylib"]
+crate-type = ["lib"]
 name = "solana_stake_program"
 
 [package.metadata.docs.rs]

programs/stake/src/lib.rs

@@ -4,11 +4,7 @@ pub mod config;
 pub mod stake_instruction;
 pub mod stake_state;
 
-solana_sdk::declare_program!(
+solana_sdk::declare_id!("Stake11111111111111111111111111111111111111");
-    "Stake11111111111111111111111111111111111111",
-    solana_stake_program,
-    stake_instruction::process_instruction
-);
 
 pub fn add_genesis_accounts(genesis_config: &mut GenesisConfig) -> u64 {
     config::add_genesis_account(genesis_config)

programs/vest/src/vest_processor.rs

@@ -161,11 +161,7 @@ mod tests {
     fn create_bank(lamports: u64) -> (Bank, Keypair) {
         let (genesis_config, mint_keypair) = create_genesis_config(lamports);
         let mut bank = Bank::new(&genesis_config);
-        bank.add_instruction_processor(
+        bank.add_static_program("vest_program", id(), process_instruction);
-            solana_config_program::id(),
-            solana_config_program::config_processor::process_instruction,
-        );
-        bank.add_instruction_processor(id(), process_instruction);
         (bank, mint_keypair)
     }
 
@@ -472,7 +468,7 @@ mod tests {
         )
         .unwrap_err();
 
-        // Ensure bob can update which account he wants vested funds transfered to.
+        // Ensure bob can update which account he wants vested funds transferred to.
         bank_client
             .transfer(1, &alice_keypair, &bob_pubkey)
             .unwrap();

programs/vote/Cargo.toml

@@ -21,7 +21,7 @@ solana-sdk = { path = "../../sdk", version = "1.2.0" }
 thiserror = "1.0"
 
 [lib]
-crate-type = ["lib", "cdylib"]
+crate-type = ["lib"]
 name = "solana_vote_program"
 
 [package.metadata.docs.rs]

programs/vote/src/lib.rs

@@ -6,10 +6,4 @@ pub mod vote_transaction;
 #[macro_use]
 extern crate solana_metrics;
 
-use crate::vote_instruction::process_instruction;
+solana_sdk::declare_id!("Vote111111111111111111111111111111111111111");
-
-solana_sdk::declare_program!(
-    "Vote111111111111111111111111111111111111111",
-    solana_vote_program,
-    process_instruction
-);

runtime/Cargo.toml

@@ -27,6 +27,7 @@ rand = "0.6.5"
 rayon = "1.3.0"
 serde = { version = "1.0.106", features = ["rc"] }
 serde_derive = "1.0.103"
+solana-config-program = { path = "../programs/config", version = "1.2.0" }
 solana-logger = { path = "../logger", version = "1.2.0" }
 solana-measure = { path = "../measure", version = "1.2.0" }
 solana-metrics = { path = "../metrics", version = "1.2.0" }
@@ -38,7 +39,6 @@ solana-vote-program = { path = "../programs/vote", version = "1.2.0" }
 tempfile = "3.1.0"
 thiserror = "1.0"
 
-
 [lib]
 crate-type = ["lib"]
 name = "solana_runtime"

runtime/benches/bank.rs

@@ -122,11 +122,12 @@ fn do_bench_transactions(
     let (mut genesis_config, mint_keypair) = create_genesis_config(100_000_000);
     genesis_config.ticks_per_slot = 100;
     let mut bank = Bank::new(&genesis_config);
-    bank.add_instruction_processor(Pubkey::new(&BUILTIN_PROGRAM_ID), process_instruction);
+    bank.add_static_program(
-    bank.register_native_instruction_processor(
+        "builtin_program",
-        "solana_noop_program",
+        Pubkey::new(&BUILTIN_PROGRAM_ID),
-        &Pubkey::new(&NOOP_PROGRAM_ID),
+        process_instruction,
     );
+    bank.add_native_program("solana_noop_program", &Pubkey::new(&NOOP_PROGRAM_ID));
     let bank = Arc::new(bank);
     let bank_client = BankClient::new_shared(&bank);
     let transactions = create_transactions(&bank_client, &mint_keypair);

runtime/src/bank.rs

@@ -18,7 +18,7 @@ use crate::{
     status_cache::{SlotDelta, StatusCache},
     storage_utils,
     storage_utils::StorageAccounts,
-    system_instruction_processor::{get_system_account_kind, SystemAccountKind},
+    system_instruction_processor::{self, get_system_account_kind, SystemAccountKind},
     transaction_batch::TransactionBatch,
     transaction_utils::OrderedIterator,
 };
@@ -375,6 +375,7 @@ impl Bank {
 
         bank.rc.accounts = Arc::new(Accounts::new(paths));
         bank.process_genesis_config(genesis_config);
+        bank.finish_init();
 
         // Freeze accounts after process_genesis_config creates the initial append vecs
         Arc::get_mut(&mut bank.rc.accounts)
@@ -457,7 +458,7 @@ impl Bank {
             is_delta: AtomicBool::new(false),
             tick_height: AtomicU64::new(parent.tick_height.load(Ordering::Relaxed)),
             signature_count: AtomicU64::new(0),
-            message_processor: MessageProcessor::default(),
+            message_processor: parent.message_processor.clone(),
             entered_epoch_callback: parent.entered_epoch_callback.clone(),
             hard_forks: parent.hard_forks.clone(),
             last_vote_sync: AtomicU64::new(parent.last_vote_sync.load(Ordering::Relaxed)),
@@ -904,14 +905,14 @@ impl Bank {
 
         // Add additional native programs specified in the genesis config
         for (name, program_id) in &genesis_config.native_instruction_processors {
-            self.register_native_instruction_processor(name, program_id);
+            self.add_native_program(name, program_id);
         }
     }
 
-    pub fn register_native_instruction_processor(&self, name: &str, program_id: &Pubkey) {
+    pub fn add_native_program(&self, name: &str, program_id: &Pubkey) {
-        debug!("Adding native program {} under {:?}", name, program_id);
         let account = native_loader::create_loadable_account(name);
         self.store_account(program_id, &account);
+        debug!("Added native program {} under {:?}", name, program_id);
     }
 
     /// Return the last block hash registered.
@@ -1765,6 +1766,29 @@ impl Bank {
         self.src = status_cache_rc;
     }
 
+    pub fn finish_init(&mut self) {
+        self.add_static_program(
+            "system_program",
+            solana_sdk::system_program::id(),
+            system_instruction_processor::process_instruction,
+        );
+        self.add_static_program(
+            "config_program",
+            solana_config_program::id(),
+            solana_config_program::config_processor::process_instruction,
+        );
+        self.add_static_program(
+            "stake_program",
+            solana_stake_program::id(),
+            solana_stake_program::stake_instruction::process_instruction,
+        );
+        self.add_static_program(
+            "vote_program",
+            solana_vote_program::id(),
+            solana_vote_program::vote_instruction::process_instruction,
+        );
+    }
+
     pub fn set_parent(&mut self, parent: &Arc<Bank>) {
         self.rc.parent = RwLock::new(Some(parent.clone()));
     }
@@ -2148,21 +2172,29 @@ impl Bank {
     }
 
     /// Add an instruction processor to intercept instructions before the dynamic loader.
-    pub fn add_instruction_processor(
+    pub fn add_static_program(
         &mut self,
+        name: &str,
         program_id: Pubkey,
         process_instruction: ProcessInstruction,
     ) {
+        match self.get_account(&program_id) {
+            Some(account) => {
+                assert_eq!(
+                    account.owner,
+                    native_loader::id(),
+                    "Cannot overwrite non-native loader account"
+                );
+            }
+            None => {
+                // Add a bogus executable native account, which will be loaded and ignored.
+                let account = native_loader::create_loadable_account(name);
+                self.store_account(&program_id, &account);
+            }
+        }
         self.message_processor
             .add_instruction_processor(program_id, process_instruction);
-
+        debug!("Added static program {} under {:?}", name, program_id);
-        if let Some(program_account) = self.get_account(&program_id) {
-            // It is not valid to intercept instructions for a non-native loader account
-            assert_eq!(program_account.owner, solana_sdk::native_loader::id());
-        } else {
-            // Register a bogus executable account, which will be loaded and ignored.
-            self.register_native_instruction_processor("", &program_id);
-        }
     }
 
     pub fn compare_bank(&self, dbank: &Bank) {
@@ -2274,8 +2306,7 @@ mod tests {
         poh_config::PohConfig,
         rent::Rent,
         signature::{Keypair, Signer},
-        system_instruction,
+        system_instruction, system_program,
-        system_program::{self, solana_system_program},
         sysvar::{fees::Fees, rewards::Rewards},
         timing::duration_as_s,
     };
@@ -2532,7 +2563,7 @@ mod tests {
         bank_with_success_txs.store_account(&keypair6.pubkey(), &account6);
 
         // Make native instruction loader rent exempt
-        let system_program_id = solana_system_program().1;
+        let system_program_id = system_program::id();
         let mut system_program_account = bank.get_account(&system_program_id).unwrap();
         system_program_account.lamports =
             bank.get_minimum_balance_for_rent_exemption(system_program_account.data.len());
@@ -2730,7 +2761,7 @@ mod tests {
             ) as u64,
         );
         bank.rent_collector.slots_per_year = 421_812.0;
-        bank.add_instruction_processor(mock_program_id, mock_process_instruction);
+        bank.add_static_program("mock_program", mock_program_id, mock_process_instruction);
 
         bank
     }
@@ -5020,28 +5051,35 @@ mod tests {
     }
 
     #[test]
-    fn test_add_instruction_processor() {
+    fn test_add_static_program() {
         let (genesis_config, mint_keypair) = create_genesis_config(500);
         let mut bank = Bank::new(&genesis_config);
 
+        fn mock_vote_program_id() -> Pubkey {
+            Pubkey::new(&[42u8; 32])
+        }
         fn mock_vote_processor(
             program_id: &Pubkey,
             _keyed_accounts: &[KeyedAccount],
             _instruction_data: &[u8],
         ) -> std::result::Result<(), InstructionError> {
-            if !solana_vote_program::check_id(program_id) {
+            if mock_vote_program_id() != *program_id {
                 return Err(InstructionError::IncorrectProgramId);
             }
             Err(InstructionError::Custom(42))
         }
 
-        assert!(bank.get_account(&solana_vote_program::id()).is_none());
+        assert!(bank.get_account(&mock_vote_program_id()).is_none());
-        bank.add_instruction_processor(solana_vote_program::id(), mock_vote_processor);
+        bank.add_static_program(
-        assert!(bank.get_account(&solana_vote_program::id()).is_some());
+            "mock_vote_program",
+            mock_vote_program_id(),
+            mock_vote_processor,
+        );
+        assert!(bank.get_account(&mock_vote_program_id()).is_some());
 
         let mock_account = Keypair::new();
         let mock_validator_identity = Keypair::new();
-        let instructions = vote_instruction::create_account(
+        let mut instructions = vote_instruction::create_account(
             &mint_keypair.pubkey(),
             &mock_account.pubkey(),
             &VoteInit {
@@ -5050,6 +5088,7 @@ mod tests {
             },
             1,
         );
+        instructions[1].program_id = mock_vote_program_id();
 
         let transaction = Transaction::new_signed_instructions(
             &[&mint_keypair, &mock_account, &mock_validator_identity],
@@ -5067,13 +5106,12 @@ mod tests {
     }
 
     #[test]
-    fn test_add_instruction_processor_for_existing_program() {
+    fn test_add_duplicate_static_program() {
         let GenesisConfigInfo {
             genesis_config,
             mint_keypair,
             ..
         } = create_genesis_config_with_leader(500, &Pubkey::new_rand(), 0);
-
         let mut bank = Bank::new(&genesis_config);
 
         fn mock_vote_processor(
@@ -5103,7 +5141,11 @@ mod tests {
         );
 
         let vote_loader_account = bank.get_account(&solana_vote_program::id()).unwrap();
-        bank.add_instruction_processor(solana_vote_program::id(), mock_vote_processor);
+        bank.add_static_program(
+            "solana_vote_program",
+            solana_vote_program::id(),
+            mock_vote_processor,
+        );
         let new_vote_loader_account = bank.get_account(&solana_vote_program::id()).unwrap();
         // Vote loader account should not be updated since it was included in the genesis config.
         assert_eq!(vote_loader_account.data, new_vote_loader_account.data);
@@ -5131,7 +5173,7 @@ mod tests {
         }
 
         // Non-native loader accounts can not be used for instruction processing
-        bank.add_instruction_processor(mint_keypair.pubkey(), mock_ix_processor);
+        bank.add_static_program("mock_program", mint_keypair.pubkey(), mock_ix_processor);
     }
     #[test]
     fn test_recent_blockhashes_sysvar() {
@@ -5150,6 +5192,7 @@ mod tests {
             bank = Arc::new(new_from_parent(&bank));
         }
     }
+
     #[test]
     fn test_bank_inherit_last_vote_sync() {
         let (genesis_config, _) = create_genesis_config(500);
@@ -5690,7 +5733,7 @@ mod tests {
         }
 
         let mock_program_id = Pubkey::new(&[2u8; 32]);
-        bank.add_instruction_processor(mock_program_id, mock_process_instruction);
+        bank.add_static_program("mock_program", mock_program_id, mock_process_instruction);
 
         let from_pubkey = Pubkey::new_rand();
         let to_pubkey = Pubkey::new_rand();
@@ -5733,7 +5776,7 @@ mod tests {
         }
 
         let mock_program_id = Pubkey::new(&[2u8; 32]);
-        bank.add_instruction_processor(mock_program_id, mock_process_instruction);
+        bank.add_static_program("mock_program", mock_program_id, mock_process_instruction);
 
         let from_pubkey = Pubkey::new_rand();
         let to_pubkey = Pubkey::new_rand();

runtime/src/genesis_utils.rs

@@ -5,7 +5,7 @@ use solana_sdk::{
     pubkey::Pubkey,
     rent::Rent,
     signature::{Keypair, Signer},
-    system_program::{self, solana_system_program},
+    system_program,
 };
 use solana_stake_program::stake_state;
 use solana_vote_program::vote_state;
@@ -133,17 +133,9 @@ pub fn create_genesis_config_with_leader_ex(
     .cloned()
     .collect();
 
-    // Bare minimum program set
-    let native_instruction_processors = vec![
-        solana_system_program(),
-        solana_vote_program!(),
-        solana_stake_program!(),
-    ];
-
     let fee_rate_governor = FeeRateGovernor::new(0, 0); // most tests can't handle transaction fees
     let mut genesis_config = GenesisConfig {
         accounts,
-        native_instruction_processors,
         fee_rate_governor,
         rent,
         ..GenesisConfig::default()

runtime/src/lib.rs

@@ -21,15 +21,12 @@ mod system_instruction_processor;
 pub mod transaction_batch;
 pub mod transaction_utils;
 
-#[macro_use]
+extern crate solana_config_program;
-extern crate solana_metrics;
+extern crate solana_stake_program;
-
-#[macro_use]
 extern crate solana_vote_program;
 
 #[macro_use]
-extern crate solana_stake_program;
+extern crate solana_metrics;
-
 #[macro_use]
 extern crate serde_derive;
 

runtime/src/message_processor.rs

@@ -1,6 +1,4 @@
-use crate::{
+use crate::{native_loader::NativeLoader, rent_collector::RentCollector};
-    native_loader::NativeLoader, rent_collector::RentCollector, system_instruction_processor,
-};
 use serde::{Deserialize, Serialize};
 use solana_sdk::{
     account::{create_keyed_readonly_accounts, Account, KeyedAccount},
@@ -161,20 +159,17 @@ impl PreAccount {
 
 pub type ProcessInstruction = fn(&Pubkey, &[KeyedAccount], &[u8]) -> Result<(), InstructionError>;
 
-#[derive(Serialize, Deserialize)]
+#[derive(Default, Deserialize, Serialize)]
 pub struct MessageProcessor {
     #[serde(skip)]
     instruction_processors: Vec<(Pubkey, ProcessInstruction)>,
     #[serde(skip)]
     native_loader: NativeLoader,
 }
-impl Default for MessageProcessor {
+impl Clone for MessageProcessor {
-    fn default() -> Self {
+    fn clone(&self) -> Self {
-        Self {
+        MessageProcessor {
-            instruction_processors: vec![(
+            instruction_processors: self.instruction_processors.clone(),
-                system_program::id(),
-                system_instruction_processor::process_instruction,
-            )],
             native_loader: NativeLoader::default(),
         }
     }
@@ -186,8 +181,16 @@ impl MessageProcessor {
         program_id: Pubkey,
         process_instruction: ProcessInstruction,
     ) {
-        self.instruction_processors
+        match self
-            .push((program_id, process_instruction));
+            .instruction_processors
+            .iter_mut()
+            .find(|(key, _)| program_id == *key)
+        {
+            Some((_, processor)) => *processor = process_instruction,
+            None => self
+                .instruction_processors
+                .push((program_id, process_instruction)),
+        }
     }
 
     /// Process an instruction

runtime/src/storage_utils.rs

@@ -103,7 +103,8 @@ pub(crate) mod tests {
         let validator_keypair = Keypair::new();
         let validator_pubkey = validator_keypair.pubkey();
         let mut bank = Bank::new(&genesis_config);
-        bank.add_instruction_processor(
+        bank.add_static_program(
+            "storage_program",
             solana_storage_program::id(),
             storage_processor::process_instruction,
         );

runtime/tests/noop.rs

@@ -12,7 +12,7 @@ fn test_program_native_noop() {
     let (genesis_config, alice_keypair) = create_genesis_config(50);
     let program_id = Pubkey::new_rand();
     let bank = Bank::new(&genesis_config);
-    bank.register_native_instruction_processor("solana_noop_program", &program_id);
+    bank.add_native_program("solana_noop_program", &program_id);
 
     // Call user program
     let instruction = create_invoke_instruction(alice_keypair.pubkey(), program_id, &1u8);

runtime/tests/stake.rs

@@ -100,13 +100,10 @@ fn test_stake_create_and_split_single_signature() {
     solana_logger::setup();
 
     let GenesisConfigInfo {
-        mut genesis_config,
+        genesis_config,
         mint_keypair: staker_keypair,
         ..
     } = create_genesis_config_with_leader(100_000_000_000, &Pubkey::new_rand(), 1_000_000);
-    genesis_config
-        .native_instruction_processors
-        .push(solana_stake_program::solana_stake_program!());
 
     let staker_pubkey = staker_keypair.pubkey();
 
@@ -166,13 +163,10 @@ fn test_stake_account_lifetime() {
     let identity_pubkey = identity_keypair.pubkey();
 
     let GenesisConfigInfo {
-        mut genesis_config,
+        genesis_config,
         mint_keypair,
         ..
     } = create_genesis_config_with_leader(100_000_000_000, &Pubkey::new_rand(), 1_000_000);
-    genesis_config
-        .native_instruction_processors
-        .push(solana_stake_program::solana_stake_program!());
     let bank = Bank::new(&genesis_config);
     let mint_pubkey = mint_keypair.pubkey();
     let mut bank = Arc::new(bank);
@@ -403,13 +397,10 @@ fn test_create_stake_account_from_seed() {
     let identity_pubkey = identity_keypair.pubkey();
 
     let GenesisConfigInfo {
-        mut genesis_config,
+        genesis_config,
         mint_keypair,
         ..
     } = create_genesis_config_with_leader(100_000_000_000, &Pubkey::new_rand(), 1_000_000);
-    genesis_config
-        .native_instruction_processors
-        .push(solana_stake_program::solana_stake_program!());
     let bank = Bank::new(&genesis_config);
     let mint_pubkey = mint_keypair.pubkey();
     let bank = Arc::new(bank);

runtime/tests/storage.rs

@@ -45,7 +45,7 @@ fn test_account_owner() {
     } = create_genesis_config(1000);
     let mut bank = Bank::new(&genesis_config);
     let mint_pubkey = mint_keypair.pubkey();
-    bank.add_instruction_processor(id(), process_instruction);
+    bank.add_static_program("storage_program", id(), process_instruction);
     let bank = Arc::new(bank);
     let bank_client = BankClient::new_shared(&bank);
 

sdk/src/genesis_config.rs

@@ -13,7 +13,7 @@ use crate::{
     rent::Rent,
     shred_version::compute_shred_version,
     signature::{Keypair, Signer},
-    system_program::{self, solana_system_program},
+    system_program,
 };
 use bincode::{deserialize, serialize};
 use chrono::{TimeZone, Utc};
@@ -72,7 +72,7 @@ pub fn create_genesis_config(lamports: u64) -> (GenesisConfig, Keypair) {
                 faucet_keypair.pubkey(),
                 Account::new(lamports, 0, &system_program::id()),
             )],
-            &[solana_system_program()],
+            &[],
         ),
         faucet_keypair,
     )

sdk/src/system_program.rs

@@ -1,5 +1 @@
 crate::declare_id!("11111111111111111111111111111111");
-
-pub fn solana_system_program() -> (String, crate::pubkey::Pubkey) {
-    ("solana_system_program".to_string(), id())
-}

stake-accounts/src/stake_accounts.rs

@@ -216,11 +216,7 @@ mod tests {
 
     fn create_bank(lamports: u64) -> (Bank, Keypair, u64) {
         let (genesis_config, mint_keypair) = create_genesis_config(lamports);
-        let mut bank = Bank::new(&genesis_config);
+        let bank = Bank::new(&genesis_config);
-        bank.add_instruction_processor(
-            solana_stake_program::id(),
-            solana_stake_program::stake_instruction::process_instruction,
-        );
         let rent = bank.get_minimum_balance_for_rent_exemption(std::mem::size_of::<StakeState>());
         (bank, mint_keypair, rent)
     }