how to monitor solana token tokens to run solana arbitrage bot

[haihaidavid6]

how to monitor solana token tokens to run solana arbitrage bot

[x89]

WHIRLPOOLS_POOL_SIZE=952

METEORA_POOLS_PROGRAM=Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB

#[derive(Debug)]
pub struct LiquidityPool {
// Account Discriminator (8 bytes)
pub lp_mint: Pubkey, // 32 bytes
pub token_a_mint: Pubkey, // 32 bytes
pub token_b_mint: Pubkey, // 32 bytes
pub a_vault: Pubkey, // 32 bytes
pub b_vault: Pubkey, // 32 bytes
pub a_vault_lp: Pubkey, // 32 bytes
pub b_vault_lp: Pubkey, // 32 bytes
pub a_vault_lp_bump: u8, // 1 byte
pub enabled: bool, // 1 byte
pub protocol_token_a_fee: Pubkey, // 32 bytes
pub protocol_token_b_fee: Pubkey, // 32 bytes
pub fee_last_updated_at: u64, // 8 bytes
pub padding0: [u8; 24], // 24 bytes
pub fees: PoolFees, // 32 bytes
pub pool_type: PoolType, // 1 byte
pub stake: Pubkey, // 32 bytes
pub total_locked_lp: u64, // 8 bytes
pub bootstrapping: Bootstrapping, // 40 bytes
pub partner_info: PartnerInfo, // 48 bytes
pub padding: Padding, // 360 bytes
pub curve_type: CurveType, // 1 byte
}

#[derive(Debug)]
pub struct PoolFees {
pub trade_fee_numerator: u64, // 8 bytes
pub trade_fee_denominator: u64, // 8 bytes
pub protocol_trade_fee_numerator: u64, // 8 bytes
pub protocol_trade_fee_denominator: u64, // 8 bytes
}

#[derive(Debug)]
pub enum PoolType {
Permissionless,
// Other variants would go here
}

#[derive(Debug)]
pub struct Bootstrapping {
pub activation_point: u64, // 8 bytes
pub whitelisted_vault: Pubkey, // 32 bytes
pub pool_creator: Pubkey, // 32 bytes
pub activation_type: u8, // 1 byte
}

#[derive(Debug)]
pub struct PartnerInfo {
pub fee_numerator: u64, // 8 bytes
pub partner_authority: Pubkey, // 32 bytes
pub pending_fee_a: u64, // 8 bytes
pub pending_fee_b: u64, // 8 bytes
}

#[derive(Debug)]
pub struct Padding {
pub padding0: [u8; 6], // 6 bytes
pub padding1: [u64; 21], // 168 bytes
pub padding2: [u64; 21], // 168 bytes
}

#[derive(Debug)]
pub enum CurveType {
ConstantProduct,
// Other curve types would go here
}

let data: &[u8] = /* your account data */;

// Account discriminator (8 bytes)
let _discriminator = &data[0..8];

// Pubkey fields
let lp_mint = Pubkey::new_from_slice(&data[8..40]).unwrap();
let token_a_mint = Pubkey::new_from_slice(&data[40..72]).unwrap();
let token_b_mint = Pubkey::new_from_slice(&data[72..104]).unwrap();
let a_vault = Pubkey::new_from_slice(&data[104..136]).unwrap();
let b_vault = Pubkey::new_from_slice(&data[136..168]).unwrap();
let a_vault_lp = Pubkey::new_from_slice(&data[168..200]).unwrap();
let b_vault_lp = Pubkey::new_from_slice(&data[200..232]).unwrap();

// u8/bool fields
let a_vault_lp_bump = data[232];
let enabled = data[233] != 0;

// Protocol fee pubkeys
let protocol_token_a_fee = Pubkey::new_from_slice(&data[234..266]).unwrap();
let protocol_token_b_fee = Pubkey::new_from_slice(&data[266..298]).unwrap();

