token-2022: Nits of token-2022 extensions (#348)

Nits

Author: febo

programs/token-2022/src/instructions/extensions/default_account_state/initialize.rs

@@ -1,5 +1,5 @@
 use {
-    crate::instructions::extensions::ExtensionDiscriminator,
+    crate::{instructions::extensions::ExtensionDiscriminator, state::AccountState},
     solana_account_view::AccountView,
     solana_address::Address,
     solana_instruction_view::{cpi::invoke, InstructionAccount, InstructionView},
@@ -24,7 +24,7 @@ pub struct Initialize<'a, 'b> {
 
     /// The default account state in which new token accounts should be
     /// initialized.
-    pub state: u8,
+    pub state: AccountState,
 
     /// The token program.
     pub token_program: &'b Address,
@@ -42,7 +42,7 @@ impl Initialize<'_, '_> {
                 data: &[
                     ExtensionDiscriminator::DefaultAccountState as u8,
                     Self::DISCRIMINATOR,
-                    self.state,
+                    self.state as u8,
                 ],
             },
             &[self.mint],

programs/token-2022/src/instructions/extensions/default_account_state/update.rs

@@ -1,5 +1,8 @@
 use {
-    crate::instructions::{extensions::ExtensionDiscriminator, MAX_MULTISIG_SIGNERS},
+    crate::{
+        instructions::{extensions::ExtensionDiscriminator, MAX_MULTISIG_SIGNERS},
+        state::AccountState,
+    },
     core::{mem::MaybeUninit, slice},
     solana_account_view::AccountView,
     solana_address::Address,
@@ -31,101 +34,110 @@ pub struct Update<'a, 'b, 'c> {
     pub freeze_authority: &'a AccountView,
 
     /// The signer accounts if the authority is a multisig.
-    pub signers: &'c [&'a AccountView],
+    pub multisig_signers: &'c [&'a AccountView],
 
     /// The new account state in which new token accounts should be
     /// initialized.
-    pub state: u8,
+    pub state: AccountState,
 
     /// The token program.
     pub token_program: &'b Address,
 }
 
-impl Update<'_, '_, '_> {
+impl<'a, 'b, 'c> Update<'a, 'b, 'c> {
     pub const DISCRIMINATOR: u8 = 1;
 
+    /// Creates a new `Update` instruction with a single owner/delegate
+    /// authority.
+    #[inline(always)]
+    pub fn new(
+        token_program: &'b Address,
+        mint: &'a AccountView,
+        freeze_authority: &'a AccountView,
+        state: AccountState,
+    ) -> Self {
+        Self::with_multisig_signers(token_program, mint, freeze_authority, state, &[])
+    }
+
+    /// Creates a new `Update` instruction with a multisignature owner/delegate
+    /// authority and signer accounts.
+    #[inline(always)]
+    pub fn with_multisig_signers(
+        token_program: &'b Address,
+        mint: &'a AccountView,
+        freeze_authority: &'a AccountView,
+        state: AccountState,
+        multisig_signers: &'c [&'a AccountView],
+    ) -> Self {
+        Self {
+            mint,
+            freeze_authority,
+            multisig_signers,
+            state,
+            token_program,
+        }
+    }
+
     #[inline(always)]
     pub fn invoke(&self) -> ProgramResult {
         self.invoke_signed(&[])
     }
 
     #[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.
 
-        const UNINIT_INSTRUCTION_ACCOUNTS: MaybeUninit<InstructionAccount> =
-            MaybeUninit::<InstructionAccount>::uninit();
-        let mut instruction_accounts = [UNINIT_INSTRUCTION_ACCOUNTS; 2 + MAX_MULTISIG_SIGNERS];
-
-        // SAFETY: The allocation is valid to the maximum number of accounts.
-        unsafe {
-            // mint
-            instruction_accounts
-                .get_unchecked_mut(0)
-                .write(InstructionAccount::writable(self.mint.address()));
-
-            // freeze_authority
-            instruction_accounts
-                .get_unchecked_mut(1)
-                .write(InstructionAccount::new(
-                    self.freeze_authority.address(),
-                    false,
-                    self.signers.is_empty(),
-                ));
-
-            // signer accounts
-            for (account, signer) in instruction_accounts
-                .get_unchecked_mut(2..)
-                .iter_mut()
-                .zip(self.signers.iter())
-            {
-                account.write(InstructionAccount::readonly_signer(signer.address()));
-            }
-        }
+        let mut instruction_accounts =
+            [const { MaybeUninit::<InstructionAccount>::uninit() }; 2 + MAX_MULTISIG_SIGNERS];
 
-        let instruction = InstructionView {
-            program_id: self.token_program,
-            data: &[
-                ExtensionDiscriminator::DefaultAccountState as u8,
-                Self::DISCRIMINATOR,
-                self.state,
-            ],
-            accounts: unsafe {
-                slice::from_raw_parts(instruction_accounts.as_ptr() as _, expected_accounts)
-            },
-        };
+        instruction_accounts[0].write(InstructionAccount::writable(self.mint.address()));
+
+        instruction_accounts[1].write(InstructionAccount::new(
+            self.freeze_authority.address(),
+            false,
+            self.multisig_signers.is_empty(),
+        ));
+
+        for (account, signer) in instruction_accounts[2..]
+            .iter_mut()
+            .zip(self.multisig_signers.iter())
+        {
+            account.write(InstructionAccount::readonly_signer(signer.address()));
+        }
 
         // Accounts.
 
-        const UNINIT_ACCOUNT_VIEWS: MaybeUninit<&AccountView> = MaybeUninit::uninit();
-        let mut accounts = [UNINIT_ACCOUNT_VIEWS; 2 + MAX_MULTISIG_SIGNERS];
-
-        // SAFETY: The allocation is valid to the maximum number of accounts.
-        unsafe {
-            // mint
-            accounts.get_unchecked_mut(0).write(self.mint);
-
-            // freeze_authority
-            accounts.get_unchecked_mut(1).write(self.freeze_authority);
-
-            // signer accounts
-            for (account, signer) in accounts
-                .get_unchecked_mut(2..)
-                .iter_mut()
-                .zip(self.signers.iter())
-            {
-                account.write(signer);
-            }
+        let mut accounts =
+            [const { MaybeUninit::<&AccountView>::uninit() }; 2 + MAX_MULTISIG_SIGNERS];
+
+        accounts[0].write(self.mint);
+
+        accounts[1].write(self.freeze_authority);
+
+        for (account, signer) in accounts[2..].iter_mut().zip(self.multisig_signers.iter()) {
+            account.write(signer);
         }
 
         invoke_signed_with_bounds::<{ 2 + MAX_MULTISIG_SIGNERS }>(
-            &instruction,
+            &InstructionView {
+                program_id: self.token_program,
+                // SAFETY: instruction accounts has `expected_accounts` initialized.
+                accounts: unsafe {
+                    slice::from_raw_parts(instruction_accounts.as_ptr() as _, expected_accounts)
+                },
+                data: &[
+                    ExtensionDiscriminator::DefaultAccountState as u8,
+                    Self::DISCRIMINATOR,
+                    self.state as u8,
+                ],
+            },
+            // SAFETY: accounts has `expected_accounts` initialized.
             unsafe { slice::from_raw_parts(accounts.as_ptr() as _, expected_accounts) },
             signers,
         )

programs/token-2022/src/instructions/extensions/group_member_pointer/initialize.rs

@@ -42,15 +42,10 @@ impl Initialize<'_, '_> {
 
         let mut instruction_data = [UNINIT_BYTE; 66];
 
-        // discriminators
-        write_bytes(
-            &mut instruction_data[..2],
-            &[
-                ExtensionDiscriminator::GroupMemberPointer as u8,
-                Initialize::DISCRIMINATOR,
-            ],
-        );
-        // authority
+        instruction_data[0].write(ExtensionDiscriminator::GroupMemberPointer as u8);
+
+        instruction_data[1].write(Self::DISCRIMINATOR);
+
         write_bytes(
             &mut instruction_data[2..34],
             if let Some(authority) = self.authority {
@@ -59,7 +54,7 @@ impl Initialize<'_, '_> {
                 &[0u8; 32]
             },
         );
-        // member_address
+
         write_bytes(
             &mut instruction_data[34..66],
             if let Some(member_address) = self.member_address {
@@ -69,14 +64,16 @@ impl Initialize<'_, '_> {
             },
         );
 
-        // Instruction.
-
-        let instruction = InstructionView {
-            program_id: self.token_program,
-            accounts: &[InstructionAccount::writable(self.mint.address())],
-            data: unsafe { from_raw_parts(instruction_data.as_ptr() as _, instruction_data.len()) },
-        };
-
-        invoke(&instruction, &[self.mint])
+        invoke(
+            &InstructionView {
+                program_id: self.token_program,
+                accounts: &[InstructionAccount::writable(self.mint.address())],
+                // SAFETY: `instruction_data` is initialized.
+                data: unsafe {
+                    from_raw_parts(instruction_data.as_ptr() as _, instruction_data.len())
+                },
+            },
+            &[self.mint],
+        )
     }
 }