sol_parser_sdk/logs/

meteora_dlmm.rs

//! Meteora DLMM log parser
//!
//! Parse Meteora DLMM program log events

use super::utils::*;
use crate::core::events::*;
use solana_sdk::signature::Signature;

/// Meteora DLMM 事件 discriminator 常量
pub mod discriminators {
    pub const SWAP_EVENT: [u8; 8] = [81, 108, 227, 190, 205, 208, 10, 196];
    pub const SWAP2_EVENT: [u8; 8] = [46, 116, 82, 215, 148, 27, 84, 77];
    pub const ADD_LIQUIDITY_EVENT: [u8; 8] = [31, 94, 125, 90, 227, 52, 61, 186];
    pub const REMOVE_LIQUIDITY_EVENT: [u8; 8] = [116, 244, 97, 232, 103, 31, 152, 58];
    pub const INITIALIZE_POOL_EVENT: [u8; 8] = [185, 74, 252, 125, 27, 215, 188, 111];
    pub const CREATE_POSITION_EVENT: [u8; 8] = [144, 142, 252, 84, 157, 53, 37, 121];
    pub const CLOSE_POSITION_EVENT: [u8; 8] = [255, 196, 16, 107, 28, 202, 53, 128];
    pub const CLAIM_FEE_EVENT: [u8; 8] = [75, 122, 154, 48, 140, 74, 123, 163];
    pub const CLAIM_FEE2_EVENT: [u8; 8] = [232, 171, 242, 97, 58, 77, 35, 45];

    pub const LEGACY_SWAP_EVENT: [u8; 8] = [143, 190, 90, 218, 196, 30, 51, 222];
    pub const LEGACY_ADD_LIQUIDITY_EVENT: [u8; 8] = [181, 157, 89, 67, 143, 182, 52, 72];
    pub const LEGACY_REMOVE_LIQUIDITY_EVENT: [u8; 8] = [80, 85, 209, 72, 24, 206, 35, 178];
    pub const LEGACY_INITIALIZE_BIN_ARRAY_EVENT: [u8; 8] = [11, 18, 155, 194, 33, 115, 238, 119];
    pub const LEGACY_INITIALIZE_POOL_EVENT: [u8; 8] = [95, 180, 10, 172, 84, 174, 232, 40];
    pub const LEGACY_CREATE_POSITION_EVENT: [u8; 8] = [123, 233, 11, 43, 146, 180, 97, 119];
    pub const LEGACY_CLOSE_POSITION_EVENT: [u8; 8] = [94, 168, 102, 45, 59, 122, 137, 54];
    pub const LEGACY_CLAIM_FEE_EVENT: [u8; 8] = [152, 70, 208, 111, 104, 91, 44, 1];
}

/// 主要的 Meteora DLMM 日志解析函数
pub fn parse_log(
    log: &str,
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    parse_structured_log(log, signature, slot, tx_index, block_time_us, grpc_recv_us)
}

