swap out bankrun for litesvm in rust-sdk whirlpool tests

Author: jshiohaha

docs/rust/Cargo.lock

@@ -45,8 +45,12 @@ bs58 = { version = "^0.5.1", default-features = false }
 
 [dev-dependencies]
 serial_test = { version = "^3.1" }
-solana-program-test = { version = "^3" }
+litesvm = { version = "^0.8" }
+litesvm-token = "0.8.1"
 solana-version = { version = "^3" }
+solana-clock = { version = "^3" }
+solana-sysvar = { version = "^3" }
+agave-feature-set = { version = "^3.0" }
 async-trait = { version = "^0.1" }
 base64 = { version = "^0.20" }
 toml = { version = "^0.7" }

examples/rust-sdk/whirlpool_repositioning_bot/Cargo.lock

@@ -1,12 +1,15 @@
 use serde::Deserialize;
 use serde_json::from_value;
-use solana_account_decoder::UiAccountData;
+use solana_account_decoder::{UiAccountData, UiAccountEncoding};
 use solana_client::{nonblocking::rpc_client::RpcClient, rpc_request::TokenAccountsFilter};
 use solana_pubkey::Pubkey;
 use solana_rent::Rent;
 use solana_sysvar_id::SysvarId;
 use std::{error::Error, str::FromStr};
 
