refactor: replace with_indexer with photon_url in LightClientConfig (#1814)

sergeytimoshin · web-flow · commit c7b2aa37e726 · 2025-06-16T21:34:01.000+02:00
* refactor: replace `with_indexer` with `photon_url` in `LightClientConfig` and adjust related tests and RPC calls

* use `indexer_url` from config as photon_url in register_for_epoch_with_retry

* forester: use `indexer_url` from config as photon_url in `SolanaRpcPoolBuilder`
diff --git a/forester-utils/src/rpc_pool.rs b/forester-utils/src/rpc_pool.rs
@@ -26,6 +26,7 @@ pub enum PoolError {
 
 pub struct SolanaConnectionManager<R: Rpc + 'static> {
     url: String,
+    photon_url: Option<String>,
     commitment: CommitmentConfig,
     // TODO: implement Rpc for SolanaConnectionManager and rate limit requests.
     _rpc_rate_limiter: Option<RateLimiter>,
@@ -36,12 +37,14 @@ pub struct SolanaConnectionManager<R: Rpc + 'static> {
 impl<R: Rpc + 'static> SolanaConnectionManager<R> {
     pub fn new(
         url: String,
+        photon_url: Option<String>,
         commitment: CommitmentConfig,
         rpc_rate_limiter: Option<RateLimiter>,
         send_tx_rate_limiter: Option<RateLimiter>,
     ) -> Self {
         Self {
             url,
+            photon_url,
             commitment,
             _rpc_rate_limiter: rpc_rate_limiter,
             _send_tx_rate_limiter: send_tx_rate_limiter,
@@ -58,8 +61,8 @@ impl<R: Rpc + 'static> bb8::ManageConnection for SolanaConnectionManager<R> {
     async fn connect(&self) -> Result<Self::Connection, Self::Error> {
         let config = LightClientConfig {
             url: self.url.to_string(),
+            photon_url: self.photon_url.clone(),
             commitment_config: Some(self.commitment),
-            with_indexer: false,
             fetch_active_tree: false,
         };
 
@@ -86,6 +89,8 @@ pub struct SolanaRpcPool<R: Rpc + 'static> {
 #[derive(Debug)]
 pub struct SolanaRpcPoolBuilder<R: Rpc> {
     url: Option<String>,
+    photon_url: Option<String>,
+
     commitment: Option<CommitmentConfig>,
 
     max_size: u32,
@@ -110,6 +115,7 @@ impl<R: Rpc> SolanaRpcPoolBuilder<R> {
     pub fn new() -> Self {
         Self {
             url: None,
+            photon_url: None,
             commitment: None,
             max_size: 50,
             connection_timeout_secs: 15,
@@ -128,6 +134,11 @@ impl<R: Rpc> SolanaRpcPoolBuilder<R> {
         self
     }
 
+    pub fn photon_url(mut self, url: Option<String>) -> Self {
+        self.photon_url = url;
+        self
+    }
+
     pub fn commitment(mut self, commitment: CommitmentConfig) -> Self {
         self.commitment = Some(commitment);
         self
@@ -183,6 +194,7 @@ impl<R: Rpc> SolanaRpcPoolBuilder<R> {
 
         let manager = SolanaConnectionManager::new(
             url,
+            self.photon_url,
             commitment,
             self.rpc_rate_limiter,
             self.send_tx_rate_limiter,
diff --git a/forester/src/epoch_manager.rs b/forester/src/epoch_manager.rs
@@ -475,10 +475,9 @@ impl<R: Rpc, I: Indexer + IndexerType<R> + 'static> EpochManager<R, I> {
     ) -> Result<ForesterEpochInfo> {
         let rpc = LightClient::new(LightClientConfig {
             url: self.config.external_services.rpc_url.to_string(),
+            photon_url: self.config.external_services.indexer_url.clone(),
             commitment_config: None,
             fetch_active_tree: false,
-
-            with_indexer: false,
         })
         .await
         .unwrap();
@@ -545,10 +544,9 @@ impl<R: Rpc, I: Indexer + IndexerType<R> + 'static> EpochManager<R, I> {
         info!("Registering for epoch: {}", epoch);
         let mut rpc = LightClient::new(LightClientConfig {
             url: self.config.external_services.rpc_url.to_string(),
+            photon_url: None,
             commitment_config: None,
             fetch_active_tree: false,
-
-            with_indexer: false,
         })
         .await
         .unwrap();
@@ -1198,9 +1196,9 @@ impl<R: Rpc, I: Indexer + IndexerType<R> + 'static> EpochManager<R, I> {
         info!("Reporting work");
         let mut rpc = LightClient::new(LightClientConfig {
             url: self.config.external_services.rpc_url.to_string(),
+            photon_url: None,
             commitment_config: None,
             fetch_active_tree: false,
-            with_indexer: false,
         })
         .await
         .unwrap();
diff --git a/forester/src/forester_status.rs b/forester/src/forester_status.rs
@@ -173,9 +173,9 @@ pub async fn fetch_forester_status(args: &StatusArgs) -> crate::Result<()> {
     debug!("RPC URL: {}", config.external_services.rpc_url);
     let mut rpc = LightClient::new(LightClientConfig {
         url: config.external_services.rpc_url.to_string(),
+        photon_url: None,
         commitment_config: None,
         fetch_active_tree: false,
-        with_indexer: false,
     })
     .await?;
     let trees = fetch_trees(&rpc).await?;
diff --git a/forester/src/lib.rs b/forester/src/lib.rs
@@ -55,10 +55,9 @@ pub async fn run_queue_info(
 ) -> Result<()> {
     let mut rpc = LightClient::new(LightClientConfig {
         url: config.external_services.rpc_url.to_string(),
+        photon_url: None,
         commitment_config: None,
         fetch_active_tree: false,
-
-        with_indexer: false,
     })
     .await
     .unwrap();
@@ -122,6 +121,7 @@ pub async fn run_pipeline<R: Rpc, I: Indexer + IndexerType<R> + 'static>(
 ) -> Result<()> {
     let mut builder = SolanaRpcPoolBuilder::<R>::default()
         .url(config.external_services.rpc_url.to_string())
+        .photon_url(config.external_services.indexer_url.clone())
         .commitment(CommitmentConfig::confirmed())
         .max_size(config.rpc_pool_config.max_size)
         .connection_timeout_secs(config.rpc_pool_config.connection_timeout_secs)
diff --git a/forester/tests/address_v2_test.rs b/forester/tests/address_v2_test.rs
@@ -11,7 +11,7 @@ use light_batched_merkle_tree::{
 use light_client::{
     indexer::{photon_indexer::PhotonIndexer, AddressWithTree},
     local_test_validator::{LightValidatorConfig, ProverConfig},
-    rpc::{client::RpcUrl, merkle_tree::MerkleTreeExt, LightClient, LightClientConfig, Rpc},
+    rpc::{merkle_tree::MerkleTreeExt, LightClient, LightClientConfig, Rpc},
 };
 use light_compressed_account::{
     address::derive_address,
@@ -32,7 +32,7 @@ use light_test_utils::{
 use rand::{prelude::StdRng, Rng, SeedableRng};
 use serial_test::serial;
 use solana_program::{native_token::LAMPORTS_PER_SOL, pubkey::Pubkey};
-use solana_sdk::{commitment_config::CommitmentConfig, signature::Keypair, signer::Signer};
+use solana_sdk::{signature::Keypair, signer::Signer};
 use tokio::sync::{mpsc, oneshot, Mutex};
 
 use crate::test_utils::{forester_config, init};
@@ -71,14 +71,7 @@ async fn test_create_v2_address() {
     config.derivation_pubkey = env.protocol.forester.pubkey();
     config.general_config = GeneralConfig::test_address_v2();
 
-    let mut rpc = LightClient::new(LightClientConfig {
-        url: RpcUrl::Localnet.to_string(),
-        commitment_config: Some(CommitmentConfig::processed()),
-        fetch_active_tree: false,
-        with_indexer: true,
-    })
-    .await
-    .unwrap();
+    let mut rpc = LightClient::new(LightClientConfig::local()).await.unwrap();
     rpc.payer = env.protocol.forester.insecure_clone();
 
     ensure_sufficient_balance(
diff --git a/forester/tests/batched_address_test.rs b/forester/tests/batched_address_test.rs
@@ -65,9 +65,9 @@ async fn test_address_batched() {
     let commitment_config = CommitmentConfig::confirmed();
     let mut rpc = LightClient::new(LightClientConfig {
         url: RpcUrl::Localnet.to_string(),
+        photon_url: None,
         commitment_config: Some(commitment_config),
         fetch_active_tree: false,
-        with_indexer: false,
     })
     .await
     .unwrap();
diff --git a/forester/tests/batched_state_async_indexer_test.rs b/forester/tests/batched_state_async_indexer_test.rs
@@ -12,7 +12,7 @@ use light_client::{
         GetCompressedTokenAccountsByOwnerOrDelegateOptions, Indexer,
     },
     local_test_validator::{LightValidatorConfig, ProverConfig},
-    rpc::{client::RpcUrl, LightClient, LightClientConfig, Rpc},
+    rpc::{LightClient, LightClientConfig, Rpc},
 };
 use light_compressed_account::{
     address::derive_address_legacy,
@@ -38,7 +38,6 @@ use rand::{prelude::SliceRandom, rngs::StdRng, Rng, SeedableRng};
 use serial_test::serial;
 use solana_program::{native_token::LAMPORTS_PER_SOL, pubkey::Pubkey};
 use solana_sdk::{
-    commitment_config::CommitmentConfig,
     signature::{Keypair, Signature},
     signer::Signer,
 };
@@ -222,14 +221,7 @@ async fn test_state_indexer_async_batched() {
 // ─────────────────────────────────────────────────────────────────────────────
 
 async fn setup_rpc_connection(forester: &Keypair) -> LightClient {
-    let mut rpc = LightClient::new(LightClientConfig {
-        url: RpcUrl::Localnet.to_string(),
-        commitment_config: Some(CommitmentConfig::processed()),
-        fetch_active_tree: false,
-        with_indexer: true,
-    })
-    .await
-    .unwrap();
+    let mut rpc = LightClient::new(LightClientConfig::local()).await.unwrap();
     rpc.payer = forester.insecure_clone();
     rpc
 }
diff --git a/forester/tests/batched_state_indexer_test.rs b/forester/tests/batched_state_indexer_test.rs
@@ -12,7 +12,7 @@ use light_batched_merkle_tree::{
 use light_client::{
     indexer::{photon_indexer::PhotonIndexer, Indexer, IndexerRpcConfig, RetryConfig},
     local_test_validator::{LightValidatorConfig, ProverConfig},
-    rpc::{client::RpcUrl, LightClient, LightClientConfig, Rpc},
+    rpc::{LightClient, LightClientConfig, Rpc},
 };
 use light_compressed_account::TreeType;
 use light_program_test::{accounts::test_accounts::TestAccounts, indexer::TestIndexer};
@@ -61,15 +61,7 @@ async fn test_state_indexer_batched() {
         .await
         .unwrap();
 
-    let commitment_config = CommitmentConfig::confirmed();
-    let mut rpc = LightClient::new(LightClientConfig {
-        url: RpcUrl::Localnet.to_string(),
-        fetch_active_tree: false,
-        commitment_config: Some(commitment_config),
-        with_indexer: true,
-    })
-    .await
-    .unwrap();
+    let mut rpc = LightClient::new(LightClientConfig::local()).await.unwrap();
     rpc.payer = forester_keypair.insecure_clone();
 
     rpc.airdrop_lamports(&forester_keypair.pubkey(), LAMPORTS_PER_SOL * 100_000)
diff --git a/forester/tests/batched_state_test.rs b/forester/tests/batched_state_test.rs
@@ -69,9 +69,9 @@ async fn test_state_batched() {
     let commitment_config = CommitmentConfig::confirmed();
     let mut rpc = LightClient::new(LightClientConfig {
         url: RpcUrl::Localnet.to_string(),
+        photon_url: None,
         commitment_config: Some(commitment_config),
         fetch_active_tree: false,
-        with_indexer: false,
     })
     .await
     .unwrap();
diff --git a/forester/tests/e2e_test.rs b/forester/tests/e2e_test.rs
@@ -60,14 +60,9 @@ async fn test_epoch_monitor_with_2_foresters() {
         .await
         .unwrap();
 
-    let mut rpc = LightClient::new(LightClientConfig {
-        url: RpcUrl::Localnet.to_string(),
-        commitment_config: Some(CommitmentConfig::confirmed()),
-        fetch_active_tree: false,
-        with_indexer: false,
-    })
-    .await
-    .unwrap();
+    let mut rpc = LightClient::new(LightClientConfig::local_no_indexer())
+        .await
+        .unwrap();
     rpc.payer = forester_keypair1.insecure_clone();
 
     // Airdrop to both foresters and governance authority
@@ -410,9 +405,9 @@ async fn test_epoch_double_registration() {
 
     let mut rpc = LightClient::new(LightClientConfig {
         url: RpcUrl::Localnet.to_string(),
+        photon_url: None,
         commitment_config: Some(CommitmentConfig::confirmed()),
         fetch_active_tree: false,
-        with_indexer: false,
     })
     .await
     .unwrap();
diff --git a/forester/tests/priority_fee_test.rs b/forester/tests/priority_fee_test.rs
@@ -7,9 +7,8 @@ use forester::{
     ForesterConfig,
 };
 use light_client::rpc::{LightClient, LightClientConfig, Rpc};
-use light_test_utils::RpcUrl;
 use reqwest::Url;
-use solana_sdk::{commitment_config::CommitmentConfig, signature::Signer};
+use solana_sdk::signature::Signer;
 
 use crate::test_utils::init;
 mod test_utils;
@@ -79,14 +78,7 @@ async fn test_priority_fee_request() {
     let config = ForesterConfig::new_for_start(&args).expect("Failed to create config");
 
     // Setup RPC connection using config
-    let mut rpc = LightClient::new(LightClientConfig {
-        url: RpcUrl::Localnet.to_string(),
-        commitment_config: Some(CommitmentConfig::confirmed()),
-        fetch_active_tree: false,
-        with_indexer: false,
-    })
-    .await
-    .unwrap();
+    let mut rpc = LightClient::new(LightClientConfig::local()).await.unwrap();
     rpc.payer = config.payer_keypair.insecure_clone();
 
     let account_keys = vec![config.payer_keypair.pubkey()];
diff --git a/program-tests/utils/src/setup_accounts.rs b/program-tests/utils/src/setup_accounts.rs
@@ -13,7 +13,7 @@ pub async fn setup_accounts(keypairs: TestKeypairs, url: RpcUrl) -> Result<TestA
     let mut rpc = light_client::rpc::LightClient::new(LightClientConfig {
         commitment_config: Some(CommitmentConfig::confirmed()),
         url: url.to_string(),
-        with_indexer: false,
+        photon_url: None,
         fetch_active_tree: false,
     })
     .await
diff --git a/sdk-libs/client/src/rpc/client.rs b/sdk-libs/client/src/rpc/client.rs
@@ -110,21 +110,8 @@ impl LightClient {
         let client = RpcClient::new_with_commitment(config.url.to_string(), commitment_config);
         let retry_config = retry_config.unwrap_or_default();
 
-        let indexer = if config.with_indexer {
-            if config.url == RpcUrl::Localnet.to_string() {
-                Some(PhotonIndexer::new(
-                    "http://127.0.0.1:8784".to_string(),
-                    None,
-                ))
-            } else {
-                Some(PhotonIndexer::new(
-                    config.url.to_string(),
-                    None, // TODO: test that this is not required
-                ))
-            }
-        } else {
-            None
-        };
+        let indexer = config.photon_url.map(|path| PhotonIndexer::new(path, None));
+
         let mut new = Self {
             client,
             payer,
diff --git a/sdk-libs/client/src/rpc/rpc_trait.rs b/sdk-libs/client/src/rpc/rpc_trait.rs
@@ -27,24 +27,24 @@ use crate::{
 pub struct LightClientConfig {
     pub url: String,
     pub commitment_config: Option<CommitmentConfig>,
-    pub with_indexer: bool,
+    pub photon_url: Option<String>,
     pub fetch_active_tree: bool,
 }
 
 impl LightClientConfig {
-    pub fn new(url: String) -> Self {
+    pub fn new(url: String, photon_url: Option<String>) -> Self {
         Self {
             url,
+            photon_url,
             commitment_config: Some(CommitmentConfig::confirmed()),
-            with_indexer: true,
             fetch_active_tree: true,
         }
     }
     pub fn local_no_indexer() -> Self {
         Self {
             url: RpcUrl::Localnet.to_string(),
             commitment_config: Some(CommitmentConfig::confirmed()),
-            with_indexer: false,
+            photon_url: None,
             fetch_active_tree: false,
         }
     }
@@ -53,16 +53,16 @@ impl LightClientConfig {
         Self {
             url: RpcUrl::Localnet.to_string(),
             commitment_config: Some(CommitmentConfig::confirmed()),
-            with_indexer: true,
+            photon_url: Some("http://127.0.0.1:8784".to_string()),
             fetch_active_tree: false,
         }
     }
 
-    pub fn devnet() -> Self {
+    pub fn devnet(photon_url: Option<String>) -> Self {
         Self {
             url: RpcUrl::Devnet.to_string(),
+            photon_url,
             commitment_config: Some(CommitmentConfig::confirmed()),
-            with_indexer: true,
             fetch_active_tree: true,
         }
     }
diff --git a/xtask/src/create_batch_address_tree.rs b/xtask/src/create_batch_address_tree.rs
@@ -41,9 +41,9 @@ pub async fn create_batch_address_tree(options: Options) -> anyhow::Result<()> {
     };
     let mut rpc = LightClient::new(LightClientConfig {
         url: rpc_url,
+        photon_url: None,
         commitment_config: None,
         fetch_active_tree: false,
-        with_indexer: false,
     })
     .await
     .unwrap();
diff --git a/xtask/src/create_batch_state_tree.rs b/xtask/src/create_batch_state_tree.rs
diff --git a/xtask/src/create_state_tree.rs b/xtask/src/create_state_tree.rs
diff --git a/xtask/src/create_update_protocol_config_ix.rs b/xtask/src/create_update_protocol_config_ix.rs
diff --git a/xtask/src/new_deployment.rs b/xtask/src/new_deployment.rs