/// 解析结构化日志（基于 discriminator）
fn parse_structured_log(
    log: &str,
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let program_data = extract_program_data(log)?;
    if program_data.len() < 8 {
        return None;
    }

    let discriminator: [u8; 8] = program_data[0..8].try_into().ok()?;
    let data = &program_data[8..];

    match discriminator {
        discriminators::SWAP_EVENT | discriminators::LEGACY_SWAP_EVENT => {
            parse_swap_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        discriminators::SWAP2_EVENT => {
            parse_swap2_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        discriminators::ADD_LIQUIDITY_EVENT | discriminators::LEGACY_ADD_LIQUIDITY_EVENT => {
            parse_add_liquidity_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        discriminators::REMOVE_LIQUIDITY_EVENT | discriminators::LEGACY_REMOVE_LIQUIDITY_EVENT => {
            parse_remove_liquidity_event(
                data,
                signature,
                slot,
                tx_index,
                block_time_us,
                grpc_recv_us,
            )
        }
        discriminators::LEGACY_INITIALIZE_BIN_ARRAY_EVENT => parse_initialize_bin_array_event(
            data,
            signature,
            slot,
            tx_index,
            block_time_us,
            grpc_recv_us,
        ),
        discriminators::INITIALIZE_POOL_EVENT => {
            parse_lb_pair_create_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        discriminators::LEGACY_INITIALIZE_POOL_EVENT => parse_initialize_pool_event(
            data,
            signature,
            slot,
            tx_index,
            block_time_us,
            grpc_recv_us,
        ),
        discriminators::CREATE_POSITION_EVENT => parse_position_create_event(
            data,
            signature,
            slot,
            tx_index,
            block_time_us,
            grpc_recv_us,
        ),
        discriminators::LEGACY_CREATE_POSITION_EVENT => parse_create_position_event(
            data,
            signature,
            slot,
            tx_index,
            block_time_us,
            grpc_recv_us,
        ),
        discriminators::CLOSE_POSITION_EVENT => {
            parse_position_close_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        discriminators::LEGACY_CLOSE_POSITION_EVENT => {
            parse_close_position_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        discriminators::CLAIM_FEE_EVENT | discriminators::LEGACY_CLAIM_FEE_EVENT => {
            parse_claim_fee_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        discriminators::CLAIM_FEE2_EVENT => {
            parse_claim_fee2_event(data, signature, slot, tx_index, block_time_us, grpc_recv_us)
        }
        _ => None,
    }
}

// =============================================================================
// Public from_data parsers - Accept pre-decoded data, eliminate double decode
// =============================================================================

#[inline(always)]
pub fn parse_swap_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let from = read_pubkey(data, offset)?;
    offset += 32;

    let start_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let end_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let amount_in = read_u64_le(data, offset)?;
    offset += 8;

    let amount_out = read_u64_le(data, offset)?;
    offset += 8;

    let swap_for_y = read_bool(data, offset)?;
    offset += 1;

    let fee = read_u64_le(data, offset)?;
    offset += 8;

    let protocol_fee = read_u64_le(data, offset)?;
    offset += 8;

    let fee_bps = read_u128_le(data, offset)?;
    offset += 16;

    let host_fee = read_u64_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmSwap(MeteoraDlmmSwapEvent {
        metadata,
        pool,
        from,
        start_bin_id,
        end_bin_id,
        amount_in,
        amount_out,
        swap_for_y,
        fee,
        protocol_fee,
        fee_bps,
        host_fee,
    }))
}

#[inline(always)]
pub fn parse_swap2_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    if data.len() < 147 {
        return None;
    }
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let from = read_pubkey(data, offset)?;
    offset += 32;

    let start_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let end_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let swap_for_y = read_bool(data, offset)?;
    offset += 1;

    let fee_bps = read_u128_le(data, offset)?;
    offset += 16;

    let amount_in = read_u64_le(data, offset)?;
    offset += 8;

    let _amount_left = read_u64_le(data, offset)?;
    offset += 8;

    let amount_out = read_u64_le(data, offset)?;
    offset += 8;

    let fee = read_u64_le(data, offset)?;
    offset += 8;

    let protocol_fee = read_u64_le(data, offset)?;
    offset += 8;

    let _limit_order_fee = read_u64_le(data, offset)?;
    offset += 8;

    let host_fee = read_u64_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmSwap(MeteoraDlmmSwapEvent {
        metadata,
        pool,
        from,
        start_bin_id,
        end_bin_id,
        amount_in,
        amount_out,
        swap_for_y,
        fee,
        protocol_fee,
        fee_bps,
        host_fee,
    }))
}

#[inline(always)]
pub fn parse_add_liquidity_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let from = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let amount_0 = read_u64_le(data, offset)?;
    offset += 8;

    let amount_1 = read_u64_le(data, offset)?;
    offset += 8;

    let active_bin_id = read_i32_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmAddLiquidity(MeteoraDlmmAddLiquidityEvent {
        metadata,
        pool,
        from,
        position,
        amounts: [amount_0, amount_1],
        active_bin_id,
    }))
}

#[inline(always)]
pub fn parse_remove_liquidity_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let from = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let amount_0 = read_u64_le(data, offset)?;
    offset += 8;

    let amount_1 = read_u64_le(data, offset)?;
    offset += 8;

    let active_bin_id = read_i32_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmRemoveLiquidity(MeteoraDlmmRemoveLiquidityEvent {
        metadata,
        pool,
        from,
        position,
        amounts: [amount_0, amount_1],
        active_bin_id,
    }))
}

