Fixing issue with exact out dumping

bin/cli/src/main.rs

@@ -168,7 +168,10 @@ async fn main() -> Result<(), anyhow::Error> {
                 }
                 &CREATE_REFERRAL_LOG_DISCRIMINANT => {
                     let event = bytemuck::from_bytes::<CreateReferralLog>(&decoded[8..]);
-                    println!("CreateReferralLog - referer: {:?}, referee: {:?}, vault: {:?}, mint: {:?}", event.referer, event.referee, event.vault, event.mint);
+                    println!(
+                        "CreateReferralLog - referer: {:?}, referee: {:?}, vault: {:?}, mint: {:?}",
+                        event.referer, event.referee, event.vault, event.mint
+                    );
                 }
                 _ => panic!("Unknown log discriminant"),
             }

lib/dex-infinity/Cargo.toml

@@ -24,7 +24,7 @@ async-trait = "0.1.79"
 chrono = "0.4.38"
 sha2 = "0.10.8"
 tracing = "0.1.40"
-spl-associated-token-account = "1.0.5"
+spl-associated-token-account = { version = "1.0.5", features = ["no-entrypoint"] }
 
 # infinity
 solana-readonly-account = { version = "1.1.0", features=["solana-sdk"] }

lib/dex-infinity/src/infinity.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::collections::HashSet;
+use std::str::FromStr;
 use std::sync::Arc;
 
 use jupiter_amm_interface::{Amm, QuoteParams, SwapMode};
