adding fixes to run autobahn on eclipse

lib/dex-orca/src/orca.rs

@@ -310,10 +310,17 @@ pub async fn fetch_all_whirlpools(
         .await?;
     let result = whirlpools
         .iter()
-        .map(|account| {
-            let whirlpool: Whirlpool =
-                AnchorDeserialize::deserialize(&mut &account.data[8..]).unwrap();
-            (account.pubkey, whirlpool)
+        .filter_map(|account| {
+            let pubkey = account.pubkey;
+            let whirlpool: Result<Whirlpool, std::io::Error> =
+                AnchorDeserialize::deserialize(&mut &account.data[8..]);
+            match whirlpool {
+                Ok(whirlpool) => Some((account.pubkey, whirlpool)),
+                Err(e) => {
+                    error!("Error deserializing whirlpool account : {pubkey:?} error: {e:?}");
+                    None
+                }
+            }
         })
         .collect_vec();
     Ok(result)

lib/dex-orca/src/orca_dex.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use anchor_lang::Id;
 use anchor_spl::token::spl_token;
-use anchor_spl::token::spl_token::state::AccountState;
+use anchor_spl::token::spl_token::state::{Account, AccountState};
 use anchor_spl::token_2022::Token2022;
 use anyhow::Context;
 use itertools::Itertools;
@@ -229,7 +229,12 @@ impl OrcaDex {
             .iter()
             .filter(|x| {
                 x.1.owner == Token2022::id()
-                    || spl_token::state::Account::unpack(x.1.data()).unwrap().state
+                    || spl_token::state::Account::unpack(x.1.data())
+                        .unwrap_or(Account {
+                            state: AccountState::Frozen,
+                            ..Default::default()
+                        })
+                        .state
                         == AccountState::Frozen
             })
             .map(|x| x.0)
@@ -246,7 +251,10 @@ impl OrcaDex {
         // TODO: actually need to dynamically adjust subscriptions based on the tick?
         let tick_arrays = filtered_pools
             .iter()
-            .map(|(pk, wp)| whirlpool_tick_array_pks(wp, pk, program_id))
+            .map(|(pk, wp)| {
+                println!("whirlpool : {pk}, {}", wp.tick_spacing);
+                whirlpool_tick_array_pks(wp, pk, program_id)
+            })
             .collect_vec();
 
         let edge_pairs = filtered_pools

lib/dex-orca/tests/test_cropper.rs

@@ -8,6 +8,16 @@ use router_lib::test_tools::{generate_dex_rpc_dump, rpc};
 
 #[tokio::test]
 async fn test_dump_input_data_cropper() -> anyhow::Result<()> {
+    let is_eclipse = std::env::var("ECLIPSE")
+        .map(|x| {
+            let value: bool = x.parse().unwrap();
+            value
+        })
+        .unwrap_or_default();
+    if is_eclipse {
+        // crooper is not yet on eclipse
+        return Ok(());
+    }
     let options = HashMap::from([
         (
             "program_id".to_string(),

lib/router-feed-lib/src/get_program_account.rs

@@ -205,6 +205,47 @@ pub async fn get_compressed_program_account_rpc(
     Ok((min_slot, snap_result))
 }
 
+// called on startup to get the required accounts, few calls with some 100 thousand accounts
+#[tracing::instrument(skip_all, level = "trace")]
+pub async fn get_uncompressed_program_account_rpc(
+    rpc_client: &RpcClient,
+    filters: &HashSet<Pubkey>,
+    config: RpcProgramAccountsConfig,
+) -> anyhow::Result<(u64, Vec<AccountWrite>)> {
+    let slot = rpc_client.get_slot().await?;
+    let config = RpcProgramAccountsConfig {
+        with_context: Some(true),
+        account_config: RpcAccountInfoConfig {
+            encoding: Some(UiAccountEncoding::Base64),
+            min_context_slot: Some(slot),
+            commitment: config.account_config.commitment,
+            data_slice: config.account_config.data_slice,
+        },
+        filters: config.filters,
+    };
+
+    let mut snap_result = vec![];
+    let mut min_slot = u64::MAX;
+
+    // use getGPA compressed if available
+    for program_id in filters.iter() {
+        info!("gPA for {}", program_id);
+        min_slot = slot.min(min_slot);
+        let account_snapshot = rpc_client
+            .get_program_accounts_with_config(&program_id, config.clone())
+            .await
+            .map_err_anyhow()?;
+        tracing::log::debug!("gpa snapshot received {}", program_id);
+
+        let iter = account_snapshot.iter().map(|(pk, account)| {
+            account_write_from(*pk, slot, SNAP_ACCOUNT_WRITE_VERSION, account.clone())
+        });
+        snap_result.extend(iter);
+    }
+
+    Ok((min_slot, snap_result))
+}
+
 // called on startup to get the required accounts, few calls with some 100 thousand accounts
 #[tracing::instrument(skip_all, level = "trace")]
 pub async fn get_uncompressed_program_account(

lib/router-feed-lib/src/router_rpc_wrapper.rs

@@ -9,7 +9,10 @@ use solana_sdk::account::Account;
 use solana_sdk::pubkey::Pubkey;
 
 use crate::account_write::AccountWrite;
-use crate::get_program_account::{fetch_multiple_accounts, get_compressed_program_account_rpc};
+use crate::get_program_account::{
+    fetch_multiple_accounts, get_compressed_program_account_rpc,
+    get_uncompressed_program_account_rpc,
+};
 use crate::router_rpc_client::RouterRpcClientTrait;
 
 pub struct RouterRpcWrapper {
@@ -52,10 +55,21 @@ impl RouterRpcClientTrait for RouterRpcWrapper {
         pubkey: &Pubkey,
         config: RpcProgramAccountsConfig,
     ) -> anyhow::Result<Vec<AccountWrite>> {
-        Ok(
-            get_compressed_program_account_rpc(&self.rpc, &HashSet::from([*pubkey]), config)
-                .await?
-                .1,
-        )
+        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 disable_compressed {
+            Ok(
+                get_uncompressed_program_account_rpc(&self.rpc, &HashSet::from([*pubkey]), config)
+                    .await?
+                    .1,
+            )
+        } else {
+            Ok(
+                get_compressed_program_account_rpc(&self.rpc, &HashSet::from([*pubkey]), config)
+                    .await?
+                    .1,
+            )
+        }
     }
 }

lib/router-lib/src/dex/interface.rs

@@ -194,7 +194,6 @@ pub trait DexInterface: Sync + Send {
     /// simulation tests.
     fn program_ids(&self) -> HashSet<Pubkey>;
 
-
     /// Initializes an Edge from ChainData (production) or BanksClient (test).
     /// The Edge will be dropped once a new Edge for the same EdgeIndentifier
     /// has been initialized. After calling initialize the DexInterface needs

lib/router-lib/src/test_tools/generate_dex_rpc_dump.rs

@@ -227,7 +227,7 @@ pub async fn run_dump_swap_ix_with_custom_amount(
             continue;
         };
 
-        debug!(
+        println!(
             "#{} || quote: {} => {} : {} => {}",
             success,
             id.input_mint(),

scripts/smoke-test.sh

@@ -8,7 +8,9 @@ export DUMP_MAINNET_DATA=1 RUST_LOG=info
 
 # define in addition
 # RPC_HTTP_URL="http://fcs-ams1._peer.internal:18899" 
-
+# for eclipse
+# export ECLIPSE=true
+# export DISABLE_COMRPESSED_GPA=true
 
 # saber
 DUMP_SABER_START=$(date)