add dpendency to spl-token-confidential-transfer-* crates

Author: samkim-crypto

Cargo.lock

@@ -1,11 +1,48 @@
-use solana_zk_sdk::encryption::pod::grouped_elgamal::{
-    PodGroupedElGamalCiphertext2Handles, PodGroupedElGamalCiphertext3Handles,
+use {
+    crate::errors::TokenProofExtractionError,
+    solana_zk_sdk::encryption::pod::{
+        elgamal::PodElGamalCiphertext,
+        grouped_elgamal::{
+            PodGroupedElGamalCiphertext2Handles, PodGroupedElGamalCiphertext3Handles,
+        },
+        pedersen::PodPedersenCommitment,
+    },
 };
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[repr(C)]
 pub struct PodTransferAmountCiphertext(pub(crate) PodGroupedElGamalCiphertext3Handles);
 
+impl PodTransferAmountCiphertext {
+    pub fn extract_commitment(&self) -> PodPedersenCommitment {
+        self.0.extract_commitment()
+    }
+
+    pub fn try_extract_ciphertext(
+        &self,
+        index: usize,
+    ) -> Result<PodElGamalCiphertext, TokenProofExtractionError> {
+        self.0
+            .try_extract_ciphertext(index)
+            .map_err(|_| TokenProofExtractionError::CiphertextExtraction)
+    }
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[repr(C)]
 pub struct PodFeeCiphertext(pub(crate) PodGroupedElGamalCiphertext2Handles);
+
+impl PodFeeCiphertext {
+    pub fn extract_commitment(&self) -> PodPedersenCommitment {
+        self.0.extract_commitment()
+    }
+
+    pub fn try_extract_ciphertext(
+        &self,
+        index: usize,
+    ) -> Result<PodElGamalCiphertext, TokenProofExtractionError> {
+        self.0
+            .try_extract_ciphertext(index)
+            .map_err(|_| TokenProofExtractionError::CiphertextExtraction)
+    }
+}

token/confidential-transfer/proof-extraction/src/encryption.rs

@@ -12,4 +12,6 @@ pub enum TokenProofExtractionError {
     FeeParametersMismatch,
     #[error("Curve arithmetic failed")]
     CurveArithmetic,
+    #[error("Ciphertext extraction failed")]
+    CiphertextExtraction,
 }

token/confidential-transfer/proof-extraction/src/errors.rs

@@ -27,6 +27,8 @@ solana-security-txt = "1.1.1"
 solana-zk-sdk = "2.0.3"
 spl-memo = { version = "5.0", path = "../../memo/program", features = [ "no-entrypoint" ] }
 spl-token = { version = "6.0",  path = "../program", features = ["no-entrypoint"] }
+spl-token-confidential-transfer-ciphertext-arithmetic = { version = "0.1.0", path = "../confidential-transfer/ciphertext-arithmetic" }
+spl-token-confidential-transfer-proof-extraction = { version = "0.1.0", path = "../confidential-transfer/proof-extraction" }
 spl-token-group-interface = { version = "0.3.0", path = "../../token-group/interface" }
 spl-token-metadata-interface = { version = "0.4.0", path = "../../token-metadata/interface" }
 spl-transfer-hook-interface = { version = "0.7.0", path = "../transfer-hook/interface" }
@@ -37,6 +39,9 @@ serde = { version = "1.0.207", optional = true }
 serde_with = { version = "3.9.0", optional = true }
 base64 = { version = "0.22.1", optional = true }
 
+[target.'cfg(not(target_os = "solana"))'.dependencies]
+spl-token-confidential-transfer-proof-generation = { version = "0.1.0", path = "../confidential-transfer/proof-generation"}
+
 [dev-dependencies]
 lazy_static = "1.5.0"
 proptest = "1.5"

token/program-2022/Cargo.toml

@@ -1,12 +1,15 @@
 //! Error types
 
+#[cfg(not(target_os = "solana"))]
+use spl_token_confidential_transfer_proof_generation::errors::TokenProofGenerationError;
 use {
     num_derive::FromPrimitive,
     solana_program::{
         decode_error::DecodeError,
         msg,
         program_error::{PrintProgramError, ProgramError},
     },
+    spl_token_confidential_transfer_proof_extraction::errors::TokenProofExtractionError,
     thiserror::Error,
 };
 
@@ -243,6 +246,18 @@ pub enum TokenError {
     /// Ciphertext arithmetic failed
     #[error("Ciphertext arithmetic failed")]
     CiphertextArithmeticFailed,
+    /// Pedersen commitments did not match
+    #[error("Pedersen commitment mismatch")]
+    PedersenCommitmentMismatch,
+    /// Range proof length did not match
+    #[error("Range proof length mismatch")]
+    RangeProofLengthMismatch,
+    /// Illegal transfer amount bit length
+    #[error("Illegal transfer amount bit length")]
+    IllegalBitLength,
+    /// Fee calculation failed
+    #[error("Fee calculation failed")]
+    FeeCalculation,
 }
 impl From<TokenError> for ProgramError {
     fn from(e: TokenError) -> Self {
@@ -418,6 +433,49 @@ impl PrintProgramError for TokenError {
             TokenError::CiphertextArithmeticFailed => {
                 msg!("Ciphertext arithmetic failed")
             }
+            TokenError::PedersenCommitmentMismatch => {
+                msg!("Pedersen commitments did not match")
+            }
+            TokenError::RangeProofLengthMismatch => {
+                msg!("Range proof lengths did not match")
+            }
+            TokenError::IllegalBitLength => {
+                msg!("Illegal transfer amount bit length")
+            }
+            TokenError::FeeCalculation => {
+                msg!("Transfer fee calculation failed")
+            }
+        }
+    }
+}
+
+#[cfg(not(target_os = "solana"))]
+impl From<TokenProofGenerationError> for TokenError {
+    fn from(e: TokenProofGenerationError) -> Self {
+        match e {
+            TokenProofGenerationError::ProofGeneration(_) => TokenError::ProofGeneration,
+            TokenProofGenerationError::NotEnoughFunds => TokenError::InsufficientFunds,
+            TokenProofGenerationError::IllegalAmountBitLength => TokenError::IllegalBitLength,
+            TokenProofGenerationError::FeeCalculation => TokenError::FeeCalculation,
+        }
+    }
+}
+
+impl From<TokenProofExtractionError> for TokenError {
+    fn from(e: TokenProofExtractionError) -> Self {
+        match e {
+            TokenProofExtractionError::ElGamalPubkeyMismatch => {
+                TokenError::ConfidentialTransferElGamalPubkeyMismatch
+            }
+            TokenProofExtractionError::PedersenCommitmentMismatch => {
+                TokenError::PedersenCommitmentMismatch
+            }
+            TokenProofExtractionError::RangeProofLengthMismatch => {
+                TokenError::RangeProofLengthMismatch
+            }
+            TokenProofExtractionError::FeeParametersMismatch => TokenError::FeeParametersMismatch,
+            TokenProofExtractionError::CurveArithmetic => TokenError::CiphertextArithmeticFailed,
+            TokenProofExtractionError::CiphertextExtraction => TokenError::MalformedCiphertext,
         }
     }
 }

token/program-2022/src/error.rs

@@ -2,25 +2,22 @@ use {
     crate::{
         error::TokenError,
         extension::confidential_transfer::{
-            split_proof_generation::transfer_split_proof_data, ConfidentialTransferAccount,
-            DecryptableBalance, EncryptedBalance, PENDING_BALANCE_LO_BIT_LENGTH,
+            ConfidentialTransferAccount, DecryptableBalance, EncryptedBalance,
+            PENDING_BALANCE_LO_BIT_LENGTH,
         },
     },
     bytemuck::{Pod, Zeroable},
-    solana_zk_token_sdk::{
+    solana_zk_sdk::{
         encryption::{
             auth_encryption::{AeCiphertext, AeKey},
             elgamal::{ElGamalKeypair, ElGamalPubkey, ElGamalSecretKey},
         },
-        instruction::{
-            transfer::{FeeParameters, TransferData, TransferWithFeeData},
-            withdraw::WithdrawData,
-            zero_balance::ZeroBalanceProofData,
-            BatchedGroupedCiphertext3HandlesValidityProofData, BatchedRangeProofU128Data,
-            CiphertextCommitmentEqualityProofData,
-        },
+        zk_elgamal_proof_program::proof_data::ZeroCiphertextProofData,
     },
     spl_pod::primitives::PodU64,
+    spl_token_confidential_transfer_proof_generation::transfer::{
+        transfer_split_proof_data, TransferProofData,
+    },
 };
 
 /// Confidential transfer extension information needed to construct an
@@ -44,13 +41,13 @@ impl EmptyAccountAccountInfo {
     pub fn generate_proof_data(
         &self,
         elgamal_keypair: &ElGamalKeypair,
-    ) -> Result<ZeroBalanceProofData, TokenError> {
+    ) -> Result<ZeroCiphertextProofData, TokenError> {
         let available_balance = self
             .available_balance
             .try_into()
             .map_err(|_| TokenError::MalformedCiphertext)?;
 
-        ZeroBalanceProofData::new(elgamal_keypair, &available_balance)
+        ZeroCiphertextProofData::new(elgamal_keypair, &available_balance)
             .map_err(|_| TokenError::ProofGeneration)
     }
 }
@@ -240,37 +237,6 @@ impl TransferAccountInfo {
             .ok_or(TokenError::AccountDecryption)
     }
 
-    /// Create a transfer proof data.
-    pub fn generate_transfer_proof_data(
-        &self,
-        transfer_amount: u64,
-        elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-    ) -> Result<TransferData, TokenError> {
-        let current_source_available_balance = self
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        let current_source_decrypted_available_balance =
-            self.decrypted_available_balance(aes_key)?;
-
-        let default_auditor_pubkey = ElGamalPubkey::default();
-        let auditor_elgamal_pubkey = auditor_elgamal_pubkey.unwrap_or(&default_auditor_pubkey);
-
-        TransferData::new(
-            transfer_amount,
-            (
-                current_source_decrypted_available_balance,
-                &current_source_available_balance,
-            ),
-            elgamal_keypair,
-            (destination_elgamal_pubkey, auditor_elgamal_pubkey),
-        )
-        .map_err(|_| TokenError::ProofGeneration)
-    }
-
     /// Create a transfer proof data that is split into equality, ciphertext
     /// validity, and range proofs.
     pub fn generate_split_transfer_proof_data(
@@ -280,14 +246,7 @@ impl TransferAccountInfo {
         aes_key: &AeKey,
         destination_elgamal_pubkey: &ElGamalPubkey,
         auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-    ) -> Result<
-        (
-            CiphertextCommitmentEqualityProofData,
-            BatchedGroupedCiphertext3HandlesValidityProofData,
-            BatchedRangeProofU128Data,
-        ),
-        TokenError,
-    > {
+    ) -> Result<TransferProofData, TokenError> {
         let current_available_balance = self
             .available_balance
             .try_into()
@@ -306,48 +265,7 @@ impl TransferAccountInfo {
             destination_elgamal_pubkey,
             auditor_elgamal_pubkey,
         )
-    }
-
-    /// Create a transfer with fee proof data
-    #[allow(clippy::too_many_arguments)]
-    pub fn generate_transfer_with_fee_proof_data(
-        &self,
-        transfer_amount: u64,
-        elgamal_keypair: &ElGamalKeypair,
-        aes_key: &AeKey,
-        destination_elgamal_pubkey: &ElGamalPubkey,
-        auditor_elgamal_pubkey: Option<&ElGamalPubkey>,
-        withdraw_withheld_authority_elgamal_pubkey: &ElGamalPubkey,
-        fee_rate_basis_points: u16,
-        maximum_fee: u64,
-    ) -> Result<TransferWithFeeData, TokenError> {
-        let current_source_available_balance = self
-            .available_balance
-            .try_into()
-            .map_err(|_| TokenError::MalformedCiphertext)?;
-        let current_source_decrypted_available_balance =
-            self.decrypted_available_balance(aes_key)?;
-
-        let default_auditor_pubkey = ElGamalPubkey::default();
-        let auditor_elgamal_pubkey = auditor_elgamal_pubkey.unwrap_or(&default_auditor_pubkey);
-
-        let fee_parameters = FeeParameters {
-            fee_rate_basis_points,
-            maximum_fee,
-        };
-
-        TransferWithFeeData::new(
-            transfer_amount,
-            (
-                current_source_decrypted_available_balance,
-                &current_source_available_balance,
-            ),
-            elgamal_keypair,
-            (destination_elgamal_pubkey, auditor_elgamal_pubkey),
-            fee_parameters,
-            withdraw_withheld_authority_elgamal_pubkey,
-        )
-        .map_err(|_| TokenError::ProofGeneration)
+        .map_err(|e| -> TokenError { e.into() })
     }
 
     /// Update the decryptable available balance.

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

@@ -33,23 +33,10 @@ pub mod processor;
 /// Transfer Extension
 pub mod verify_proof;
 
-/// Helper functions to generate split zero-knowledge proofs for confidential
-/// transfers in the Confidential Transfer Extension.
-///
-/// The logic in this submodule should belong to the `solana-zk-token-sdk` and
-/// will be removed with the next upgrade to the Solana program.
-#[cfg(not(target_os = "solana"))]
-pub mod split_proof_generation;
-
 /// Confidential Transfer Extension account information needed for instructions
 #[cfg(not(target_os = "solana"))]
 pub mod account_info;
 
-/// Ciphertext extraction and proof related helper logic
-///
-/// This submodule should be removed with the next upgrade to the Solana program
-pub mod ciphertext_extraction;
-
 /// ElGamal ciphertext containing an account balance
 pub type EncryptedBalance = PodElGamalCiphertext;
 /// Authenticated encryption containing an account balance