#[inline(always)]
pub fn parse_initialize_pool_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let creator = read_pubkey(data, offset)?;
    offset += 32;

    let active_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let bin_step = read_u16_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmInitializePool(MeteoraDlmmInitializePoolEvent {
        metadata,
        pool,
        creator,
        active_bin_id,
        bin_step,
    }))
}

#[inline(always)]
pub fn parse_initialize_bin_array_from_data(
    data: &[u8],
    metadata: EventMetadata,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let bin_array = read_pubkey(data, offset)?;
    offset += 32;

    let index = read_i64_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmInitializeBinArray(MeteoraDlmmInitializeBinArrayEvent {
        metadata,
        pool,
        bin_array,
        index,
    }))
}

#[inline(always)]
pub fn parse_create_position_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;
    offset += 32;

    let lower_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let width = read_u32_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmCreatePosition(MeteoraDlmmCreatePositionEvent {
        metadata,
        pool,
        position,
        owner,
        lower_bin_id,
        width,
    }))
}

#[inline(always)]
pub fn parse_close_position_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;

    Some(DexEvent::MeteoraDlmmClosePosition(MeteoraDlmmClosePositionEvent {
        metadata,
        pool,
        position,
        owner,
    }))
}

#[inline(always)]
pub fn parse_claim_fee_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;
    offset += 32;

    let fee_x = read_u64_le(data, offset)?;
    offset += 8;

    let fee_y = read_u64_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmClaimFee(MeteoraDlmmClaimFeeEvent {
        metadata,
        pool,
        position,
        owner,
        fee_x,
        fee_y,
    }))
}

#[inline(always)]
pub fn parse_claim_fee2_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    if data.len() < 116 {
        return None;
    }
    parse_claim_fee_from_data(data, metadata)
}

#[inline(always)]
pub fn parse_lb_pair_create_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let bin_step = read_u16_le(data, offset)?;

    Some(DexEvent::MeteoraDlmmInitializePool(MeteoraDlmmInitializePoolEvent {
        metadata,
        pool,
        creator: Default::default(),
        active_bin_id: 0,
        bin_step,
    }))
}

#[inline(always)]
pub fn parse_position_create_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;

    Some(DexEvent::MeteoraDlmmCreatePosition(MeteoraDlmmCreatePositionEvent {
        metadata,
        pool,
        position,
        owner,
        lower_bin_id: 0,
        width: 0,
    }))
}

#[inline(always)]
pub fn parse_position_close_from_data(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    let mut offset = 0;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;

    Some(DexEvent::MeteoraDlmmClosePosition(MeteoraDlmmClosePositionEvent {
        metadata,
        pool: Default::default(),
        position,
        owner,
    }))
}

/// 解析交换事件
fn parse_swap_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let from = read_pubkey(data, offset)?;
    offset += 32;

    let start_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let end_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let amount_in = read_u64_le(data, offset)?;
    offset += 8;

    let amount_out = read_u64_le(data, offset)?;
    offset += 8;

    let swap_for_y = read_bool(data, offset)?;
    offset += 1;

    let fee = read_u64_le(data, offset)?;
    offset += 8;

    let protocol_fee = read_u64_le(data, offset)?;
    offset += 8;

    let fee_bps = read_u128_le(data, offset)?;
    offset += 16;

    let host_fee = read_u64_le(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmSwap(MeteoraDlmmSwapEvent {
        metadata,
        pool,
        from,
        start_bin_id,
        end_bin_id,
        amount_in,
        amount_out,
        swap_for_y,
        fee,
        protocol_fee,
        fee_bps,
        host_fee,
    }))
}

