Add confidential transfers test

Cargo.toml

@@ -77,6 +77,7 @@ spl-token-2022 = { version = "9.0.0", features = ["no-entrypoint"] }
 spl-token-wrap = { path = "program", features = ["no-entrypoint"] }
 spl-transfer-hook-interface = "0.10.0"
 tempfile = "3.20.0"
+test-case = "3.3.1"
 test-transfer-hook = { path = "program/tests/programs/test-transfer-hook", features = ["no-entrypoint"] }
 thiserror = "2.0.12"
 tokio = { version = "1.45.1", features = ["full"] }

program/Cargo.toml

@@ -40,8 +40,8 @@ spl-token-2022 = { workspace = true }
 mollusk-svm = { workspace = true }
 mollusk-svm-programs-token = { workspace = true }
 solana-account = { workspace = true }
-solana-sdk-ids = { workspace = true }
 spl-tlv-account-resolution = { workspace = true }
+test-case = { workspace = true }
 test-transfer-hook = { workspace = true }
 
 [lib]

program/tests/helpers/extensions.rs

@@ -3,6 +3,7 @@ use {
     spl_pod::{optional_keys::OptionalNonZeroPubkey, primitives::PodU64},
     spl_token_2022::{
         extension::{
+            confidential_transfer::ConfidentialTransferMint,
             immutable_owner::ImmutableOwner,
             mint_close_authority::MintCloseAuthority,
             transfer_fee::{TransferFee, TransferFeeAmount, TransferFeeConfig},
@@ -15,6 +16,7 @@ use {
 
 #[derive(Clone, Debug)]
 pub enum MintExtension {
+    ConfidentialTransfer,
     TransferHook,
     TransferFeeConfig,
     MintCloseAuthority(Pubkey),
@@ -26,6 +28,7 @@ impl MintExtension {
             MintExtension::TransferHook => ExtensionType::TransferHook,
             MintExtension::TransferFeeConfig => ExtensionType::TransferFeeConfig,
             MintExtension::MintCloseAuthority(_) => ExtensionType::MintCloseAuthority,
+            MintExtension::ConfidentialTransfer => ExtensionType::ConfidentialTransferMint,
         }
     }
 }
@@ -71,6 +74,11 @@ pub fn init_mint_extensions(
                 extension.close_authority =
                     OptionalNonZeroPubkey::try_from(Some(*authority)).unwrap();
             }
+            MintExtension::ConfidentialTransfer => {
+                state
+                    .init_extension::<ConfidentialTransferMint>(false)
+                    .unwrap();
+            }
         }
     }
 }

program/tests/test_create_mint.rs

@@ -2,6 +2,8 @@ use {
     crate::helpers::{
         common::{TokenProgram, DEFAULT_MINT_DECIMALS},
         create_mint_builder::CreateMintBuilder,
+        extensions::MintExtension,
+        mint_builder::MintBuilder,
     },
     mollusk_svm::result::Check,
     solana_account::Account,
@@ -20,6 +22,7 @@ use {
         error::TokenWrapError, get_wrapped_mint_address, get_wrapped_mint_authority,
         state::Backpointer,
     },
+    test_case::test_case,
 };
 
 pub mod helpers;
@@ -275,3 +278,48 @@ fn test_successful_spl_token_2022_to_spl_token() {
         bytemuck::from_bytes::<Backpointer>(&result.wrapped_backpointer.account.data[..]);
     assert_eq!(backpointer.unwrapped_mint, unwrapped_mint_address);
 }
+
+#[test_case(MintExtension::ConfidentialTransfer)]
+#[test_case(MintExtension::TransferHook)]
+#[test_case(MintExtension::TransferFeeConfig)]
+#[test_case(MintExtension::MintCloseAuthority(Pubkey::new_unique()))]
+fn test_create_mint_from_extended_mint(extension: MintExtension) {
+    let unwrapped_mint = MintBuilder::new()
+        .token_program(TokenProgram::SplToken2022)
+        .with_extension(extension)
+        .build();
+
+    let result = CreateMintBuilder::default()
+        .unwrapped_mint_account(unwrapped_mint.account)
+        .unwrapped_mint_addr(unwrapped_mint.key)
+        .unwrapped_token_program(TokenProgram::SplToken2022)
+        .wrapped_token_program(TokenProgram::SplToken)
+        .execute();
+
+    assert_eq!(result.wrapped_mint.account.owner, spl_token::id());
+    let wrapped_mint_data =
+        PodStateWithExtensions::<PodMint>::unpack(&result.wrapped_mint.account.data)
+            .unwrap()
+            .base;
+
+    assert_eq!(wrapped_mint_data.decimals, DEFAULT_MINT_DECIMALS);
+    let expected_mint_authority = get_wrapped_mint_authority(&result.wrapped_mint.key);
+    assert_eq!(
+        wrapped_mint_data
+            .mint_authority
+            .ok_or(ProgramError::InvalidAccountData)
+            .unwrap(),
+        expected_mint_authority,
+    );
+    assert_eq!(wrapped_mint_data.supply, PodU64::from(0));
+    assert_eq!(wrapped_mint_data.is_initialized, PodBool::from_bool(true));
+    assert_eq!(wrapped_mint_data.freeze_authority, PodCOption::none());
+
+    assert_eq!(
+        result.wrapped_backpointer.account.owner,
+        spl_token_wrap::id()
+    );
+    let backpointer =
+        bytemuck::from_bytes::<Backpointer>(&result.wrapped_backpointer.account.data[..]);
+    assert_eq!(backpointer.unwrapped_mint, unwrapped_mint.key);
+}

