Initial ConfidentialTransferInstruction::EmptyAccount test

Author: mvines

token/client/src/token.rs

@@ -19,10 +19,14 @@ use spl_token_2022::{
         StateWithExtensionsOwned,
     },
     instruction, native_mint,
-    solana_zk_token_sdk::encryption::{auth_encryption::*, elgamal::*},
+    solana_zk_token_sdk::{
+        encryption::{auth_encryption::*, elgamal::*},
+        errors::ProofError,
+    },
     state::{Account, AccountState, Mint},
 };
 use std::{
+    convert::TryInto,
     fmt, io,
     sync::{Arc, RwLock},
     time::{Duration, Instant},
@@ -41,6 +45,8 @@ pub enum TokenError {
     AccountInvalidOwner,
     #[error("invalid account mint")]
     AccountInvalidMint,
+    #[error("proof error: {0}")]
+    Proof(ProofError),
 }
 impl PartialEq for TokenError {
     fn eq(&self, other: &Self) -> bool {
@@ -968,7 +974,7 @@ where
     }
 
     /// Approves a token account for confidential transfers
-    pub async fn confidential_transfer_approve_token_account<S2: Signer>(
+    pub async fn confidential_transfer_approve_account<S2: Signer>(
         &self,
         token_account: &Pubkey,
         authority: &S2,
@@ -985,6 +991,36 @@ where
         .await
     }
 
+    /// Prepare a token account for closing
+    pub async fn confidential_transfer_empty_account<S2: Signer>(
+        &self,
+        token_account: &Pubkey,
+        authority: &S2,
+        elgamal_keypair: &ElGamalKeypair,
+    ) -> TokenResult<T::Output> {
+        let state = self.get_account_info(&token_account).await.unwrap();
+        let extension =
+            state.get_extension::<confidential_transfer::ConfidentialTransferAccount>()?;
+
+        let proof_data = confidential_transfer::instruction::CloseAccountData::new(
+            &elgamal_keypair,
+            &extension.available_balance.try_into().unwrap(),
+        )
+        .map_err(TokenError::Proof)?;
+
+        self.process_ixs(
+            &confidential_transfer::instruction::empty_account(
+                &self.program_id,
+                token_account,
+                &authority.pubkey(),
+                &[],
+                &proof_data,
+            )?,
+            &[authority],
+        )
+        .await
+    }
+
     /// Enable confidential transfer `Deposit` and `Transfer` instructions for a token account
     pub async fn confidential_transfer_enable_balance_credits<S2: Signer>(
         &self,

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

@@ -176,7 +176,7 @@ async fn ct_configure_token_account() {
     );
 
     token
-        .confidential_transfer_approve_token_account(&alice_token_account, &ct_mint_authority)
+        .confidential_transfer_approve_account(&alice_token_account, &ct_mint_authority)
         .await
         .unwrap();
 
@@ -235,3 +235,37 @@ async fn ct_enable_disable_balance_credits() {
         .unwrap();
     assert!(bool::from(&extension.allow_balance_credits));
 }
+
+#[tokio::test]
+async fn ct_new_account_is_empty() {
+    let ConfidentialTransferMintWithKeypairs { ct_mint, .. } =
+        ConfidentialTransferMintWithKeypairs::new();
+    let mut context = TestContext::new().await;
+    context
+        .init_token_with_mint(vec![
+            ExtensionInitializationParams::ConfidentialTransferMint { ct_mint },
+        ])
+        .await
+        .unwrap();
+
+    let TokenContext { token, alice, .. } = context.token_context.unwrap();
+
+    let alice_token_account = token
+        .create_auxiliary_token_account_with_extension_space(
+            &alice,
+            &alice.pubkey(),
+            vec![ExtensionType::ConfidentialTransferAccount],
+        )
+        .await
+        .unwrap();
+
+    let (alice_elgamal_keypair, _) = token
+        .confidential_transfer_configure_token_account_and_keypairs(&alice_token_account, &alice)
+        .await
+        .unwrap();
+
+    token
+        .confidential_transfer_empty_account(&alice_token_account, &alice, &alice_elgamal_keypair)
+        .await
+        .unwrap();
+}