sol_parser_sdk/logs/

discriminator_lut.rs

//! Discriminator Lookup Table (LUT) - Compile-time constant array
//!
//! Zero-latency optimization: Use const array with binary search for O(log n) discriminator -> event type mapping
//! Expected latency reduction: 1-10ns (binary search on sorted array, better cache locality than match)

use crate::core::events::{DexEvent, EventMetadata};
use crate::grpc::types::EventType;

/// Discriminator type alias for clarity
pub type Discriminator = u64;

/// Parser function type - takes decoded data and metadata, returns parsed event
pub type ParserFn = fn(&[u8], EventMetadata) -> Option<DexEvent>;

/// Event metadata for discriminator lookup
#[derive(Debug, Clone, Copy)]
pub struct DiscriminatorInfo {
    pub discriminator: u64,
    pub parser: ParserFn,
    pub protocol: Protocol,
    pub name: &'static str,  // Human-readable name for debugging
}

/// Protocol enum for quick protocol identification
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Protocol {
    PumpFun,
    PumpSwap,
    RaydiumClmm,
    RaydiumCpmm,
    RaydiumAmm,
    OrcaWhirlpool,
    MeteoraAmm,
    MeteoraDamm,
    MeteoraDlmm,
}

// ============================================================================
// Parser function wrappers - delegate to protocol-specific parsers
// ============================================================================

// PumpFun parsers
#[inline(always)]
fn parse_pumpfun_create(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump::parse_create_from_data(data, metadata)
}

#[inline(always)]
fn parse_pumpfun_trade(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump::parse_trade_from_data(data, metadata, false)
}

#[inline(always)]
fn parse_pumpfun_migrate(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump::parse_migrate_from_data(data, metadata)
}

// PumpSwap parsers
#[inline(always)]
fn parse_pumpswap_buy(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump_amm::parse_buy_from_data(data, metadata)
}

#[inline(always)]
fn parse_pumpswap_sell(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump_amm::parse_sell_from_data(data, metadata)
}

#[inline(always)]
fn parse_pumpswap_create_pool(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump_amm::parse_create_pool_from_data(data, metadata)
}

#[inline(always)]
fn parse_pumpswap_add_liquidity(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump_amm::parse_add_liquidity_from_data(data, metadata)
}

#[inline(always)]
fn parse_pumpswap_remove_liquidity(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::pump_amm::parse_remove_liquidity_from_data(data, metadata)
}

