implement authority type

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},
-    solana_pubkey::Pubkey,
+    spl_pod::optional_keys::OptionalNonZeroPubkey
 };
 
 /// Instruction types for the permissioned burn extension
@@ -16,7 +16,7 @@ pub mod instruction;
 #[repr(C)]
 pub struct PermissionedBurnConfig {
     /// Authority that is required for burning
-    pub authority: Pubkey,
+    pub authority: OptionalNonZeroPubkey,
 }
 
 impl Extension for PermissionedBurnConfig {

interface/src/instruction.rs

@@ -1160,6 +1160,8 @@ pub enum AuthorityType {
     ScaledUiAmount,
     /// Authority to pause or resume minting / transferring / burning
     Pause,
+    /// Authority to perform a permissioned token burn
+    PermissionedBurn,
 }
 
 impl AuthorityType {
@@ -1182,6 +1184,7 @@ impl AuthorityType {
             AuthorityType::GroupMemberPointer => 14,
             AuthorityType::ScaledUiAmount => 15,
             AuthorityType::Pause => 16,
+            AuthorityType::PermissionedBurn => 17,
         }
     }
 
@@ -1205,6 +1208,7 @@ impl AuthorityType {
             14 => Ok(AuthorityType::GroupMemberPointer),
             15 => Ok(AuthorityType::ScaledUiAmount),
             16 => Ok(AuthorityType::Pause),
+            17 => Ok(AuthorityType::PermissionedBurn),
             _ => Err(TokenError::InvalidInstruction.into()),
         }
     }

program/src/extension/permissioned_burn/processor.rs

@@ -28,7 +28,7 @@ fn process_initialize(
     let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(&mut mint_data)?;
 
     let extension = mint.init_extension::<PermissionedBurnConfig>(true)?;
-    extension.authority = *authority;
+    extension.authority = Some(*authority).try_into()?;
 
     Ok(())
 }

program/src/processor.rs

@@ -967,6 +967,19 @@ impl Processor {
                     )?;
                     extension.authority = new_authority.try_into()?;
                 }
+                AuthorityType::PermissionedBurn => {
+                    let extension = mint.get_extension_mut::<PermissionedBurnConfig>()?;
+                    let maybe_authority: Option<Pubkey> = extension.authority.into();
+                    let authority = maybe_authority.ok_or(TokenError::AuthorityTypeNotSupported)?;
+                    Self::validate_owner(
+                        program_id,
+                        &authority,
+                        authority_info,
+                        authority_info_data_len,
+                        account_info_iter.as_slice(),
+                    )?;
+                    extension.authority = new_authority.try_into()?;
+                }
                 _ => {
                     return Err(TokenError::AuthorityTypeNotSupported.into());
                 }
@@ -1118,7 +1131,8 @@ impl Processor {
                 return Err(ProgramError::MissingRequiredSignature);
             }
 
-            if *approver_ai.key != ext.authority {
+            let maybe_burn_authority: Option<Pubkey> = ext.authority.into();
+            if Some(*approver_ai.key) != maybe_burn_authority {
                 return Err(ProgramError::InvalidAccountData);
             }
         }