new PermissionedBurn instruction

Author: Szegoo

interface/src/extension/permissioned_burn/mod.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use {
     crate::extension::{Extension, ExtensionType},
     bytemuck::{Pod, Zeroable},
-    spl_pod::optional_keys::OptionalNonZeroPubkey
+    spl_pod::optional_keys::OptionalNonZeroPubkey,
 };
 
 /// Instruction types for the permissioned burn extension

program/src/pod_instruction.rs

@@ -115,7 +115,9 @@ pub(crate) enum PodTokenInstruction {
     ConfidentialMintBurnExtension,
     ScaledUiAmountExtension,
     PausableExtension,
+    // 45
     PermissionedBurnExtension,
+    PermissionedBurn,
 }
 
 fn unpack_pubkey_option(input: &[u8]) -> Result<PodCOption<Pubkey>, ProgramError> {

program/src/processor.rs

@@ -1086,6 +1086,57 @@ impl Processor {
         accounts: &[AccountInfo],
         amount: u64,
         instruction_variant: InstructionVariant,
+    ) -> ProgramResult {
+        Self::do_process_burn(program_id, accounts, amount, instruction_variant)
+    }
+
+    /// Processes a [`PermissionedBurn`](enum.TokenInstruction.html) instruction.
+    pub(crate) fn process_permissioned_burn(
+        program_id: &Pubkey,
+        accounts: &[AccountInfo],
+        amount: u64,
+        instruction_variant: InstructionVariant,
+    ) -> ProgramResult {
+        let account_info_iter = &mut accounts.iter();
+
+        let source_account_info = next_account_info(account_info_iter)?;
+        let mint_info = next_account_info(account_info_iter)?;
+        let authority_info = next_account_info(account_info_iter)?;
+        let authority_info_data_len = authority_info.data_len();
+
+        let mut mint_data = mint_info.data.borrow_mut();
+        let mint = PodStateWithExtensionsMut::<PodMint>::unpack(&mut mint_data)?;
+
+        if let Ok(ext) = mint.get_extension::<PermissionedBurnConfig>() {
+            // Pull the required extra signer from the accounts
+            let approver_ai = next_account_info(account_info_iter)?;
+
+            if !approver_ai.is_signer {
+                return Err(ProgramError::MissingRequiredSignature);
+            }
+
+            let maybe_burn_authority: Option<Pubkey> = ext.authority.into();
+            if Some(*approver_ai.key) != maybe_burn_authority {
+                return Err(ProgramError::InvalidAccountData);
+            }
+        }
+
+        let remaining_after = account_info_iter.as_slice();
+        let mut forward = vec![
+            source_account_info.clone(),
+            mint_info.clone(),
+            authority_info.clone(),
+        ];
+        forward.extend_from_slice(remaining_after);
+
+        Self::do_process_burn(program_id, &forward, amount, instruction_variant)
+    }
+
+    fn do_process_burn(
+        program_id: &Pubkey,
+        accounts: &[AccountInfo],
+        amount: u64,
+        instruction_variant: InstructionVariant,
     ) -> ProgramResult {
         let account_info_iter = &mut accounts.iter();
 
@@ -1123,19 +1174,6 @@ impl Processor {
                 return Err(TokenError::MintPaused.into());
             }
         }
-        if let Ok(ext) = mint.get_extension::<PermissionedBurnConfig>() {
-            // Pull the required extra signer from the accounts
-            let approver_ai = next_account_info(account_info_iter)?;
-
-            if !approver_ai.is_signer {
-                return Err(ProgramError::MissingRequiredSignature);
-            }
-
-            let maybe_burn_authority: Option<Pubkey> = ext.authority.into();
-            if Some(*approver_ai.key) != maybe_burn_authority {
-                return Err(ProgramError::InvalidAccountData);
-            }
-        }
 
         let maybe_permanent_delegate = get_permanent_delegate(&mint);
 
@@ -1775,6 +1813,16 @@ impl Processor {
                         InstructionVariant::Unchecked,
                     )
                 }
+                PodTokenInstruction::PermissionedBurn => {
+                    msg!("Instruction: PermissionedBurn");
+                    let data = decode_instruction_data::<AmountData>(input)?;
+                    Self::process_burn(
+                        program_id,
+                        accounts,
+                        data.amount.into(),
+                        InstructionVariant::Unchecked,
+                    )
+                }
                 PodTokenInstruction::CloseAccount => {
                     msg!("Instruction: CloseAccount");
                     Self::process_close_account(program_id, accounts)