// Raydium CLMM parsers
#[inline(always)]
fn parse_raydium_clmm_swap(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_clmm::parse_swap_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_clmm_increase_liquidity(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_clmm::parse_increase_liquidity_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_clmm_decrease_liquidity(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_clmm::parse_decrease_liquidity_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_clmm_create_pool(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_clmm::parse_create_pool_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_clmm_collect_fee(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_clmm::parse_collect_fee_from_data(data, metadata)
}

// Raydium CPMM parsers
#[inline(always)]
fn parse_raydium_cpmm_swap_base_in(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_cpmm::parse_swap_base_in_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_cpmm_swap_base_out(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_cpmm::parse_swap_base_out_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_cpmm_create_pool(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_cpmm::parse_create_pool_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_cpmm_deposit(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_cpmm::parse_deposit_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_cpmm_withdraw(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_cpmm::parse_withdraw_from_data(data, metadata)
}

// Raydium AMM V4 parsers
#[inline(always)]
fn parse_raydium_amm_swap_base_in(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_amm::parse_swap_base_in_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_amm_swap_base_out(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_amm::parse_swap_base_out_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_amm_deposit(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_amm::parse_deposit_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_amm_withdraw(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_amm::parse_withdraw_from_data(data, metadata)
}

#[inline(always)]
fn parse_raydium_amm_initialize2(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::raydium_amm::parse_initialize2_from_data(data, metadata)
}

// Orca Whirlpool parsers
#[inline(always)]
fn parse_orca_traded(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::orca_whirlpool::parse_traded_from_data(data, metadata)
}

#[inline(always)]
fn parse_orca_liquidity_increased(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::orca_whirlpool::parse_liquidity_increased_from_data(data, metadata)
}

#[inline(always)]
fn parse_orca_liquidity_decreased(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::orca_whirlpool::parse_liquidity_decreased_from_data(data, metadata)
}

#[inline(always)]
fn parse_orca_pool_initialized(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::orca_whirlpool::parse_pool_initialized_from_data(data, metadata)
}

// Meteora AMM parsers
#[inline(always)]
fn parse_meteora_amm_swap(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::meteora_amm::parse_swap_from_data(data, metadata)
}

#[inline(always)]
fn parse_meteora_amm_add_liquidity(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::meteora_amm::parse_add_liquidity_from_data(data, metadata)
}

#[inline(always)]
fn parse_meteora_amm_remove_liquidity(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::meteora_amm::parse_remove_liquidity_from_data(data, metadata)
}

#[inline(always)]
fn parse_meteora_amm_bootstrap_liquidity(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::meteora_amm::parse_bootstrap_liquidity_from_data(data, metadata)
}

#[inline(always)]
fn parse_meteora_amm_pool_created(data: &[u8], metadata: EventMetadata) -> Option<DexEvent> {
    crate::logs::meteora_amm::parse_pool_created_from_data(data, metadata)
}

// ============================================================================
// Const lookup table - Sorted by discriminator for binary search
// ============================================================================

macro_rules! disc_entry {
    ($disc:expr, $name:expr, $parser:expr, $protocol:expr) => {
        DiscriminatorInfo {
            discriminator: $disc,
            parser: $parser,
            protocol: $protocol,
            name: $name,
        }
    };
}

/// Compile-time constant array: discriminator -> parser info
/// MUST be kept sorted by discriminator for binary search!
///
/// Expected latency: 3-8ns (binary search on 31 entries = max 5 comparisons)
pub const DISCRIMINATOR_LUT: &[DiscriminatorInfo] = &[
    // Raydium AMM V4 events (sorted first - smallest discriminators)
    disc_entry!(0x0100000000000000, "Raydium AMM Initialize2", parse_raydium_amm_initialize2, Protocol::RaydiumAmm),
    disc_entry!(0x0300000000000000, "Raydium AMM Deposit", parse_raydium_amm_deposit, Protocol::RaydiumAmm),
    disc_entry!(0x0400000000000000, "Raydium AMM Withdraw", parse_raydium_amm_withdraw, Protocol::RaydiumAmm),
    disc_entry!(0x0900000000000000, "Raydium AMM Swap Base In", parse_raydium_amm_swap_base_in, Protocol::RaydiumAmm),
    disc_entry!(0x0B00000000000000, "Raydium AMM Swap Base Out", parse_raydium_amm_swap_base_out, Protocol::RaydiumAmm),

    // Raydium CLMM events
    disc_entry!(0x012C5B686FD026A0, "Raydium CLMM Decrease Liquidity", parse_raydium_clmm_decrease_liquidity, Protocol::RaydiumClmm),
    disc_entry!(0x0AB0EE45DF591D85, "Raydium CLMM Increase Liquidity", parse_raydium_clmm_increase_liquidity, Protocol::RaydiumClmm),

    // Raydium CPMM events
    disc_entry!(0x22A16D949C4612B7, "Raydium CPMM Withdraw", parse_raydium_cpmm_withdraw, Protocol::RaydiumCpmm),

    // PumpSwap events
    disc_entry!(0x2ADC03A50A372F3E, "PumpSwap Sell", parse_pumpswap_sell, Protocol::PumpSwap),

    // Meteora AMM events
    disc_entry!(0x3A981F67E861F474, "Meteora AMM Remove Liquidity", parse_meteora_amm_remove_liquidity, Protocol::MeteoraAmm),
    disc_entry!(0x529DDC6858292CCA, "Meteora AMM Pool Created", parse_meteora_amm_pool_created, Protocol::MeteoraAmm),

    // PumpSwap and PumpFun events
    disc_entry!(0x74A776A0D20C31B1, "PumpSwap Create Pool", parse_pumpswap_create_pool, Protocol::PumpSwap),
    disc_entry!(0x7663EBDE4DA91B1B, "PumpFun Create", parse_pumpfun_create, Protocol::PumpFun),
    disc_entry!(0x7777F52C1F52F467, "PumpSwap Buy", parse_pumpswap_buy, Protocol::PumpSwap),
    disc_entry!(0x77AB68BB63CF98A4, "Raydium CLMM Collect Fee", parse_raydium_clmm_collect_fee, Protocol::RaydiumClmm),
    disc_entry!(0x906B8E1F533DF878, "PumpSwap Add Liquidity", parse_pumpswap_add_liquidity, Protocol::PumpSwap),
    disc_entry!(0x94EA945DB95DE9BD, "PumpFun Migrate", parse_pumpfun_migrate, Protocol::PumpFun),
    disc_entry!(0x96A02B93AF49CAE1, "Orca Whirlpool Traded", parse_orca_traded, Protocol::OrcaWhirlpool),
    disc_entry!(0xA19BFE6690071E1E, "Orca Whirlpool Liquidity Increased", parse_orca_liquidity_increased, Protocol::OrcaWhirlpool),
    disc_entry!(0xABB5CA7047241A6, "Orca Whirlpool Liquidity Decreased", parse_orca_liquidity_decreased, Protocol::OrcaWhirlpool),
    disc_entry!(0xADB44AA35662D937, "Raydium CPMM Swap Base Out", parse_raydium_cpmm_swap_base_out, Protocol::RaydiumCpmm),
    disc_entry!(0xB6F2E15289C623F2, "Raydium CPMM Deposit", parse_raydium_cpmm_deposit, Protocol::RaydiumCpmm),
    disc_entry!(0xBA3D34E35A7D5E1F, "Meteora AMM Add Liquidity", parse_meteora_amm_add_liquidity, Protocol::MeteoraAmm),
    disc_entry!(0xBC4068CF8ED192E9, "Raydium CLMM Create Pool", parse_raydium_clmm_create_pool, Protocol::RaydiumClmm),
    disc_entry!(0xC0472CA01A850916, "PumpSwap Remove Liquidity", parse_pumpswap_remove_liquidity, Protocol::PumpSwap),
    disc_entry!(0xC40AD0CDBE6CE351, "Meteora AMM Swap", parse_meteora_amm_swap, Protocol::MeteoraAmm),
    disc_entry!(0xC887759EE19EC6F8, "Raydium CLMM Swap", parse_raydium_clmm_swap, Protocol::RaydiumClmm),
    disc_entry!(0xDE331EC4DA5ABE8F, "Raydium CPMM Swap Base In", parse_raydium_cpmm_swap_base_in, Protocol::RaydiumCpmm),
    disc_entry!(0xE5FEC60C57AD7664, "Orca Whirlpool Initialize", parse_orca_pool_initialized, Protocol::OrcaWhirlpool),
    disc_entry!(0xEE61E64ED37FDBBD, "PumpFun Trade", parse_pumpfun_trade, Protocol::PumpFun),
    disc_entry!(0xF70E375C88267F79, "Meteora AMM Bootstrap Liquidity", parse_meteora_amm_bootstrap_liquidity, Protocol::MeteoraAmm),
];

/// Fast lookup by discriminator - O(log n) binary search
///
/// With 31 entries, this requires at most 5 comparisons
#[inline(always)]
pub fn lookup_discriminator(discriminator: u64) -> Option<&'static DiscriminatorInfo> {
    DISCRIMINATOR_LUT
        .binary_search_by_key(&discriminator, |info| info.discriminator)
        .ok()
        .map(|idx| &DISCRIMINATOR_LUT[idx])
}

/// Get event name from discriminator
#[inline(always)]
pub fn discriminator_to_name(discriminator: u64) -> Option<&'static str> {
    lookup_discriminator(discriminator).map(|info| info.name)
}

/// Get protocol from discriminator
#[inline(always)]
pub fn discriminator_to_protocol(discriminator: u64) -> Option<Protocol> {
    lookup_discriminator(discriminator).map(|info| info.protocol)
}

/// Parse event using discriminator lookup
#[inline(always)]
pub fn parse_with_discriminator(
    discriminator: u64,
    data: &[u8],
    metadata: EventMetadata,
) -> Option<DexEvent> {
    let info = lookup_discriminator(discriminator)?;
    (info.parser)(data, metadata)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_lut_is_sorted() {
        // Verify the LUT is sorted (required for binary search)
        for i in 1..DISCRIMINATOR_LUT.len() {
            assert!(
                DISCRIMINATOR_LUT[i - 1].discriminator < DISCRIMINATOR_LUT[i].discriminator,
                "LUT not sorted at index {}: {:x} >= {:x}",
                i,
                DISCRIMINATOR_LUT[i - 1].discriminator,
                DISCRIMINATOR_LUT[i].discriminator
            );
        }
    }

    #[test]
    fn test_discriminator_lookup() {
        // PumpFun Create
        let disc = 0x7663EBDE4DA91B1B;
        let info = lookup_discriminator(disc).unwrap();
        assert_eq!(info.name, "PumpFun Create");
        assert_eq!(info.protocol, Protocol::PumpFun);

        // Raydium CLMM Swap
        let disc = 0xC887759EE19EC6F8;
        let info = lookup_discriminator(disc).unwrap();
        assert_eq!(info.name, "Raydium CLMM Swap");
        assert_eq!(info.protocol, Protocol::RaydiumClmm);

        // Unknown discriminator
        let disc = 0xFFFFFFFFFFFFFFFF;
        assert!(lookup_discriminator(disc).is_none());
    }

    #[test]
    fn test_event_name_lookup() {
        // PumpSwap Buy
        let disc = 0x7777F52C1F52F467;
        assert_eq!(
            discriminator_to_name(disc),
            Some("PumpSwap Buy")
        );

        // Raydium AMM Swap Base In
        let disc = 0x0900000000000000;
        assert_eq!(
            discriminator_to_name(disc),
            Some("Raydium AMM Swap Base In")
        );
    }

    #[test]
    fn test_protocol_lookup() {
        assert_eq!(
            discriminator_to_protocol(0x7663EBDE4DA91B1B),
            Some(Protocol::PumpFun)
        );
        assert_eq!(
            discriminator_to_protocol(0xC887759EE19EC6F8),
            Some(Protocol::RaydiumClmm)
        );
        assert_eq!(
            discriminator_to_protocol(0x96A02B93AF49CAE1),
            Some(Protocol::OrcaWhirlpool)
        );
    }
}