gavindiaz/solana-streamer
1
0
Fork 0
mirror of https://github.com/0xfnzero/solana-streamer.git synced 2026-08-19 11:58:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Release solana-streamer-sdk v1.4.3

Browse Source 
Route gRPC, ShredStream, and account parsing through sol-parser-sdk.

Remove local protocol parsing implementations.

Depend on sol-parser-sdk v0.4.8 from crates.io.
This commit is contained in:
0xfnzero
2026-05-16 06:45:35 +08:00
parent 55e6bc6459
commit 92bac16fd4
43 changed files with 837 additions and 5460 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/streaming/event_parser/protocols/bonk/parser.rs
Executable → Regular
+8 -582
View File
@@ -1,605 +1,31 @@
use crate::streaming::event_parser::{
common::EventMetadata, core::EventDispatcher, DexEvent, Protocol,
};
use solana_sdk::pubkey::Pubkey;
use crate::streaming::event_parser::{
common::{utils::*, EventMetadata, EventType},
protocols::bonk::{
bonk_pool_create_event_log_decode, bonk_trade_event_log_decode, discriminators, AmmFeeOn,
BonkMigrateToAmmEvent, BonkMigrateToCpswapEvent, BonkPoolCreateEvent, BonkTradeEvent,
ConstantCurve, CurveParams, FixedCurve, LinearCurve, MintParams, TradeDirection,
VestingParams,
},
DexEvent,
};
pub use sol_parser_sdk::instr::program_ids::BONK_PROGRAM_ID;
/// Bonk Program ID
pub const BONK_PROGRAM_ID: Pubkey =
solana_sdk::pubkey!("LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj");
/// 解析 Bonk instruction data
///
/// 根据判别器路由到具体的 instruction 解析函数
pub fn parse_bonk_instruction_data(
discriminator: &[u8],
data: &[u8],
accounts: &[Pubkey],
metadata: EventMetadata,
) -> Option<DexEvent> {
match discriminator {
discriminators::BUY_EXACT_IN => parse_buy_exact_in_instruction(data, accounts, metadata),
discriminators::BUY_EXACT_OUT => parse_buy_exact_out_instruction(data, accounts, metadata),
discriminators::SELL_EXACT_IN => parse_sell_exact_in_instruction(data, accounts, metadata),
discriminators::SELL_EXACT_OUT => {
parse_sell_exact_out_instruction(data, accounts, metadata)
}
discriminators::INITIALIZE => parse_initialize_instruction(data, accounts, metadata),
discriminators::INITIALIZE_V2 => parse_initialize_v2_instruction(data, accounts, metadata),
discriminators::INITIALIZE_WITH_TOKEN_2022 => {
parse_initialize_with_token_2022_instruction(data, accounts, metadata)
}
discriminators::MIGRATE_TO_AMM => {
parse_migrate_to_amm_instruction(data, accounts, metadata)
}
discriminators::MIGRATE_TO_CP_SWAP => {
parse_migrate_to_cpswap_instruction(data, accounts, metadata)
}
_ => None,
}
EventDispatcher::dispatch_instruction(Protocol::Bonk, discriminator, data, accounts, metadata)
}
/// 解析 Bonk inner instruction data
///
/// 根据判别器路由到具体的 inner instruction 解析函数
pub fn parse_bonk_inner_instruction_data(
discriminator: &[u8],
data: &[u8],
metadata: EventMetadata,
) -> Option<DexEvent> {
match discriminator {
discriminators::TRADE_EVENT => parse_trade_inner_instruction(data, metadata),
discriminators::POOL_CREATE_EVENT => parse_pool_create_inner_instruction(data, metadata),
_ => None,
}
EventDispatcher::dispatch_inner_instruction(Protocol::Bonk, discriminator, data, metadata)
}
/// 解析 Bonk 账户数据
///
/// 根据判别器路由到具体的账户解析函数
pub fn parse_bonk_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::POOL_STATE_ACCOUNT => {
crate::streaming::event_parser::protocols::bonk::types::pool_state_parser(
account, metadata,
)
}
discriminators::GLOBAL_CONFIG_ACCOUNT => {
crate::streaming::event_parser::protocols::bonk::types::global_config_parser(
account, metadata,
)
}
discriminators::PLATFORM_CONFIG_ACCOUNT => {
crate::streaming::event_parser::protocols::bonk::types::platform_config_parser(
account, metadata,
)
}
_ => None,
}
}
/// Parse pool creation event
fn parse_pool_create_inner_instruction(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
// Note: event_type will be set by the instruction parser, not here
// Because different initialize instructions have different event types
if let Some(event) = bonk_pool_create_event_log_decode(data) {
Some(DexEvent::BonkPoolCreateEvent(BonkPoolCreateEvent { metadata, ..event }))
} else {
None
}
}
/// Parse trade event
fn parse_trade_inner_instruction(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
if let Some(event) = bonk_trade_event_log_decode(data) {
if metadata.event_type == EventType::BonkBuyExactIn
|| metadata.event_type == EventType::BonkBuyExactOut
{
if event.trade_direction != TradeDirection::Buy {
return None;
}
} else if (metadata.event_type == EventType::BonkSellExactIn
|| metadata.event_type == EventType::BonkSellExactOut)
&& event.trade_direction != TradeDirection::Sell
{
return None;
}
Some(DexEvent::BonkTradeEvent(BonkTradeEvent { metadata, ..event }))
} else {
None
}
}
/// Parse buy instruction event
fn parse_buy_exact_in_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkBuyExactIn;
if data.len() < 16 || accounts.len() < 18 {
return None;
}
let amount_in = read_u64_le(data, 0)?;
let minimum_amount_out = read_u64_le(data, 8)?;
let share_fee_rate = read_u64_le(data, 16)?;
Some(DexEvent::BonkTradeEvent(BonkTradeEvent {
metadata,
amount_in,
minimum_amount_out,
share_fee_rate,
payer: accounts[0],
global_config: accounts[2],
platform_config: accounts[3],
pool_state: accounts[4],
user_base_token: accounts[5],
user_quote_token: accounts[6],
base_vault: accounts[7],
quote_vault: accounts[8],
base_token_mint: accounts[9],
quote_token_mint: accounts[10],
base_token_program: accounts[11],
quote_token_program: accounts[12],
system_program: accounts[15],
platform_associated_account: accounts[16],
creator_associated_account: accounts[17],
trade_direction: TradeDirection::Buy,
..Default::default()
}))
}
fn parse_buy_exact_out_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkBuyExactOut;
if data.len() < 16 || accounts.len() < 18 {
return None;
}
let amount_out = read_u64_le(data, 0)?;
let maximum_amount_in = read_u64_le(data, 8)?;
let share_fee_rate = read_u64_le(data, 16)?;
Some(DexEvent::BonkTradeEvent(BonkTradeEvent {
metadata,
amount_out,
maximum_amount_in,
share_fee_rate,
payer: accounts[0],
global_config: accounts[2],
platform_config: accounts[3],
pool_state: accounts[4],
user_base_token: accounts[5],
user_quote_token: accounts[6],
base_vault: accounts[7],
quote_vault: accounts[8],
base_token_mint: accounts[9],
quote_token_mint: accounts[10],
base_token_program: accounts[11],
quote_token_program: accounts[12],
system_program: accounts[15],
platform_associated_account: accounts[16],
creator_associated_account: accounts[17],
trade_direction: TradeDirection::Buy,
..Default::default()
}))
}
fn parse_sell_exact_in_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkSellExactIn;
if data.len() < 16 || accounts.len() < 18 {
return None;
}
let amount_in = read_u64_le(data, 0)?;
let minimum_amount_out = read_u64_le(data, 8)?;
let share_fee_rate = read_u64_le(data, 16)?;
Some(DexEvent::BonkTradeEvent(BonkTradeEvent {
metadata,
amount_in,
minimum_amount_out,
share_fee_rate,
payer: accounts[0],
global_config: accounts[2],
platform_config: accounts[3],
pool_state: accounts[4],
user_base_token: accounts[5],
user_quote_token: accounts[6],
base_vault: accounts[7],
quote_vault: accounts[8],
base_token_mint: accounts[9],
quote_token_mint: accounts[10],
base_token_program: accounts[11],
quote_token_program: accounts[12],
system_program: accounts[15],
platform_associated_account: accounts[16],
creator_associated_account: accounts[17],
trade_direction: TradeDirection::Sell,
..Default::default()
}))
}
fn parse_sell_exact_out_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkSellExactOut;
if data.len() < 16 || accounts.len() < 18 {
return None;
}
let amount_out = read_u64_le(data, 0)?;
let maximum_amount_in = read_u64_le(data, 8)?;
let share_fee_rate = read_u64_le(data, 16)?;
Some(DexEvent::BonkTradeEvent(BonkTradeEvent {
metadata,
amount_out,
maximum_amount_in,
share_fee_rate,
payer: accounts[0],
global_config: accounts[2],
platform_config: accounts[3],
pool_state: accounts[4],
user_base_token: accounts[5],
user_quote_token: accounts[6],
base_vault: accounts[7],
quote_vault: accounts[8],
base_token_mint: accounts[9],
quote_token_mint: accounts[10],
base_token_program: accounts[11],
quote_token_program: accounts[12],
system_program: accounts[15],
platform_associated_account: accounts[16],
creator_associated_account: accounts[17],
trade_direction: TradeDirection::Sell,
..Default::default()
}))
}
/// Parse initialize event
fn parse_initialize_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkInitialize;
if data.len() < 24 {
return None;
}
let mut offset = 0;
let base_mint_param = parse_mint_params(data, &mut offset)?;
let curve_param = parse_curve_params(data, &mut offset)?;
let vesting_param = parse_vesting_params(data, &mut offset)?;
Some(DexEvent::BonkPoolCreateEvent(BonkPoolCreateEvent {
metadata,
payer: accounts[0],
creator: accounts[1],
global_config: accounts[2],
platform_config: accounts[3],
pool_state: accounts[5],
base_mint: accounts[6],
quote_mint: accounts[7],
base_vault: accounts[8],
quote_vault: accounts[9],
base_mint_param,
curve_param,
vesting_param,
..Default::default()
}))
}
/// Parse initialize event
fn parse_initialize_v2_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkInitializeV2;
if data.len() < 24 {
return None;
}
let mut offset = 0;
let base_mint_param = parse_mint_params(data, &mut offset)?;
let curve_param = parse_curve_params(data, &mut offset)?;
let vesting_param = parse_vesting_params(data, &mut offset)?;
let amm_fee_on = data[offset];
Some(DexEvent::BonkPoolCreateEvent(BonkPoolCreateEvent {
metadata,
payer: accounts[0],
creator: accounts[1],
global_config: accounts[2],
platform_config: accounts[3],
pool_state: accounts[5],
base_mint: accounts[6],
quote_mint: accounts[7],
base_vault: accounts[8],
quote_vault: accounts[9],
base_mint_param,
curve_param,
vesting_param,
amm_fee_on: if amm_fee_on == 0 {
Some(AmmFeeOn::QuoteToken)
} else {
Some(AmmFeeOn::BothToken)
},
..Default::default()
}))
}
/// Parse initialize event
fn parse_initialize_with_token_2022_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkInitializeWithToken2022;
if data.len() < 24 {
return None;
}
let mut offset = 0;
let base_mint_param = parse_mint_params(data, &mut offset)?;
let curve_param = parse_curve_params(data, &mut offset)?;
let vesting_param = parse_vesting_params(data, &mut offset)?;
let amm_fee_on = data[offset];
Some(DexEvent::BonkPoolCreateEvent(BonkPoolCreateEvent {
metadata,
payer: accounts[0],
creator: accounts[1],
global_config: accounts[2],
platform_config: accounts[3],
pool_state: accounts[5],
base_mint: accounts[6],
quote_mint: accounts[7],
base_vault: accounts[8],
quote_vault: accounts[9],
base_mint_param,
curve_param,
vesting_param,
amm_fee_on: if amm_fee_on == 0 {
Some(AmmFeeOn::QuoteToken)
} else {
Some(AmmFeeOn::BothToken)
},
..Default::default()
}))
}
/// Parse MintParams structure
fn parse_mint_params(data: &[u8], offset: &mut usize) -> Option<MintParams> {
// Read decimals (1 byte)
let decimals = read_u8(data, *offset)?;
*offset += 1;
// Read name string length and content
let name_len = read_u32_le(data, *offset)? as usize;
*offset += 4;
if data.len() < *offset + name_len {
return None;
}
let name = String::from_utf8(data[*offset..*offset + name_len].to_vec()).ok()?;
*offset += name_len;
// Read symbol string length and content
let symbol_len = read_u32_le(data, *offset)? as usize;
*offset += 4;
if data.len() < *offset + symbol_len {
return None;
}
let symbol = String::from_utf8(data[*offset..*offset + symbol_len].to_vec()).ok()?;
*offset += symbol_len;
// Read uri string length and content
let uri_len = read_u32_le(data, *offset)? as usize;
*offset += 4;
if data.len() < *offset + uri_len {
return None;
}
let uri = String::from_utf8(data[*offset..*offset + uri_len].to_vec()).ok()?;
*offset += uri_len;
Some(MintParams { decimals, name, symbol, uri })
}
/// Parse CurveParams structure
fn parse_curve_params(data: &[u8], offset: &mut usize) -> Option<CurveParams> {
// Read curve type identifier (1 byte)
let curve_type = read_u8(data, *offset)?;
*offset += 1;
match curve_type {
0 => {
// Constant curve
let supply = read_u64_le(data, *offset)?;
*offset += 8;
let total_base_sell = read_u64_le(data, *offset)?;
*offset += 8;
let total_quote_fund_raising = read_u64_le(data, *offset)?;
*offset += 8;
let migrate_type = read_u8(data, *offset)?;
*offset += 1;
Some(CurveParams::Constant {
data: ConstantCurve {
supply,
total_base_sell,
total_quote_fund_raising,
migrate_type,
},
})
}
1 => {
// Fixed curve
let supply = read_u64_le(data, *offset)?;
*offset += 8;
let total_quote_fund_raising = read_u64_le(data, *offset)?;
*offset += 8;
let migrate_type = read_u8(data, *offset)?;
*offset += 1;
Some(CurveParams::Fixed {
data: FixedCurve { supply, total_quote_fund_raising, migrate_type },
})
}
2 => {
// Linear curve
let supply = read_u64_le(data, *offset)?;
*offset += 8;
let total_quote_fund_raising = read_u64_le(data, *offset)?;
*offset += 8;
let migrate_type = read_u8(data, *offset)?;
*offset += 1;
Some(CurveParams::Linear {
data: LinearCurve { supply, total_quote_fund_raising, migrate_type },
})
}
_ => None,
}
}
/// Parse VestingParams structure
fn parse_vesting_params(data: &[u8], offset: &mut usize) -> Option<VestingParams> {
let total_locked_amount = read_u64_le(data, *offset)?;
*offset += 8;
let cliff_period = read_u64_le(data, *offset)?;
*offset += 8;
let unlock_period = read_u64_le(data, *offset)?;
*offset += 8;
Some(VestingParams { total_locked_amount, cliff_period, unlock_period })
}
/// Parse migrate to AMM event
fn parse_migrate_to_amm_instruction(
data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkMigrateToAmm;
if data.len() < 16 {
return None;
}
let base_lot_size = u64::from_le_bytes(data[0..8].try_into().unwrap());
let quote_lot_size = u64::from_le_bytes(data[8..16].try_into().unwrap());
let market_vault_signer_nonce = data[16];
Some(DexEvent::BonkMigrateToAmmEvent(BonkMigrateToAmmEvent {
metadata,
base_lot_size,
quote_lot_size,
market_vault_signer_nonce,
payer: accounts[0],
base_mint: accounts[1],
quote_mint: accounts[2],
openbook_program: accounts[3],
market: accounts[4],
request_queue: accounts[5],
event_queue: accounts[6],
bids: accounts[7],
asks: accounts[8],
market_vault_signer: accounts[9],
market_base_vault: accounts[10],
market_quote_vault: accounts[11],
amm_program: accounts[12],
amm_pool: accounts[13],
amm_authority: accounts[14],
amm_open_orders: accounts[15],
amm_lp_mint: accounts[16],
amm_base_vault: accounts[17],
amm_quote_vault: accounts[18],
amm_target_orders: accounts[19],
amm_config: accounts[20],
amm_create_fee_destination: accounts[21],
authority: accounts[22],
pool_state: accounts[23],
global_config: accounts[24],
base_vault: accounts[25],
quote_vault: accounts[26],
pool_lp_token: accounts[27],
spl_token_program: accounts[28],
associated_token_program: accounts[29],
system_program: accounts[30],
rent_program: accounts[31],
..Default::default()
}))
}
/// Parse migrate to CP Swap event
fn parse_migrate_to_cpswap_instruction(
_data: &[u8],
accounts: &[Pubkey],
mut metadata: EventMetadata,
) -> Option<DexEvent> {
metadata.event_type = EventType::BonkMigrateToCpswap;
Some(DexEvent::BonkMigrateToCpswapEvent(BonkMigrateToCpswapEvent {
metadata,
payer: accounts[0],
base_mint: accounts[1],
quote_mint: accounts[2],
platform_config: accounts[3],
cpswap_program: accounts[4],
cpswap_pool: accounts[5],
cpswap_authority: accounts[6],
cpswap_lp_mint: accounts[7],
cpswap_base_vault: accounts[8],
cpswap_quote_vault: accounts[9],
cpswap_config: accounts[10],
cpswap_create_pool_fee: accounts[11],
cpswap_observation: accounts[12],
lock_program: accounts[13],
lock_authority: accounts[14],
lock_lp_vault: accounts[15],
authority: accounts[16],
pool_state: accounts[17],
global_config: accounts[18],
base_vault: accounts[19],
quote_vault: accounts[20],
pool_lp_token: accounts[21],
base_token_program: accounts[22],
quote_token_program: accounts[23],
associated_token_program: accounts[24],
system_program: accounts[25],
rent_program: accounts[26],
metadata_program: accounts[27],
remaining_accounts: accounts[28..].to_vec(),
..Default::default()
}))
EventDispatcher::dispatch_account(Protocol::Bonk, discriminator, account, metadata)
}