fn parse_swap2_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        Default::default(),
        grpc_recv_us,
    );
    parse_swap2_from_data(data, metadata)
}

/// 解析添加流动性事件
fn parse_add_liquidity_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let from = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let amount_0 = read_u64_le(data, offset)?;
    offset += 8;

    let amount_1 = read_u64_le(data, offset)?;
    offset += 8;

    let active_bin_id = read_i32_le(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmAddLiquidity(MeteoraDlmmAddLiquidityEvent {
        metadata,
        pool,
        from,
        position,
        amounts: [amount_0, amount_1],
        active_bin_id,
    }))
}

/// 解析移除流动性事件
fn parse_remove_liquidity_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let from = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let amount_0 = read_u64_le(data, offset)?;
    offset += 8;

    let amount_1 = read_u64_le(data, offset)?;
    offset += 8;

    let active_bin_id = read_i32_le(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmRemoveLiquidity(MeteoraDlmmRemoveLiquidityEvent {
        metadata,
        pool,
        from,
        position,
        amounts: [amount_0, amount_1],
        active_bin_id,
    }))
}

/// 解析池初始化事件
fn parse_initialize_pool_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let creator = read_pubkey(data, offset)?;
    offset += 32;

    let active_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let bin_step = read_u16_le(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmInitializePool(MeteoraDlmmInitializePoolEvent {
        metadata,
        pool,
        creator,
        active_bin_id,
        bin_step,
    }))
}

/// 解析 Bin Array 初始化事件
fn parse_initialize_bin_array_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let bin_array = read_pubkey(data, offset)?;
    offset += 32;

    let index = read_i64_le(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmInitializeBinArray(MeteoraDlmmInitializeBinArrayEvent {
        metadata,
        pool,
        bin_array,
        index,
    }))
}

/// 解析创建头寸事件
fn parse_create_position_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;
    offset += 32;

    let lower_bin_id = read_i32_le(data, offset)?;
    offset += 4;

    let width = read_u32_le(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmCreatePosition(MeteoraDlmmCreatePositionEvent {
        metadata,
        pool,
        position,
        owner,
        lower_bin_id,
        width,
    }))
}

/// 解析关闭头寸事件
fn parse_close_position_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmClosePosition(MeteoraDlmmClosePositionEvent {
        metadata,
        pool,
        position,
        owner,
    }))
}

/// 解析费用领取事件
fn parse_claim_fee_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let mut offset = 0;

    let pool = read_pubkey(data, offset)?;
    offset += 32;

    let position = read_pubkey(data, offset)?;
    offset += 32;

    let owner = read_pubkey(data, offset)?;
    offset += 32;

    let fee_x = read_u64_le(data, offset)?;
    offset += 8;

    let fee_y = read_u64_le(data, offset)?;

    let metadata =
        create_metadata_simple(signature, slot, tx_index, block_time_us, pool, grpc_recv_us);

    Some(DexEvent::MeteoraDlmmClaimFee(MeteoraDlmmClaimFeeEvent {
        metadata,
        pool,
        position,
        owner,
        fee_x,
        fee_y,
    }))
}

fn parse_claim_fee2_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        Default::default(),
        grpc_recv_us,
    );
    parse_claim_fee2_from_data(data, metadata)
}

fn parse_lb_pair_create_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        Default::default(),
        grpc_recv_us,
    );
    parse_lb_pair_create_from_data(data, metadata)
}

fn parse_position_create_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        Default::default(),
        grpc_recv_us,
    );
    parse_position_create_from_data(data, metadata)
}

fn parse_position_close_event(
    data: &[u8],
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        Default::default(),
        grpc_recv_us,
    );
    parse_position_close_from_data(data, metadata)
}