// u64 and padding
let fee_last_updated_at = u64::from_le_bytes(data[298..306].try_into().unwrap());
let mut padding0 = [0u8; 24];
padding0.copy_from_slice(&data[306..330]);

// PoolFees
let fees = PoolFees {
trade_fee_numerator: u64::from_le_bytes(data[330..338].try_into().unwrap()),
trade_fee_denominator: u64::from_le_bytes(data[338..346].try_into().unwrap()),
protocol_trade_fee_numerator: u64::from_le_bytes(data[346..354].try_into().unwrap()),
protocol_trade_fee_denominator: u64::from_le_bytes(data[354..362].try_into().unwrap()),
};

// PoolType (assuming 0 = Permissionless)
let pool_type = match data[362] {
0 => PoolType::Permissionless,
_ => unimplemented!("Unknown pool type"),
};

// Stake pubkey
let stake = Pubkey::new_from_slice(&data[363..395]).unwrap();

// total_locked_lp
let total_locked_lp = u64::from_le_bytes(data[395..403].try_into().unwrap());

// Bootstrapping
let bootstrapping = Bootstrapping {
activation_point: u64::from_le_bytes(data[403..411].try_into().unwrap()),
whitelisted_vault: Pubkey::new_from_slice(&data[411..443]).unwrap(),
pool_creator: Pubkey::new_from_slice(&data[443..475]).unwrap(),
activation_type: data[475],
};

// PartnerInfo
let partner_info = PartnerInfo {
fee_numerator: u64::from_le_bytes(data[476..484].try_into().unwrap()),
partner_authority: Pubkey::new_from_slice(&data[484..516]).unwrap(),
pending_fee_a: u64::from_le_bytes(data[516..524].try_into().unwrap()),
pending_fee_b: u64::from_le_bytes(data[524..532].try_into().unwrap()),
};

// Padding
let mut padding = Padding {
padding0: [0u8; 6],
padding1: [0u64; 21],
padding2: [0u64; 21],
};
padding.padding0.copy_from_slice(&data[532..538]);
for i in 0..21 {
let offset = 538 + i * 8;
padding.padding1[i] = u64::from_le_bytes(data[offset..offset+8].try_into().unwrap());
}
for i in 0..21 {
let offset = 706 + i * 8;
padding.padding2[i] = u64::from_le_bytes(data[offset..offset+8].try_into().unwrap());
}

// CurveType
let curve_type = match data[874] {
0 => CurveType::ConstantProduct,
_ => unimplemented!("Unknown curve type"),
};

let pool = LiquidityPool {
lp_mint,
token_a_mint,
token_b_mint,
a_vault,
b_vault,
a_vault_lp,
b_vault_lp,
a_vault_lp_bump,
enabled,
protocol_token_a_fee,
protocol_token_b_fee,
fee_last_updated_at,
padding0,
fees,
pool_type,
stake,
total_locked_lp,
bootstrapping,
partner_info,
padding,
curve_type,
};

[x89]

RAYDIUM_CLMM_PROGRAM=CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK
RAYDIUM_CLMM_POOL_SIZE=1544

//token_mint0 = 73
//token_mint1 = 105

