refactor: test indexer

examples/name-service/programs/name-service-without-macros/tests/test.rs

@@ -348,7 +348,8 @@ where
     let event = rpc
         .create_and_send_transaction_with_event(&[instruction], &payer.pubkey(), &[payer], None)
         .await?;
-    test_indexer.add_compressed_accounts_with_token_data(&event.unwrap().0);
+    let slot = rpc.get_slot().await.unwrap();
+    test_indexer.add_compressed_accounts_with_token_data(slot, &event.unwrap().0);
     Ok(())
 }
 
@@ -421,7 +422,8 @@ where
     let event = rpc
         .create_and_send_transaction_with_event(&[instruction], &payer.pubkey(), &[payer], None)
         .await?;
-    test_indexer.add_compressed_accounts_with_token_data(&event.unwrap().0);
+    let slot = rpc.get_slot().await.unwrap();
+    test_indexer.add_compressed_accounts_with_token_data(slot, &event.unwrap().0);
     Ok(())
 }
 

examples/name-service/programs/name-service/tests/test.rs

@@ -356,7 +356,8 @@ where
     let event = rpc
         .create_and_send_transaction_with_event(&[instruction], &payer.pubkey(), &[payer], None)
         .await?;
-    test_indexer.add_compressed_accounts_with_token_data(&event.unwrap().0);
+    let slot = rpc.get_slot().await.unwrap();
+    test_indexer.add_compressed_accounts_with_token_data(slot, &event.unwrap().0);
     Ok(())
 }
 
@@ -435,7 +436,8 @@ where
     let event = rpc
         .create_and_send_transaction_with_event(&[instruction], &payer.pubkey(), &[payer], None)
         .await?;
-    test_indexer.add_compressed_accounts_with_token_data(&event.unwrap().0);
+    let slot = rpc.get_slot().await.unwrap();
+    test_indexer.add_compressed_accounts_with_token_data(slot, &event.unwrap().0);
     Ok(())
 }
 

examples/token-escrow/programs/token-escrow/Cargo.toml

@@ -25,13 +25,14 @@ light-compressed-token = { workspace = true }
 light-system-program = { workspace = true }
 account-compression = { workspace = true }
 light-hasher = { workspace = true }
-light-verifier = { workspace = true }
 light-sdk = { workspace = true, features = ["legacy"] }
 
 [target.'cfg(not(target_os = "solana"))'.dependencies]
 solana-sdk = { workspace = true }
 
 [dev-dependencies]
+light-verifier = { workspace = true }
+light-client = { workspace = true }
 light-test-utils = { workspace = true, features = ["devenv"] }
 light-program-test = { workspace = true, features = ["devenv"] }
 tokio = { workspace = true }

examples/token-escrow/programs/token-escrow/tests/test.rs

@@ -10,15 +10,22 @@
 // - create escrow pda and just prove that utxo exists -> read utxo from compressed token account
 // release compressed tokens
 
+use light_client::indexer::Indexer;
 use light_hasher::Poseidon;
-use light_program_test::test_env::{setup_test_programs_with_accounts, EnvAccounts};
+use light_program_test::{
+    indexer::{TestIndexer, TestIndexerExtensions},
+    test_env::{setup_test_programs_with_accounts, EnvAccounts},
+};
 use light_prover_client::gnark::helpers::{ProofType, ProverConfig};
 use light_system_program::sdk::{compressed_account::MerkleContext, event::PublicTransactionEvent};
 use light_test_utils::{
     airdrop_lamports, assert_rpc_error,
-    indexer::TestIndexer,
+    conversions::{
+        program_to_sdk_public_transaction_event, sdk_to_program_compressed_account,
+        sdk_to_program_compressed_proof, sdk_to_program_token_data,
+    },
     spl::{create_mint_helper, mint_tokens_helper},
-    FeeConfig, Indexer, RpcConnection, RpcError, TransactionParams,
+    FeeConfig, RpcConnection, RpcError, TransactionParams,
 };
 use light_verifier::VerifierError;
 use solana_sdk::{
@@ -205,16 +212,16 @@ async fn test_escrow_pda() {
     );
 }
 
