mirror of
https://github.com/0xfnzero/solana-streamer.git
synced 2026-08-13 08:58:05 +00:00
328 lines
10 KiB
Rust
Executable File
328 lines
10 KiB
Rust
Executable File
use crate::streaming::event_parser::{
|
|
common::{read_u64_le, EventMetadata, EventType},
|
|
protocols::raydium_amm_v4::{
|
|
discriminators, RaydiumAmmV4DepositEvent, RaydiumAmmV4Initialize2Event,
|
|
RaydiumAmmV4SwapEvent, RaydiumAmmV4WithdrawEvent, RaydiumAmmV4WithdrawPnlEvent,
|
|
},
|
|
DexEvent,
|
|
};
|
|
use solana_sdk::pubkey::Pubkey;
|
|
|
|
/// Raydium AMM V4程序ID
|
|
pub const RAYDIUM_AMM_V4_PROGRAM_ID: Pubkey =
|
|
solana_sdk::pubkey!("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8");
|
|
|
|
/// 解析 Raydium AMM V4 instruction data
|
|
///
|
|
/// 根据判别器路由到具体的 instruction 解析函数
|
|
pub fn parse_raydium_amm_v4_instruction_data(
|
|
discriminator: &[u8],
|
|
data: &[u8],
|
|
accounts: &[Pubkey],
|
|
metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
match discriminator {
|
|
discriminators::SWAP_BASE_IN => {
|
|
parse_swap_base_input_instruction(data, accounts, metadata)
|
|
}
|
|
discriminators::SWAP_BASE_OUT => {
|
|
parse_swap_base_output_instruction(data, accounts, metadata)
|
|
}
|
|
discriminators::DEPOSIT => parse_deposit_instruction(data, accounts, metadata),
|
|
discriminators::INITIALIZE2 => parse_initialize2_instruction(data, accounts, metadata),
|
|
discriminators::WITHDRAW => parse_withdraw_instruction(data, accounts, metadata),
|
|
discriminators::WITHDRAW_PNL => {
|
|
parse_withdraw_pnl_instruction(data, accounts, metadata)
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// 解析 Raydium AMM V4 inner instruction data
|
|
///
|
|
/// Raydium AMM V4 没有 inner instruction 事件
|
|
pub fn parse_raydium_amm_v4_inner_instruction_data(
|
|
_discriminator: &[u8],
|
|
_data: &[u8],
|
|
_metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
None
|
|
}
|
|
|
|
|
|
/// 解析 Raydium AMM V4 账户数据
|
|
///
|
|
/// 根据判别器路由到具体的账户解析函数
|
|
pub fn parse_raydium_amm_v4_account_data(
|
|
discriminator: &[u8],
|
|
account: &crate::streaming::grpc::AccountPretty,
|
|
metadata: crate::streaming::event_parser::common::EventMetadata,
|
|
) -> Option<crate::streaming::event_parser::DexEvent> {
|
|
match discriminator {
|
|
discriminators::AMM_INFO => {
|
|
crate::streaming::event_parser::protocols::raydium_amm_v4::types::amm_info_parser(account, metadata)
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
|
|
/// 解析提现指令事件
|
|
fn parse_withdraw_pnl_instruction(
|
|
_data: &[u8],
|
|
accounts: &[Pubkey],
|
|
mut metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
metadata.event_type = EventType::RaydiumAmmV4WithdrawPnl;
|
|
|
|
if accounts.len() < 17 {
|
|
return None;
|
|
}
|
|
|
|
Some(DexEvent::RaydiumAmmV4WithdrawPnlEvent(RaydiumAmmV4WithdrawPnlEvent {
|
|
metadata,
|
|
token_program: accounts[0],
|
|
amm: accounts[1],
|
|
amm_config: accounts[2],
|
|
amm_authority: accounts[3],
|
|
amm_open_orders: accounts[4],
|
|
pool_coin_token_account: accounts[5],
|
|
pool_pc_token_account: accounts[6],
|
|
coin_pnl_token_account: accounts[7],
|
|
pc_pnl_token_account: accounts[8],
|
|
pnl_owner_account: accounts[9],
|
|
amm_target_orders: accounts[10],
|
|
serum_program: accounts[11],
|
|
serum_market: accounts[12],
|
|
serum_event_queue: accounts[13],
|
|
serum_coin_vault_account: accounts[14],
|
|
serum_pc_vault_account: accounts[15],
|
|
serum_vault_signer: accounts[16],
|
|
}))
|
|
}
|
|
|
|
/// 解析移除流动性指令事件
|
|
fn parse_withdraw_instruction(
|
|
data: &[u8],
|
|
accounts: &[Pubkey],
|
|
mut metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
metadata.event_type = EventType::RaydiumAmmV4Withdraw;
|
|
|
|
if data.len() < 8 || accounts.len() < 22 {
|
|
return None;
|
|
}
|
|
let amount = read_u64_le(data, 0)?;
|
|
|
|
Some(DexEvent::RaydiumAmmV4WithdrawEvent(RaydiumAmmV4WithdrawEvent {
|
|
metadata,
|
|
amount,
|
|
|
|
token_program: accounts[0],
|
|
amm: accounts[1],
|
|
amm_authority: accounts[2],
|
|
amm_open_orders: accounts[3],
|
|
amm_target_orders: accounts[4],
|
|
lp_mint_address: accounts[5],
|
|
pool_coin_token_account: accounts[6],
|
|
pool_pc_token_account: accounts[7],
|
|
pool_withdraw_queue: accounts[8],
|
|
pool_temp_lp_token_account: accounts[9],
|
|
serum_program: accounts[10],
|
|
serum_market: accounts[11],
|
|
serum_coin_vault_account: accounts[12],
|
|
serum_pc_vault_account: accounts[13],
|
|
serum_vault_signer: accounts[14],
|
|
user_lp_token_account: accounts[15],
|
|
user_coin_token_account: accounts[16],
|
|
user_pc_token_account: accounts[17],
|
|
user_owner: accounts[18],
|
|
serum_event_queue: accounts[19],
|
|
serum_bids: accounts[20],
|
|
serum_asks: accounts[21],
|
|
}))
|
|
}
|
|
|
|
/// 解析初始化指令事件
|
|
fn parse_initialize2_instruction(
|
|
data: &[u8],
|
|
accounts: &[Pubkey],
|
|
mut metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
metadata.event_type = EventType::RaydiumAmmV4Initialize2;
|
|
|
|
if data.len() < 25 || accounts.len() < 21 {
|
|
return None;
|
|
}
|
|
let nonce = data[0];
|
|
let open_time = read_u64_le(data, 1)?;
|
|
let init_pc_amount = read_u64_le(data, 9)?;
|
|
let init_coin_amount = read_u64_le(data, 17)?;
|
|
|
|
Some(DexEvent::RaydiumAmmV4Initialize2Event(RaydiumAmmV4Initialize2Event {
|
|
metadata,
|
|
nonce,
|
|
open_time,
|
|
init_pc_amount,
|
|
init_coin_amount,
|
|
|
|
token_program: accounts[0],
|
|
spl_associated_token_account: accounts[1],
|
|
system_program: accounts[2],
|
|
rent: accounts[3],
|
|
amm: accounts[4],
|
|
amm_authority: accounts[5],
|
|
amm_open_orders: accounts[6],
|
|
lp_mint: accounts[7],
|
|
coin_mint: accounts[8],
|
|
pc_mint: accounts[9],
|
|
pool_coin_token_account: accounts[10],
|
|
pool_pc_token_account: accounts[11],
|
|
pool_withdraw_queue: accounts[12],
|
|
amm_target_orders: accounts[13],
|
|
pool_temp_lp: accounts[14],
|
|
serum_program: accounts[15],
|
|
serum_market: accounts[16],
|
|
user_wallet: accounts[17],
|
|
user_token_coin: accounts[18],
|
|
user_token_pc: accounts[19],
|
|
user_lp_token_account: accounts[20],
|
|
}))
|
|
}
|
|
|
|
/// 解析添加流动性指令事件
|
|
fn parse_deposit_instruction(
|
|
data: &[u8],
|
|
accounts: &[Pubkey],
|
|
mut metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
metadata.event_type = EventType::RaydiumAmmV4Deposit;
|
|
|
|
if data.len() < 24 || accounts.len() < 14 {
|
|
return None;
|
|
}
|
|
let max_coin_amount = read_u64_le(data, 0)?;
|
|
let max_pc_amount = read_u64_le(data, 8)?;
|
|
let base_side = read_u64_le(data, 16)?;
|
|
|
|
Some(DexEvent::RaydiumAmmV4DepositEvent(RaydiumAmmV4DepositEvent {
|
|
metadata,
|
|
max_coin_amount,
|
|
max_pc_amount,
|
|
base_side,
|
|
|
|
token_program: accounts[0],
|
|
amm: accounts[1],
|
|
amm_authority: accounts[2],
|
|
amm_open_orders: accounts[3],
|
|
amm_target_orders: accounts[4],
|
|
lp_mint_address: accounts[5],
|
|
pool_coin_token_account: accounts[6],
|
|
pool_pc_token_account: accounts[7],
|
|
serum_market: accounts[8],
|
|
user_coin_token_account: accounts[9],
|
|
user_pc_token_account: accounts[10],
|
|
user_lp_token_account: accounts[11],
|
|
user_owner: accounts[12],
|
|
serum_event_queue: accounts[13],
|
|
}))
|
|
}
|
|
|
|
/// 解析买入指令事件
|
|
fn parse_swap_base_output_instruction(
|
|
data: &[u8],
|
|
accounts: &[Pubkey],
|
|
mut metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
metadata.event_type = EventType::RaydiumAmmV4SwapBaseOut;
|
|
|
|
if data.len() < 16 || accounts.len() < 17 {
|
|
return None;
|
|
}
|
|
let max_amount_in = read_u64_le(data, 0)?;
|
|
let amount_out = read_u64_le(data, 8)?;
|
|
|
|
let mut accounts = accounts.to_vec();
|
|
if accounts.len() == 17 {
|
|
// 添加一个默认的 Pubkey 作为 amm_target_orders 的占位符
|
|
// 因为在某些情况下，amm_target_orders 可能是可选的
|
|
accounts.insert(4, Pubkey::default());
|
|
}
|
|
|
|
Some(DexEvent::RaydiumAmmV4SwapEvent(RaydiumAmmV4SwapEvent {
|
|
metadata,
|
|
max_amount_in,
|
|
amount_out,
|
|
|
|
token_program: accounts[0],
|
|
amm: accounts[1],
|
|
amm_authority: accounts[2],
|
|
amm_open_orders: accounts[3],
|
|
amm_target_orders: Some(accounts[4]),
|
|
pool_coin_token_account: accounts[5],
|
|
pool_pc_token_account: accounts[6],
|
|
serum_program: accounts[7],
|
|
serum_market: accounts[8],
|
|
serum_bids: accounts[9],
|
|
serum_asks: accounts[10],
|
|
serum_event_queue: accounts[11],
|
|
serum_coin_vault_account: accounts[12],
|
|
serum_pc_vault_account: accounts[13],
|
|
serum_vault_signer: accounts[14],
|
|
user_source_token_account: accounts[15],
|
|
user_destination_token_account: accounts[16],
|
|
user_source_owner: accounts[17],
|
|
|
|
..Default::default()
|
|
}))
|
|
}
|
|
|
|
/// 解析买入指令事件
|
|
fn parse_swap_base_input_instruction(
|
|
data: &[u8],
|
|
accounts: &[Pubkey],
|
|
mut metadata: EventMetadata,
|
|
) -> Option<DexEvent> {
|
|
metadata.event_type = EventType::RaydiumAmmV4SwapBaseIn;
|
|
|
|
if data.len() < 16 || accounts.len() < 17 {
|
|
return None;
|
|
}
|
|
let amount_in = read_u64_le(data, 0)?;
|
|
let minimum_amount_out = read_u64_le(data, 8)?;
|
|
|
|
let mut accounts = accounts.to_vec();
|
|
if accounts.len() == 17 {
|
|
// 添加一个默认的 Pubkey 作为 amm_target_orders 的占位符
|
|
// 因为在某些情况下，amm_target_orders 可能是可选的
|
|
accounts.insert(4, Pubkey::default());
|
|
}
|
|
|
|
Some(DexEvent::RaydiumAmmV4SwapEvent(RaydiumAmmV4SwapEvent {
|
|
metadata,
|
|
amount_in,
|
|
minimum_amount_out,
|
|
|
|
token_program: accounts[0],
|
|
amm: accounts[1],
|
|
amm_authority: accounts[2],
|
|
amm_open_orders: accounts[3],
|
|
amm_target_orders: Some(accounts[4]),
|
|
pool_coin_token_account: accounts[5],
|
|
pool_pc_token_account: accounts[6],
|
|
serum_program: accounts[7],
|
|
serum_market: accounts[8],
|
|
serum_bids: accounts[9],
|
|
serum_asks: accounts[10],
|
|
serum_event_queue: accounts[11],
|
|
serum_coin_vault_account: accounts[12],
|
|
serum_pc_vault_account: accounts[13],
|
|
serum_vault_signer: accounts[14],
|
|
user_source_token_account: accounts[15],
|
|
user_destination_token_account: accounts[16],
|
|
user_source_owner: accounts[17],
|
|
|
|
..Default::default()
|
|
}))
|
|
}
|