#[derive(Debug)]
pub struct ConcentratedLiquidityPool {
// Account Discriminator (8 bytes)
pub bump: u8, // 1 byte
pub amm_config: Pubkey, // 32 bytes
pub owner: Pubkey, // 32 bytes
pub token_mint0: Pubkey, // 32 bytes
pub token_mint1: Pubkey, // 32 bytes
pub token_vault0: Pubkey, // 32 bytes
pub token_vault1: Pubkey, // 32 bytes
pub observation_key: Pubkey, // 32 bytes
pub mint_decimals0: u8, // 1 byte
pub mint_decimals1: u8, // 1 byte
pub tick_spacing: u16, // 2 bytes
pub liquidity: u128, // 16 bytes
pub sqrt_price_x64: u128, // 16 bytes
pub tick_current: i32, // 4 bytes
pub padding3: u16, // 2 bytes
pub padding4: u16, // 2 bytes
pub fee_growth_global0_x64: u128, // 16 bytes
pub fee_growth_global1_x64: u128, // 16 bytes
pub protocol_fees_token0: u64, // 8 bytes
pub protocol_fees_token1: u64, // 8 bytes
pub swap_in_amount_token0: u128, // 16 bytes
pub swap_out_amount_token1: u128, // 16 bytes
pub swap_in_amount_token1: u128, // 16 bytes
pub swap_out_amount_token0: u128, // 16 bytes
pub status: u8, // 1 byte
pub padding: [u8; 7], // 7 bytes
pub reward_infos: [RewardInfo; 3], // 3 * 104 = 312 bytes
pub tick_array_bitmap: [u64; 16], // 16 * 8 = 128 bytes
pub total_fees_token0: u64, // 8 bytes
pub total_fees_claimed_token0: u64, // 8 bytes
pub total_fees_token1: u64, // 8 bytes
pub total_fees_claimed_token1: u64, // 8 bytes
pub fund_fees_token0: u64, // 8 bytes
pub fund_fees_token1: u64, // 8 bytes
pub open_time: u64, // 8 bytes
pub recent_epoch: u64, // 8 bytes
pub padding1: [u64; 24], // 192 bytes
pub padding2: [u64; 32], // 256 bytes
}

#[derive(Debug)]
pub struct RewardInfo {
pub mint: Pubkey, // 32 bytes
pub vault: Pubkey, // 32 bytes
pub authority: Pubkey, // 32 bytes
pub emissions_per_second_x64: u128, // 16 bytes
pub growth_global_x64: u128, // 16 bytes
}

let data: &[u8] = /* your account data */;

// Account discriminator (8 bytes)
let _discriminator = &data[0..8];

// Initial fields
let bump = data[8];
let amm_config = Pubkey::new_from_slice(&data[9..41]).unwrap();
let owner = Pubkey::new_from_slice(&data[41..73]).unwrap();
let token_mint0 = Pubkey::new_from_slice(&data[73..105]).unwrap();
let token_mint1 = Pubkey::new_from_slice(&data[105..137]).unwrap();
let token_vault0 = Pubkey::new_from_slice(&data[137..169]).unwrap();
let token_vault1 = Pubkey::new_from_slice(&data[169..201]).unwrap();
let observation_key = Pubkey::new_from_slice(&data[201..233]).unwrap();
let mint_decimals0 = data[233];
let mint_decimals1 = data[234];
let tick_spacing = u16::from_le_bytes(data[235..237].try_into().unwrap());
let liquidity = u128::from_le_bytes(data[237..253].try_into().unwrap());
let sqrt_price_x64 = u128::from_le_bytes(data[253..269].try_into().unwrap());
let tick_current = i32::from_le_bytes(data[269..273].try_into().unwrap());
let padding3 = u16::from_le_bytes(data[273..275].try_into().unwrap());
let padding4 = u16::from_le_bytes(data[275..277].try_into().unwrap());
let fee_growth_global0_x64 = u128::from_le_bytes(data[277..293].try_into().unwrap());
let fee_growth_global1_x64 = u128::from_le_bytes(data[293..309].try_into().unwrap());
let protocol_fees_token0 = u64::from_le_bytes(data[309..317].try_into().unwrap());
let protocol_fees_token1 = u64::from_le_bytes(data[317..325].try_into().unwrap());
let swap_in_amount_token0 = u128::from_le_bytes(data[325..341].try_into().unwrap());
let swap_out_amount_token1 = u128::from_le_bytes(data[341..357].try_into().unwrap());
let swap_in_amount_token1 = u128::from_le_bytes(data[357..373].try_into().unwrap());
let swap_out_amount_token0 = u128::from_le_bytes(data[373..389].try_into().unwrap());
let status = data[389];
let padding = [data[390], data[391], data[392], data[393], data[394], data[395], data[396]];

