avoiding adding environment variable everywhere

blockworks-foundation · Nov 18, 2024 · 119f44b · 119f44b
1 parent a56b1f5
commit 119f44b
Show file tree

Hide file tree

Showing 10 changed files with 30 additions and 98 deletions.
diff --git a/bin/autobahn-router/src/tests/dump_all_dex.rs b/bin/autobahn-router/src/tests/dump_all_dex.rs
@@ -21,13 +21,8 @@ mod tests {
         router_feed_lib::utils::tracing_subscriber_init();
         syscallstubs::deactivate_program_logs();
 
-        let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-            .unwrap_or("false".to_string());
-        let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
         let rpc_url = env::var("RPC_HTTP_URL")?;
-        let (mut rpc_client, _chain_data) =
-            rpc::rpc_dumper_client(rpc_url, "all.lz4", !disable_compressed);
+        let (mut rpc_client, _chain_data) = rpc::rpc_dumper_client(rpc_url, "all.lz4");
 
         let dexs = dex_test_utils::get_all_dex(&mut rpc_client).await?;
 

diff --git a/lib/dex-infinity/tests/test_infinity.rs b/lib/dex-infinity/tests/test_infinity.rs
@@ -8,23 +8,18 @@ use router_lib::test_tools::{generate_dex_rpc_dump, rpc};
 
 #[tokio::test]
 async fn test_dump_input_data_infinity() -> anyhow::Result<()> {
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
     if router_test_lib::config_should_dump_mainnet_data() {
-        step_1_infinity(!disable_compressed).await?;
+        step_1_infinity().await?;
     }
 
     step_2_infinity().await?;
 
     Ok(())
 }
 
-async fn step_1_infinity(enable_compression: bool) -> anyhow::Result<()> {
+async fn step_1_infinity() -> anyhow::Result<()> {
     let rpc_url = env::var("RPC_HTTP_URL")?;
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "infinity_dump.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "infinity_dump.lz4");
 
     let options = HashMap::from([]);
     let dex = dex_infinity::InfinityDex::initialize(&mut rpc_client, options).await?;

diff --git a/lib/dex-invariant/tests/test_invariant.rs b/lib/dex-invariant/tests/test_invariant.rs
@@ -8,27 +8,20 @@ use router_lib::test_tools::{generate_dex_rpc_dump, rpc};
 #[tokio::test]
 async fn test_dump_input_data_invariant() -> anyhow::Result<()> {
     let options = HashMap::from([]);
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
 
     if router_test_lib::config_should_dump_mainnet_data() {
-        invariant_step_1(&options, !disable_compressed).await?;
+        invariant_step_1(&options).await?;
     }
 
     invariant_step_2(&options).await?;
 
     Ok(())
 }
 
-async fn invariant_step_1(
-    options: &HashMap<String, String>,
-    enable_compression: bool,
-) -> anyhow::Result<()> {
+async fn invariant_step_1(options: &HashMap<String, String>) -> anyhow::Result<()> {
     let rpc_url = env::var("RPC_HTTP_URL")?;
 
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "invariant_swap.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "invariant_swap.lz4");
     let dex = dex_invariant::InvariantDex::initialize(&mut rpc_client, options.clone()).await?;
 
     generate_dex_rpc_dump::run_dump_mainnet_data(dex, rpc_client, chain_data).await?;

diff --git a/lib/dex-openbook-v2/tests/test_openbook_v2_cp.rs b/lib/dex-openbook-v2/tests/test_openbook_v2_cp.rs
@@ -9,27 +9,19 @@ use solana_program_test::tokio;
 #[tokio::test]
 async fn test_dump_input_data_openbook_v2() -> anyhow::Result<()> {
     let options = HashMap::from([]);
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
     if router_test_lib::config_should_dump_mainnet_data() {
-        openbook_v2_step_1(&options, !disable_compressed).await?;
+        openbook_v2_step_1(&options).await?;
     }
 
     openbook_v2_step_2(&options).await?;
 
     Ok(())
 }
 
-async fn openbook_v2_step_1(
-    options: &HashMap<String, String>,
-    enable_compression: bool,
-) -> anyhow::Result<()> {
+async fn openbook_v2_step_1(options: &HashMap<String, String>) -> anyhow::Result<()> {
     let rpc_url: String = env::var("RPC_HTTP_URL")?;
 
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "openbook_v2_dump.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "openbook_v2_dump.lz4");
 
     let dex = dex_openbook_v2::OpenbookV2Dex::initialize(&mut rpc_client, options.clone()).await?;
 

diff --git a/lib/dex-orca/tests/test_cropper.rs b/lib/dex-orca/tests/test_cropper.rs
@@ -18,11 +18,6 @@ async fn test_dump_input_data_cropper() -> anyhow::Result<()> {
         // crooper is not yet on eclipse
         return Ok(());
     }
-
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
     let options = HashMap::from([
         (
             "program_id".to_string(),
@@ -32,22 +27,18 @@ async fn test_dump_input_data_cropper() -> anyhow::Result<()> {
     ]);
 
     if router_test_lib::config_should_dump_mainnet_data() {
-        cropper_step_1(&options, !disable_compressed).await?;
+        cropper_step_1(&options).await?;
     }
 
     cropper_step_2(&options).await?;
 
     Ok(())
 }
 
-async fn cropper_step_1(
-    options: &HashMap<String, String>,
-    enable_compression: bool,
-) -> anyhow::Result<()> {
+async fn cropper_step_1(options: &HashMap<String, String>) -> anyhow::Result<()> {
     let rpc_url = env::var("RPC_HTTP_URL")?;
 
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "cropper_dump.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "cropper_dump.lz4");
 
     let dex = dex_orca::OrcaDex::initialize(&mut rpc_client, options.clone()).await?;
 

diff --git a/lib/dex-orca/tests/test_orca.rs b/lib/dex-orca/tests/test_orca.rs
@@ -12,27 +12,18 @@ async fn test_dump_input_data_orca() -> anyhow::Result<()> {
         ("program_id".to_string(), whirlpools_client::ID.to_string()),
         ("program_name".to_string(), "Orca".to_string()),
     ]);
-
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
     if router_test_lib::config_should_dump_mainnet_data() {
-        orca_step_1(&options, !disable_compressed).await?;
+        orca_step_1(&options).await?;
     }
 
     orca_step_2(&options).await?;
 
     Ok(())
 }
 
-async fn orca_step_1(
-    options: &HashMap<String, String>,
-    enable_compression: bool,
-) -> anyhow::Result<()> {
+async fn orca_step_1(options: &HashMap<String, String>) -> anyhow::Result<()> {
     let rpc_url = env::var("RPC_HTTP_URL")?;
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "orca_dump.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "orca_dump.lz4");
 
     let dex = dex_orca::OrcaDex::initialize(&mut rpc_client, options.clone()).await?;
 

diff --git a/lib/dex-raydium-cp/tests/test_raydium_cp.rs b/lib/dex-raydium-cp/tests/test_raydium_cp.rs
@@ -10,27 +10,19 @@ use router_lib::test_tools::{generate_dex_rpc_dump, rpc};
 async fn test_dump_input_data_raydium_cp() -> anyhow::Result<()> {
     let options = HashMap::from([]);
 
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
     if router_test_lib::config_should_dump_mainnet_data() {
-        raydium_cp_step_1(&options, !disable_compressed).await?;
+        raydium_cp_step_1(&options).await?;
     }
 
     raydium_cp_step_2(&options).await?;
 
     Ok(())
 }
 
-async fn raydium_cp_step_1(
-    options: &HashMap<String, String>,
-    enable_compression: bool,
-) -> anyhow::Result<()> {
+async fn raydium_cp_step_1(options: &HashMap<String, String>) -> anyhow::Result<()> {
     let rpc_url = env::var("RPC_HTTP_URL")?;
 
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "raydium_cp_dump.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "raydium_cp_dump.lz4");
 
     let dex = dex_raydium_cp::RaydiumCpDex::initialize(&mut rpc_client, options.clone()).await?;
 

diff --git a/lib/dex-raydium/tests/test_raydium.rs b/lib/dex-raydium/tests/test_raydium.rs
@@ -8,27 +8,18 @@ use router_lib::test_tools::{generate_dex_rpc_dump, rpc};
 #[tokio::test]
 async fn test_dump_input_data_raydium() -> anyhow::Result<()> {
     let options = HashMap::from([]);
-
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
     if router_test_lib::config_should_dump_mainnet_data() {
-        raydium_step_1(&options, !disable_compressed).await?;
+        raydium_step_1(&options).await?;
     }
 
     raydium_step_2(&options).await?;
 
     Ok(())
 }
 
-async fn raydium_step_1(
-    options: &HashMap<String, String>,
-    enable_compression: bool,
-) -> anyhow::Result<()> {
+async fn raydium_step_1(options: &HashMap<String, String>) -> anyhow::Result<()> {
     let rpc_url = env::var("RPC_HTTP_URL")?;
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "raydium_dump.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "raydium_dump.lz4");
 
     let dex = dex_raydium::RaydiumDex::initialize(&mut rpc_client, options.clone()).await?;
 

diff --git a/lib/dex-saber/tests/test_saber.rs b/lib/dex-saber/tests/test_saber.rs
@@ -10,26 +10,18 @@ use router_lib::test_tools::{generate_dex_rpc_dump, rpc};
 async fn test_dump_input_data_saber() -> anyhow::Result<()> {
     let options = HashMap::from([]);
 
-    let disable_compressed = std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string())
-        .unwrap_or("false".to_string());
-    let disable_compressed: bool = disable_compressed.trim().parse().unwrap();
-
     if router_test_lib::config_should_dump_mainnet_data() {
-        saber_step_1(&options, !disable_compressed).await?;
+        saber_step_1(&options).await?;
     }
 
     saber_step_2(&options).await?;
 
     Ok(())
 }
 
-async fn saber_step_1(
-    options: &HashMap<String, String>,
-    enable_compression: bool,
-) -> anyhow::Result<()> {
+async fn saber_step_1(options: &HashMap<String, String>) -> anyhow::Result<()> {
     let rpc_url = env::var("RPC_HTTP_URL")?;
-    let (mut rpc_client, chain_data) =
-        rpc::rpc_dumper_client(rpc_url, "saber_dump.lz4", enable_compression);
+    let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "saber_dump.lz4");
 
     let dex = dex_saber::SaberDex::initialize(&mut rpc_client, options.clone()).await?;
 

diff --git a/lib/router-lib/src/test_tools/rpc.rs b/lib/router-lib/src/test_tools/rpc.rs
@@ -166,11 +166,11 @@ impl Drop for DumpRpcClient {
     }
 }
 
-pub fn rpc_dumper_client(
-    url: String,
-    out_path: &str,
-    gpa_compression_enabled: bool,
-) -> (RouterRpcClient, ChainDataArcRw) {
+pub fn rpc_dumper_client(url: String, out_path: &str) -> (RouterRpcClient, ChainDataArcRw) {
+    let disable_compressed_gpa =
+        std::env::var::<String>("DISABLE_COMRPESSED_GPA".to_string()).unwrap_or("true".to_string());
+    let gpa_compression_enabled: bool = !disable_compressed_gpa.trim().parse::<bool>().unwrap();
+
     let chain_data = ChainDataArcRw::new(RwLock::new(ChainData::new()));
     let rpc_client = RouterRpcClient {
         rpc: Box::new(DumpRpcClient {