More nits

Author: febo

programs/token-2022/src/instructions/extensions/mod.rs

@@ -19,7 +19,6 @@ pub mod transfer_hook;
 pub enum ExtensionDiscriminator {
     MintCloseAuthority = 25,
     TransferFee = 26,
-
     DefaultAccountState = 28,
     MemoTransfer = 30,
     InterestBearingMint = 33,

programs/token-2022/src/instructions/extensions/transfer_fee/harvest_withheld_tokens_to_mint.rs

@@ -1,6 +1,6 @@
 use {
-    crate::{instructions::ExtensionDiscriminator, UNINIT_ACCOUNT_REF, UNINIT_INSTRUCTION_ACCOUNT},
-    core::slice::from_raw_parts,
+    crate::instructions::ExtensionDiscriminator,
+    core::{mem::MaybeUninit, slice::from_raw_parts},
     solana_account_view::AccountView,
     solana_address::Address,
     solana_instruction_view::{
@@ -45,40 +45,27 @@ impl HarvestWithheldTokensToMint<'_, '_, '_> {
 
         // Instruction accounts.
 
-        let mut instruction_accounts = [UNINIT_INSTRUCTION_ACCOUNT; MAX_STATIC_CPI_ACCOUNTS];
+        let mut instruction_accounts =
+            [const { MaybeUninit::<InstructionAccount>::uninit() }; MAX_STATIC_CPI_ACCOUNTS];
 
-        // SAFETY: The expected number of accounts has been validated to be less than
-        // the maximum allocated.
-        unsafe {
-            instruction_accounts
-                .get_unchecked_mut(0)
-                .write(InstructionAccount::writable(self.mint.address()));
+        instruction_accounts[0].write(InstructionAccount::writable(self.mint.address()));
 
-            for (instruction_account, source) in instruction_accounts
-                .get_unchecked_mut(1..)
-                .iter_mut()
-                .zip(self.sources.iter())
-            {
-                instruction_account.write(InstructionAccount::writable(source.address()));
-            }
+        for (instruction_account, source) in instruction_accounts[1..]
+            .iter_mut()
+            .zip(self.sources.iter())
+        {
+            instruction_account.write(InstructionAccount::writable(source.address()));
         }
 
         // Accounts.
 
-        let mut accounts = [UNINIT_ACCOUNT_REF; MAX_STATIC_CPI_ACCOUNTS];
+        let mut accounts =
+            [const { MaybeUninit::<&AccountView>::uninit() }; MAX_STATIC_CPI_ACCOUNTS];
 
-        // SAFETY: The expected number of accounts has been validated to be less than
-        // the maximum allocated.
-        unsafe {
-            accounts.get_unchecked_mut(0).write(self.mint);
+        accounts[0].write(self.mint);
 
-            for (account, source) in accounts
-                .get_unchecked_mut(1..)
-                .iter_mut()
-                .zip(self.sources.iter())
-            {
-                account.write(*source);
-            }
+        for (account, source) in accounts[1..].iter_mut().zip(self.sources.iter()) {
+            account.write(*source);
         }
 
         invoke_with_bounds::<MAX_STATIC_CPI_ACCOUNTS>(

programs/token-2022/src/instructions/extensions/transfer_fee/initialize_transfer_fee_config.rs

@@ -56,36 +56,32 @@ impl InitializeTransferFeeConfig<'_, '_> {
         // - 2 bytes for each optional authority
         let mut data_len = 2 + 2 + 8 + 2;
 
-        // discriminators
-        write_bytes(
-            &mut instruction_data[..2],
-            &[
-                ExtensionDiscriminator::TransferFee as u8,
-                Self::DISCRIMINATOR,
-            ],
-        );
-        // transfer_fee_config_authority
+        instruction_data[0].write(ExtensionDiscriminator::TransferFee as u8);
+
+        instruction_data[1].write(Self::DISCRIMINATOR);
+
         if let Some(authority) = self.transfer_fee_config_authority {
             instruction_data[2].write(1);
             write_bytes(&mut instruction_data[3..35], authority.as_ref());
+            // Add 32 bytes for the authority.
             data_len += size_of::<Address>();
         } else {
             instruction_data[2].write(0);
         }
-        // withdraw_withheld_authority
         if let Some(authority) = self.withdraw_withheld_authority {
             instruction_data[35].write(1);
             write_bytes(&mut instruction_data[36..68], authority.as_ref());
+            // Add 32 bytes for the authority.
             data_len += size_of::<Address>();
         } else {
             instruction_data[35].write(0);
         }
-        // transfer_fee_basis_points
+
         write_bytes(
             &mut instruction_data[68..70],
             &self.transfer_fee_basis_points.to_le_bytes(),
         );
-        // maximum_fee
+
         write_bytes(
             &mut instruction_data[70..78],
             &self.maximum_fee.to_le_bytes(),

programs/token-2022/src/instructions/extensions/transfer_fee/set_transfer_fee.rs

@@ -1,9 +1,6 @@
 use {
-    crate::{
-        instructions::{ExtensionDiscriminator, MAX_MULTISIG_SIGNERS},
-        UNINIT_ACCOUNT_REF, UNINIT_INSTRUCTION_ACCOUNT,
-    },
-    core::slice::from_raw_parts,
+    crate::instructions::{ExtensionDiscriminator, MAX_MULTISIG_SIGNERS},
+    core::{mem::MaybeUninit, slice::from_raw_parts},
     solana_account_view::AccountView,
     solana_address::Address,
     solana_instruction_view::{
@@ -34,7 +31,7 @@ pub struct SetTransferFee<'a, 'b, 'c> {
     pub authority: &'a AccountView,
 
     /// Multisignature owner/delegate.
-    pub signers: &'c [&'a AccountView],
+    pub multisig_signers: &'c [&'a AccountView],
 
     /// Amount of transfer collected as fees, expressed as basis points of
     /// the transfer amount
@@ -60,7 +57,7 @@ impl<'a, 'b, 'c> SetTransferFee<'a, 'b, 'c> {
         transfer_fee_basis_points: u16,
         maximum_fee: u64,
     ) -> Self {
-        Self::with_signers(
+        Self::with_multisig_signers(
             token_program,
             mint,
             authority,
@@ -73,18 +70,18 @@ impl<'a, 'b, 'c> SetTransferFee<'a, 'b, 'c> {
     /// Creates a new `SetTransferFee` instruction with a multisignature
     /// owner/delegate authority and signer accounts.
     #[inline(always)]
-    pub fn with_signers(
+    pub fn with_multisig_signers(
         token_program: &'b Address,
         mint: &'a AccountView,
         authority: &'a AccountView,
         transfer_fee_basis_points: u16,
         maximum_fee: u64,
-        signers: &'c [&'a AccountView],
+        multisig_signers: &'c [&'a AccountView],
     ) -> Self {
         Self {
             mint,
             authority,
-            signers,
+            multisig_signers,
             transfer_fee_basis_points,
             maximum_fee,
             token_program,
@@ -98,56 +95,43 @@ impl<'a, 'b, 'c> SetTransferFee<'a, 'b, 'c> {
 
     #[inline(always)]
     pub fn invoke_signed(&self, signers: &[Signer]) -> ProgramResult {
-        if self.signers.len() > MAX_MULTISIG_SIGNERS {
+        if self.multisig_signers.len() > MAX_MULTISIG_SIGNERS {
             return Err(ProgramError::InvalidArgument);
         }
 
-        let expected_accounts = 2 + self.signers.len();
+        let expected_accounts = 2 + self.multisig_signers.len();
 
         // Instruction accounts.
 
-        let mut instruction_accounts = [UNINIT_INSTRUCTION_ACCOUNT; 2 + MAX_MULTISIG_SIGNERS];
-
-        // SAFETY: The allocation is valid to the maximum number of accounts.
-        unsafe {
-            instruction_accounts
-                .get_unchecked_mut(0)
-                .write(InstructionAccount::writable(self.mint.address()));
-
-            instruction_accounts
-                .get_unchecked_mut(1)
-                .write(InstructionAccount::new(
-                    self.authority.address(),
-                    false,
-                    self.signers.is_empty(),
-                ));
-
-            for (instruction_account, signer) in instruction_accounts
-                .get_unchecked_mut(2..)
-                .iter_mut()
-                .zip(self.signers.iter())
-            {
-                instruction_account.write(InstructionAccount::readonly_signer(signer.address()));
-            }
+        let mut instruction_accounts =
+            [const { MaybeUninit::<InstructionAccount>::uninit() }; 2 + MAX_MULTISIG_SIGNERS];
+
+        instruction_accounts[0].write(InstructionAccount::writable(self.mint.address()));
+
+        instruction_accounts[1].write(InstructionAccount::new(
+            self.authority.address(),
+            false,
+            self.multisig_signers.is_empty(),
+        ));
+
+        for (instruction_account, signer) in instruction_accounts[2..]
+            .iter_mut()
+            .zip(self.multisig_signers.iter())
+        {
+            instruction_account.write(InstructionAccount::readonly_signer(signer.address()));
         }
 
         // Accounts.
 
-        let mut accounts = [UNINIT_ACCOUNT_REF; 2 + MAX_MULTISIG_SIGNERS];
+        let mut accounts =
+            [const { MaybeUninit::<&AccountView>::uninit() }; 2 + MAX_MULTISIG_SIGNERS];
 
-        // SAFETY: The allocation is valid to the maximum number of accounts.
-        unsafe {
-            accounts.get_unchecked_mut(0).write(self.mint);
+        accounts[0].write(self.mint);
 
-            accounts.get_unchecked_mut(1).write(self.authority);
+        accounts[1].write(self.authority);
 
-            for (account, signer) in accounts
-                .get_unchecked_mut(2..)
-                .iter_mut()
-                .zip(self.signers.iter())
-            {
-                account.write(*signer);
-            }
+        for (account, signer) in accounts[2..].iter_mut().zip(self.multisig_signers.iter()) {
+            account.write(*signer);
         }
 
         invoke_signed_with_bounds::<{ 2 + MAX_MULTISIG_SIGNERS }>(