-pub async fn perform_escrow<R: RpcConnection>(
+pub async fn perform_escrow<R: RpcConnection, I: Indexer<R> + TestIndexerExtensions<R>>(
     rpc: &mut R,
-    test_indexer: &mut TestIndexer<R>,
+    test_indexer: &mut I,
     env: &EnvAccounts,
     payer: &Keypair,
     escrow_amount: &u64,
     lock_up_time: &u64,
 ) -> Instruction {
     let input_compressed_token_account_data = test_indexer
-        .token_compressed_accounts
+        .get_token_compressed_accounts()
         .iter()
         .find(|x| {
             println!("searching token account: {:?}", x.token_data);
@@ -253,7 +260,9 @@ pub async fn perform_escrow<R: RpcConnection>(
         .await;
 
     let create_ix_inputs = CreateEscrowInstructionInputs {
-        input_token_data: &[input_compressed_token_account_data.token_data.clone()],
+        input_token_data: &[sdk_to_program_token_data(
+            input_compressed_token_account_data.token_data.clone(),
+        )],
         lock_up_time: *lock_up_time,
         signer: &payer_pubkey,
         input_merkle_context: &[MerkleContext {
@@ -270,16 +279,21 @@ pub async fn perform_escrow<R: RpcConnection>(
         ],
         output_compressed_accounts: &Vec::new(),
         root_indices: &rpc_result.root_indices,
-        proof: &Some(rpc_result.proof),
+        proof: &Some(sdk_to_program_compressed_proof(rpc_result.proof)),
         mint: &input_compressed_token_account_data.token_data.mint,
-        input_compressed_accounts: &[compressed_input_account_with_context.compressed_account],
+        input_compressed_accounts: &[sdk_to_program_compressed_account(
+            compressed_input_account_with_context.compressed_account,
+        )],
     };
     create_escrow_instruction(create_ix_inputs, *escrow_amount)
 }
 
-pub async fn perform_escrow_with_event<R: RpcConnection>(
+pub async fn perform_escrow_with_event<
+    R: RpcConnection,
+    I: Indexer<R> + TestIndexerExtensions<R>,
+>(
     rpc: &mut R,
-    test_indexer: &mut TestIndexer<R>,
+    test_indexer: &mut I,
     env: &EnvAccounts,
     payer: &Keypair,
     escrow_amount: &u64,
@@ -307,13 +321,16 @@ pub async fn perform_escrow_with_event<R: RpcConnection>(
         .await?
         .unwrap();
     let slot = rpc.get_slot().await.unwrap();
-    test_indexer.add_compressed_accounts_with_token_data(slot, &event.0);
+    test_indexer.add_compressed_accounts_with_token_data(
+        slot,
+        &program_to_sdk_public_transaction_event(event.0),
+    );
     Ok(())
 }
 
-pub async fn perform_escrow_failing<R: RpcConnection>(
+pub async fn perform_escrow_failing<R: RpcConnection, I: Indexer<R> + TestIndexerExtensions<R>>(
     rpc: &mut R,
-    test_indexer: &mut TestIndexer<R>,
+    test_indexer: &mut I,
     env: &EnvAccounts,
     payer: &Keypair,
     escrow_amount: &u64,
@@ -330,17 +347,17 @@ pub async fn perform_escrow_failing<R: RpcConnection>(
     rpc.process_transaction(transaction).await
 }
 
-pub async fn assert_escrow<R: RpcConnection>(
+pub async fn assert_escrow<R: RpcConnection, I: Indexer<R> + TestIndexerExtensions<R>>(
     rpc: &mut R,
-    test_indexer: &TestIndexer<R>,
+    test_indexer: &I,
     payer_pubkey: &Pubkey,
     amount: u64,
     escrow_amount: u64,
     lock_up_time: &u64,
 ) {
     let token_owner_pda = get_token_owner_pda(payer_pubkey).0;
     let token_data_escrow = test_indexer
-        .token_compressed_accounts
+        .get_token_compressed_accounts()
         .iter()
         .find(|x| x.token_data.owner == token_owner_pda)
         .unwrap()
@@ -349,8 +366,10 @@ pub async fn assert_escrow<R: RpcConnection>(
     assert_eq!(token_data_escrow.amount, escrow_amount);
     assert_eq!(token_data_escrow.owner, token_owner_pda);
 
-    let token_data_change_compressed_token_account =
-        test_indexer.token_compressed_accounts[0].token_data.clone();
+    let token_data_change_compressed_token_account = test_indexer.get_token_compressed_accounts()
+        [0]
+    .token_data
+    .clone();
     assert_eq!(
         token_data_change_compressed_token_account.amount,
         amount - escrow_amount
@@ -369,9 +388,9 @@ pub async fn assert_escrow<R: RpcConnection>(
     assert_eq!(timelock_account.slot, *lock_up_time + current_slot);
 }
 
-pub async fn perform_withdrawal<R: RpcConnection>(
+pub async fn perform_withdrawal<R: RpcConnection, I: Indexer<R> + TestIndexerExtensions<R>>(
     context: &mut R,
-    test_indexer: &mut TestIndexer<R>,
+    test_indexer: &mut I,
     env: &EnvAccounts,
     payer: &Keypair,
     withdrawal_amount: &u64,
@@ -380,7 +399,7 @@ pub async fn perform_withdrawal<R: RpcConnection>(
     let payer_pubkey = payer.pubkey();
     let token_owner_pda = get_token_owner_pda(&invalid_signer.unwrap_or(payer_pubkey)).0;
     let escrow_token_data_with_context = test_indexer
-        .token_compressed_accounts
+        .get_token_compressed_accounts()
         .iter()
         .find(|x| {
             x.token_data.owner == token_owner_pda && x.token_data.amount >= *withdrawal_amount
@@ -414,7 +433,9 @@ pub async fn perform_withdrawal<R: RpcConnection>(
         .await;
 
     let create_ix_inputs = CreateEscrowInstructionInputs {
-        input_token_data: &[escrow_token_data_with_context.token_data.clone()],
+        input_token_data: &[sdk_to_program_token_data(
+            escrow_token_data_with_context.token_data.clone(),
+        )],
         lock_up_time: 0,
         signer: &payer_pubkey,
         input_merkle_context: &[MerkleContext {
@@ -431,17 +452,22 @@ pub async fn perform_withdrawal<R: RpcConnection>(
         ],
         output_compressed_accounts: &Vec::new(),
         root_indices: &rpc_result.root_indices,
-        proof: &Some(rpc_result.proof),
+        proof: &Some(sdk_to_program_compressed_proof(rpc_result.proof)),
         mint: &escrow_token_data_with_context.token_data.mint,
-        input_compressed_accounts: &[compressed_input_account_with_context.compressed_account],
+        input_compressed_accounts: &[sdk_to_program_compressed_account(
+            compressed_input_account_with_context.compressed_account,
+        )],
     };
 
     create_withdrawal_escrow_instruction(create_ix_inputs, *withdrawal_amount)
 }
 
-pub async fn perform_withdrawal_with_event<R: RpcConnection>(
+pub async fn perform_withdrawal_with_event<
+    R: RpcConnection,
+    I: Indexer<R> + TestIndexerExtensions<R>,
+>(
     rpc: &mut R,
-    test_indexer: &mut TestIndexer<R>,
+    test_indexer: &mut I,
     env: &EnvAccounts,
     payer: &Keypair,
     withdrawal_amount: &u64,
@@ -466,13 +492,19 @@ pub async fn perform_withdrawal_with_event<R: RpcConnection>(
         .await?
         .unwrap();
     let slot = rpc.get_slot().await.unwrap();
-    test_indexer.add_compressed_accounts_with_token_data(slot, &event.0);
+    test_indexer.add_compressed_accounts_with_token_data(
+        slot,
+        &program_to_sdk_public_transaction_event(event.0),
+    );
     Ok(())
 }
 
-pub async fn perform_withdrawal_failing<R: RpcConnection>(
+pub async fn perform_withdrawal_failing<
+    R: RpcConnection,
+    I: Indexer<R> + TestIndexerExtensions<R>,
+>(
     rpc: &mut R,
-    test_indexer: &mut TestIndexer<R>,
+    test_indexer: &mut I,
     env: &EnvAccounts,
     payer: &Keypair,
     withdrawal_amount: &u64,
@@ -495,15 +527,15 @@ pub async fn perform_withdrawal_failing<R: RpcConnection>(
     );
     rpc.process_transaction(transaction).await
 }
-pub fn assert_withdrawal<R: RpcConnection>(
-    test_indexer: &TestIndexer<R>,
+pub fn assert_withdrawal<R: RpcConnection, I: Indexer<R> + TestIndexerExtensions<R>>(
+    test_indexer: &I,
     payer_pubkey: &Pubkey,
     withdrawal_amount: u64,
     escrow_amount: u64,
 ) {
     let token_owner_pda = get_token_owner_pda(payer_pubkey).0;
     let token_data_withdrawal = test_indexer
-        .token_compressed_accounts
+        .get_token_compressed_accounts()
         .iter()
         .any(|x| x.token_data.owner == *payer_pubkey && x.token_data.amount == withdrawal_amount);
 
@@ -512,10 +544,13 @@ pub fn assert_withdrawal<R: RpcConnection>(
         "Withdrawal compressed account doesn't exist or has incorrect amount {} expected amount",
         withdrawal_amount
     );
-    let token_data_escrow_change = test_indexer.token_compressed_accounts.iter().any(|x| {
-        x.token_data.owner == token_owner_pda
-            && x.token_data.amount == escrow_amount - withdrawal_amount
-    });
+    let token_data_escrow_change = test_indexer
+        .get_token_compressed_accounts()
+        .iter()
+        .any(|x| {
+            x.token_data.owner == token_owner_pda
+                && x.token_data.amount == escrow_amount - withdrawal_amount
+        });
     assert!(
         token_data_escrow_change,
         "Escrow change compressed account doesn't exist or has incorrect amount {} expected amount",