[token-2022, confidential-extension] Add confidential transfer authority type (#4025)

Author: samkim-crypto

token/cli/src/main.rs

@@ -753,6 +753,7 @@ async fn command_authorize(
         AuthorityType::WithheldWithdraw => "withdraw withheld authority",
         AuthorityType::InterestRate => "interest rate authority",
         AuthorityType::PermanentDelegate => "permanent delegate",
+        AuthorityType::ConfidentialTransferMint => "confidential transfer mint authority",
     };
 
     let (mint_pubkey, previous_authority) = if !config.sign_only {
@@ -800,6 +801,7 @@ async fn command_authorize(
                         ))
                     }
                 }
+                AuthorityType::ConfidentialTransferMint => unimplemented!(),
             }?;
 
             Ok((account, previous_authority))
@@ -833,7 +835,8 @@ async fn command_authorize(
                 | AuthorityType::TransferFeeConfig
                 | AuthorityType::WithheldWithdraw
                 | AuthorityType::InterestRate
-                | AuthorityType::PermanentDelegate => Err(format!(
+                | AuthorityType::PermanentDelegate
+                | AuthorityType::ConfidentialTransferMint => Err(format!(
                     "Authority type `{}` not supported for SPL Token accounts",
                     auth_str
                 )),

token/client/src/token.rs

@@ -1491,28 +1491,18 @@ where
     pub async fn confidential_transfer_update_mint<S: Signer>(
         &self,
         authority: &S,
-        new_authority: Option<&S>,
         auto_approve_new_account: bool,
         auditor_encryption_pubkey: Option<EncryptionPubkey>,
     ) -> TokenResult<T::Output> {
-        let mut signers = vec![authority];
-        let new_authority_pubkey = if let Some(new_authority) = new_authority {
-            signers.push(new_authority);
-            Some(new_authority.pubkey())
-        } else {
-            None
-        };
-
         self.process_ixs(
             &[confidential_transfer::instruction::update_mint(
                 &self.program_id,
                 &self.pubkey,
                 &authority.pubkey(),
-                new_authority_pubkey.as_ref(),
                 auto_approve_new_account,
                 auditor_encryption_pubkey,
             )?],
-            &signers,
+            &[authority],
         )
         .await
     }

token/program-2022-test/tests/confidential_transfer.rs

@@ -17,6 +17,7 @@ use {
             },
             BaseStateWithExtensions, ExtensionType,
         },
+        instruction,
         pod::EncryptionPubkey,
         solana_zk_token_sdk::{
             encryption::{auth_encryption::*, elgamal::*},
@@ -287,8 +288,6 @@ async fn check_withheld_amount_in_mint<T>(
 
 #[tokio::test]
 async fn ct_initialize_and_update_mint() {
-    let wrong_keypair = Keypair::new();
-
     let ConfidentialTransferMintWithKeypairs {
         ct_mint,
         ct_mint_authority,
@@ -317,87 +316,102 @@ async fn ct_initialize_and_update_mint() {
 
     // Change the authority
     let new_ct_mint_authority = Keypair::new();
-    let new_ct_mint = ConfidentialTransferMint {
-        authority: Some(new_ct_mint_authority.pubkey()).try_into().unwrap(),
-        ..ConfidentialTransferMint::default()
-    };
+    let wrong_keypair = Keypair::new();
 
     let err = token
-        .confidential_transfer_update_mint(
-            &wrong_keypair,
-            Some(&new_ct_mint_authority),
-            new_ct_mint.auto_approve_new_accounts.into(),
-            new_ct_mint
-                .withdraw_withheld_authority_encryption_pubkey
-                .into(),
+        .set_authority(
+            token.get_address(),
+            &wrong_keypair.pubkey(),
+            Some(&new_ct_mint_authority.pubkey()),
+            instruction::AuthorityType::ConfidentialTransferMint,
+            &[&wrong_keypair],
         )
         .await
         .unwrap_err();
+
     assert_eq!(
         err,
         TokenClientError::Client(Box::new(TransportError::TransactionError(
-            TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
+            TransactionError::InstructionError(
+                0,
+                InstructionError::Custom(TokenError::OwnerMismatch as u32)
+            )
         )))
     );
+
     token
+        .set_authority(
+            token.get_address(),
+            &ct_mint_authority.pubkey(),
+            Some(&new_ct_mint_authority.pubkey()),
+            instruction::AuthorityType::ConfidentialTransferMint,
+            &[&ct_mint_authority],
+        )
+        .await
+        .unwrap();
+
+    // New authority can change mint parameters while the old cannot
+    let new_auto_approve_new_accounts = false;
+    let new_auditor_encryption_pubkey = None;
+
+    let err = token
         .confidential_transfer_update_mint(
             &ct_mint_authority,
-            Some(&new_ct_mint_authority),
-            new_ct_mint.auto_approve_new_accounts.into(),
-            new_ct_mint
-                .withdraw_withheld_authority_encryption_pubkey
-                .into(),
+            new_auto_approve_new_accounts,
+            new_auditor_encryption_pubkey,
         )
         .await
-        .unwrap();
+        .unwrap_err();
 
-    let state = token.get_mint_info().await.unwrap();
-    let extension = state.get_extension::<ConfidentialTransferMint>().unwrap();
-    assert_eq!(extension.authority, new_ct_mint.authority);
     assert_eq!(
-        extension.auto_approve_new_accounts,
-        new_ct_mint.auto_approve_new_accounts
-    );
-    assert_eq!(
-        extension.auditor_encryption_pubkey,
-        new_ct_mint.auditor_encryption_pubkey
-    );
-    assert_eq!(
-        extension.withdraw_withheld_authority_encryption_pubkey,
-        ct_mint.withdraw_withheld_authority_encryption_pubkey,
+        err,
+        TokenClientError::Client(Box::new(TransportError::TransactionError(
+            TransactionError::InstructionError(
+                0,
+                InstructionError::Custom(TokenError::OwnerMismatch as u32)
+            )
+        )))
     );
-    assert_eq!(extension.withheld_amount, ct_mint.withheld_amount);
 
-    // Clear the authority
-    let new_ct_mint = ConfidentialTransferMint::default();
     token
         .confidential_transfer_update_mint(
             &new_ct_mint_authority,
-            None,
-            new_ct_mint.auto_approve_new_accounts.into(),
-            new_ct_mint
-                .withdraw_withheld_authority_encryption_pubkey
-                .into(),
+            new_auto_approve_new_accounts,
+            new_auditor_encryption_pubkey,
         )
         .await
         .unwrap();
 
     let state = token.get_mint_info().await.unwrap();
     let extension = state.get_extension::<ConfidentialTransferMint>().unwrap();
-    assert_eq!(extension.authority, new_ct_mint.authority);
     assert_eq!(
-        extension.auto_approve_new_accounts,
-        new_ct_mint.auto_approve_new_accounts
+        extension.authority,
+        Some(new_ct_mint_authority.pubkey()).try_into().unwrap()
     );
     assert_eq!(
-        extension.auditor_encryption_pubkey,
-        new_ct_mint.auditor_encryption_pubkey
+        extension.auto_approve_new_accounts,
+        new_auto_approve_new_accounts.try_into().unwrap(),
     );
     assert_eq!(
-        extension.withdraw_withheld_authority_encryption_pubkey,
-        ct_mint.withdraw_withheld_authority_encryption_pubkey,
+        extension.auditor_encryption_pubkey,
+        new_auditor_encryption_pubkey.try_into().unwrap(),
     );
-    assert_eq!(extension.withheld_amount, ct_mint.withheld_amount);
+
+    // Set new authority to None
+    token
+        .set_authority(
+            token.get_address(),
+            &new_ct_mint_authority.pubkey(),
+            None,
+            instruction::AuthorityType::ConfidentialTransferMint,
+            &[&new_ct_mint_authority],
+        )
+        .await
+        .unwrap();
+
+    let state = token.get_mint_info().await.unwrap();
+    let extension = state.get_extension::<ConfidentialTransferMint>().unwrap();
+    assert_eq!(extension.authority, None.try_into().unwrap());
 }
 
 #[tokio::test]

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

@@ -46,14 +46,15 @@ pub enum ConfidentialTransferInstruction {
 
     /// Updates the confidential transfer mint configuration for a mint.
     ///
+    /// Use `TokenInstruction::SetAuthority` to update the confidential transfer mint authority.
+    ///
     /// The `withdraw_withheld_authority_encryption_pubkey` and `withheld_amount` ciphertext are
     /// not updatable.
     ///
     /// Accounts expected by this instruction:
     ///
     ///   0. `[writable]` The SPL Token mint.
     ///   1. `[signer]` Confidential transfer mint authority.
-    ///   2. `[signer]` New confidential transfer mint authority.
     ///
     /// Data expected by this instruction:
     ///   `UpdateMintData`
@@ -576,21 +577,15 @@ pub fn update_mint(
     token_program_id: &Pubkey,
     mint: &Pubkey,
     authority: &Pubkey,
-    new_authority: Option<&Pubkey>,
     auto_approve_new_accounts: bool,
     auditor_encryption_pubkey: Option<EncryptionPubkey>,
 ) -> Result<Instruction, ProgramError> {
     check_program_account(token_program_id)?;
 
-    let mut accounts = vec![
+    let accounts = vec![
         AccountMeta::new(*mint, false),
         AccountMeta::new_readonly(*authority, true),
     ];
-    if let Some(new_authority) = new_authority {
-        accounts.push(AccountMeta::new_readonly(*new_authority, true));
-    } else {
-        accounts.push(AccountMeta::new_readonly(Pubkey::default(), false));
-    }
 
     Ok(encode_instruction(
         token_program_id,

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

@@ -87,7 +87,6 @@ fn process_update_mint(
     let account_info_iter = &mut accounts.iter();
     let mint_info = next_account_info(account_info_iter)?;
     let authority_info = next_account_info(account_info_iter)?;
-    let new_authority_info = next_account_info(account_info_iter)?;
 
     check_program_account(mint_info.owner)?;
     let mint_data = &mut mint_info.data.borrow_mut();
@@ -98,18 +97,14 @@ fn process_update_mint(
     let confidential_transfer_mint_authority =
         maybe_confidential_transfer_mint_authority.ok_or(TokenError::NoAuthorityExists)?;
 
-    if !authority_info.is_signer
-        || confidential_transfer_mint_authority != *authority_info.key
-        || (!new_authority_info.is_signer && *new_authority_info.key != Pubkey::default())
-    {
+    if !authority_info.is_signer {
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    if *new_authority_info.key == Pubkey::default() {
-        confidential_transfer_mint.authority = None.try_into()?;
-    } else {
-        confidential_transfer_mint.authority = Some(*new_authority_info.key).try_into()?;
+    if confidential_transfer_mint_authority != *authority_info.key {
+        return Err(TokenError::OwnerMismatch.into());
     }
+
     confidential_transfer_mint.auto_approve_new_accounts = auto_approve_new_account;
     confidential_transfer_mint.auditor_encryption_pubkey = *auditor_encryption_pubkey;
     Ok(())

token/program-2022/src/instruction.rs

@@ -1007,6 +1007,9 @@ pub enum AuthorityType {
     InterestRate,
     /// Authority to transfer or burn any tokens for a mint
     PermanentDelegate,
+    /// Authority to update confidential transfer mint and aprove accounts for confidential
+    /// transfers
+    ConfidentialTransferMint,
 }
 
 impl AuthorityType {
@@ -1021,6 +1024,7 @@ impl AuthorityType {
             AuthorityType::CloseMint => 6,
             AuthorityType::InterestRate => 7,
             AuthorityType::PermanentDelegate => 8,
+            AuthorityType::ConfidentialTransferMint => 9,
         }
     }
 
@@ -1035,6 +1039,7 @@ impl AuthorityType {
             6 => Ok(AuthorityType::CloseMint),
             7 => Ok(AuthorityType::InterestRate),
             8 => Ok(AuthorityType::PermanentDelegate),
+            9 => Ok(AuthorityType::ConfidentialTransferMint),
             _ => Err(TokenError::InvalidInstruction.into()),
         }
     }

token/program-2022/src/processor.rs

@@ -5,7 +5,7 @@ use {
         check_program_account, cmp_pubkeys,
         error::TokenError,
         extension::{
-            confidential_transfer::{self, ConfidentialTransferAccount},
+            confidential_transfer::{self, ConfidentialTransferAccount, ConfidentialTransferMint},
             cpi_guard::{self, in_cpi, CpiGuard},
             default_account_state::{self, DefaultAccountState},
             immutable_owner::ImmutableOwner,
@@ -741,6 +741,22 @@ impl Processor {
                     )?;
                     extension.delegate = new_authority.try_into()?;
                 }
+                AuthorityType::ConfidentialTransferMint => {
+                    let extension = mint.get_extension_mut::<ConfidentialTransferMint>()?;
+                    let maybe_confidential_transfer_mint_authority: Option<Pubkey> =
+                        extension.authority.into();
+                    let confidential_transfer_mint_authority =
+                        maybe_confidential_transfer_mint_authority
+                            .ok_or(TokenError::AuthorityTypeNotSupported)?;
+                    Self::validate_owner(
+                        program_id,
+                        &confidential_transfer_mint_authority,
+                        authority_info,
+                        authority_info_data_len,
+                        account_info_iter.as_slice(),
+                    )?;
+                    extension.authority = new_authority.try_into()?;
+                }
                 _ => {
                     return Err(TokenError::AuthorityTypeNotSupported.into());
                 }