Default solana-test-validator --bpf-programs to upgradeable loader (#30485)

* Dedupe parsing

* Update --bpf-program param to use upgradeable loader, upgrade authority disabled

* Update add_program to use upgreadeable loader

* Deprecate non-upgradeable utils

test-validator/src/lib.rs

@@ -69,6 +69,7 @@ pub struct AccountInfo<'a> {
     pub filename: &'a str,
 }
 
+#[deprecated(since = "1.16.0", note = "Please use `UpgradeableProgramInfo` instead")]
 #[derive(Clone)]
 pub struct ProgramInfo {
     pub program_id: Pubkey,
@@ -118,6 +119,7 @@ pub struct TestValidatorGenesis {
     warp_slot: Option<Slot>,
     no_bpf_jit: bool,
     accounts: HashMap<Pubkey, AccountSharedData>,
+    #[allow(deprecated)]
     programs: Vec<ProgramInfo>,
     upgradeable_programs: Vec<UpgradeableProgramInfo>,
     ticks_per_slot: Option<u64>,
@@ -150,6 +152,7 @@ impl Default for TestValidatorGenesis {
             warp_slot: Option::<Slot>::default(),
             no_bpf_jit: bool::default(),
             accounts: HashMap::<Pubkey, AccountSharedData>::default(),
+            #[allow(deprecated)]
             programs: Vec::<ProgramInfo>::default(),
             upgradeable_programs: Vec::<UpgradeableProgramInfo>::default(),
             ticks_per_slot: Option::<u64>::default(),
@@ -482,15 +485,21 @@ impl TestValidatorGenesis {
         let program_path = solana_program_test::find_file(&format!("{program_name}.so"))
             .unwrap_or_else(|| panic!("Unable to locate program {program_name}"));
 
-        self.programs.push(ProgramInfo {
+        self.upgradeable_programs.push(UpgradeableProgramInfo {
             program_id,
-            loader: solana_sdk::bpf_loader::id(),
+            loader: solana_sdk::bpf_loader_upgradeable::id(),
+            upgrade_authority: Pubkey::default(),
             program_path,
         });
         self
     }
 
     /// Add a list of programs to the test environment.
+    #[deprecated(
+        since = "1.16.0",
+        note = "Please use `add_upgradeable_programs_with_path()` instead"
+    )]
+    #[allow(deprecated)]
     pub fn add_programs_with_path(&mut self, programs: &[ProgramInfo]) -> &mut Self {
         for program in programs {
             self.programs.push(program.clone());
@@ -680,6 +689,7 @@ impl TestValidator {
         for (address, account) in solana_program_test::programs::spl_programs(&config.rent) {
             accounts.entry(address).or_insert(account);
         }
+        #[allow(deprecated)]
         for program in &config.programs {
             let data = solana_program_test::read_file(&program.program_path);
             accounts.insert(

validator/src/bin/solana-test-validator.rs

@@ -179,32 +179,41 @@ fn main() {
 
     let faucet_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), faucet_port);
 
-    let mut programs_to_load = vec![];
+    let parse_address = |address: &str, input_type: &str| {
+        address
+            .parse::<Pubkey>()
+            .or_else(|_| read_keypair_file(address).map(|keypair| keypair.pubkey()))
+            .unwrap_or_else(|err| {
+                println!("Error: invalid {input_type} {address}: {err}");
+                exit(1);
+            })
+    };
+
+    let parse_program_path = |program: &str| {
+        let program_path = PathBuf::from(program);
+        if !program_path.exists() {
+            println!(
+                "Error: program file does not exist: {}",
+                program_path.display()
+            );
+            exit(1);
+        }
+        program_path
+    };
+
+    let mut upgradeable_programs_to_load = vec![];
     if let Some(values) = matches.values_of("bpf_program") {
         let values: Vec<&str> = values.collect::<Vec<_>>();
         for address_program in values.chunks(2) {
             match address_program {
                 [address, program] => {
-                    let address = address
-                        .parse::<Pubkey>()
-                        .or_else(|_| read_keypair_file(address).map(|keypair| keypair.pubkey()))
-                        .unwrap_or_else(|err| {
-                            println!("Error: invalid address {address}: {err}");
-                            exit(1);
-                        });
+                    let address = parse_address(address, "address");
+                    let program_path = parse_program_path(program);
 
-                    let program_path = PathBuf::from(program);
-                    if !program_path.exists() {
-                        println!(
-                            "Error: program file does not exist: {}",
-                            program_path.display()
-                        );
-                        exit(1);
-                    }
-
-                    programs_to_load.push(ProgramInfo {
+                    upgradeable_programs_to_load.push(UpgradeableProgramInfo {
                         program_id: address,
-                        loader: solana_sdk::bpf_loader::id(),
+                        loader: solana_sdk::bpf_loader_upgradeable::id(),
+                        upgrade_authority: Pubkey::default(),
                         program_path,
                     });
                 }
@@ -213,19 +222,13 @@ fn main() {
         }
     }
 
-    let mut upgradeable_programs_to_load = vec![];
     if let Some(values) = matches.values_of("upgradeable_program") {
         let values: Vec<&str> = values.collect::<Vec<_>>();
         for address_program_upgrade_authority in values.chunks(3) {
             match address_program_upgrade_authority {
                 [address, program, upgrade_authority] => {
-                    let address = address
-                        .parse::<Pubkey>()
-                        .or_else(|_| read_keypair_file(address).map(|keypair| keypair.pubkey()))
-                        .unwrap_or_else(|err| {
-                            println!("Error: invalid address {address}: {err}");
-                            exit(1);
-                        });
+                    let address = parse_address(address, "address");
+                    let program_path = parse_program_path(program);
                     let upgrade_authority_address = if *upgrade_authority == "none" {
                         Pubkey::default()
                     } else {
@@ -242,15 +245,6 @@ fn main() {
                             })
                     };
 
-                    let program_path = PathBuf::from(program);
-                    if !program_path.exists() {
-                        println!(
-                            "Error: program file does not exist: {}",
-                            program_path.display()
-                        );
-                        exit(1);
-                    }
-
                     upgradeable_programs_to_load.push(UpgradeableProgramInfo {
                         program_id: address,
                         loader: solana_sdk::bpf_loader_upgradeable::id(),
@@ -458,7 +452,6 @@ fn main() {
         })
         .bpf_jit(!matches.is_present("no_bpf_jit"))
         .rpc_port(rpc_port)
-        .add_programs_with_path(&programs_to_load)
         .add_upgradeable_programs_with_path(&upgradeable_programs_to_load)
         .add_accounts_from_json_files(&accounts_to_load)
         .unwrap_or_else(|e| {

validator/src/cli.rs

@@ -2016,7 +2016,7 @@ pub fn test_app<'a>(version: &'a str, default_args: &'a DefaultTestArgs) -> App<
                 .number_of_values(2)
                 .multiple(true)
                 .help(
-                    "Add a SBF program to the genesis configuration. \
+                    "Add a SBF program to the genesis configuration with upgrades disabled. \
                        If the ledger already exists then this parameter is silently ignored. \
                        First argument can be a pubkey string or path to a keypair",
                 ),