Adds CLI command.

Author: Lichtso

cli-output/src/cli_output.rs

@@ -2468,6 +2468,25 @@ impl fmt::Display for CliUpgradeableProgramExtended {
     }
 }
 
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CliUpgradeableProgramMigrated {
+    pub program_id: String,
+}
+impl QuietDisplay for CliUpgradeableProgramMigrated {}
+impl VerboseDisplay for CliUpgradeableProgramMigrated {}
+impl fmt::Display for CliUpgradeableProgramMigrated {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(f)?;
+        writeln!(
+            f,
+            "Migrated Program Id {} from loader-v3 to loader-v4",
+            &self.program_id,
+        )?;
+        Ok(())
+    }
+}
+
 #[derive(Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CliUpgradeableBuffer {

cli/src/program.rs

@@ -31,7 +31,7 @@ use {
         return_signers_with_config, CliProgram, CliProgramAccountType, CliProgramAuthority,
         CliProgramBuffer, CliProgramId, CliUpgradeableBuffer, CliUpgradeableBuffers,
         CliUpgradeableProgram, CliUpgradeableProgramClosed, CliUpgradeableProgramExtended,
-        CliUpgradeablePrograms, ReturnSignersConfig,
+        CliUpgradeableProgramMigrated, CliUpgradeablePrograms, ReturnSignersConfig,
     },
     solana_client::{
         connection_cache::ConnectionCache,
@@ -171,6 +171,10 @@ pub enum ProgramCliCommand {
         program_pubkey: Pubkey,
         additional_bytes: u32,
     },
+    Migrate {
+        program_pubkey: Pubkey,
+        authority_signer_index: SignerIndex,
+    },
 }
 
 pub trait ProgramSubCommands {
@@ -632,6 +636,32 @@ impl ProgramSubCommands for App<'_, '_> {
                                      data account",
                                 ),
                         ),
+                )
+                .subcommand(
+                    SubCommand::with_name("migrate")
+                        .about(
+                            "Migrates an upgradeable program to loader-v4",
+                        )
+                        .arg(
+                            Arg::with_name("program_id")
+                                .index(1)
+                                .value_name("PROGRAM_ID")
+                                .takes_value(true)
+                                .required(true)
+                                .validator(is_valid_pubkey)
+                                .help("Address of the program to extend"),
+                        )
+                        .arg(
+                            Arg::with_name("authority")
+                                .long("authority")
+                                .value_name("AUTHORITY_SIGNER")
+                                .takes_value(true)
+                                .validator(is_valid_signer)
+                                .help(
+                                    "Upgrade authority [default: the default configured \
+                                     keypair]",
+                                ),
+                        ),
                 ),
         )
         .subcommand(
@@ -991,6 +1021,29 @@ pub fn parse_program_subcommand(
                 signers: signer_info.signers,
             }
         }
+        ("migrate", Some(matches)) => {
+            let program_pubkey = pubkey_of(matches, "program_id").unwrap();
+
+            let (authority_signer, authority_pubkey) =
+                signer_of(matches, "authority", wallet_manager)?;
+
+            let signer_info = default_signer.generate_unique_signers(
+                vec![
+                    Some(default_signer.signer_from_path(matches, wallet_manager)?),
+                    authority_signer,
+                ],
+                matches,
+                wallet_manager,
+            )?;
+
+            CliCommandInfo {
+                command: CliCommand::Program(ProgramCliCommand::Migrate {
+                    program_pubkey,
+                    authority_signer_index: signer_info.index_of(authority_pubkey).unwrap(),
+                }),
+                signers: signer_info.signers,
+            }
+        }
         _ => unreachable!(),
     };
     Ok(response)
@@ -1175,6 +1228,15 @@ pub fn process_program_subcommand(
             program_pubkey,
             additional_bytes,
         } => process_extend_program(&rpc_client, config, *program_pubkey, *additional_bytes),
+        ProgramCliCommand::Migrate {
+            program_pubkey,
+            authority_signer_index,
+        } => process_migrate_program(
+            &rpc_client,
+            config,
+            *program_pubkey,
+            *authority_signer_index,
+        ),
     }
 }
 
@@ -2387,6 +2449,97 @@ fn process_extend_program(
         }))
 }
 
+fn process_migrate_program(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    program_pubkey: Pubkey,
+    authority_signer_index: SignerIndex,
+) -> ProcessResult {
+    let payer_pubkey = config.signers[0].pubkey();
+    let authority_signer = config.signers[authority_signer_index];
+
+    let program_account = match rpc_client
+        .get_account_with_commitment(&program_pubkey, config.commitment)?
+        .value
+    {
+        Some(program_account) => Ok(program_account),
+        None => Err(format!("Unable to find program {program_pubkey}")),
+    }?;
+
+    if !bpf_loader_upgradeable::check_id(&program_account.owner) {
+        return Err(format!("Account {program_pubkey} is not an upgradeable program").into());
+    }
+
+    let programdata_pubkey = match program_account.state() {
+        Ok(UpgradeableLoaderState::Program {
+            programdata_address: programdata_pubkey,
+        }) => Ok(programdata_pubkey),
+        _ => Err(format!(
+            "Account {program_pubkey} is not an upgradeable program"
+        )),
+    }?;
+
+    let programdata_account = match rpc_client
+        .get_account_with_commitment(&programdata_pubkey, config.commitment)?
+        .value
+    {
+        Some(programdata_account) => Ok(programdata_account),
+        None => Err(format!("Program {program_pubkey} is closed")),
+    }?;
+
+    let upgrade_authority_address = match programdata_account.state() {
+        Ok(UpgradeableLoaderState::ProgramData {
+            slot: _,
+            upgrade_authority_address,
+        }) => Ok(upgrade_authority_address),
+        _ => Err(format!("Program {program_pubkey} is closed")),
+    }?;
+
+    if upgrade_authority_address != Some(authority_signer.pubkey()) {
+        return Err(format!(
+            "Upgrade authority {:?} does not match {:?}",
+            upgrade_authority_address,
+            Some(authority_signer.pubkey())
+        )
+        .into());
+    }
+
+    let blockhash = rpc_client.get_latest_blockhash()?;
+
+    let mut tx = Transaction::new_unsigned(Message::new(
+        &[bpf_loader_upgradeable::migrate_program(
+            &programdata_pubkey,
+            &program_pubkey,
+            &authority_signer.pubkey(),
+        )],
+        Some(&payer_pubkey),
+    ));
+
+    tx.try_sign(&[config.signers[0]], blockhash)?;
+    let result = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
+        &tx,
+        config.commitment,
+        config.send_transaction_config,
+    );
+    if let Err(err) = result {
+        if let ClientErrorKind::TransactionError(TransactionError::InstructionError(
+            _,
+            InstructionError::InvalidInstructionData,
+        )) = err.kind()
+        {
+            return Err("Migrating a program is not supported by the cluster".into());
+        } else {
+            return Err(format!("Migrate program failed: {err}").into());
+        }
+    }
+
+    Ok(config
+        .output_format
+        .formatted_string(&CliUpgradeableProgramMigrated {
+            program_id: program_pubkey.to_string(),
+        }))
+}
+
 pub fn calculate_max_chunk_size<F>(create_msg: &F) -> usize
 where
     F: Fn(u32, Vec<u8>) -> Message,