// RewardInfos (3 items)
let mut reward_infos = [RewardInfo::default(); 3];
for i in 0..3 {
let offset = 397 + i * 104;
reward_infos[i] = RewardInfo {
mint: Pubkey::new_from_slice(&data[offset..offset+32]).unwrap(),
vault: Pubkey::new_from_slice(&data[offset+32..offset+64]).unwrap(),
authority: Pubkey::new_from_slice(&data[offset+64..offset+96]).unwrap(),
emissions_per_second_x64: u128::from_le_bytes(data[offset+96..offset+112].try_into().unwrap()),
growth_global_x64: u128::from_le_bytes(data[offset+112..offset+128].try_into().unwrap()),
};
}

// Tick array bitmap (16 u64 values)
let mut tick_array_bitmap = [0u64; 16];
for i in 0..16 {
let offset = 709 + i * 8;
tick_array_bitmap[i] = u64::from_le_bytes(data[offset..offset+8].try_into().unwrap());
}

// Remaining fields
let total_fees_token0 = u64::from_le_bytes(data[837..845].try_into().unwrap());
let total_fees_claimed_token0 = u64::from_le_bytes(data[845..853].try_into().unwrap());
let total_fees_token1 = u64::from_le_bytes(data[853..861].try_into().unwrap());
let total_fees_claimed_token1 = u64::from_le_bytes(data[861..869].try_into().unwrap());
let fund_fees_token0 = u64::from_le_bytes(data[869..877].try_into().unwrap());
let fund_fees_token1 = u64::from_le_bytes(data[877..885].try_into().unwrap());
let open_time = u64::from_le_bytes(data[885..893].try_into().unwrap());
let recent_epoch = u64::from_le_bytes(data[893..901].try_into().unwrap());

// Padding arrays
let mut padding1 = [0u64; 24];
for i in 0..24 {
let offset = 901 + i * 8;
padding1[i] = u64::from_le_bytes(data[offset..offset+8].try_into().unwrap());
}

let mut padding2 = [0u64; 32];
for i in 0..32 {
let offset = 1093 + i * 8;
padding2[i] = u64::from_le_bytes(data[offset..offset+8].try_into().unwrap());
}

let pool = ConcentratedLiquidityPool {
bump,
amm_config,
owner,
token_mint0,
token_mint1,
token_vault0,
token_vault1,
observation_key,
mint_decimals0,
mint_decimals1,
tick_spacing,
liquidity,
sqrt_price_x64,
tick_current,
padding3,
padding4,
fee_growth_global0_x64,
fee_growth_global1_x64,
protocol_fees_token0,
protocol_fees_token1,
swap_in_amount_token0,
swap_out_amount_token1,
swap_in_amount_token1,
swap_out_amount_token0,
status,
padding,
reward_infos,
tick_array_bitmap,
total_fees_token0,
total_fees_claimed_token0,
total_fees_token1,
total_fees_claimed_token1,
fund_fees_token0,
fund_fees_token1,
open_time,
recent_epoch,
padding1,
padding2,
};

[x89]

METEORA_DLMM_POOL_SIZE=904
METEORA_DLMM_PROGRAM=LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo

