pinocchio_token/instructions/

initialize_multisig_2.rs

use {
    crate::{
        instructions::{
            account_borrow_failed_error, invalid_argument_error, CpiWriter, MAX_MULTISIG_SIGNERS,
        },
        UNINIT_BYTE, UNINIT_CPI_ACCOUNT, UNINIT_INSTRUCTION_ACCOUNT,
    },
    core::{mem::MaybeUninit, slice::from_raw_parts},
    solana_account_view::AccountView,
    solana_instruction_view::{
        cpi::{invoke_unchecked, CpiAccount},
        InstructionAccount, InstructionView,
    },
    solana_program_error::{ProgramError, ProgramResult},
};

/// Like [`super::InitializeMultisig`], but does not require the
/// Rent sysvar to be provided
///
/// Accounts expected by this instruction:
///
///   0. `[writable]` The multisignature account to initialize.
///   1. `..+N` `[signer]` The signer accounts, must equal to N where `1 <= N <=
///      11`.
pub struct InitializeMultisig2<'account, 'multisig, MultisigSigner: AsRef<AccountView>>
where
    'account: 'multisig,
{
    /// The multisignature account to initialize.
    pub multisig: &'account AccountView,

    ///  The signer accounts.
    pub multisig_signers: &'multisig [MultisigSigner],

    /// The number of signers (M) required to validate this multisignature
    /// account.
    pub m: u8,
}

impl<'account, 'multisig, MultisigSigner: AsRef<AccountView>>
    InitializeMultisig2<'account, 'multisig, MultisigSigner>
where
    'account: 'multisig,
{
    pub const DISCRIMINATOR: u8 = 19;

    /// Maximum number of accounts expected by this instruction.
    ///
    /// The required number of accounts will depend whether the
    /// source account has a single owner or a multisignature
    /// owner.
    pub const MAX_ACCOUNTS_LEN: usize = 1 + MAX_MULTISIG_SIGNERS;

    /// Instruction data length:
    ///   - discriminator (1 byte)
    ///   - number of signers (1 byte)
    pub const DATA_LEN: usize = 2;

    #[inline(always)]
    pub fn new(
        multisig: &'account AccountView,
        multisig_signers: &'multisig [MultisigSigner],
        m: u8,
    ) -> Self {
        Self {
            multisig,
            multisig_signers,
            m,
        }
    }

    #[inline(always)]
    pub fn invoke(&self) -> ProgramResult {
        if self.multisig_signers.len() > MAX_MULTISIG_SIGNERS {
            return Err(ProgramError::InvalidArgument);
        }

        let mut instruction_accounts =
            [UNINIT_INSTRUCTION_ACCOUNT; InitializeMultisig2::<&AccountView>::MAX_ACCOUNTS_LEN];
        let written_instruction_accounts =
            self.write_instruction_accounts(&mut instruction_accounts)?;

        let mut accounts =
            [UNINIT_CPI_ACCOUNT; InitializeMultisig2::<&AccountView>::MAX_ACCOUNTS_LEN];
        let written_accounts = self.write_accounts(&mut accounts)?;

        let mut instruction_data = [UNINIT_BYTE; InitializeMultisig2::<&AccountView>::DATA_LEN];
        let written_instruction_data = self.write_instruction_data(&mut instruction_data)?;

        unsafe {
            invoke_unchecked(
                &InstructionView {
                    program_id: &crate::ID,
                    accounts: from_raw_parts(
                        instruction_accounts.as_ptr() as _,
                        written_instruction_accounts,
                    ),
                    data: from_raw_parts(instruction_data.as_ptr() as _, written_instruction_data),
                },
                from_raw_parts(accounts.as_ptr() as _, written_accounts),
            );
        }

        Ok(())
    }
}

impl<MultisigSigner: AsRef<AccountView>> CpiWriter for InitializeMultisig2<'_, '_, MultisigSigner> {
    #[inline(always)]
    fn write_accounts<'cpi>(
        &self,
        accounts: &mut [MaybeUninit<CpiAccount<'cpi>>],
    ) -> Result<usize, ProgramError>
    where
        Self: 'cpi,
    {
        write_accounts(self.multisig, self.multisig_signers, accounts)
    }

    #[inline(always)]
    fn write_instruction_accounts<'cpi>(
        &self,
        accounts: &mut [MaybeUninit<InstructionAccount<'cpi>>],
    ) -> Result<usize, ProgramError>
    where
        Self: 'cpi,
    {
        write_instruction_accounts(self.multisig, self.multisig_signers, accounts)
    }

    #[inline(always)]
    fn write_instruction_data(&self, data: &mut [MaybeUninit<u8>]) -> Result<usize, ProgramError> {
        write_instruction_data(self.m, data)
    }
}

impl<MultisigSigner: AsRef<AccountView>> super::IntoBatch
    for InitializeMultisig2<'_, '_, MultisigSigner>
{
    #[inline(always)]
    fn into_batch<'account, 'state>(
        self,
        batch: &mut super::Batch<'account, 'state>,
    ) -> ProgramResult
    where
        Self: 'account + 'state,
    {
        batch.push(
            |accounts| write_accounts(self.multisig, self.multisig_signers, accounts),
            |accounts| write_instruction_accounts(self.multisig, self.multisig_signers, accounts),
            |data| write_instruction_data(self.m, data),
        )
    }
}

#[inline(always)]
fn write_accounts<'account, 'multisig, 'out, MultisigSigner: AsRef<AccountView>>(
    multisig: &'account AccountView,
    multisig_signers: &'multisig [MultisigSigner],
    accounts: &mut [MaybeUninit<CpiAccount<'out>>],
) -> Result<usize, ProgramError>
where
    'account: 'out,
    'multisig: 'out,
{
    let expected_accounts = 1 + multisig_signers.len();

    if expected_accounts > accounts.len() {
        return Err(invalid_argument_error());
    }

    if multisig.is_borrowed() {
        return Err(account_borrow_failed_error());
    }

    CpiAccount::init_from_account_view(multisig, &mut accounts[0]);

    for (account, signer) in accounts[1..expected_accounts]
        .iter_mut()
        .zip(multisig_signers.iter())
    {
        CpiAccount::init_from_account_view(signer.as_ref(), account);
    }

    Ok(expected_accounts)
}

#[inline(always)]
fn write_instruction_accounts<'account, 'multisig, 'out, MultisigSigner: AsRef<AccountView>>(
    multisig: &'account AccountView,
    multisig_signers: &'multisig [MultisigSigner],
    accounts: &mut [MaybeUninit<InstructionAccount<'out>>],
) -> Result<usize, ProgramError>
where
    'account: 'out,
    'multisig: 'out,
{
    let expected_accounts = 1 + multisig_signers.len();

    if expected_accounts > accounts.len() {
        return Err(invalid_argument_error());
    }

    accounts[0].write(InstructionAccount::writable(multisig.address()));

    for (account, signer) in accounts[1..expected_accounts]
        .iter_mut()
        .zip(multisig_signers.iter())
    {
        account.write(InstructionAccount::readonly(signer.as_ref().address()));
    }

    Ok(expected_accounts)
}

#[inline(always)]
fn write_instruction_data(m: u8, data: &mut [MaybeUninit<u8>]) -> Result<usize, ProgramError> {
    if data.len() < InitializeMultisig2::<&AccountView>::DATA_LEN {
        return Err(invalid_argument_error());
    }

    data[0].write(InitializeMultisig2::<&AccountView>::DISCRIMINATOR);

    data[1].write(m);

    Ok(InitializeMultisig2::<&AccountView>::DATA_LEN)
}