Refactor test code to use PhotonIndexer instead of PhotonClient.

sdk-libs/client/src/indexer/photon_indexer.rs

@@ -24,7 +24,7 @@ use crate::{
 pub struct PhotonIndexer<R: RpcConnection> {
     configuration: Configuration,
     #[allow(dead_code)]
-    rpc: R,
+    pub rpc: R,
 }
 
 impl<R: RpcConnection> PhotonIndexer<R> {

sdk-libs/client/tests/rpc_client.rs

@@ -1,7 +1,4 @@
-use light_client::{
-    photon_rpc::{AddressWithTree, Base58Conversions, Hash, PhotonClient},
-    rpc::SolanaRpcConnection,
-};
+use light_client::rpc::SolanaRpcConnection;
 use light_compressed_token::mint_sdk::{
     create_create_token_pool_instruction, create_mint_to_instruction,
 };
@@ -14,11 +11,12 @@ use light_system_program::sdk::{
 };
 use light_test_utils::RpcConnection;
 use light_utils::hash_to_bn254_field_size_be;
-use num_traits::ToPrimitive;
 use solana_sdk::{
     native_token::LAMPORTS_PER_SOL, signature::Keypair, signer::Signer, system_instruction,
     transaction::Transaction,
 };
+use light_client::indexer::{AddressWithTree, Base58Conversions, Hash, Indexer};
+use light_client::indexer::photon_indexer::PhotonIndexer;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_all_endpoints() {
@@ -48,27 +46,31 @@ async fn test_all_endpoints() {
     spawn_validator(config).await;
 
     let env_accounts = EnvAccounts::get_local_test_validator_accounts();
-    let mut rpc: SolanaRpcConnection =
+    let rpc: SolanaRpcConnection =
         SolanaRpcConnection::new("http://127.0.0.1:8899".to_string(), None);
-    let client = PhotonClient::new("http://127.0.0.1:8784".to_string());
+    let mut indexer = PhotonIndexer::new(
+        "http://127.0.0.1:8784".to_string(),
+        None,
+        rpc,
+    );
 
-    let payer_pubkey = rpc.get_payer().pubkey();
-    rpc.airdrop_lamports(&payer_pubkey, LAMPORTS_PER_SOL)
+    let payer_pubkey = indexer.rpc.get_payer().pubkey();
+    indexer.rpc.airdrop_lamports(&payer_pubkey, LAMPORTS_PER_SOL)
         .await
         .unwrap();
 
     // create compressed account
     let lamports = LAMPORTS_PER_SOL / 2;
     let output_account = CompressedAccount {
         lamports,
-        owner: rpc.get_payer().pubkey(),
+        owner: indexer.rpc.get_payer().pubkey(),
         data: None,
         address: None,
     };
 
     let ix = create_invoke_instruction(
-        &rpc.get_payer().pubkey(),
-        &rpc.get_payer().pubkey(),
+        &indexer.rpc.get_payer().pubkey(),
+        &indexer.rpc.get_payer().pubkey(),
         &[],
         &[output_account],
         &[],
@@ -85,10 +87,10 @@ async fn test_all_endpoints() {
     let tx_create_compressed_account = Transaction::new_signed_with_payer(
         &[ix],
         Some(&payer_pubkey),
-        &[&rpc.get_payer()],
-        rpc.client.get_latest_blockhash().unwrap(),
+        &[&indexer.rpc.get_payer()],
+        indexer.rpc.client.get_latest_blockhash().unwrap(),
     );
-    rpc.client
+    indexer.rpc.client
         .send_and_confirm_transaction(&tx_create_compressed_account)
         .unwrap();
 
@@ -97,7 +99,7 @@ async fn test_all_endpoints() {
     let mint = Keypair::new();
 
     // Setup mint and create compressed token account
-    let mint_rent = rpc
+    let mint_rent = indexer.rpc
         .client
         .get_minimum_balance_for_rent_exemption(82)
         .unwrap();
@@ -124,10 +126,10 @@ async fn test_all_endpoints() {
     let tx = Transaction::new_signed_with_payer(
         &[create_mint_ix, init_mint_ix, create_pool_ix],
         Some(&payer_pubkey),
-        &[rpc.get_payer(), &mint],
-        rpc.client.get_latest_blockhash().unwrap(),
+        &[indexer.rpc.get_payer(), &mint],
+        indexer.rpc.client.get_latest_blockhash().unwrap(),
     );
-    rpc.client.send_and_confirm_transaction(&tx).unwrap();
+    indexer.rpc.client.send_and_confirm_transaction(&tx).unwrap();
 
     let amount = 1_000_000;
 
@@ -146,14 +148,14 @@ async fn test_all_endpoints() {
     let tx = Transaction::new_signed_with_payer(
         &[mint_ix],
         Some(&payer_pubkey),
-        &[&rpc.get_payer()],
-        rpc.client.get_latest_blockhash().unwrap(),
+        &[&indexer.rpc.get_payer()],
+        indexer.rpc.client.get_latest_blockhash().unwrap(),
     );
-    rpc.client.send_and_confirm_transaction(&tx).unwrap();
+    indexer.rpc.client.send_and_confirm_transaction(&tx).unwrap();
 
     let pubkey = payer_pubkey;
-    let hashes = client
-        .get_rpc_compressed_accounts_by_owner(&pubkey)
+    let hashes = indexer
+        .get_compressed_accounts_by_owner(&pubkey)
         .await
         .unwrap();
     assert!(!hashes.is_empty());
@@ -166,86 +168,81 @@ async fn test_all_endpoints() {
         tree: env_accounts.address_merkle_tree_pubkey,
     }];
 
-    let accounts = client
+    let accounts = indexer
         .get_multiple_compressed_accounts(None, Some(hashes.clone()))
         .await
         .unwrap();
 
-    assert!(!accounts.value.is_empty());
-    assert_eq!(accounts.value[0].hash, first_hash);
+    assert!(!accounts.is_empty());
+    assert_eq!(Hash::from_base58(&accounts[0].hash).unwrap(), first_hash);
 
-    let result = client
+    let result = indexer
         .get_validity_proof(hashes.clone(), new_addresses)
         .await
         .unwrap();
     assert_eq!(
-        Hash::from_base58(result.value.leaves[0].as_ref()).unwrap(),
+        Hash::from_base58(result.leaves[0].as_ref()).unwrap(),
         hashes[0]
     );
 
-    let account = client
+    let account = indexer
         .get_compressed_account(None, Some(first_hash))
         .await
         .unwrap();
-    assert_eq!(account.value.lamports, lamports);
-    assert_eq!(account.value.owner, rpc.get_payer().pubkey().to_string());
+    assert_eq!(account.lamports, lamports);
+    assert_eq!(account.owner, indexer.rpc.get_payer().pubkey().to_string());
 
-    let balance = client
+    let balance = indexer
         .get_compressed_account_balance(None, Some(first_hash))
         .await
         .unwrap();
-    assert_eq!(balance.value.lamports, lamports);
+    assert_eq!(balance, lamports);
 
-    let signatures = client
+    let signatures = indexer
         .get_compression_signatures_for_account(first_hash)
         .await
         .unwrap();
     assert_eq!(
-        signatures.value.items[0].signature,
+        signatures[0],
         tx_create_compressed_account.signatures[0].to_string()
     );
 
-    let token_account = &client
+    let token_account = &indexer
         .get_compressed_token_accounts_by_owner(&pubkey, None)
         .await
-        .unwrap()
-        .value
-        .items[0];
-    assert_eq!(token_account.token_data.mint, mint.pubkey().to_string());
-    assert_eq!(token_account.token_data.owner, payer_pubkey.to_string());
+        .unwrap()[0];
+    assert_eq!(token_account.token_data.mint, mint.pubkey());
+    assert_eq!(token_account.token_data.owner, payer_pubkey);
 
-    let balance = client
+    let balance = indexer
         .get_compressed_token_account_balance(
             None,
-            Some(
-                Hash::from_base58(token_account.account.hash.as_ref())
-                    .unwrap()
-                    .to_bytes(),
-            ),
+            Some(token_account.compressed_account.hash().unwrap()),
         )
         .await
         .unwrap();
-    assert_eq!(balance.value.amount, amount.to_string());
+    assert_eq!(balance, amount);
 
-    let balances = client
+    let balances = indexer
         .get_compressed_token_balances_by_owner(&pubkey, None)
         .await
         .unwrap();
     assert_eq!(
-        balances.value.token_balances[0].balance,
-        amount.to_i32().unwrap()
+        balances.token_balances[0].balance,
+        amount
     );
 
-    let proofs = client
-        .get_multiple_compressed_account_proofs(hashes.clone())
+    let hashes_str = hashes.iter().map(|h| h.to_base58()).collect();
+    let proofs = indexer
+        .get_multiple_compressed_account_proofs(hashes_str)
         .await
         .unwrap();
     assert!(!proofs.is_empty());
     assert_eq!(proofs[0].hash, hashes[0].to_base58());
 
     let addresses = vec![hash_to_bn254_field_size_be(&seed).unwrap().0];
-    let new_address_proofs = client
-        .get_multiple_new_address_proofs(env_accounts.merkle_tree_pubkey, addresses)
+    let new_address_proofs = indexer
+        .get_multiple_new_address_proofs(env_accounts.merkle_tree_pubkey.to_bytes(), addresses)
         .await
         .unwrap();
     assert!(!new_address_proofs.is_empty());