Specifying the multisig PDA as transaction execution signer.

[eloylp]

Hey hello 👋

Whats the problem we are trying to solve ?

We would like to use the Squads protocol multisig Rust SDK for creating a transaction, which would upgrade an arbitrary Solana program by calling the solana_program::bpf_loader_upgradeable::upgrade at the moment of proposal execution.

What we are finding so far ?

We are finding that the execute_message method, is only adding as signers transaction level related seeds we cannot set as upgrade_authority of target programs due to their lifetime (per tx).

What we are expecting to happen ?

We would like to add the multisig level account as signer of the CPI, so the target program to upgrade can set it as its own upgrade_authority, granting the upgrade operation through the multisig after a successful votation.

We could also use this method for changing the upgrade_authority to a new one if the multisig members decides so ...

Is this scenario possible ? Thanks in advance :)

[halz101]

impl<'a, 'info> ExecutableTransactionMessage<'a, 'info> {
// Helper function to check if protected accounts are writable
fn check_protected_accounts(ix: &Instruction, protected_accounts: &[Pubkey]) -> Result<()> {
for account_meta in ix.accounts.iter().filter(|m| m.is_writable) {
require!(
!protected_accounts.contains(&account_meta.pubkey),
MultisigError::ProtectedAccount
);
}
Ok(())
}

// Optimized conversion function for ephemeral signer seeds
fn convert_ephemeral_signer_seeds(
    ephemeral_signer_seeds: &[Vec<Vec<u8>>],
) -> Vec<&[&[u8]]> {
    ephemeral_signer_seeds
        .iter()
        .map(|seeds| seeds.iter().map(Vec::as_slice).collect::<Vec<&[u8]>>())
        .map(Vec::as_slice)
        .collect::<Vec<&[&[u8]]>>()
}

/// Executes all instructions in the message via CPI calls.
/// # Arguments
/// * `vault_seeds` - Seeds for the vault PDA.
/// * `ephemeral_signer_seeds` - Seeds for the ephemeral signer PDAs.
/// * `protected_accounts` - Accounts that must not be passed as writable to the CPI calls to prevent potential reentrancy attacks.
pub fn execute_message(
    self,
    vault_seeds: &[&[u8]],
    ephemeral_signer_seeds: &[Vec<Vec<u8>>],
    protected_accounts: &[Pubkey],
) -> Result<()> {
    let signer_seeds = {
        let mut seeds = Self::convert_ephemeral_signer_seeds(ephemeral_signer_seeds);
        seeds.push(vault_seeds);
        seeds
    };

    for (ix, account_infos) in self.to_instructions_and_accounts().iter() {
        Self::check_protected_accounts(ix, protected_accounts)?;
        invoke_signed(&ix, &account_infos, &signer_seeds)?;
    }
    Ok(())
}

}