@@ -106,6 +107,7 @@ impl DexInterface for InfinityDex {
 
     fn program_ids(&self) -> HashSet<Pubkey> {
         [
+            Pubkey::from_str("5ocnV1qiCgaQR8Jb8xWnVbApfaygJ8tNoZfgPwsgx9kx").unwrap(),
             s_controller_lib::program::ID,
             sanctum_spl_multi_stake_pool_program::ID,
             sanctum_spl_stake_pool_program::ID,

lib/router-lib/Cargo.toml

@@ -32,3 +32,4 @@ lz4 = "1.25.0"
 async-channel = "1.9.0"
 lazy_static = "1.5.0"
 anchor-spl = { version = "0.29.0", features = ["associated_token"] }
+sha2 = "0.10.8"

lib/router-lib/src/lib.rs

@@ -9,6 +9,6 @@ pub mod test_tools;
 pub mod utils;
 
 pub mod autobahn_executor {
-  use solana_sdk::declare_id;
-  declare_id!("AutobNFLMzX1rFCDgwWpwr3ztG5c1oDbSrGq7Jj2LgE");
+    use solana_sdk::declare_id;
+    declare_id!("AutobNFLMzX1rFCDgwWpwr3ztG5c1oDbSrGq7Jj2LgE");
 }

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

@@ -8,13 +8,14 @@ use itertools::Itertools;
 use mango_feeds_connector::chain_data::AccountData;
 use router_feed_lib::router_rpc_client::{RouterRpcClient, RouterRpcClientTrait};
 use router_test_lib::{execution_dump, serialize};
+use sha2::{Digest, Sha256};
 use solana_sdk::account::ReadableAccount;
+use solana_sdk::bpf_loader_upgradeable::UpgradeableLoaderState;
 use solana_sdk::clock::Clock;
 use solana_sdk::pubkey::Pubkey;
 use solana_sdk::signature::Keypair;
 use solana_sdk::signer::Signer;
 use solana_sdk::sysvar::SysvarId;
-use std::collections::HashSet;
 use std::sync::Arc;
 use tracing::{debug, error};
 
@@ -67,7 +68,7 @@ pub async fn run_dump_mainnet_data_with_custom_amount(
     let mut skipped = 0;
     let mut success = 0;
 
-    let mut accounts_needed = HashSet::new();
+    let mut accounts_needed = dex.program_ids();
     for id in edges_identifiers {
         accounts_needed.insert(id.input_mint());
         accounts_needed.insert(id.output_mint());
@@ -123,7 +124,20 @@ pub async fn run_dump_mainnet_data_with_custom_amount(
     for x in accounts_needed.iter().take(10) {
         println!("- {} ", x);
     }
-    rpc_client.get_multiple_accounts(&accounts_needed).await?;
+    let accounts = rpc_client.get_multiple_accounts(&accounts_needed).await?;
+
+    for (_, account) in accounts {
+        // get buffer for upgradable programs
+        if account.owner == solana_sdk::bpf_loader_upgradeable::ID {
+            let state = bincode::deserialize::<UpgradeableLoaderState>(&account.data).unwrap();
+            if let UpgradeableLoaderState::Program {
+                programdata_address,
+            } = state
+            {
+                rpc_client.get_account(&programdata_address).await?;
+            }
+        }
+    }
 
     println!("Error count: {}", errors);
     println!("Skipped count: {}", skipped);
@@ -232,6 +246,25 @@ pub async fn run_dump_swap_ix_with_custom_amount(
             is_exact_out: false,
         });
 
+        let chain_data_reader = chain_data.read().unwrap();
+        for account in swap_ix.instruction.accounts {
+            if let Ok(acc) = chain_data_reader.account(&account.pubkey) {
+                dump.accounts.insert(account.pubkey, acc.account.clone());
+            } else {
+                error!("Missing account (needed for swap) {}", account.pubkey);
+            }
+        }
+        let account = chain_data_reader
+            .account(&id.input_mint())
+            .expect("missing mint");
+        dump.accounts
+            .insert(id.input_mint(), account.account.clone());
+        let account = chain_data_reader
+            .account(&id.input_mint())
+            .expect("missing mint");
+        dump.accounts
+            .insert(id.output_mint(), account.account.clone());
+
         // build exact out tests
         if dex.supports_exact_out(&id) {
             let Ok(mut quote_exact_out) =
@@ -284,48 +317,47 @@ pub async fn run_dump_swap_ix_with_custom_amount(
                         error!("Missing account (needed for swap) {}", account.pubkey);
                     }
                 }
-
-                let account = chain_data_reader
-                    .account(&id.input_mint())
-                    .expect("missing mint");
-                dump.accounts
-                    .insert(id.input_mint(), account.account.clone());
-
-                let account = chain_data_reader
-                    .account(&id.input_mint())
-                    .expect("missing mint");
-                dump.accounts
-                    .insert(id.output_mint(), account.account.clone());
             }
         }
-
-        let chain_data_reader = chain_data.read().unwrap();
-        for account in swap_ix.instruction.accounts {
-            if let Ok(acc) = chain_data_reader.account(&account.pubkey) {
-                dump.accounts.insert(account.pubkey, acc.account.clone());
-            } else {
-                error!("Missing account (needed for swap) {}", account.pubkey);
-            }
-        }
-
-        let account = chain_data_reader
-            .account(&id.input_mint())
-            .expect("missing mint");
-        dump.accounts
-            .insert(id.input_mint(), account.account.clone());
-
-        let account = chain_data_reader
-            .account(&id.input_mint())
-            .expect("missing mint");
-        dump.accounts
-            .insert(id.output_mint(), account.account.clone());
     }
 
     println!("Error count: {}", errors);
     println!("Skipped count: {}", skipped);
     println!("Success count: {}", success);
     println!("Exactout Success count: {}", exact_out_sucess);
 
+    for program in dump.programs.clone() {
+        let program_account = account_provider.account(&program)?;
+
+        dump.accounts
+            .insert(program, program_account.account.clone());
+        // use downloaded buffers for the upgradable programs
+        if *program_account.account.owner() == solana_sdk::bpf_loader_upgradeable::ID {
+            let state =
+                bincode::deserialize::<UpgradeableLoaderState>(program_account.account.data())
+                    .unwrap();
+            if let UpgradeableLoaderState::Program {
+                programdata_address,
+            } = state
+            {
+                let program_data_account = account_provider.account(&programdata_address)?;
+                dump.accounts
+                    .insert(programdata_address, program_data_account.account);
+            }
+        }
+    }
+
+    for program in &dump.programs {
+        debug!("program : {program:?}");
+    }
+
+    for (pk, program) in &dump.accounts {
+        let mut hasher = Sha256::new();
+        hasher.update(program.data());
+        let result = hasher.finalize();
+        let base64 = base64::encode(result);
+        debug!("account : {pk:?} dump : {base64:?}");
+    }
     serialize::serialize_to_file(
         &dump,
         &format!("../../programs/simulator/tests/fixtures/{}", dump_name).to_string(),

lib/router-test-lib/src/execution_dump.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use serde_derive::{Deserialize, Serialize};
 use solana_sdk::account::AccountSharedData;
@@ -17,7 +17,7 @@ pub struct ExecutionItem {
 #[derive(Clone, Serialize, Deserialize)]
 pub struct ExecutionDump {
     pub wallet_keypair: String,
-    pub programs: Vec<Pubkey>,
+    pub programs: HashSet<Pubkey>,
     pub cache: Vec<ExecutionItem>,
     pub accounts: HashMap<Pubkey, AccountSharedData>,
 }

lib/router-test-lib/src/serialize.rs

@@ -12,6 +12,7 @@ where
     let mut writer = lz4::EncoderBuilder::new().build(file_writer).unwrap();
     writer.write_all(serialized_data.as_slice()).unwrap();
     writer.flush().unwrap();
+    let _ = writer.finish();
 }
 
 pub fn deserialize_from_file<T>(path: &String) -> anyhow::Result<T>

programs/autobahn-executor/src/lib.rs

@@ -1,5 +1,5 @@
-mod instructions;
 pub mod create_pda;
+mod instructions;
 pub mod logs;
 pub mod swap_ix;
 pub mod utils;
@@ -14,7 +14,6 @@ use solana_program::program_error::ProgramError;
 use solana_program::program_pack::Pack;
 use solana_program::{account_info::AccountInfo, pubkey::Pubkey};
 
-
 #[cfg(not(feature = "no-entrypoint"))]
 use {default_env::default_env, solana_program::entrypoint, solana_security_txt::security_txt};
 

programs/simulator/Cargo.toml

@@ -31,3 +31,8 @@ bonfida-test-utils = "0.4.4"
 log = "0.4.14"
 env_logger = "0.9.0"
 bincode = "1.3.3"
+sha2 = "0.10.8"
+base64 = "0.12.3"
+
+[profile.test]
+inherits = "release"