fix amount

Author: ananas-block

program-libs/ctoken-types/src/state/solana_ctoken.rs

@@ -40,6 +40,38 @@ pub struct CompressedToken {
     pub extensions: Option<Vec<ExtensionStruct>>,
 }
 
+impl CompressedToken {
+    /// Extract amount directly from account data slice using hardcoded offset
+    /// CompressedToken layout: mint (32 bytes) + owner (32 bytes) + amount (8 bytes)
+    pub fn amount_from_slice(data: &[u8]) -> Result<u64, ZeroCopyError> {
+        const AMOUNT_OFFSET: usize = 64; // 32 (mint) + 32 (owner)
+        
+        if data.len() < AMOUNT_OFFSET + 8 {
+            return Err(ZeroCopyError::Size);
+        }
+        
+        let amount_bytes = &data[AMOUNT_OFFSET..AMOUNT_OFFSET + 8];
+        let amount = u64::from_le_bytes(
+            amount_bytes
+                .try_into()
+                .map_err(|_| ZeroCopyError::Size)?
+        );
+        
+        Ok(amount)
+    }
+    
+    /// Extract amount from an AccountInfo
+    #[cfg(feature = "solana")]
+    pub fn amount_from_account_info(
+        account_info: &solana_account_info::AccountInfo,
+    ) -> Result<u64, ZeroCopyError> {
+        let data = account_info
+            .try_borrow_data()
+            .map_err(|_| ZeroCopyError::Size)?;
+        Self::amount_from_slice(&data)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone, AnchorSerialize, AnchorDeserialize)]
 pub struct CompressedTokenMeta {
     /// The mint associated with this account

sdk-libs/compressed-token-sdk/src/error.rs

@@ -2,6 +2,7 @@ use light_compressed_token_types::error::LightTokenSdkTypeError;
 use light_ctoken_types::CTokenError;
 use light_sdk::error::LightSdkError;
 use light_sdk_types::error::LightSdkTypesError;
+use light_zero_copy::errors::ZeroCopyError;
 use solana_program_error::ProgramError;
 use thiserror::Error;
 
@@ -51,6 +52,8 @@ pub enum TokenSdkError {
     LightSdkError(#[from] LightSdkError),
     #[error(transparent)]
     LightSdkTypesError(#[from] LightSdkTypesError),
+    #[error(transparent)]
+    ZeroCopyError(#[from] ZeroCopyError),
 }
 #[cfg(feature = "anchor")]
 impl From<TokenSdkError> for anchor_lang::prelude::ProgramError {
@@ -89,6 +92,7 @@ impl From<TokenSdkError> for u32 {
             TokenSdkError::CTokenError(e) => e.into(),
             TokenSdkError::LightSdkTypesError(e) => e.into(),
             TokenSdkError::LightSdkError(e) => e.into(),
+            TokenSdkError::ZeroCopyError(e) => e.into(),
         }
     }
 }

sdk-libs/compressed-token-sdk/src/instructions/compress_and_close.rs

@@ -22,7 +22,6 @@ pub struct CompressAndCloseIndices {
     pub authority_index: u8,
     pub rent_recipient_index: u8,
     pub output_tree_index: u8,
-    pub amount: u64,
 }
 
 /// Find and validate all required account indices from packed_accounts
@@ -34,7 +33,6 @@ fn find_account_indices(
     authority: impl Into<Pubkey>,
     rent_recipient_pubkey: Pubkey,
     output_tree_pubkey: Pubkey,
-    amount: u64,
 ) -> Result<CompressAndCloseIndices, TokenSdkError> {
     let mint_pubkey = mint_pubkey.into();
     let owner_pubkey = owner_pubkey.into();
@@ -77,7 +75,6 @@ fn find_account_indices(
         authority_index,
         rent_recipient_index,
         output_tree_index,
-        amount,
     })
 }
 
@@ -105,13 +102,24 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
     let mut token_accounts = Vec::with_capacity(indices.len());
 
     for idx in indices {
+        // Get the amount from the source token account
+        let source_account = packed_accounts
+            .get(idx.source_index as usize)
+            .ok_or(TokenSdkError::InvalidAccountData)?;
+        
+        let account_data = source_account
+            .try_borrow_data()
+            .map_err(|_| TokenSdkError::AccountBorrowFailed)?;
+        
+        let amount = light_ctoken_types::state::CompressedToken::amount_from_slice(&account_data)?;
+
         // Create CTokenAccount2 for CompressAndClose operation
         let mut token_account =
             CTokenAccount2::new_empty(idx.owner_index, idx.mint_index, idx.output_tree_index);
 
         // Set up compress_and_close with actual indices
         token_account.compress_and_close(
-            idx.amount,
+            amount,
             idx.source_index,
             idx.authority_index,
             idx.rent_recipient_index,
@@ -191,9 +199,6 @@ pub fn compress_and_close_ctoken_accounts<'info>(
             light_ctoken_types::state::CompressedToken::zero_copy_at(&account_data)
                 .map_err(|_| TokenSdkError::InvalidAccountData)?;
 
-        // Get the amount (full balance) - convert from zero-copy type
-        let amount = u64::from(*compressed_token.amount);
-
         // Extract pubkeys from the deserialized account
         let mint_pubkey = Pubkey::from(compressed_token.mint.to_bytes());
         let owner_pubkey = Pubkey::from(compressed_token.owner.to_bytes());
@@ -254,7 +259,6 @@ pub fn compress_and_close_ctoken_accounts<'info>(
             authority,
             rent_recipient_pubkey.ok_or(TokenSdkError::InvalidAccountData)?,
             output_tree_pubkey.ok_or(TokenSdkError::InvalidAccountData)?,
-            amount,
         )?;
 
         indices_vec.push(indices);