program/tests/test_unwrap.rs

@@ -5,7 +5,9 @@ use {
             TokenProgram, DEFAULT_MINT_SUPPLY,
         },
         create_mint_builder::CreateMintBuilder,
-        extensions::MintExtension::{TransferFeeConfig as TransferFeeConfigExt, TransferHook},
+        extensions::MintExtension::{
+            ConfidentialTransfer, TransferFeeConfig as TransferFeeConfigExt, TransferHook,
+        },
         mint_builder::MintBuilder,
         token_account_builder::TokenAccountBuilder,
         unwrap_builder::{UnwrapBuilder, UnwrapResult},
@@ -461,3 +463,35 @@ fn unwrap_with_transfer_fee() {
             .unwrap();
     assert_eq!(u64::from(escrow.base.amount), 0);
 }
+
+#[test]
+fn test_unwrap_with_confidential_transfer_mint() {
+    let source_starting_amount = 50_000;
+    let recipient_starting_amount = 25_000;
+    let escrow_starting_amount = 100_000;
+    let unwrap_amount = 30_000;
+
+    let unwrapped_mint = MintBuilder::new()
+        .token_program(TokenProgram::SplToken2022)
+        .with_extension(ConfidentialTransfer)
+        .build();
+
+    let unwrap_result = UnwrapBuilder::default()
+        .unwrapped_token_program(TokenProgram::SplToken2022)
+        .wrapped_token_program(TokenProgram::SplToken)
+        .unwrapped_mint(unwrapped_mint)
+        .wrapped_token_starting_amount(source_starting_amount)
+        .recipient_starting_amount(recipient_starting_amount)
+        .escrow_starting_amount(escrow_starting_amount)
+        .unwrap_amount(unwrap_amount)
+        .check(Check::success())
+        .execute();
+
+    assert_unwrap_result(
+        source_starting_amount,
+        recipient_starting_amount,
+        escrow_starting_amount,
+        unwrap_amount,
+        &unwrap_result,
+    );
+}

program/tests/test_wrap.rs

@@ -5,7 +5,9 @@ use {
             TokenProgram, DEFAULT_MINT_SUPPLY,
         },
         create_mint_builder::CreateMintBuilder,
-        extensions::MintExtension::{TransferFeeConfig as MintTransferFeeConfig, TransferHook},
+        extensions::MintExtension::{
+            ConfidentialTransfer, TransferFeeConfig as MintTransferFeeConfig, TransferHook,
+        },
         mint_builder::MintBuilder,
         token_account_builder::TokenAccountBuilder,
         wrap_builder::{WrapBuilder, WrapResult},
@@ -406,3 +408,24 @@ fn wrap_with_transfer_fee() {
         fee
     );
 }
+
+#[test]
+fn test_wrap_with_confidential_transfer_mint() {
+    let starting_amount = 50_000;
+    let wrap_amount = 12_555;
+
+    let unwrapped_mint = MintBuilder::new()
+        .token_program(TokenProgram::SplToken2022)
+        .with_extension(ConfidentialTransfer)
+        .build();
+
+    let wrap_result = WrapBuilder::default()
+        .unwrapped_token_program(TokenProgram::SplToken2022)
+        .wrapped_token_program(TokenProgram::SplToken2022)
+        .recipient_starting_amount(starting_amount)
+        .wrap_amount(wrap_amount)
+        .unwrapped_mint(unwrapped_mint)
+        .execute();
+
+    assert_wrap_result(starting_amount, wrap_amount, &wrap_result);
+}