cleanup

Author: abcalphabet

token/cli/src/clap_app.rs

@@ -2848,11 +2848,20 @@ pub fn app<'a, 'b>(
                         .value_name("CONFIDENTIAL_SUPPLY_KEYPAIR")
                         .takes_value(true)
                         .help(
-                            "The confidential supply encryption keypair used to decrypt the supply. \
+                            "The confidential supply encryption keypair used to decrypt ElGamalCiphertext supply. \
                               Either the authority or the confidential-supply-keypair have \
                               to be specified in order for the supply to be decrypted."
                         )
                 )
+                .arg(
+                    Arg::with_name("confidential_supply_aes_key")
+                        .long("confidential-supply-aes-key")
+                        .value_name("CONFIDENTIAL_SUPPLY_AES_KEY")
+                        .takes_value(true)
+                        .help(
+                            "The aes key used to decrypt the decryptable portion of the confidential supply."
+                        )
+                )
                 .nonce_args(true)
         )
         .subcommand(
@@ -2888,6 +2897,16 @@ pub fn app<'a, 'b>(
                             "The current confidential supply encryption keypair."
                         )
                 )
+                .arg(
+                    Arg::with_name("supply_aes_key")
+                        .long("supply-aes-key")
+                        .value_name("SUPPLY_AES_KEY")
+                        .takes_value(true)
+                        .required(true)
+                        .help(
+                            "The aes key to decrypt the decryptable confidential supply."
+                        )
+                )
                 .arg(
                     Arg::with_name("new_supply_keypair")
                         .long("new-supply-keypair")

token/cli/src/command.rs

@@ -4828,10 +4828,18 @@ pub async fn process_command<'a>(
 
                 ElGamalKeypair::new_from_signer(&*auth_signer, b"").unwrap()
             };
+            let aes_key = if arg_matches.is_present("confidential_supply_aes_key") {
+                aes_key_of(arg_matches, "confidential_supply_aes_key").unwrap()
+            } else {
+                let (auth_signer, _auth) =
+                    config.signer_or_default(arg_matches, "authority", &mut wallet_manager);
+
+                AeKey::new_from_signer(&*auth_signer, b"").unwrap()
+            };
 
             let token_cl = token_client_from_config(config, &token, None)?;
             let supply = token_cl
-                .confidential_supply(&elgamal_keypair)
+                .confidential_supply(&elgamal_keypair, &aes_key)
                 .await
                 .map_err(|e| format!("Could not fetch confidential supply for {token}: {e}",))?;
 
@@ -4843,6 +4851,7 @@ pub async fn process_command<'a>(
                 .unwrap();
             let cur_elgamal_keypair =
                 elgamal_keypair_of(arg_matches, "current_supply_keypair").unwrap();
+            let supply_aes_key = aes_key_of(arg_matches, "supply_aes_key").unwrap();
             let new_elgamal_keypair =
                 elgamal_keypair_of(arg_matches, "new_supply_keypair").unwrap();
             let (auth_signer, auth) =
@@ -4855,8 +4864,9 @@ pub async fn process_command<'a>(
                         .rotate_supply_elgamal(
                             &auth,
                             &cur_elgamal_keypair,
+                            &supply_aes_key,
                             &new_elgamal_keypair,
-                            &[auth_signer],
+                            &[&auth_signer],
                         )
                         .await?,
                     false,

token/cli/src/encryption_keypair.rs

@@ -3,12 +3,9 @@
 //! NOTE: this module should be remoeved in the next Solana upgrade.
 
 use {
-    base64::{prelude::BASE64_STANDARD, Engine},
-    clap::ArgMatches,
-    spl_token_2022::solana_zk_sdk::encryption::{
-        elgamal::{ElGamalKeypair, ElGamalPubkey},
-        pod::elgamal::PodElGamalPubkey,
-    },
+    base64::{prelude::BASE64_STANDARD, Engine}, clap::ArgMatches, solana_sdk::signer::EncodableKey, spl_token_2022::solana_zk_sdk::encryption::{
+        auth_encryption::AeKey, elgamal::{ElGamalKeypair, ElGamalPubkey}, pod::elgamal::PodElGamalPubkey
+    }
 };
 
 const ELGAMAL_PUBKEY_MAX_BASE64_LEN: usize = 44;