#[derive(Debug)]
pub struct LiquidityPool {
// Account Discriminator (8 bytes)
pub parameters: StaticParameters, // 32 bytes
pub v_parameters: VariableParameters, // 32 bytes
pub bump_seed: u8, // 1 byte
pub bin_step_seed: [u8; 2], // 2 bytes
pub pair_type: u8, // 1 byte
pub active_id: i32, // 4 bytes
pub bin_step: u16, // 2 bytes
pub status: u8, // 1 byte
pub require_base_factor_seed: u8, // 1 byte
pub base_factor_seed: [u8; 2], // 2 bytes
pub activation_type: u8, // 1 byte
pub creator_pool_on_off_control: u8, // 1 byte
pub token_x_mint: Pubkey, // 32 bytes
pub token_y_mint: Pubkey, // 32 bytes
pub reserve_x: Pubkey, // 32 bytes
pub reserve_y: Pubkey, // 32 bytes
pub protocol_fee: ProtocolFee, // 16 bytes
pub padding1: [u8; 32], // 32 bytes
pub reward_infos: [RewardInfo; 2], // 2 * 112 = 224 bytes
pub oracle: Pubkey, // 32 bytes
pub bin_array_bitmap: [u64; 16], // 128 bytes
pub last_updated_at: i64, // 8 bytes
pub padding2: [u8; 32], // 32 bytes
pub pre_activation_swap_address: Pubkey, // 32 bytes
pub base_key: Pubkey, // 32 bytes
pub activation_point: u64, // 8 bytes
pub pre_activation_duration: u64, // 8 bytes
pub padding3: [u8; 8], // 8 bytes
pub padding4: u64, // 8 bytes
pub creator: Pubkey, // 32 bytes
pub token_mint_x_program_flag: u8, // 1 byte
pub token_mint_y_program_flag: u8, // 1 byte
pub reserved: [u8; 22], // 22 bytes
}

#[derive(Debug)]
pub struct StaticParameters {
pub base_factor: u16, // 2 bytes
pub filter_period: u16, // 2 bytes
pub decay_period: u16, // 2 bytes
pub reduction_factor: u16, // 2 bytes
pub variable_fee_control: u32, // 4 bytes
pub max_volatility_accumulator: u32, // 4 bytes
pub min_bin_id: i32, // 4 bytes
pub max_bin_id: i32, // 4 bytes
pub protocol_share: u16, // 2 bytes
pub base_fee_power_factor: u8, // 1 byte
pub padding: [u8; 5], // 5 bytes
}

#[derive(Debug)]
pub struct VariableParameters {
pub volatility_accumulator: u32, // 4 bytes
pub volatility_reference: u32, // 4 bytes
pub index_reference: i32, // 4 bytes
pub padding: [u8; 4], // 4 bytes
pub last_update_timestamp: i64, // 8 bytes
pub padding1: [u8; 8], // 8 bytes
}

#[derive(Debug)]
pub struct ProtocolFee {
pub amount_x: u64, // 8 bytes
pub amount_y: u64, // 8 bytes
}

#[derive(Debug)]
pub struct RewardInfo {
pub mint: Pubkey, // 32 bytes
pub vault: Pubkey, // 32 bytes
pub funder: Pubkey, // 32 bytes
pub reward_duration: u64, // 8 bytes
pub reward_duration_end: u64, // 8 bytes
pub reward_rate: u64, // 8 bytes
pub last_update_time: u64, // 8 bytes
pub cumulative_seconds_with_empty_liquidity_reward: u64, // 8 bytes
}

//reserve_x = 8+32*2+16=88
//reserve_y=112

