token-2022: Add init mint close authority (#2744)

Author: joncinque

token/program-2022/src/error.rs

@@ -102,6 +102,9 @@ pub enum TokenError {
     /// Available balance mismatch
     #[error("Available balance mismatch")]
     ConfidentialTransferAvailableBalanceMismatch,
+    /// Mint has non-zero supply. Burn all tokens before closing the mint.
+    #[error("Mint has non-zero supply. Burn all tokens before closing the mint")]
+    MintHasSupply,
 }
 impl From<TokenError> for ProgramError {
     fn from(e: TokenError) -> Self {

token/program-2022/src/extension/mod.rs

@@ -193,6 +193,61 @@ fn type_and_tlv_indices<S: BaseState>(
     }
 }
 
+fn get_extension<S: BaseState, V: Extension>(tlv_data: &[u8]) -> Result<&V, ProgramError> {
+    if V::TYPE.get_account_type() != S::ACCOUNT_TYPE {
+        return Err(ProgramError::InvalidAccountData);
+    }
+    let TlvIndices {
+        type_start: _,
+        length_start,
+        value_start,
+    } = get_extension_indices::<V>(tlv_data, false)?;
+    let length = pod_from_bytes::<Length>(&tlv_data[length_start..value_start])?;
+    let value_end = value_start.saturating_add(usize::from(*length));
+    pod_from_bytes::<V>(&tlv_data[value_start..value_end])
+}
+
+/// Encapsulates owned immutable base state data (mint or account) with possible extensions
+#[derive(Debug, PartialEq)]
+pub struct StateWithExtensionsOwned<S: BaseState> {
+    /// Unpacked base data
+    pub base: S,
+    /// Raw TLV data, deserialized on demand
+    tlv_data: Vec<u8>,
+}
+impl<S: BaseState> StateWithExtensionsOwned<S> {
+    /// Unpack base state, leaving the extension data as a slice
+    ///
+    /// Fails if the base state is not initialized.
+    pub fn unpack(mut input: Vec<u8>) -> Result<Self, ProgramError> {
+        check_min_len_and_not_multisig(&input, S::LEN)?;
+        let mut rest = input.split_off(S::LEN);
+        let base = S::unpack(&input)?;
+        if let Some((account_type_index, tlv_start_index)) = type_and_tlv_indices::<S>(&rest)? {
+            let account_type = AccountType::try_from(rest[account_type_index])
+                .map_err(|_| ProgramError::InvalidAccountData)?;
+            check_account_type::<S>(account_type)?;
+            let tlv_data = rest.split_off(tlv_start_index);
+            Ok(Self { base, tlv_data })
+        } else {
+            Ok(Self {
+                base,
+                tlv_data: vec![],
+            })
+        }
+    }
+
+    /// Unpack a portion of the TLV data as the desired type
+    pub fn get_extension<V: Extension>(&self) -> Result<&V, ProgramError> {
+        get_extension::<S, V>(&self.tlv_data)
+    }
+
+    /// Iterates through the TLV entries, returning only the types
+    pub fn get_extension_types(&self) -> Result<Vec<ExtensionType>, ProgramError> {
+        get_extension_types(&self.tlv_data)
+    }
+}
+
 /// Encapsulates immutable base state data (mint or account) with possible extensions
 #[derive(Debug, PartialEq)]
 pub struct StateWithExtensions<'data, S: BaseState> {
@@ -227,17 +282,7 @@ impl<'data, S: BaseState> StateWithExtensions<'data, S> {
 
     /// Unpack a portion of the TLV data as the desired type
     pub fn get_extension<V: Extension>(&self) -> Result<&V, ProgramError> {
-        if V::TYPE.get_account_type() != S::ACCOUNT_TYPE {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        let TlvIndices {
-            type_start: _,
-            length_start,
-            value_start,
-        } = get_extension_indices::<V>(self.tlv_data, false)?;
-        let length = pod_from_bytes::<Length>(&self.tlv_data[length_start..value_start])?;
-        let value_end = value_start.saturating_add(usize::from(*length));
-        pod_from_bytes::<V>(&self.tlv_data[value_start..value_end])
+        get_extension::<S, V>(self.tlv_data)
     }
 
     /// Iterates through the TLV entries, returning only the types

token/program-2022/src/instruction.rs

@@ -1418,6 +1418,20 @@ pub fn get_account_data_size(
     })
 }
 
+/// Creates an `InitializeMintCloseAuthority` instruction
+pub fn initialize_mint_close_authority(
+    token_program_id: &Pubkey,
+    mint_pubkey: &Pubkey,
+    close_authority: COption<Pubkey>,
+) -> Result<Instruction, ProgramError> {
+    check_program_account(token_program_id)?;
+    Ok(Instruction {
+        program_id: *token_program_id,
+        accounts: vec![AccountMeta::new(*mint_pubkey, false)],
+        data: TokenInstruction::InitializeMintCloseAuthority { close_authority }.pack(),
+    })
+}
+
 /// Utility function that checks index is between MIN_SIGNERS and MAX_SIGNERS
 pub fn is_valid_signer_index(index: usize) -> bool {
     (MIN_SIGNERS..=MAX_SIGNERS).contains(&index)

token/program-2022/src/processor.rs

@@ -5,6 +5,7 @@ use crate::{
     error::TokenError,
     extension::{
         confidential_transfer::{self, ConfidentialTransferAccount},
+        mint_close_authority::MintCloseAuthority,
         transfer_fee, ExtensionType, StateWithExtensions, StateWithExtensionsMut,
     },
     instruction::{is_valid_signer_index, AuthorityType, TokenInstruction, MAX_SIGNERS},
@@ -23,6 +24,7 @@ use solana_program::{
     pubkey::Pubkey,
     sysvar::{rent::Rent, Sysvar},
 };
+use std::convert::TryInto;
 
 /// Program state handler.
 pub struct Processor {}
@@ -37,27 +39,33 @@ impl Processor {
         let account_info_iter = &mut accounts.iter();
         let mint_info = next_account_info(account_info_iter)?;
         let mint_data_len = mint_info.data_len();
+        let mut mint_data = mint_info.data.borrow_mut();
         let rent = if rent_sysvar_account {
             Rent::from_account_info(next_account_info(account_info_iter)?)?
         } else {
             Rent::get()?
         };
 
-        let mut mint = Mint::unpack_unchecked(&mint_info.data.borrow())?;
-        if mint.is_initialized {
-            return Err(TokenError::AlreadyInUse.into());
-        }
-
         if !rent.is_exempt(mint_info.lamports(), mint_data_len) {
             return Err(TokenError::NotRentExempt.into());
         }
 
-        mint.mint_authority = COption::Some(mint_authority);
-        mint.decimals = decimals;
-        mint.is_initialized = true;
-        mint.freeze_authority = freeze_authority;
+        let mut mint = StateWithExtensionsMut::<Mint>::unpack_uninitialized(&mut mint_data)?;
+        if mint.base.is_initialized {
+            return Err(TokenError::AlreadyInUse.into());
+        }
 
-        Mint::pack(mint, &mut mint_info.data.borrow_mut())?;
+        let extension_types = mint.get_extension_types()?;
+        if ExtensionType::get_account_len::<Mint>(&extension_types) != mint_data_len {
+            return Err(ProgramError::InvalidAccountData);
+        }
+
+        mint.base.mint_authority = COption::Some(mint_authority);
+        mint.base.decimals = decimals;
+        mint.base.is_initialized = true;
+        mint.base.freeze_authority = freeze_authority;
+        mint.pack_base();
+        mint.init_account_type()?;
 
         Ok(())
     }
@@ -763,10 +771,18 @@ impl Processor {
 
     /// Processes an [InitializeMintCloseAuthority](enum.TokenInstruction.html) instruction
     pub fn process_initialize_mint_close_authority(
-        _accounts: &[AccountInfo],
-        _close_authority: COption<Pubkey>,
+        accounts: &[AccountInfo],
+        close_authority: COption<Pubkey>,
     ) -> ProgramResult {
-        unimplemented!();
+        let account_info_iter = &mut accounts.iter();
+        let mint_account_info = next_account_info(account_info_iter)?;
+
+        let mut mint_data = mint_account_info.data.borrow_mut();
+        let mut mint = StateWithExtensionsMut::<Mint>::unpack_uninitialized(&mut mint_data)?;
+        let extension = mint.init_extension::<MintCloseAuthority>()?;
+        extension.close_authority = close_authority.try_into()?;
+
+        Ok(())
     }
 
     /// Processes a [GetAccountDataSize](enum.TokenInstruction.html) instruction
@@ -1027,6 +1043,9 @@ impl PrintProgramError for TokenError {
             TokenError::ConfidentialTransferAvailableBalanceMismatch => {
                 msg!("Error: Available balance mismatch")
             }
+            TokenError::MintHasSupply => {
+                msg!("Error: Mint has non-zero supply. Burn all tokens before closing the mint")
+            }
         }
     }
 }