Confidential mint burn extension: Token program changes

token/program-2022/src/extension/confidential_mint_burn/instruction.rs

@@ -17,7 +17,6 @@ use {
         pubkey::Pubkey,
     },
     solana_zk_sdk::encryption::pod::{auth_encryption::PodAeCiphertext, elgamal::PodElGamalPubkey},
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
 };
 #[cfg(not(target_os = "solana"))]
 use {
@@ -187,9 +186,6 @@ pub enum ConfidentialMintBurnInstruction {
 #[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
 #[repr(C)]
 pub struct InitializeMintData {
-    /// Authority used to modify the `ConfidentialMintBurn` mint
-    /// configuration and mint new tokens
-    pub authority: OptionalNonZeroPubkey,
     /// The ElGamal pubkey used to encrypt the confidential supply
     #[cfg_attr(feature = "serde-traits", serde(with = "elgamalpubkey_fromstr"))]
     pub supply_elgamal_pubkey: PodElGamalPubkey,
@@ -278,21 +274,18 @@ pub struct BurnInstructionData {
 pub fn initialize_mint(
     token_program_id: &Pubkey,
     mint: &Pubkey,
-    authority: &Pubkey,
     supply_elgamal_pubkey: PodElGamalPubkey,
     decryptable_supply: PodAeCiphertext,
 ) -> Result<Instruction, ProgramError> {
     check_program_account(token_program_id)?;
     let accounts = vec![AccountMeta::new(*mint, false)];
 
-    let authority = Some(*authority);
     Ok(encode_instruction(
         token_program_id,
         accounts,
         TokenInstruction::ConfidentialMintBurnExtension,
         ConfidentialMintBurnInstruction::InitializeMint,
         &InitializeMintData {
-            authority: authority.try_into()?,
             supply_elgamal_pubkey,
             decryptable_supply,
         },

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

@@ -5,7 +5,6 @@ use {
         auth_encryption::PodAeCiphertext,
         elgamal::{PodElGamalCiphertext, PodElGamalPubkey},
     },
-    spl_pod::optional_keys::OptionalNonZeroPubkey,
 };
 
 /// Maximum bit length of any mint or burn amount
@@ -33,9 +32,6 @@ pub mod account_info;
 #[derive(Clone, Copy, Debug, Default, PartialEq, Pod, Zeroable)]
 #[repr(C)]
 pub struct ConfidentialMintBurn {
-    /// Authority to modify the `ConfidentialMintBurnMint` configuration and to
-    /// mint new confidential tokens
-    pub authority: OptionalNonZeroPubkey,
     /// The confidential supply of the mint (encrypted by `encryption_pubkey`)
     pub confidential_supply: PodElGamalCiphertext,
     /// The decryptable confidential supply of the mint

token/program-2022/src/extension/confidential_mint_burn/processor.rs

@@ -34,6 +34,7 @@ use {
             CiphertextCiphertextEqualityProofContext, CiphertextCiphertextEqualityProofData,
         },
     },
+    spl_pod::optional_keys::OptionalNonZeroPubkey,
     spl_token_confidential_transfer_proof_extraction::instruction::verify_and_extract_context,
 };
 
@@ -48,7 +49,6 @@ fn process_initialize_mint(accounts: &[AccountInfo], data: &InitializeMintData)
     let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack_uninitialized(mint_data)?;
     let mint_burn_extension = mint.init_extension::<ConfidentialMintBurn>(true)?;
 
-    mint_burn_extension.authority = data.authority;
     mint_burn_extension.supply_elgamal_pubkey = data.supply_elgamal_pubkey;
     mint_burn_extension.decryptable_supply = data.decryptable_supply;
 
@@ -68,6 +68,7 @@ fn process_rotate_supply_elgamal_pubkey(
     check_program_account(mint_info.owner)?;
     let mint_data = &mut mint_info.data.borrow_mut();
     let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(mint_data)?;
+    let mint_authority = mint.base.mint_authority;
     let mint_burn_extension = mint.get_extension_mut::<ConfidentialMintBurn>()?;
 
     let proof_context = verify_and_extract_context::<
@@ -95,8 +96,8 @@ fn process_rotate_supply_elgamal_pubkey(
     let authority_info = next_account_info(account_info_iter)?;
     let authority_info_data_len = authority_info.data_len();
 
-    let authority = Option::<Pubkey>::from(mint_burn_extension.authority)
-        .ok_or(TokenError::NoAuthorityExists)?;
+    let authority = OptionalNonZeroPubkey::try_from(mint_authority)?;
+    let authority = Option::<Pubkey>::from(authority).ok_or(TokenError::NoAuthorityExists)?;
 
     Processor::validate_owner(
         program_id,
@@ -126,10 +127,11 @@ fn process_update_decryptable_supply(
     check_program_account(mint_info.owner)?;
     let mint_data = &mut mint_info.data.borrow_mut();
     let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(mint_data)?;
+    let mint_authority = mint.base.mint_authority;
     let mint_burn_extension = mint.get_extension_mut::<ConfidentialMintBurn>()?;
 
-    let authority = Option::<Pubkey>::from(mint_burn_extension.authority)
-        .ok_or(TokenError::NoAuthorityExists)?;
+    let authority = OptionalNonZeroPubkey::try_from(mint_authority)?;
+    let authority = Option::<Pubkey>::from(authority).ok_or(TokenError::NoAuthorityExists)?;
 
     Processor::validate_owner(
         program_id,
@@ -158,6 +160,7 @@ fn process_confidential_mint(
     check_program_account(mint_info.owner)?;
     let mint_data = &mut mint_info.data.borrow_mut();
     let mut mint = PodStateWithExtensionsMut::<PodMint>::unpack(mint_data)?;
+    let mint_authority = mint.base.mint_authority;
 
     let auditor_elgamal_pubkey = mint
         .get_extension::<ConfidentialTransferMint>()?
@@ -178,8 +181,8 @@ fn process_confidential_mint(
     let authority_info = next_account_info(account_info_iter)?;
     let authority_info_data_len = authority_info.data_len();
 
-    let authority = Option::<Pubkey>::from(mint_burn_extension.authority)
-        .ok_or(TokenError::NoAuthorityExists)?;
+    let authority = OptionalNonZeroPubkey::try_from(mint_authority)?;
+    let authority = Option::<Pubkey>::from(authority).ok_or(TokenError::NoAuthorityExists)?;
 
     Processor::validate_owner(
         program_id,
@@ -314,19 +317,19 @@ fn process_confidential_burn(
         return Err(TokenError::ConfidentialTransferElGamalPubkeyMismatch.into());
     }
 
-    let source_transfer_amount_lo = &proof_context
+    let burn_amount_lo = &proof_context
         .burn_amount_ciphertext_lo
         .try_extract_ciphertext(0)
         .map_err(|_| ProgramError::InvalidAccountData)?;
-    let source_transfer_amount_hi = &proof_context
+    let burn_amount_hi = &proof_context
         .burn_amount_ciphertext_hi
         .try_extract_ciphertext(0)
         .map_err(|_| ProgramError::InvalidAccountData)?;
 
     let new_source_available_balance = ciphertext_arithmetic::subtract_with_lo_hi(
         &confidential_transfer_account.available_balance,
-        source_transfer_amount_lo,
-        source_transfer_amount_hi,
+        burn_amount_lo,
+        burn_amount_hi,
     )
     .ok_or(TokenError::CiphertextArithmeticFailed)?;
 

token/program-2022/src/processor.rs

@@ -905,20 +905,6 @@ impl Processor {
                     )?;
                     extension.authority = new_authority.try_into()?;
                 }
-                AuthorityType::MintConfidentialTokens => {
-                    let extension = mint.get_extension_mut::<ConfidentialMintBurn>()?;
-                    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());
                 }