Lightprotocol
diff --git a/‎forester/tests/test_indexer_interface.rs‎
Lines changed: 31 additions & 19 deletions b/‎forester/tests/test_indexer_interface.rs‎
Lines changed: 31 additions & 19 deletions
diff --git a/‎sdk-libs/client/src/indexer/photon_indexer.rs‎
Lines changed: 1 addition & 57 deletions b/‎sdk-libs/client/src/indexer/photon_indexer.rs‎
Lines changed: 1 addition & 57 deletions
@@ -11,7 +11,7 @@
 /// 4. Compressible token accounts - on-chain accounts that can be compressed
 use std::collections::HashMap;
 
-use anchor_lang::Discriminator;
+use anchor_lang::{AnchorDeserialize, Discriminator};
 use borsh::BorshSerialize;
 use create_address_test_program::create_invoke_cpi_instruction;
 use light_client::{
@@ -368,6 +368,13 @@ async fn test_indexer_interface_scenarios() {
         compressed_mint_pda, create_mint_sig
     );
 
+    // Warp forward so rent expires - required before CompressAndCloseMint
+    let current_slot = rpc.get_slot().await.unwrap();
+    let target_slot = current_slot + light_compressible::rent::SLOTS_PER_EPOCH * 30;
+    rpc.warp_to_slot(target_slot)
+        .await
+        .expect("warp_to_slot so mint rent expires");
+
     // Now compress and close the mint to make it fully compressed
     println!("Compressing mint via CompressAndCloseMint...");
 
@@ -483,36 +490,41 @@ async fn test_indexer_interface_scenarios() {
     );
     println!("  PASSED: Compressible account resolved from on-chain");
 
-    // ============ Test 2: getTokenAccountInterface with compressible token account (on-chain) ============
-    println!("\nTest 2: getTokenAccountInterface with compressible token account (on-chain)...");
-    let compressible_token_interface = photon_indexer
-        .get_token_account_interface(&compressible_token_account, None)
+    println!("\nTest 2: getAccountInterface for compressible token account (on-chain)...");
+    let compressible_token_interface = rpc
+        .get_account_interface(&compressible_token_account, None)
         .await
-        .expect("getTokenAccountInterface should not error")
+        .expect("getAccountInterface should not error")
         .value
-        .expect("Compressible token account should be found via token interface");
+        .expect("Compressible token account should be found");
 
     assert!(
-        compressible_token_interface.account.is_hot(),
+        compressible_token_interface.is_hot(),
         "Token account should be hot (on-chain)"
     );
     assert!(
-        compressible_token_interface.account.cold.is_none(),
+        compressible_token_interface.cold.is_none(),
         "On-chain token account should not have cold context"
     );
     assert_eq!(
-        compressible_token_interface.account.key, compressible_token_account,
+        compressible_token_interface.key, compressible_token_account,
         "Token account key should match"
     );
-    assert_eq!(
-        compressible_token_interface.token.mint, decompressed_mint_pda,
-        "Token mint should match decompressed mint"
-    );
-    assert_eq!(
-        compressible_token_interface.token.owner,
-        compressible_owner.pubkey(),
-        "Token owner should match compressible owner"
-    );
+    {
+        let token = light_token_interface::state::Token::deserialize(
+            &mut &compressible_token_interface.account.data[..],
+        )
+        .expect("parse token account");
+        assert_eq!(
+            token.mint, decompressed_mint_pda,
+            "Token mint should match decompressed mint"
+        );
+        assert_eq!(
+            token.owner,
+            compressible_owner.pubkey(),
+            "Token owner should match compressible owner"
+        );
+    }
     println!("  PASSED: Token account interface resolved with correct token data");
 
     // ============ Test 3: getMultipleAccountInterfaces batch lookup ============
 
@@ -9,7 +9,7 @@ use tracing::{error, trace, warn};
 
 use super::types::{
     AccountInterface, CompressedAccount, CompressedTokenAccount, OwnerBalance,
-    SignatureWithMetadata, TokenAccountInterface, TokenBalance,
+    SignatureWithMetadata, TokenBalance,
 };
 use crate::indexer::{
     base58::Base58Conversions,
@@ -1761,46 +1761,6 @@ impl PhotonIndexer {
         .await
     }
 
-    pub async fn get_token_account_interface(
-        &self,
-        address: &Pubkey,
-        config: Option<IndexerRpcConfig>,
-    ) -> Result<Response<Option<TokenAccountInterface>>, IndexerError> {
-        let response = self.get_account_interface(address, config).await?;
-        let value = match response.value {
-            Some(ai) => {
-                let token = parse_token_data_from_indexer_account(&ai)?;
-                Some(TokenAccountInterface { account: ai, token })
-            }
-            None => None,
-        };
-        Ok(Response {
-            context: response.context,
-            value,
-        })
-    }
-
-    pub async fn get_associated_token_account_interface(
-        &self,
-        owner: &Pubkey,
-        mint: &Pubkey,
-        config: Option<IndexerRpcConfig>,
-    ) -> Result<Response<Option<TokenAccountInterface>>, IndexerError> {
-        let ata_address = light_token::instruction::get_associated_token_address(owner, mint);
-        let response = self.get_account_interface(&ata_address, config).await?;
-        let value = match response.value {
-            Some(ai) => {
-                let token = parse_token_data_from_indexer_account(&ai)?;
-                Some(TokenAccountInterface { account: ai, token })
-            }
-            None => None,
-        };
-        Ok(Response {
-            context: response.context,
-            value,
-        })
-    }
-
     pub async fn get_multiple_account_interfaces(
         &self,
         addresses: Vec<&Pubkey>,
@@ -1853,19 +1813,3 @@ impl PhotonIndexer {
         .await
     }
 }
-
-/// Parse token data from an indexer AccountInterface.
-/// For compressed (cold) accounts: borsh-deserializes TokenData from the cold data bytes.
-/// For on-chain (hot) accounts: returns default TokenData (downstream conversion re-parses from SPL layout).
-fn parse_token_data_from_indexer_account(
-    ai: &AccountInterface,
-) -> Result<light_token::compat::TokenData, IndexerError> {
-    match &ai.cold {
-        Some(cold) => borsh::BorshDeserialize::deserialize(&mut cold.data.data.as_slice())
-            .map_err(|e| IndexerError::decode_error("token_data", e)),
-        None => {
-            // Hot account — downstream will re-parse from SPL account data directly
-            Ok(light_token::compat::TokenData::default())
-        }
-    }
-}