small fix & add to rust-legacy

Author: Szegoo

clients/rust-legacy/src/token.rs

@@ -44,9 +44,9 @@ use {
                 self, ConfidentialTransferFeeAmount, ConfidentialTransferFeeConfig,
             },
             cpi_guard, default_account_state, group_member_pointer, group_pointer,
-            interest_bearing_mint, memo_transfer, metadata_pointer, pausable, scaled_ui_amount,
-            transfer_fee, transfer_hook, BaseStateWithExtensions, Extension, ExtensionType,
-            StateWithExtensionsOwned,
+            interest_bearing_mint, memo_transfer, metadata_pointer, pausable, permissioned_burn,
+            scaled_ui_amount, transfer_fee, transfer_hook, BaseStateWithExtensions, Extension,
+            ExtensionType, StateWithExtensionsOwned,
         },
         instruction,
         solana_zk_sdk::{
@@ -201,6 +201,9 @@ pub enum ExtensionInitializationParams {
     PausableConfig {
         authority: Pubkey,
     },
+    PermissionedBurnConfig {
+        authority: Pubkey,
+    },
     ConfidentialMintBurn {
         supply_elgamal_pubkey: PodElGamalPubkey,
         decryptable_supply: PodAeCiphertext,
@@ -226,6 +229,7 @@ impl ExtensionInitializationParams {
             Self::GroupMemberPointer { .. } => ExtensionType::GroupMemberPointer,
             Self::ScaledUiAmountConfig { .. } => ExtensionType::ScaledUiAmount,
             Self::PausableConfig { .. } => ExtensionType::Pausable,
+            Self::PermissionedBurnConfig { .. } => ExtensionType::PermissionedBurn,
             Self::ConfidentialMintBurn { .. } => ExtensionType::ConfidentialMintBurn,
         }
     }
@@ -348,6 +352,9 @@ impl ExtensionInitializationParams {
             Self::PausableConfig { authority } => {
                 pausable::instruction::initialize(token_program_id, mint, &authority)
             }
+            Self::PermissionedBurnConfig { authority } => {
+                permissioned_burn::instruction::initialize(token_program_id, mint, &authority)
+            }
             Self::ConfidentialMintBurn {
                 supply_elgamal_pubkey,
                 decryptable_supply,

clients/rust-legacy/tests/permissioned_burn.rs

@@ -0,0 +1,100 @@
+mod program_test;
+use {
+    program_test::{TestContext, TokenContext},
+    solana_program_error::ProgramError,
+    solana_program_test::tokio,
+    solana_sdk::{
+        instruction::InstructionError, pubkey::Pubkey, signature::Signer, signer::keypair::Keypair,
+        transaction::TransactionError, transport::TransportError,
+    },
+    spl_token_2022_interface::extension::BaseStateWithExtensions,
+    spl_token_2022_interface::{
+        error::TokenError, extension::permissioned_burn::PermissionedBurnConfig,
+    },
+    spl_token_client::token::{ExtensionInitializationParams, TokenError as TokenClientError},
+};
+
+#[tokio::test]
+async fn success_initialize() {
+    let authority = Pubkey::new_unique();
+    let mut context = TestContext::new().await;
+    context
+        .init_token_with_mint(vec![
+            ExtensionInitializationParams::PermissionedBurnConfig { authority },
+        ])
+        .await
+        .unwrap();
+    let TokenContext {
+        token,
+        mint_authority,
+        alice,
+        ..
+    } = context.token_context.unwrap();
+
+    let state = token.get_mint_info().await.unwrap();
+    let extension = state.get_extension::<PermissionedBurnConfig>().unwrap();
+    assert_eq!(Option::<Pubkey>::from(extension.authority), Some(authority));
+
+    // mint a token
+    let amount = 10;
+    token
+        .mint_to(
+            &alice.pubkey(),
+            &mint_authority.pubkey(),
+            amount,
+            &[&mint_authority],
+        )
+        .await
+        .unwrap();
+
+    // regular burn fails
+    let error = token
+        .burn(&alice.pubkey(), &alice.pubkey(), 1, &[&alice])
+        .await
+        .unwrap_err();
+    // assert_eq!(
+    //     error,
+    //     TokenClientError::Client(Box::new(TransportError::TransactionError(
+    //         TransactionError::InstructionError(
+    //             0,
+    //             InstructionError::Custom(ProgramError::MissingRequiredSignature as u32)
+    //         )
+    //     )))
+    // );
+
+    // // checked is ok
+    // token
+    //     .burn(&alice_account, &alice.pubkey(), 1, &[&alice])
+    //     .await
+    //     .unwrap();
+
+    // // burn too much is not ok
+    // let error = token
+    //     .burn(&alice_account, &alice.pubkey(), amount, &[&alice])
+    //     .await
+    //     .unwrap_err();
+    // assert_eq!(
+    //     error,
+    //     TokenClientError::Client(Box::new(TransportError::TransactionError(
+    //         TransactionError::InstructionError(
+    //             0,
+    //             InstructionError::Custom(TokenError::InsufficientFunds as u32)
+    //         )
+    //     )))
+    // );
+
+    // // wrong signer
+    // let error = token
+    //     .burn(&alice_account, &bob.pubkey(), 1, &[&bob])
+    //     .await
+    //     .unwrap_err();
+    // assert_eq!(
+    //     error,
+    //     TokenClientError::Client(Box::new(TransportError::TransactionError(
+    //         TransactionError::InstructionError(
+    //             0,
+    //             InstructionError::Custom(TokenError::OwnerMismatch as u32)
+    //         )
+    //     )))
+    // );
+}

program/src/processor.rs

@@ -1102,7 +1102,6 @@ impl Processor {
         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)?;
@@ -1816,7 +1815,7 @@ impl Processor {
                 PodTokenInstruction::PermissionedBurn => {
                     msg!("Instruction: PermissionedBurn");
                     let data = decode_instruction_data::<AmountData>(input)?;
-                    Self::process_burn(
+                    Self::process_permissioned_burn(
                         program_id,
                         accounts,
                         data.amount.into(),