match rpc_client.get_program_accounts_with_config(
&program_id,
RpcProgramAccountsConfig {
filters: Some(vec![
RpcFilterType::DataSize(METEORA_DLMM_POOL_SIZE),
solana_client::rpc_filter::RpcFilterType::Memcmp(Memcmp::new(88, MemcmpEncodedBytes::Base64(base64::encode(mint.to_bytes())),
solana_client::rpc_filter::RpcFilterType::Memcmp(Memcmp::new(112, MemcmpEncodedBytes::Base64(base64::encode(wsol_address.to_bytes())),
)),
]),
account_config: RpcAccountInfoConfig {
encoding: Some(UiAccountEncoding::Base64),
..RpcAccountInfoConfig::default()
},
..RpcProgramAccountsConfig::default()
},)
{
Ok (accounts) => {

let data: &[u8] = /* your account data */;

// Account discriminator (8 bytes)
let _discriminator = &data[0..8];

// StaticParameters (32 bytes)
let parameters = StaticParameters {
base_factor: u16::from_le_bytes(data[8..10].try_into().unwrap()),
filter_period: u16::from_le_bytes(data[10..12].try_into().unwrap()),
decay_period: u16::from_le_bytes(data[12..14].try_into().unwrap()),
reduction_factor: u16::from_le_bytes(data[14..16].try_into().unwrap()),
variable_fee_control: u32::from_le_bytes(data[16..20].try_into().unwrap()),
max_volatility_accumulator: u32::from_le_bytes(data[20..24].try_into().unwrap()),
min_bin_id: i32::from_le_bytes(data[24..28].try_into().unwrap()),
max_bin_id: i32::from_le_bytes(data[28..32].try_into().unwrap()),
protocol_share: u16::from_le_bytes(data[32..34].try_into().unwrap()),
base_fee_power_factor: data[34],
padding: [data[35], data[36], data[37], data[38], data[39]],
};

// VariableParameters (32 bytes)
let v_parameters = VariableParameters {
volatility_accumulator: u32::from_le_bytes(data[40..44].try_into().unwrap()),
volatility_reference: u32::from_le_bytes(data[44..48].try_into().unwrap()),
index_reference: i32::from_le_bytes(data[48..52].try_into().unwrap()),
padding: [data[52], data[53], data[54], data[55]],
last_update_timestamp: i64::from_le_bytes(data[56..64].try_into().unwrap()),
padding1: [data[64], data[65], data[66], data[67], data[68], data[69], data[70], data[71]],
};

// Fixed fields
let bump_seed = data[72];
let bin_step_seed = [data[73], data[74]];
let pair_type = data[75];
let active_id = i32::from_le_bytes(data[76..80].try_into().unwrap());
let bin_step = u16::from_le_bytes(data[80..82].try_into().unwrap());
let status = data[82];
let require_base_factor_seed = data[83];
let base_factor_seed = [data[84], data[85]];
let activation_type = data[86];
let creator_pool_on_off_control = data[87];

// Pubkey fields
let token_x_mint = Pubkey::new_from_slice(&data[88..120]).unwrap();
let token_y_mint = Pubkey::new_from_slice(&data[120..152]).unwrap();
let reserve_x = Pubkey::new_from_slice(&data[152..184]).unwrap();
let reserve_y = Pubkey::new_from_slice(&data[184..216]).unwrap();

// ProtocolFee
let protocol_fee = ProtocolFee {
amount_x: u64::from_le_bytes(data[216..224].try_into().unwrap()),
amount_y: u64::from_le_bytes(data[224..232].try_into().unwrap()),
};

// padding1
let mut padding1 = [0u8; 32];
padding1.copy_from_slice(&data[232..264]);

// RewardInfos (2 items)
let mut reward_infos = [RewardInfo::default(); 2];
for i in 0..2 {
let offset = 264 + i * 112;
reward_infos[i] = RewardInfo {
mint: Pubkey::new_from_slice(&data[offset..offset+32]).unwrap(),
vault: Pubkey::new_from_slice(&data[offset+32..offset+64]).unwrap(),
funder: Pubkey::new_from_slice(&data[offset+64..offset+96]).unwrap(),
reward_duration: u64::from_le_bytes(data[offset+96..offset+104].try_into().unwrap()),
reward_duration_end: u64::from_le_bytes(data[offset+104..offset+112].try_into().unwrap()),
reward_rate: u64::from_le_bytes(data[offset+112..offset+120].try_into().unwrap()),
last_update_time: u64::from_le_bytes(data[offset+120..offset+128].try_into().unwrap()),
cumulative_seconds_with_empty_liquidity_reward: u64::from_le_bytes(data[offset+128..offset+136].try_into().unwrap()),
};
}

// Continue parsing remaining fields...
// [Additional parsing logic for oracle, bin_array_bitmap, etc...]

let pool = LiquidityPool {
parameters,
v_parameters,
bump_seed,
bin_step_seed,
pair_type,
active_id,
bin_step,
status,
require_base_factor_seed,
base_factor_seed,
activation_type,
creator_pool_on_off_control,
token_x_mint,
token_y_mint,
reserve_x,
reserve_y,
protocol_fee,
padding1,
reward_infos,
// ... remaining fields
};