@@ -68,6 +65,14 @@ pub(crate) fn elgamal_keypair_of(
     ElGamalKeypair::read_json_file(path).map_err(|e| e.to_string())
 }
 
+pub(crate) fn aes_key_of(
+    matches: &ArgMatches,
+    name: &str,
+) -> Result<AeKey, String> {
+    let path = matches.value_of(name).unwrap();
+    AeKey::read_from_file(path).map_err(|e| e.to_string())
+}
+
 fn elgamal_pubkey_from_str(s: &str) -> Option<PodElGamalPubkey> {
     if s.len() > ELGAMAL_PUBKEY_MAX_BASE64_LEN {
         return None;

token/client/src/token.rs

@@ -59,7 +59,7 @@ use {
             encryption::{
                 auth_encryption::{AeCiphertext, AeKey},
                 elgamal::{ElGamalCiphertext, ElGamalKeypair, ElGamalPubkey, ElGamalSecretKey},
-                pod::elgamal::PodElGamalPubkey,
+                pod::{auth_encryption::PodAeCiphertext, elgamal::PodElGamalPubkey},
             },
             zk_elgamal_proof_program::{
                 self,
@@ -3598,23 +3598,46 @@ where
     pub async fn confidential_supply(
         &self,
         supply_elgamal_keypair: &ElGamalKeypair,
+        supply_aes_key: &AeKey,
     ) -> Result<u64, TokenError> {
         let mint = self.get_mint_info().await?;
         let confidential_mint_burn_ext = mint.get_extension::<ConfidentialMintBurn>()?;
 
-        // Currently only correctly displays supplies until u32::MAX,
-        // the supply ciphertext will still be correct after, but it
-        // can't be decrypted here until a corresponding decryption
-        // method is added to the solana-zk-token-sdk
-        Ok(supply_elgamal_keypair
+        let current_decyptable_supply =
+            if confidential_mint_burn_ext.decryptable_supply != PodAeCiphertext::default() {
+                // decrypt the current supply
+                let decryptable_supply: AeCiphertext = confidential_mint_burn_ext
+                    .decryptable_supply
+                    .try_into()
+                    .map_err(|_| TokenError::AccountDecryption)?;
+                decryptable_supply
+                    .decrypt(supply_aes_key)
+                    .ok_or(TokenError::AccountDecryption)?
+            } else {
+                0
+            };
+
+        // get the difference between the supply ciphertext and the decryptable supply
+        // explanation see https://github.com/solana-labs/solana-program-library/pull/6881#issuecomment-2385579058
+        let decryptable_supply_ciphertext = supply_elgamal_keypair
+            .pubkey()
+            .encrypt(current_decyptable_supply);
+        let current_supply: ElGamalCiphertext = confidential_mint_burn_ext
+                .confidential_supply
+                .try_into()
+                .map_err(|_| TokenError::AccountDecryption)?;
+        let ct_decryptable_to_current_diff = decryptable_supply_ciphertext - current_supply;
+        let decryptable_to_current_diff = supply_elgamal_keypair
             .secret()
-            .decrypt_u32(
-                &TryInto::<ElGamalCiphertext>::try_into(
-                    confidential_mint_burn_ext.confidential_supply,
-                )
-                .map_err(|_| TokenError::Program(ProgramError::InvalidAccountData))?,
-            )
-            .unwrap_or_default())
+            .decrypt_u32(&ct_decryptable_to_current_diff)
+            .ok_or(TokenError::AccountDecryption)?;
+
+        // compute the total supply
+        current_decyptable_supply
+            .checked_sub(decryptable_to_current_diff)
+            .ok_or(TokenError::TokenProgramError(String::from(
+                "Confidential supply underflow",
+            )))
     }
 
     pub async fn supply_elgamal_pubkey(&self) -> TokenResult<Option<ElGamalPubkey>> {
@@ -3633,6 +3656,7 @@ where
         &self,
         authority: &Pubkey,
         supply_elgamal_keypair: &ElGamalKeypair,
+        supply_aes_key: &AeKey,
         new_supply_elgamal_keypair: &ElGamalKeypair,
         signing_keypairs: &S,
     ) -> TokenResult<T::Output> {
@@ -3641,7 +3665,7 @@ where
 
         let mint = self.get_mint_info().await?;
         let extension_state = mint.get_extension::<ConfidentialMintBurn>()?;
-        let current_supply = self.confidential_supply(supply_elgamal_keypair).await?;
+        let current_supply = self.confidential_supply(supply_elgamal_keypair, supply_aes_key).await?;
 
         self.process_ixs(
             &confidential_mint_burn::instruction::rotate_supply_elgamal(

token/confidential-transfer/proof-generation/src/mint.rs

@@ -104,7 +104,7 @@ pub fn mint_split_proof_data(
 
     // compute the new supply
     let new_supply = current_decyptable_supply
-        .checked_add(decryptable_to_current_diff)
+        .checked_sub(decryptable_to_current_diff)
         .ok_or(TokenProofGenerationError::IllegalAmountBitLength)?
         .checked_add(mint_amount)
         .ok_or(TokenProofGenerationError::IllegalAmountBitLength)?;

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

@@ -16,7 +16,6 @@ use {
             },
             BaseStateWithExtensions,
         },
-        proof::ProofLocation,
         solana_zk_sdk::encryption::{
             auth_encryption::AeKey, elgamal::*, pod::elgamal::PodElGamalPubkey,
         },
@@ -112,7 +111,7 @@ async fn test_confidential_mint() {
 
     assert_eq!(
         token
-            .confidential_supply(&auditor_elgamal_keypair,)
+            .confidential_supply(&auditor_elgamal_keypair, &supply_aes_key)
             .await
             .unwrap(),
         MINT_AMOUNT
@@ -159,7 +158,7 @@ async fn test_confidential_burn() {
 
     assert_eq!(
         token
-            .confidential_supply(&auditor_elgamal_keypair,)
+            .confidential_supply(&auditor_elgamal_keypair, &supply_aes_key)
             .await
             .unwrap(),
         MINT_AMOUNT
@@ -313,7 +312,7 @@ async fn test_confidential_burn() {
 
     assert_eq!(
         token
-            .confidential_supply(&auditor_elgamal_keypair,)
+            .confidential_supply(&auditor_elgamal_keypair, &supply_aes_key)
             .await
             .unwrap(),
         MINT_AMOUNT - BURN_AMOUNT,
@@ -360,7 +359,7 @@ async fn test_rotate_supply_elgamal() {
 
     assert_eq!(
         token
-            .confidential_supply(&auditor_elgamal_keypair,)
+            .confidential_supply(&auditor_elgamal_keypair, &supply_aes_key)
             .await
             .unwrap(),
         MINT_AMOUNT
@@ -371,6 +370,7 @@ async fn test_rotate_supply_elgamal() {
         .rotate_supply_elgamal(
             &authority.pubkey(),
             &auditor_elgamal_keypair,
+            &supply_aes_key,
             &new_supply_elgamal_keypair,
             &[authority],
         )
@@ -379,7 +379,7 @@ async fn test_rotate_supply_elgamal() {
 
     assert_eq!(
         token
-            .confidential_supply(&new_supply_elgamal_keypair)
+            .confidential_supply(&new_supply_elgamal_keypair, &supply_aes_key)
             .await
             .unwrap(),
         MINT_AMOUNT