/// 文本回退解析
fn parse_text_log(
    log: &str,
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    use super::utils::text_parser::*;

    if log.contains("swap") || log.contains("Swap") {
        return parse_swap_from_text(log, signature, slot, tx_index, block_time_us, grpc_recv_us);
    }

    if log.contains("add") && log.contains("liquidity") {
        return parse_add_liquidity_from_text(
            log,
            signature,
            slot,
            tx_index,
            block_time_us,
            grpc_recv_us,
        );
    }

    if log.contains("remove") && log.contains("liquidity") {
        return parse_remove_liquidity_from_text(
            log,
            signature,
            slot,
            tx_index,
            block_time_us,
            grpc_recv_us,
        );
    }

    if log.contains("initialize") && log.contains("pool") {
        return parse_initialize_pool_from_text(
            log,
            signature,
            slot,
            tx_index,
            block_time_us,
            grpc_recv_us,
        );
    }

    None
}

/// 从文本解析交换事件
fn parse_swap_from_text(
    log: &str,
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    use super::utils::text_parser::*;

    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        solana_sdk::pubkey::Pubkey::default(),
        grpc_recv_us,
    );

    Some(DexEvent::MeteoraDlmmSwap(MeteoraDlmmSwapEvent {
        metadata,
        pool: solana_sdk::pubkey::Pubkey::default(),
        from: solana_sdk::pubkey::Pubkey::default(),
        start_bin_id: 0,
        end_bin_id: 0,
        amount_in: extract_number_from_text(log, "amount_in").unwrap_or(1_000_000),
        amount_out: extract_number_from_text(log, "amount_out").unwrap_or(950_000),
        swap_for_y: detect_trade_type(log).unwrap_or(true),
        fee: extract_number_from_text(log, "fee").unwrap_or(3000),
        protocol_fee: 0,
        fee_bps: 0,
        host_fee: 0,
    }))
}

/// 从文本解析添加流动性事件
fn parse_add_liquidity_from_text(
    log: &str,
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    use super::utils::text_parser::*;

    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        solana_sdk::pubkey::Pubkey::default(),
        grpc_recv_us,
    );

    Some(DexEvent::MeteoraDlmmAddLiquidity(MeteoraDlmmAddLiquidityEvent {
        metadata,
        pool: solana_sdk::pubkey::Pubkey::default(),
        from: solana_sdk::pubkey::Pubkey::default(),
        position: solana_sdk::pubkey::Pubkey::default(),
        amounts: [
            extract_number_from_text(log, "amount_x").unwrap_or(500_000),
            extract_number_from_text(log, "amount_y").unwrap_or(500_000),
        ],
        active_bin_id: 0,
    }))
}

/// 从文本解析移除流动性事件
fn parse_remove_liquidity_from_text(
    log: &str,
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    use super::utils::text_parser::*;

    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        solana_sdk::pubkey::Pubkey::default(),
        grpc_recv_us,
    );

    Some(DexEvent::MeteoraDlmmRemoveLiquidity(MeteoraDlmmRemoveLiquidityEvent {
        metadata,
        pool: solana_sdk::pubkey::Pubkey::default(),
        from: solana_sdk::pubkey::Pubkey::default(),
        position: solana_sdk::pubkey::Pubkey::default(),
        amounts: [
            extract_number_from_text(log, "amount_x").unwrap_or(500_000),
            extract_number_from_text(log, "amount_y").unwrap_or(500_000),
        ],
        active_bin_id: 0,
    }))
}

/// 从文本解析池初始化事件
fn parse_initialize_pool_from_text(
    log: &str,
    signature: Signature,
    slot: u64,
    tx_index: u64,
    block_time_us: Option<i64>,
    grpc_recv_us: i64,
) -> Option<DexEvent> {
    use super::utils::text_parser::*;

    let metadata = create_metadata_simple(
        signature,
        slot,
        tx_index,
        block_time_us,
        solana_sdk::pubkey::Pubkey::default(),
        grpc_recv_us,
    );

    Some(DexEvent::MeteoraDlmmInitializePool(MeteoraDlmmInitializePoolEvent {
        metadata,
        pool: solana_sdk::pubkey::Pubkey::default(),
        creator: solana_sdk::pubkey::Pubkey::default(),
        active_bin_id: extract_number_from_text(log, "bin_id").unwrap_or(0) as i32,
        bin_step: extract_number_from_text(log, "bin_step").unwrap_or(1) as u16,
    }))
}