+#[cfg(test)]
+use base64;
+
 #[derive(Debug, Clone)]
 pub struct ParsedTokenAccount {
     pub pubkey: Pubkey,
@@ -42,19 +45,40 @@ pub(crate) async fn get_token_accounts_for_owner(
 
     let mut token_accounts: Vec<ParsedTokenAccount> = Vec::new();
     for account in accounts {
-        if let UiAccountData::Json(data) = account.account.data {
-            let token_program = match data.program.as_str() {
-                "spl-token" => &spl_token_interface::ID.to_string(),
-                "spl-token-2022" => &spl_token_2022_interface::ID.to_string(),
-                pubkey => pubkey,
-            };
-            let token: Parsed = from_value(data.parsed)?;
-            token_accounts.push(ParsedTokenAccount {
-                pubkey: Pubkey::from_str(&account.pubkey)?,
-                token_program: Pubkey::from_str(token_program)?,
-                mint: Pubkey::from_str(&token.info.mint)?,
-                amount: token.info.token_amount.amount.parse::<u64>()?,
-            });
+        match account.account.data {
+            UiAccountData::Json(data) => {
+                let token_program = match data.program.as_str() {
+                    "spl-token" => &spl_token_interface::ID.to_string(),
+                    "spl-token-2022" => &spl_token_2022_interface::ID.to_string(),
+                    pubkey => pubkey,
+                };
+                let token: Parsed = from_value(data.parsed)?;
+                token_accounts.push(ParsedTokenAccount {
+                    pubkey: Pubkey::from_str(&account.pubkey)?,
+                    token_program: Pubkey::from_str(token_program)?,
+                    mint: Pubkey::from_str(&token.info.mint)?,
+                    amount: token.info.token_amount.amount.parse::<u64>()?,
+                });
+            }
+            #[cfg(test)]
+            UiAccountData::Binary(data, encoding)
+                if matches!(encoding, UiAccountEncoding::Base64) =>
+            {
+                let bytes = base64::decode(&data)?;
+                if bytes.len() >= 72 {
+                    let mint_bytes: [u8; 32] = bytes[0..32].try_into()?;
+                    let _owner_bytes: [u8; 32] = bytes[32..64].try_into()?;
+                    let amount_bytes: [u8; 8] = bytes[64..72].try_into()?;
+
+                    token_accounts.push(ParsedTokenAccount {
+                        pubkey: Pubkey::from_str(&account.pubkey)?,
+                        token_program: Pubkey::from_str(&account.account.owner)?,
+                        mint: Pubkey::new_from_array(mint_bytes),
+                        amount: u64::from_le_bytes(amount_bytes),
+                    });
+                }
+            }
+            _ => {}
         }
     }
     Ok(token_accounts)

rust-sdk/whirlpool/Cargo.lock

@@ -323,7 +323,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_error_if_no_funder() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint_a = setup_mint(&ctx).await.unwrap();
         let mint_b = setup_mint(&ctx).await.unwrap();
 
@@ -336,7 +336,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_error_if_tokens_not_ordered() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint_a = setup_mint(&ctx).await.unwrap();
         let mint_b = setup_mint(&ctx).await.unwrap();
 
@@ -356,7 +356,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_splash_pool() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint_a = setup_mint(&ctx).await.unwrap();
         let mint_b = setup_mint(&ctx).await.unwrap();
         let price = 10.0;
@@ -407,7 +407,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_splash_pool_with_one_te_token() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint = setup_mint(&ctx).await.unwrap();
         let mint_te = setup_mint_te(&ctx, &[]).await.unwrap();
         let price = 10.0;
@@ -458,7 +458,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_splash_pool_with_two_te_tokens() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint_te_a = setup_mint_te(&ctx, &[]).await.unwrap();
         let mint_te_b = setup_mint_te(&ctx, &[]).await.unwrap();
         let price = 10.0;
@@ -509,7 +509,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_splash_pool_with_transfer_fee() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint = setup_mint(&ctx).await.unwrap();
         let mint_te_fee = setup_mint_te_fee(&ctx).await.unwrap();
         let price = 10.0;
@@ -560,7 +560,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_concentrated_liquidity_pool() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint_a = setup_mint(&ctx).await.unwrap();
         let mint_b = setup_mint(&ctx).await.unwrap();
         let price = 10.0;
@@ -612,7 +612,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_concentrated_liquidity_pool_with_one_te_token() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint = setup_mint(&ctx).await.unwrap();
         let mint_te = setup_mint_te(&ctx, &[]).await.unwrap();
         let price = 10.0;
@@ -664,7 +664,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_concentrated_liquidity_pool_with_two_te_tokens() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint_te_a = setup_mint_te(&ctx, &[]).await.unwrap();
         let mint_te_b = setup_mint_te(&ctx, &[]).await.unwrap();
         let price = 10.0;
@@ -716,7 +716,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_concentrated_liquidity_pool_with_transfer_fee() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint = setup_mint(&ctx).await.unwrap();
         let mint_te_fee = setup_mint_te_fee(&ctx).await.unwrap();
         let price = 10.0;
@@ -768,7 +768,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_create_concentrated_liquidity_pool_with_scaled_ui_amount() {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint = setup_mint(&ctx).await.unwrap();
         let mint_te_sua = setup_mint_te_sua(&ctx).await.unwrap();
         let price = 10.0;

rust-sdk/whirlpool/Cargo.toml

@@ -650,7 +650,7 @@ mod tests {
     use solana_client::nonblocking::rpc_client::RpcClient;
     use solana_keypair::{Keypair, Signer};
     use solana_program_pack::Pack;
-    use solana_program_test::tokio;
+
     use solana_pubkey::Pubkey;
     use spl_token_2022_interface::{
         extension::StateWithExtensionsOwned, state::Account as TokenAccount2022,
@@ -843,7 +843,7 @@ mod tests {
     ) {
         let rt = tokio::runtime::Runtime::new().unwrap();
         rt.block_on(async {
-            let ctx = RpcContext::new().await;
+            let ctx = RpcContext::new();
 
             let minted = setup_all_mints(&ctx).await.unwrap();
             let user_atas = setup_all_atas(&ctx, &minted).await.unwrap();
@@ -932,7 +932,7 @@ mod tests {
         #[case] lower_tick: i32,
         #[case] upper_tick: i32,
     ) -> Result<(), Box<dyn Error>> {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let minted = setup_all_mints(&ctx).await?;
         let user_atas = setup_all_atas(&ctx, &minted).await?;
 
@@ -1058,7 +1058,7 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn test_close_position_fails_if_missing_mint() -> Result<(), Box<dyn Error>> {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
 
         let bogus_mint = Pubkey::new_unique();
 

rust-sdk/whirlpool/src/account.rs

@@ -1,21 +1,19 @@
 use std::error::Error;
 
 use orca_whirlpools_client::{get_position_address, Position, Whirlpool};
-use serial_test::serial;
 use solana_keypair::Signer;
 use solana_program_pack::Pack;
-use solana_program_test::tokio::{self};
 use solana_pubkey::Pubkey;
 use spl_token_2022_interface::state::Account;
+use tokio::{self};
 
 use crate::{
     close_position_instructions, create_concentrated_liquidity_pool_instructions,
     create_splash_pool_instructions, decrease_liquidity_instructions,
     harvest_position_instructions, increase_liquidity_instructions,
-    open_full_range_position_instructions_with_params, swap_instructions,
+    open_full_range_position_instructions, swap_instructions,
     tests::{setup_ata_with_amount, setup_mint_with_decimals, RpcContext},
-    DecreaseLiquidityParam, IncreaseLiquidityParam, OpenPositionParams, SwapQuote, SwapType,
-    SPLASH_POOL_TICK_SPACING,
+    DecreaseLiquidityParam, IncreaseLiquidityParam, SwapQuote, SwapType, SPLASH_POOL_TICK_SPACING,
 };
 
 struct TestContext {
@@ -28,7 +26,7 @@ struct TestContext {
 
 impl TestContext {
     pub async fn new() -> Result<Self, Box<dyn Error>> {
-        let ctx = RpcContext::new().await;
+        let ctx = RpcContext::new();
         let mint_a = setup_mint_with_decimals(&ctx, 9).await?;
         let mint_b = setup_mint_with_decimals(&ctx, 9).await?;
         let ata_a = setup_ata_with_amount(&ctx, mint_a, 500_000_000_000).await?;
@@ -102,15 +100,12 @@ impl TestContext {
         let token_a_before = Account::unpack(&infos_before[0].as_ref().unwrap().data)?;
         let token_b_before = Account::unpack(&infos_before[1].as_ref().unwrap().data)?;
 
-        let position = open_full_range_position_instructions_with_params(
+        let position = open_full_range_position_instructions(
             &self.ctx.rpc,
             pool,
             IncreaseLiquidityParam::Liquidity(1000000000),
             None,
             Some(self.ctx.signer.pubkey()),
-            OpenPositionParams {
-                with_token_metadata_extension: false,
-            },
         )
         .await?;
 
@@ -524,7 +519,6 @@ impl TestContext {
 }
 
 #[tokio::test]
-#[serial]
 async fn test_splash_pool() {
     let ctx = TestContext::new().await.unwrap();
     let pool = ctx.init_splash_pool().await.unwrap();
@@ -544,7 +538,6 @@ async fn test_splash_pool() {
 }
 
 #[tokio::test]
-#[serial]
 async fn test_concentrated_liquidity_pool() {
     let ctx = TestContext::new().await.unwrap();
     let pool = ctx.init_concentrated_liquidity_pool().await.unwrap();

rust-sdk/whirlpool/src/create_pool.rs

@@ -341,7 +341,7 @@ mod tests {
     use solana_client::nonblocking::rpc_client::RpcClient;
     use solana_keypair::{Keypair, Signer};
     use solana_program_pack::Pack;
-    use solana_program_test::tokio;
+
     use solana_pubkey::Pubkey;
     use spl_token_2022_interface::{
         extension::StateWithExtensionsOwned, state::Account as TokenAccount2022,
@@ -513,7 +513,7 @@ mod tests {
     ) {
         let rt = tokio::runtime::Runtime::new().unwrap();
         rt.block_on(async {
-            let ctx = RpcContext::new().await;
+            let ctx = RpcContext::new();
 
             let minted = setup_all_mints(&ctx).await.unwrap();
             let user_atas = setup_all_atas(&ctx, &minted).await.unwrap();