diff --git a/Cargo.toml b/Cargo.toml index 6f35cd7..bd5fa11 100755 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "sol-trade-sdk" -version = "2.0.0" +version = "3.0.0" edition = "2021" authors = [ "William ", @@ -38,7 +38,6 @@ members = [ crate-type = ["cdylib", "rlib"] [dependencies] -solana-streamer-sdk = "0.5.0" solana-sdk = "3.0.0" solana-client = "3.0.0" solana-program = "3.0.0" diff --git a/README.md b/README.md index 2b83e69..a1dc4bd 100644 --- a/README.md +++ b/README.md @@ -87,14 +87,14 @@ Add the dependency to your `Cargo.toml`: ```toml # Add to your Cargo.toml -sol-trade-sdk = { path = "./sol-trade-sdk", version = "2.0.0" } +sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.0.0" } ``` ### Use crates.io ```toml # Add to your Cargo.toml -sol-trade-sdk = "2.0.0" +sol-trade-sdk = "3.0.0" ``` ## 🛠️ Usage Examples diff --git a/README_CN.md b/README_CN.md index 7eff7aa..c4eb77e 100755 --- a/README_CN.md +++ b/README_CN.md @@ -87,14 +87,14 @@ git clone https://github.com/0xfnzero/sol-trade-sdk ```toml # 添加到您的 Cargo.toml -sol-trade-sdk = { path = "./sol-trade-sdk", version = "2.0.0" } +sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.0.0" } ``` ### 使用 crates.io ```toml # 添加到您的 Cargo.toml -sol-trade-sdk = "2.0.0" +sol-trade-sdk = "3.0.0" ``` ## 🛠️ 使用示例 diff --git a/examples/address_lookup/src/main.rs b/examples/address_lookup/src/main.rs index 0cfc806..f150257 100644 --- a/examples/address_lookup/src/main.rs +++ b/examples/address_lookup/src/main.rs @@ -149,7 +149,18 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul input_token_amount: buy_sol_amount, slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), - extension_params: Box::new(PumpFunParams::from_trade(&trade_info, None)), + extension_params: Box::new(PumpFunParams::from_trade( + trade_info.bonding_curve, + trade_info.associated_bonding_curve, + trade_info.mint, + trade_info.creator, + trade_info.creator_vault, + trade_info.virtual_sol_reserves, + trade_info.virtual_sol_reserves, + trade_info.real_token_reserves, + trade_info.real_sol_reserves, + None, + )), lookup_table_key: Some(lookup_table_key), // you still need to update the AddressLookupTableCache wait_transaction_confirmed: true, create_input_token_ata: false, diff --git a/examples/bonk_copy_trading/src/main.rs b/examples/bonk_copy_trading/src/main.rs index 021f9b6..429f61e 100644 --- a/examples/bonk_copy_trading/src/main.rs +++ b/examples/bonk_copy_trading/src/main.rs @@ -142,7 +142,20 @@ async fn bonk_copy_trade_with_grpc(trade_info: BonkTradeEvent) -> AnyResult<()> input_token_amount: buy_sol_amount, slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), - extension_params: Box::new(BonkParams::from_trade(trade_info.clone())), + extension_params: Box::new(BonkParams::from_trade( + trade_info.virtual_base, + trade_info.virtual_quote, + trade_info.real_base_after, + trade_info.real_quote_after, + trade_info.pool_state, + trade_info.base_vault, + trade_info.quote_vault, + trade_info.base_token_program, + trade_info.platform_config, + trade_info.platform_associated_account, + trade_info.creator_associated_account, + trade_info.global_config, + )), lookup_table_key: None, wait_transaction_confirmed: true, create_input_token_ata: true, @@ -171,7 +184,20 @@ async fn bonk_copy_trade_with_grpc(trade_info: BonkTradeEvent) -> AnyResult<()> input_token_amount: amount_token, slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), - extension_params: Box::new(BonkParams::from_trade(trade_info.clone())), + extension_params: Box::new(BonkParams::from_trade( + trade_info.virtual_base, + trade_info.virtual_quote, + trade_info.real_base_after, + trade_info.real_quote_after, + trade_info.pool_state, + trade_info.base_vault, + trade_info.quote_vault, + trade_info.base_token_program, + trade_info.platform_config, + trade_info.platform_associated_account, + trade_info.creator_associated_account, + trade_info.global_config, + )), lookup_table_key: None, wait_transaction_confirmed: true, open_seed_optimize: false, diff --git a/examples/bonk_sniper_trading/src/main.rs b/examples/bonk_sniper_trading/src/main.rs index 7f71897..5e77cff 100644 --- a/examples/bonk_sniper_trading/src/main.rs +++ b/examples/bonk_sniper_trading/src/main.rs @@ -1,10 +1,5 @@ use sol_trade_sdk::common::spl_associated_token_account::get_associated_token_address; use sol_trade_sdk::common::TradeConfig; -use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter; -use solana_streamer_sdk::streaming::event_parser::common::EventType; -use solana_streamer_sdk::streaming::event_parser::protocols::bonk::BonkTradeEvent; -use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent}; -use solana_streamer_sdk::{match_event, streaming::ShredStreamGrpc}; use sol_trade_sdk::{ common::AnyResult, swqos::SwqosConfig, @@ -14,6 +9,11 @@ use sol_trade_sdk::{ use solana_commitment_config::CommitmentConfig; use solana_sdk::signature::Keypair; use solana_sdk::signer::Signer; +use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter; +use solana_streamer_sdk::streaming::event_parser::common::EventType; +use solana_streamer_sdk::streaming::event_parser::protocols::bonk::BonkTradeEvent; +use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent}; +use solana_streamer_sdk::{match_event, streaming::ShredStreamGrpc}; use std::sync::{ atomic::{AtomicBool, Ordering}, Arc, @@ -113,7 +113,19 @@ async fn bonk_sniper_trade_with_shreds(trade_info: BonkTradeEvent) -> AnyResult< input_token_amount: buy_sol_amount, slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), - extension_params: Box::new(BonkParams::from_dev_trade(trade_info.clone())), + extension_params: Box::new(BonkParams::from_dev_trade( + trade_info.exact_in, + trade_info.amount_in, + trade_info.amount_out, + trade_info.pool_state, + trade_info.base_vault, + trade_info.quote_vault, + trade_info.base_token_program, + trade_info.platform_config, + trade_info.platform_associated_account, + trade_info.creator_associated_account, + trade_info.global_config, + )), lookup_table_key: None, wait_transaction_confirmed: true, create_input_token_ata: true, diff --git a/examples/nonce_cache/src/main.rs b/examples/nonce_cache/src/main.rs index 9b0224b..8a91976 100644 --- a/examples/nonce_cache/src/main.rs +++ b/examples/nonce_cache/src/main.rs @@ -136,7 +136,18 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul input_token_amount: buy_sol_amount, slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), - extension_params: Box::new(PumpFunParams::from_trade(&trade_info, None)), + extension_params: Box::new(PumpFunParams::from_trade( + trade_info.bonding_curve, + trade_info.associated_bonding_curve, + trade_info.mint, + trade_info.creator, + trade_info.creator_vault, + trade_info.virtual_token_reserves, + trade_info.virtual_sol_reserves, + trade_info.real_token_reserves, + trade_info.real_sol_reserves, + None, + )), lookup_table_key: None, wait_transaction_confirmed: true, create_input_token_ata: false, diff --git a/examples/pumpfun_copy_trading/src/main.rs b/examples/pumpfun_copy_trading/src/main.rs index d1a3431..6e95403 100644 --- a/examples/pumpfun_copy_trading/src/main.rs +++ b/examples/pumpfun_copy_trading/src/main.rs @@ -132,7 +132,18 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul input_token_amount: buy_sol_amount, slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), - extension_params: Box::new(PumpFunParams::from_trade(&trade_info, None)), + extension_params: Box::new(PumpFunParams::from_trade( + trade_info.bonding_curve, + trade_info.associated_bonding_curve, + trade_info.mint, + trade_info.creator, + trade_info.creator_vault, + trade_info.virtual_token_reserves, + trade_info.virtual_sol_reserves, + trade_info.real_token_reserves, + trade_info.real_sol_reserves, + None, + )), lookup_table_key: None, wait_transaction_confirmed: true, create_input_token_ata: false, @@ -162,7 +173,18 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), with_tip: false, - extension_params: Box::new(PumpFunParams::from_trade(&trade_info, Some(true))), + extension_params: Box::new(PumpFunParams::from_trade( + trade_info.bonding_curve, + trade_info.associated_bonding_curve, + trade_info.mint, + trade_info.creator, + trade_info.creator_vault, + trade_info.virtual_token_reserves, + trade_info.virtual_sol_reserves, + trade_info.real_token_reserves, + trade_info.real_sol_reserves, + Some(true), + )), lookup_table_key: None, wait_transaction_confirmed: true, create_output_token_ata: false, diff --git a/examples/pumpfun_sniper_trading/src/main.rs b/examples/pumpfun_sniper_trading/src/main.rs index 77a62f0..6d9a7b4 100644 --- a/examples/pumpfun_sniper_trading/src/main.rs +++ b/examples/pumpfun_sniper_trading/src/main.rs @@ -100,7 +100,16 @@ async fn pumpfun_sniper_trade_with_shreds(trade_info: PumpFunTradeEvent) -> AnyR input_token_amount: buy_sol_amount, slippage_basis_points: slippage_basis_points, recent_blockhash: Some(recent_blockhash), - extension_params: Box::new(PumpFunParams::from_dev_trade(&trade_info, None)), + extension_params: Box::new(PumpFunParams::from_dev_trade( + trade_info.mint, + trade_info.token_amount, + trade_info.max_sol_cost, + trade_info.creator, + trade_info.bonding_curve, + trade_info.associated_bonding_curve, + trade_info.creator_vault, + None, + )), lookup_table_key: None, wait_transaction_confirmed: true, create_input_token_ata: true, diff --git a/examples/pumpswap_trading/src/main.rs b/examples/pumpswap_trading/src/main.rs index ab7530b..894f20e 100644 --- a/examples/pumpswap_trading/src/main.rs +++ b/examples/pumpswap_trading/src/main.rs @@ -131,7 +131,19 @@ async fn create_solana_trade_client() -> AnyResult { } async fn pumpswap_trade_with_grpc_buy_event(trade_info: PumpSwapBuyEvent) -> AnyResult<()> { - let params = PumpSwapParams::from_buy_trade(&trade_info); + let params = PumpSwapParams::new( + trade_info.pool, + trade_info.base_mint, + trade_info.quote_mint, + trade_info.pool_base_token_account, + trade_info.pool_quote_token_account, + trade_info.pool_base_token_reserves, + trade_info.pool_quote_token_reserves, + trade_info.coin_creator_vault_ata, + trade_info.coin_creator_vault_authority, + trade_info.base_token_program, + trade_info.quote_token_program, + ); let mint = if trade_info.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT { trade_info.quote_mint } else { @@ -142,7 +154,19 @@ async fn pumpswap_trade_with_grpc_buy_event(trade_info: PumpSwapBuyEvent) -> Any } async fn pumpswap_trade_with_grpc_sell_event(trade_info: PumpSwapSellEvent) -> AnyResult<()> { - let params = PumpSwapParams::from_sell_trade(&trade_info); + let params = PumpSwapParams::new( + trade_info.pool, + trade_info.base_mint, + trade_info.quote_mint, + trade_info.pool_base_token_account, + trade_info.pool_quote_token_account, + trade_info.pool_base_token_reserves, + trade_info.pool_quote_token_reserves, + trade_info.coin_creator_vault_ata, + trade_info.coin_creator_vault_authority, + trade_info.base_token_program, + trade_info.quote_token_program, + ); let mint = if trade_info.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT { trade_info.quote_mint } else { diff --git a/examples/raydium_amm_v4_trading/src/main.rs b/examples/raydium_amm_v4_trading/src/main.rs index d0f5232..91df000 100644 --- a/examples/raydium_amm_v4_trading/src/main.rs +++ b/examples/raydium_amm_v4_trading/src/main.rs @@ -130,9 +130,12 @@ async fn raydium_amm_v4_copy_trade_with_grpc(trade_info: RaydiumAmmV4SwapEvent) } else { amm_info.pc_mint }; - let params = RaydiumAmmV4Params::from_amm_info_and_reserves( + let params = RaydiumAmmV4Params::new( trade_info.amm, - amm_info, + amm_info.coin_mint, + amm_info.pc_mint, + amm_info.token_coin, + amm_info.token_pc, coin_reserve, pc_reserve, ); diff --git a/src/common/bonding_curve.rs b/src/common/bonding_curve.rs index 4e3f056..6a52797 100755 --- a/src/common/bonding_curve.rs +++ b/src/common/bonding_curve.rs @@ -25,6 +25,7 @@ //! - `get_final_market_cap_sol`: Calculates the final market cap in SOL after all tokens are sold //! - `get_buy_out_price`: Calculates the price to buy out all remaining tokens +use borsh::BorshDeserialize; use serde::{Deserialize, Serialize}; use solana_sdk::pubkey::Pubkey; @@ -33,14 +34,15 @@ use crate::instruction::utils::pumpfun::global_constants::{ TOKEN_TOTAL_SUPPLY, }; use crate::instruction::utils::pumpfun::{get_bonding_curve_pda, get_creator_vault_pda}; -use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::PumpFunTradeEvent; /// Represents the global configuration account for token pricing and fees -#[derive(Debug, Clone, Serialize, Deserialize, Default)] +#[derive(Debug, Clone, Serialize, Deserialize, Default, BorshDeserialize)] pub struct BondingCurveAccount { /// Unique identifier for the bonding curve + #[borsh(skip)] pub discriminator: u64, /// Account address + #[borsh(skip)] pub account: Pubkey, /// Virtual token reserves used for price calculations pub virtual_token_reserves: u64, @@ -60,15 +62,16 @@ pub struct BondingCurveAccount { impl BondingCurveAccount { pub fn from_dev_trade( + bonding_curve: Pubkey, mint: &Pubkey, dev_token_amount: u64, dev_sol_amount: u64, creator: Pubkey, ) -> Self { - let account = if mint != &Pubkey::default() { - get_bonding_curve_pda(mint).unwrap() + let account = if bonding_curve != Pubkey::default() { + bonding_curve } else { - Pubkey::default() + get_bonding_curve_pda(&mint).unwrap() }; Self { discriminator: 0, @@ -83,22 +86,30 @@ impl BondingCurveAccount { } } - pub fn from_trade(event: &PumpFunTradeEvent) -> Self { - let account = if event.bonding_curve != Pubkey::default() { - event.bonding_curve + pub fn from_trade( + bonding_curve: Pubkey, + mint: Pubkey, + creator: Pubkey, + virtual_token_reserves: u64, + virtual_sol_reserves: u64, + real_token_reserves: u64, + real_sol_reserves: u64, + ) -> Self { + let account = if bonding_curve != Pubkey::default() { + bonding_curve } else { - get_bonding_curve_pda(&event.mint).unwrap() + get_bonding_curve_pda(&mint).unwrap() }; Self { discriminator: 0, account: account, - virtual_token_reserves: event.virtual_token_reserves, - virtual_sol_reserves: event.virtual_sol_reserves, - real_token_reserves: event.real_token_reserves, - real_sol_reserves: event.real_sol_reserves, + virtual_token_reserves: virtual_token_reserves, + virtual_sol_reserves: virtual_sol_reserves, + real_token_reserves: real_token_reserves, + real_sol_reserves: real_sol_reserves, token_total_supply: TOKEN_TOTAL_SUPPLY, complete: false, - creator: event.creator, + creator: creator, } } diff --git a/src/common/nonce_cache.rs b/src/common/nonce_cache.rs index 8826529..bd28f5d 100755 --- a/src/common/nonce_cache.rs +++ b/src/common/nonce_cache.rs @@ -4,10 +4,10 @@ use solana_nonce::state::State; use solana_nonce::versions::Versions; use solana_sdk::account_utils::StateMut; use solana_sdk::pubkey::Pubkey; -use solana_streamer_sdk::common::SolanaRpcClient; use std::str::FromStr; use std::sync::{Arc, OnceLock}; use tracing::error; +use crate::common::SolanaRpcClient; /// NonceInfo structure to store nonce-related information pub struct NonceInfo { diff --git a/src/instruction/utils/bonk.rs b/src/instruction/utils/bonk.rs index fb55887..20e69b2 100644 --- a/src/instruction/utils/bonk.rs +++ b/src/instruction/utils/bonk.rs @@ -1,9 +1,9 @@ -use crate::common::SolanaRpcClient; +use crate::{ + common::SolanaRpcClient, + instruction::utils::bonk_types::{pool_state_decode, PoolState}, +}; use anyhow::anyhow; use solana_sdk::pubkey::Pubkey; -use solana_streamer_sdk::streaming::event_parser::protocols::bonk::{ - pool_state_decode, types::PoolState, -}; /// Constants used as seeds for deriving PDAs (Program Derived Addresses) pub mod seeds { diff --git a/src/instruction/utils/bonk_types.rs b/src/instruction/utils/bonk_types.rs new file mode 100644 index 0000000..ea6be6a --- /dev/null +++ b/src/instruction/utils/bonk_types.rs @@ -0,0 +1,116 @@ +use borsh::BorshDeserialize; +use serde::{Deserialize, Serialize}; +use solana_sdk::pubkey::Pubkey; + +#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub enum TradeDirection { + #[default] + Buy, + Sell, +} + +#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub enum PoolStatus { + #[default] + Fund, + Migrate, + Trade, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct MintParams { + pub decimals: u8, + pub name: String, + pub symbol: String, + pub uri: String, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct VestingParams { + pub total_locked_amount: u64, + pub cliff_period: u64, + pub unlock_period: u64, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub enum AmmFeeOn { + #[default] + QuoteToken, + BothToken, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct ConstantCurve { + pub supply: u64, + pub total_base_sell: u64, + pub total_quote_fund_raising: u64, + pub migrate_type: u8, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct FixedCurve { + pub supply: u64, + pub total_quote_fund_raising: u64, + pub migrate_type: u8, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct LinearCurve { + pub supply: u64, + pub total_quote_fund_raising: u64, + pub migrate_type: u8, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub enum CurveParams { + Constant { data: ConstantCurve }, + Fixed { data: FixedCurve }, + Linear { data: LinearCurve }, +} +impl Default for CurveParams { + fn default() -> Self { + Self::Constant { data: ConstantCurve::default() } + } +} +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct VestingSchedule { + pub total_locked_amount: u64, + pub cliff_period: u64, + pub unlock_period: u64, + pub start_time: u64, + pub allocated_share_amount: u64, +} +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct PoolState { + pub epoch: u64, + pub auth_bump: u8, + pub status: u8, + pub base_decimals: u8, + pub quote_decimals: u8, + pub migrate_type: u8, + pub supply: u64, + pub total_base_sell: u64, + pub virtual_base: u64, + pub virtual_quote: u64, + pub real_base: u64, + pub real_quote: u64, + pub total_quote_fund_raising: u64, + pub quote_protocol_fee: u64, + pub platform_fee: u64, + pub migrate_fee: u64, + pub vesting_schedule: VestingSchedule, + pub global_config: Pubkey, + pub platform_config: Pubkey, + pub base_mint: Pubkey, + pub quote_mint: Pubkey, + pub base_vault: Pubkey, + pub quote_vault: Pubkey, + pub creator: Pubkey, + pub padding: [u64; 8], +} +pub const POOL_STATE_SIZE: usize = 8 + 1 * 5 + 8 * 10 + 32 * 7 + 8 * 8 + 8 * 5; +pub fn pool_state_decode(data: &[u8]) -> Option { + if data.len() < POOL_STATE_SIZE { + return None; + } + borsh::from_slice::(&data[..POOL_STATE_SIZE]).ok() +} diff --git a/src/instruction/utils/mod.rs b/src/instruction/utils/mod.rs index cf75b01..05b57e9 100644 --- a/src/instruction/utils/mod.rs +++ b/src/instruction/utils/mod.rs @@ -3,3 +3,9 @@ pub mod pumpfun; pub mod pumpswap; pub mod raydium_amm_v4; pub mod raydium_cpmm; + +// types +pub mod bonk_types; +pub mod pumpswap_types; +pub mod raydium_amm_v4_types; +pub mod raydium_cpmm_types; \ No newline at end of file diff --git a/src/instruction/utils/pumpfun.rs b/src/instruction/utils/pumpfun.rs index 71e8448..0ecd18d 100644 --- a/src/instruction/utils/pumpfun.rs +++ b/src/instruction/utils/pumpfun.rs @@ -1,7 +1,6 @@ -use crate::common::{global::GlobalAccount, SolanaRpcClient}; +use crate::common::{bonding_curve::BondingCurveAccount, global::GlobalAccount, SolanaRpcClient}; use anyhow::anyhow; use solana_sdk::pubkey::Pubkey; -use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::PumpFunTradeEvent; use std::{collections::HashMap, sync::Arc}; use tokio::sync::RwLock; @@ -216,13 +215,7 @@ pub fn get_user_volume_accumulator_pda(user: &Pubkey) -> Option { pub async fn fetch_bonding_curve_account( rpc: &SolanaRpcClient, mint: &Pubkey, -) -> Result< - ( - Arc, - Pubkey, - ), - anyhow::Error, -> { +) -> Result<(Arc, Pubkey), anyhow::Error> { let bonding_curve_pda: Pubkey = get_bonding_curve_pda(mint).ok_or(anyhow!("Bonding curve not found"))?; @@ -231,26 +224,29 @@ pub async fn fetch_bonding_curve_account( return Err(anyhow!("Bonding curve not found")); } - let bonding_curve = solana_sdk::borsh1::try_from_slice_unchecked::< - solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::types::BondingCurve, - >(&account.data[8..]) - .map_err(|e| anyhow::anyhow!("Failed to deserialize bonding curve account: {}", e))?; + let bonding_curve = + solana_sdk::borsh1::try_from_slice_unchecked::(&account.data[8..]) + .map_err(|e| anyhow::anyhow!("Failed to deserialize bonding curve account: {}", e))?; Ok((Arc::new(bonding_curve), bonding_curve_pda)) } #[inline] -pub fn get_buy_price(amount: u64, trade_info: &PumpFunTradeEvent) -> u64 { +pub fn get_buy_price( + amount: u64, + virtual_sol_reserves: u64, + virtual_token_reserves: u64, + real_token_reserves: u64, +) -> u64 { if amount == 0 { return 0; } - let n: u128 = - (trade_info.virtual_sol_reserves as u128) * (trade_info.virtual_token_reserves as u128); - let i: u128 = (trade_info.virtual_sol_reserves as u128) + (amount as u128); + let n: u128 = (virtual_sol_reserves as u128) * (virtual_token_reserves as u128); + let i: u128 = (virtual_sol_reserves as u128) + (amount as u128); let r: u128 = n / i + 1; - let s: u128 = (trade_info.virtual_token_reserves as u128) - r; + let s: u128 = (virtual_token_reserves as u128) - r; let s_u64 = s as u64; - s_u64.min(trade_info.real_token_reserves) + s_u64.min(real_token_reserves) } diff --git a/src/instruction/utils/pumpswap.rs b/src/instruction/utils/pumpswap.rs index a262855..bec6df8 100644 --- a/src/instruction/utils/pumpswap.rs +++ b/src/instruction/utils/pumpswap.rs @@ -3,11 +3,11 @@ use crate::{ spl_associated_token_account::get_associated_token_address_with_program_id, SolanaRpcClient, }, constants::TOKEN_PROGRAM, + instruction::utils::pumpswap_types::{pool_decode, Pool}, }; use anyhow::anyhow; use solana_account_decoder::UiAccountEncoding; use solana_sdk::pubkey::Pubkey; -use solana_streamer_sdk::streaming::event_parser::protocols::pumpswap::types::{pool_decode, Pool}; /// Constants used as seeds for deriving PDAs (Program Derived Addresses) pub mod seeds { diff --git a/src/instruction/utils/pumpswap_types.rs b/src/instruction/utils/pumpswap_types.rs new file mode 100644 index 0000000..250a75d --- /dev/null +++ b/src/instruction/utils/pumpswap_types.rs @@ -0,0 +1,26 @@ +use borsh::BorshDeserialize; +use serde::{Deserialize, Serialize}; +use solana_sdk::pubkey::Pubkey; + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct Pool { + pub pool_bump: u8, + pub index: u16, + pub creator: Pubkey, + pub base_mint: Pubkey, + pub quote_mint: Pubkey, + pub lp_mint: Pubkey, + pub pool_base_token_account: Pubkey, + pub pool_quote_token_account: Pubkey, + pub lp_supply: u64, + pub coin_creator: Pubkey, +} + +pub const POOL_SIZE: usize = 1 + 2 + 32 * 6 + 8 + 32; + +pub fn pool_decode(data: &[u8]) -> Option { + if data.len() < POOL_SIZE { + return None; + } + borsh::from_slice::(&data[..POOL_SIZE]).ok() +} diff --git a/src/instruction/utils/raydium_amm_v4.rs b/src/instruction/utils/raydium_amm_v4.rs index f871f9e..0a08a61 100644 --- a/src/instruction/utils/raydium_amm_v4.rs +++ b/src/instruction/utils/raydium_amm_v4.rs @@ -1,10 +1,9 @@ +use crate::{ + common::SolanaRpcClient, + instruction::utils::raydium_amm_v4_types::{amm_info_decode, AmmInfo}, +}; use anyhow::anyhow; use solana_sdk::pubkey::Pubkey; -use solana_streamer_sdk::streaming::event_parser::protocols::raydium_amm_v4::types::{ - amm_info_decode, AmmInfo, -}; - -use crate::common::SolanaRpcClient; /// Constants used as seeds for deriving PDAs (Program Derived Addresses) pub mod seeds { diff --git a/src/instruction/utils/raydium_amm_v4_types.rs b/src/instruction/utils/raydium_amm_v4_types.rs new file mode 100644 index 0000000..6a7ebee --- /dev/null +++ b/src/instruction/utils/raydium_amm_v4_types.rs @@ -0,0 +1,79 @@ +use borsh::BorshDeserialize; +use serde::{Deserialize, Serialize}; +use solana_sdk::pubkey::Pubkey; + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct Fees { + pub min_separate_numerator: u64, + pub min_separate_denominator: u64, + pub trade_fee_numerator: u64, + pub trade_fee_denominator: u64, + pub pnl_numerator: u64, + pub pnl_denominator: u64, + pub swap_fee_numerator: u64, + pub swap_fee_denominator: u64, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct OutPutData { + pub need_take_pnl_coin: u64, + pub need_take_pnl_pc: u64, + pub total_pnl_pc: u64, + pub total_pnl_coin: u64, + pub pool_open_time: u64, + pub punish_pc_amount: u64, + pub punish_coin_amount: u64, + pub orderbook_to_init_time: u64, + pub swap_coin_in_amount: u128, + pub swap_pc_out_amount: u128, + pub swap_take_pc_fee: u64, + pub swap_pc_in_amount: u128, + pub swap_coin_out_amount: u128, + pub swap_take_coin_fee: u64, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct AmmInfo { + pub status: u64, + pub nonce: u64, + pub order_num: u64, + pub depth: u64, + pub coin_decimals: u64, + pub pc_decimals: u64, + pub state: u64, + pub reset_flag: u64, + pub min_size: u64, + pub vol_max_cut_ratio: u64, + pub amount_wave: u64, + pub coin_lot_size: u64, + pub pc_lot_size: u64, + pub min_price_multiplier: u64, + pub max_price_multiplier: u64, + pub sys_decimal_value: u64, + pub fees: Fees, + pub out_put: OutPutData, + pub token_coin: Pubkey, + pub token_pc: Pubkey, + pub coin_mint: Pubkey, + pub pc_mint: Pubkey, + pub lp_mint: Pubkey, + pub open_orders: Pubkey, + pub market: Pubkey, + pub serum_dex: Pubkey, + pub target_orders: Pubkey, + pub withdraw_queue: Pubkey, + pub token_temp_lp: Pubkey, + pub amm_owner: Pubkey, + pub lp_amount: u64, + pub client_order_id: u64, + pub padding: [u64; 2], +} + +pub const AMM_INFO_SIZE: usize = 752; + +pub fn amm_info_decode(data: &[u8]) -> Option { + if data.len() < AMM_INFO_SIZE { + return None; + } + borsh::from_slice::(&data[..AMM_INFO_SIZE]).ok() +} diff --git a/src/instruction/utils/raydium_cpmm.rs b/src/instruction/utils/raydium_cpmm.rs index 05db8d4..9e233de 100644 --- a/src/instruction/utils/raydium_cpmm.rs +++ b/src/instruction/utils/raydium_cpmm.rs @@ -1,9 +1,10 @@ -use crate::{common::SolanaRpcClient, trading::core::params::RaydiumCpmmParams}; +use crate::{ + common::SolanaRpcClient, + instruction::utils::raydium_cpmm_types::{pool_state_decode, PoolState}, + trading::core::params::RaydiumCpmmParams, +}; use anyhow::anyhow; use solana_sdk::pubkey::Pubkey; -use solana_streamer_sdk::streaming::event_parser::protocols::raydium_cpmm::types::{ - pool_state_decode, PoolState, -}; /// Constants used as seeds for deriving PDAs (Program Derived Addresses) pub mod seeds { diff --git a/src/instruction/utils/raydium_cpmm_types.rs b/src/instruction/utils/raydium_cpmm_types.rs new file mode 100644 index 0000000..2baf880 --- /dev/null +++ b/src/instruction/utils/raydium_cpmm_types.rs @@ -0,0 +1,39 @@ +use borsh::BorshDeserialize; +use serde::{Deserialize, Serialize}; +use solana_sdk::pubkey::Pubkey; + +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)] +pub struct PoolState { + pub amm_config: Pubkey, + pub pool_creator: Pubkey, + pub token0_vault: Pubkey, + pub token1_vault: Pubkey, + pub lp_mint: Pubkey, + pub token0_mint: Pubkey, + pub token1_mint: Pubkey, + pub token0_program: Pubkey, + pub token1_program: Pubkey, + pub observation_key: Pubkey, + pub auth_bump: u8, + pub status: u8, + pub lp_mint_decimals: u8, + pub mint0_decimals: u8, + pub mint1_decimals: u8, + pub lp_supply: u64, + pub protocol_fees_token0: u64, + pub protocol_fees_token1: u64, + pub fund_fees_token0: u64, + pub fund_fees_token1: u64, + pub open_time: u64, + pub recent_epoch: u64, + pub padding: [u64; 31], +} + +pub const POOL_STATE_SIZE: usize = 629; + +pub fn pool_state_decode(data: &[u8]) -> Option { + if data.len() < POOL_STATE_SIZE { + return None; + } + borsh::from_slice::(&data[..POOL_STATE_SIZE]).ok() +} diff --git a/src/trading/core/params.rs b/src/trading/core/params.rs index db2082e..a2c3ca7 100755 --- a/src/trading/core/params.rs +++ b/src/trading/core/params.rs @@ -3,19 +3,11 @@ use crate::common::bonding_curve::BondingCurveAccount; use crate::common::nonce_cache::DurableNonceInfo; use crate::common::spl_associated_token_account::get_associated_token_address_with_program_id; use crate::common::SolanaRpcClient; -use solana_streamer_sdk::streaming::event_parser::common::EventType; -use solana_streamer_sdk::streaming::event_parser::protocols::bonk::BonkTradeEvent; use crate::swqos::{SwqosClient, TradeType}; use crate::trading::common::get_multi_token_balances; use crate::trading::MiddlewareManager; use solana_hash::Hash; use solana_sdk::{pubkey::Pubkey, signature::Keypair}; -use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::PumpFunTradeEvent; -use solana_streamer_sdk::streaming::event_parser::protocols::pumpswap::{ - PumpSwapBuyEvent, PumpSwapSellEvent, -}; -use solana_streamer_sdk::streaming::event_parser::protocols::raydium_amm_v4::types::AmmInfo; -use solana_streamer_sdk::streaming::event_parser::protocols::raydium_cpmm::RaydiumCpmmSwapEvent; use std::sync::Arc; /// Swap parameters @@ -74,32 +66,55 @@ impl PumpFunParams { } pub fn from_dev_trade( - event: &PumpFunTradeEvent, + mint: Pubkey, + token_amount: u64, + max_sol_cost: u64, + creator: Pubkey, + bonding_curve: Pubkey, + associated_bonding_curve: Pubkey, + creator_vault: Pubkey, close_token_account_when_sell: Option, ) -> Self { - let bonding_curve = BondingCurveAccount::from_dev_trade( - &event.mint, - event.token_amount, - event.max_sol_cost, - event.creator, + let bonding_curve_account = BondingCurveAccount::from_dev_trade( + bonding_curve, + &mint, + token_amount, + max_sol_cost, + creator, ); Self { - bonding_curve: Arc::new(bonding_curve), - associated_bonding_curve: event.associated_bonding_curve, - creator_vault: event.creator_vault, + bonding_curve: Arc::new(bonding_curve_account), + associated_bonding_curve: associated_bonding_curve, + creator_vault: creator_vault, close_token_account_when_sell: close_token_account_when_sell, } } pub fn from_trade( - event: &PumpFunTradeEvent, + bonding_curve: Pubkey, + associated_bonding_curve: Pubkey, + mint: Pubkey, + creator: Pubkey, + creator_vault: Pubkey, + virtual_token_reserves: u64, + virtual_sol_reserves: u64, + real_token_reserves: u64, + real_sol_reserves: u64, close_token_account_when_sell: Option, ) -> Self { - let bonding_curve = BondingCurveAccount::from_trade(event); + let bonding_curve = BondingCurveAccount::from_trade( + bonding_curve, + mint, + creator, + virtual_token_reserves, + virtual_sol_reserves, + real_token_reserves, + real_sol_reserves, + ); Self { bonding_curve: Arc::new(bonding_curve), - associated_bonding_curve: event.associated_bonding_curve, - creator_vault: event.creator_vault, + associated_bonding_curve: associated_bonding_curve, + creator_vault: creator_vault, close_token_account_when_sell: close_token_account_when_sell, } } @@ -184,35 +199,31 @@ pub struct PumpSwapParams { } impl PumpSwapParams { - pub fn from_buy_trade(event: &PumpSwapBuyEvent) -> Self { + pub fn new( + pool: Pubkey, + base_mint: Pubkey, + quote_mint: Pubkey, + pool_base_token_account: Pubkey, + pool_quote_token_account: Pubkey, + pool_base_token_reserves: u64, + pool_quote_token_reserves: u64, + coin_creator_vault_ata: Pubkey, + coin_creator_vault_authority: Pubkey, + base_token_program: Pubkey, + quote_token_program: Pubkey, + ) -> Self { Self { - pool: event.pool, - base_mint: event.base_mint, - quote_mint: event.quote_mint, - pool_base_token_account: event.pool_base_token_account, - pool_quote_token_account: event.pool_quote_token_account, - pool_base_token_reserves: event.pool_base_token_reserves, - pool_quote_token_reserves: event.pool_quote_token_reserves, - coin_creator_vault_ata: event.coin_creator_vault_ata, - coin_creator_vault_authority: event.coin_creator_vault_authority, - base_token_program: event.base_token_program, - quote_token_program: event.quote_token_program, - } - } - - pub fn from_sell_trade(event: &PumpSwapSellEvent) -> Self { - Self { - pool: event.pool, - base_mint: event.base_mint, - quote_mint: event.quote_mint, - pool_base_token_account: event.pool_base_token_account, - pool_quote_token_account: event.pool_quote_token_account, - pool_base_token_reserves: event.pool_base_token_reserves, - pool_quote_token_reserves: event.pool_quote_token_reserves, - coin_creator_vault_ata: event.coin_creator_vault_ata, - coin_creator_vault_authority: event.coin_creator_vault_authority, - base_token_program: event.base_token_program, - quote_token_program: event.quote_token_program, + pool, + base_mint, + quote_mint, + pool_base_token_account, + pool_quote_token_account, + pool_base_token_reserves, + pool_quote_token_reserves, + coin_creator_vault_ata, + coin_creator_vault_authority, + base_token_program, + quote_token_program, } } @@ -329,31 +340,56 @@ impl BonkParams { ..Default::default() } } - pub fn from_trade(trade_info: BonkTradeEvent) -> Self { + pub fn from_trade( + virtual_base: u64, + virtual_quote: u64, + real_base_after: u64, + real_quote_after: u64, + pool_state: Pubkey, + base_vault: Pubkey, + quote_vault: Pubkey, + base_token_program: Pubkey, + platform_config: Pubkey, + platform_associated_account: Pubkey, + creator_associated_account: Pubkey, + global_config: Pubkey, + ) -> Self { Self { - virtual_base: trade_info.virtual_base as u128, - virtual_quote: trade_info.virtual_quote as u128, - real_base: trade_info.real_base_after as u128, - real_quote: trade_info.real_quote_after as u128, - pool_state: trade_info.pool_state, - base_vault: trade_info.base_vault, - quote_vault: trade_info.quote_vault, - mint_token_program: trade_info.base_token_program, - platform_config: trade_info.platform_config, - platform_associated_account: trade_info.platform_associated_account, - creator_associated_account: trade_info.creator_associated_account, - global_config: trade_info.global_config, + virtual_base: virtual_base as u128, + virtual_quote: virtual_quote as u128, + real_base: real_base_after as u128, + real_quote: real_quote_after as u128, + pool_state: pool_state, + base_vault: base_vault, + quote_vault: quote_vault, + mint_token_program: base_token_program, + platform_config: platform_config, + platform_associated_account: platform_associated_account, + creator_associated_account: creator_associated_account, + global_config: global_config, } } - pub fn from_dev_trade(trade_info: BonkTradeEvent) -> Self { + pub fn from_dev_trade( + is_exact_in: bool, + amount_in: u64, + amount_out: u64, + pool_state: Pubkey, + base_vault: Pubkey, + quote_vault: Pubkey, + base_token_program: Pubkey, + platform_config: Pubkey, + platform_associated_account: Pubkey, + creator_associated_account: Pubkey, + global_config: Pubkey, + ) -> Self { const DEFAULT_VIRTUAL_BASE: u128 = 1073025605596382; const DEFAULT_VIRTUAL_QUOTE: u128 = 30000852951; - let amount_in = if trade_info.metadata.event_type == EventType::BonkBuyExactIn { - trade_info.amount_in + let _amount_in = if is_exact_in { + amount_in } else { crate::instruction::utils::bonk::get_amount_in( - trade_info.amount_out, + amount_out, crate::instruction::utils::bonk::accounts::PROTOCOL_FEE_RATE, crate::instruction::utils::bonk::accounts::PLATFORM_FEE_RATE, crate::instruction::utils::bonk::accounts::SHARE_FEE_RATE, @@ -370,9 +406,9 @@ impl BonkParams { crate::instruction::utils::bonk::accounts::PLATFORM_FEE_RATE, crate::instruction::utils::bonk::accounts::SHARE_FEE_RATE, ) as u128; - let amount_out = if trade_info.metadata.event_type == EventType::BonkBuyExactIn { + let _amount_out = if is_exact_in { crate::instruction::utils::bonk::get_amount_out( - trade_info.amount_in, + amount_in, crate::instruction::utils::bonk::accounts::PROTOCOL_FEE_RATE, crate::instruction::utils::bonk::accounts::PLATFORM_FEE_RATE, crate::instruction::utils::bonk::accounts::SHARE_FEE_RATE, @@ -383,22 +419,22 @@ impl BonkParams { 0, ) as u128 } else { - trade_info.amount_out as u128 + amount_out as u128 }; - let real_base = amount_out; + let real_base = _amount_out; Self { virtual_base: DEFAULT_VIRTUAL_BASE, virtual_quote: DEFAULT_VIRTUAL_QUOTE, real_base: real_base, real_quote: real_quote, - pool_state: trade_info.pool_state, - base_vault: trade_info.base_vault, - quote_vault: trade_info.quote_vault, - mint_token_program: trade_info.base_token_program, - platform_config: trade_info.platform_config, - platform_associated_account: trade_info.platform_associated_account, - creator_associated_account: trade_info.creator_associated_account, - global_config: trade_info.global_config, + pool_state: pool_state, + base_vault: base_vault, + quote_vault: quote_vault, + mint_token_program: base_token_program, + platform_config: platform_config, + platform_associated_account: platform_associated_account, + creator_associated_account: creator_associated_account, + global_config: global_config, } } @@ -474,7 +510,7 @@ pub struct RaydiumCpmmParams { pub base_vault: Pubkey, /// Quote token vault address pub quote_vault: Pubkey, - /// Base token program ID + /// Base token program ID pub base_token_program: Pubkey, /// Quote token program ID pub quote_token_program: Pubkey, @@ -484,22 +520,30 @@ pub struct RaydiumCpmmParams { impl RaydiumCpmmParams { pub fn from_trade( - trade_info: RaydiumCpmmSwapEvent, + pool_state: Pubkey, + amm_config: Pubkey, + input_token_mint: Pubkey, + output_token_mint: Pubkey, + input_vault: Pubkey, + output_vault: Pubkey, + input_token_program: Pubkey, + output_token_program: Pubkey, + observation_state: Pubkey, base_reserve: u64, quote_reserve: u64, ) -> Self { Self { - pool_state: trade_info.pool_state, - amm_config: trade_info.amm_config, - base_mint: trade_info.input_token_mint, - quote_mint: trade_info.output_token_mint, + pool_state: pool_state, + amm_config: amm_config, + base_mint: input_token_mint, + quote_mint: output_token_mint, base_reserve: base_reserve, quote_reserve: quote_reserve, - base_vault: trade_info.input_vault, - quote_vault: trade_info.output_vault, - base_token_program: trade_info.input_token_program, - quote_token_program: trade_info.output_token_program, - observation_state: trade_info.observation_state, + base_vault: input_vault, + quote_vault: output_vault, + base_token_program: input_token_program, + quote_token_program: output_token_program, + observation_state: observation_state, } } @@ -564,21 +608,16 @@ pub struct RaydiumAmmV4Params { } impl RaydiumAmmV4Params { - pub fn from_amm_info_and_reserves( + pub fn new( amm: Pubkey, - amm_info: AmmInfo, + coin_mint: Pubkey, + pc_mint: Pubkey, + token_coin: Pubkey, + token_pc: Pubkey, coin_reserve: u64, pc_reserve: u64, ) -> Self { - Self { - amm, - coin_mint: amm_info.coin_mint, - pc_mint: amm_info.pc_mint, - token_coin: amm_info.token_coin, - token_pc: amm_info.token_pc, - coin_reserve, - pc_reserve, - } + Self { amm, coin_mint, pc_mint, token_coin, token_pc, coin_reserve, pc_reserve } } pub async fn from_amm_address_by_rpc( rpc: &SolanaRpcClient, diff --git a/src/utils/price/bonk.rs b/src/utils/price/bonk.rs index 57aa91f..305b1a5 100644 --- a/src/utils/price/bonk.rs +++ b/src/utils/price/bonk.rs @@ -1,49 +1,4 @@ -use solana_streamer_sdk::streaming::event_parser::protocols::bonk::types::PoolState; - -use crate::{ - constants::decimals::{DEFAULT_TOKEN_DECIMALS, SOL_DECIMALS}, - constants::WSOL_TOKEN_ACCOUNT, -}; - -/// Calculate the token price in WSOL based on pool state -/// -/// # Arguments -/// * `pool_state` - Pool state -/// -/// # Returns -/// Token price in WSOL as f64 -pub fn price_token_in_wsol_with_pool_state(pool_state: &PoolState) -> f64 { - if pool_state.quote_mint != WSOL_TOKEN_ACCOUNT { - log::error!("Quote mint is not WSOL: {:?}", pool_state.quote_mint); - return 0.0; - } - price_base_in_quote( - pool_state.virtual_base, - pool_state.virtual_quote, - pool_state.real_base, - pool_state.real_quote, - pool_state.base_decimals, - pool_state.quote_decimals, - ) -} - -/// Calculate the price of base in quote based on pool state -/// -/// # Arguments -/// * `pool_state` - Pool state -/// -/// # Returns -/// The price of base in quote -pub fn price_base_in_quote_with_pool_state(pool_state: &PoolState) -> f64 { - price_base_in_quote( - pool_state.virtual_base, - pool_state.virtual_quote, - pool_state.real_base, - pool_state.real_quote, - pool_state.base_decimals, - pool_state.quote_decimals, - ) -} +use crate::constants::decimals::{DEFAULT_TOKEN_DECIMALS, SOL_DECIMALS}; /// Calculate the price of token in WSOL /// diff --git a/src/utils/price/pumpfun.rs b/src/utils/price/pumpfun.rs index a5b321a..a683c60 100644 --- a/src/utils/price/pumpfun.rs +++ b/src/utils/price/pumpfun.rs @@ -1,18 +1,5 @@ -use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::types::BondingCurve; - use crate::instruction::utils::pumpfun::global_constants::{LAMPORTS_PER_SOL, SCALE}; -/// Calculate the token price in SOL based on virtual reserves -/// -/// # Arguments -/// * `bonding_curve` - Bonding curve account -/// -/// # Returns -/// Token price in SOL as f64 -pub fn price_token_in_sol_with_bonding_curve(bonding_curve: &BondingCurve) -> f64 { - price_token_in_sol(bonding_curve.virtual_sol_reserves, bonding_curve.virtual_token_reserves) -} - /// Calculate the token price in SOL based on virtual reserves /// /// # Arguments diff --git a/src/utils/price/raydium_clmm.rs b/src/utils/price/raydium_clmm.rs index 84a2db4..44c08e3 100644 --- a/src/utils/price/raydium_clmm.rs +++ b/src/utils/price/raydium_clmm.rs @@ -1,5 +1,3 @@ -use solana_streamer_sdk::streaming::event_parser::protocols::raydium_clmm::types::PoolState; - /// Calculate the price of token0 in token1 /// /// # Arguments @@ -36,33 +34,3 @@ pub fn price_token1_in_token0( ) -> f64 { 1.0 / price_token0_in_token1(sqrt_price_x64, decimals_token0, decimals_token1) } - -/// Calculate the price of token0 in token1 based on pool state -/// -/// # Arguments -/// * `pool_state` - The pool state -/// -/// # Returns -/// The price of token0 in token1 -pub fn price_token0_in_token1_with_pool_state(pool_state: &PoolState) -> f64 { - price_token0_in_token1( - pool_state.sqrt_price_x64, - pool_state.mint_decimals0, - pool_state.mint_decimals1, - ) -} - -/// Calculate the price of token1 in token0 based on pool state -/// -/// # Arguments -/// * `pool_state` - The pool state -/// -/// # Returns -/// The price of token1 in token0 -pub fn price_token1_in_token0_with_pool_state(pool_state: &PoolState) -> f64 { - price_token1_in_token0( - pool_state.sqrt_price_x64, - pool_state.mint_decimals0, - pool_state.mint_decimals1, - ) -}