sol-parser-sdk-python 0.5.6__py3-none-any.whl → 0.5.8__py3-none-any.whl

sol_parser/log_instr_dedup.py

@@ -49,16 +49,19 @@ def _ix_lane(ix_name: Any) -> int:
     return 0
 
 
-PumpfunLaneBase = Tuple[str, str, bool, int]
+OccurrenceBase = Tuple[Any, ...]
 
 
-def _next_occurrence(base: PumpfunLaneBase, counts: Dict[PumpfunLaneBase, int]) -> int:
+def _next_occurrence(base: OccurrenceBase, counts: Dict[OccurrenceBase, int]) -> int:
     current = counts.get(base, 0)
     counts[base] = current + 1
     return current
 
 
-def _dedupe_key(ev: DexEvent, pumpfun_lane_counts: Dict[PumpfunLaneBase, int]) -> Optional[str]:
+def _dedupe_key(
+    ev: DexEvent,
+    occurrence_counts: Dict[OccurrenceBase, int],
+) -> Optional[str]:
     data = ev.data
     if data is None:
         return None
@@ -71,14 +74,14 @@ def _dedupe_key(ev: DexEvent, pumpfun_lane_counts: Dict[PumpfunLaneBase, int]) -
             bool(getattr(data, "is_buy", False)),
             lane,
         )
-        occ = _next_occurrence(base, pumpfun_lane_counts)
+        occ = _next_occurrence(("PumpFun", *base), occurrence_counts)
         return f"PumpFunTrade|{base[0]}|{base[1]}|{base[2]}|{base[3]}|{occ}"
 
     t = ev.type
     if t == EventType.PUMP_FUN_CREATE:
         return f"PumpFunCreate|{getattr(data, 'mint', '')}"
     if t == EventType.PUMP_FUN_CREATE_V2:
-        return f"PumpFunCreateV2|{getattr(data, 'mint', '')}"
+        return f"PumpFunCreate|{getattr(data, 'mint', '')}"
     if t == EventType.PUMP_FUN_MIGRATE:
         return (
             f"PumpFunMigrate|{getattr(data, 'mint', '')}|"
@@ -110,13 +113,32 @@ def _dedupe_key(ev: DexEvent, pumpfun_lane_counts: Dict[PumpfunLaneBase, int]) -
     if t == EventType.PUMP_SWAP_LIQUIDITY_REMOVED:
         return f"PumpSwapLiquidityRemoved|{getattr(data, 'pool', '')}|{getattr(data, 'user', '')}"
     if t == EventType.RAYDIUM_CLMM_SWAP:
-        return f"RaydiumClmmSwap|{getattr(data, 'pool_state', '')}|{bool(getattr(data, 'zero_for_one', False))}"
+        pool = getattr(data, "pool_state", "")
+        occurrence = _next_occurrence(("RaydiumClmm", pool), occurrence_counts)
+        return f"RaydiumClmmSwap|{pool}|{occurrence}"
+    if t == EventType.RAYDIUM_CPMM_SWAP:
+        pool = getattr(data, "pool_id", "")
+        occurrence = _next_occurrence(("RaydiumCpmm", pool), occurrence_counts)
+        return f"RaydiumCpmmSwap|{pool}|{occurrence}"
     if t == EventType.RAYDIUM_AMM_V4_SWAP:
-        return f"RaydiumAmmV4Swap|{getattr(data, 'amm', '')}"
+        base_out = getattr(data, "max_amount_in", 0) != 0
+        amount = getattr(data, "amount_out" if base_out else "amount_in", 0)
+        base = (base_out, amount)
+        occurrence = _next_occurrence(("RaydiumAmmV4", *base), occurrence_counts)
+        return f"RaydiumAmmV4Swap|{base_out}|{amount}|{occurrence}"
+    if t == EventType.ORCA_WHIRLPOOL_SWAP:
+        whirlpool = getattr(data, "whirlpool", "")
+        occurrence = _next_occurrence(("OrcaWhirlpool", whirlpool), occurrence_counts)
+        return f"OrcaWhirlpoolSwap|{whirlpool}|{occurrence}"
     if t == EventType.METEORA_DLMM_SWAP:
+        base = (
+            getattr(data, "pool", ""),
+            getattr(data, "from_addr", ""),
+            bool(getattr(data, "swap_for_y", False)),
+        )
+        occurrence = _next_occurrence(("MeteoraDlmm", *base), occurrence_counts)
         return (
-            f"MeteoraDlmmSwap|{getattr(data, 'pool', '')}|"
-            f"{getattr(data, 'from_addr', '')}|{bool(getattr(data, 'swap_for_y', False))}"
+            f"MeteoraDlmmSwap|{base[0]}|{base[1]}|{base[2]}|{occurrence}"
         )
     return None
 
@@ -163,6 +185,8 @@ def _merge_pumpfun_trade(log: Any, ix: Any) -> None:
         "quote_amount",
         "virtual_quote_reserves",
         "real_quote_reserves",
+        "holder_rewards_bps",
+        "holder_rewards",
     ):
         if getattr(log, attr, 0) == 0 and getattr(ix, attr, 0) != 0:
             setattr(log, attr, getattr(ix, attr))
@@ -174,10 +198,40 @@ def _merge_pumpfun_trade(log: Any, ix: Any) -> None:
 
 
 def _merge_pumpfun_create(log: Any, ix: Any) -> None:
-    for attr in ("name", "symbol", "uri", "bonding_curve", "user", "creator", "token_program", "quote_mint"):
+    for attr in (
+        "name",
+        "symbol",
+        "uri",
+        "mint",
+        "bonding_curve",
+        "user",
+        "creator",
+        "token_program",
+        "quote_mint",
+        "quote_vault",
+        "quote_token_program",
+    ):
         _fill_attr(log, attr, ix)
-    if getattr(log, "virtual_quote_reserves", 0) == 0 and getattr(ix, "virtual_quote_reserves", 0) != 0:
-        log.virtual_quote_reserves = ix.virtual_quote_reserves
+    for attr in (
+        "timestamp",
+        "virtual_token_reserves",
+        "virtual_sol_reserves",
+        "real_token_reserves",
+        "token_total_supply",
+        "virtual_quote_reserves",
+        "creator_fee_bps",
+    ):
+        if getattr(log, attr, 0) == 0 and getattr(ix, attr, 0) != 0:
+            setattr(log, attr, getattr(ix, attr))
+    log.is_mayhem_mode = bool(getattr(log, "is_mayhem_mode", False)) or bool(
+        getattr(ix, "is_mayhem_mode", False)
+    )
+    log.is_cashback_enabled = bool(getattr(log, "is_cashback_enabled", False)) or bool(
+        getattr(ix, "is_cashback_enabled", False)
+    )
+    log.is_holder_reward = bool(getattr(log, "is_holder_reward", False)) or bool(
+        getattr(ix, "is_holder_reward", False)
+    )
 
 
 def _merge_pumpfun_create_v2(log: Any, ix: Any) -> None:
@@ -232,6 +286,10 @@ def _merge_grpc_instruction_into_log(log_ev: DexEvent, ix_ev: DexEvent) -> None:
 
     if log_ev.type in PUMPFUN_TRADE_TYPES and ix_ev.type in PUMPFUN_TRADE_TYPES:
         _merge_pumpfun_trade(log, ix)
+    elif log_ev.type == EventType.PUMP_FUN_CREATE and ix_ev.type == EventType.PUMP_FUN_CREATE_V2:
+        _merge_pumpfun_create(log, ix)
+    elif log_ev.type == EventType.PUMP_FUN_CREATE_V2 and ix_ev.type == EventType.PUMP_FUN_CREATE:
+        _merge_pumpfun_create_v2(log, ix)
     elif log_ev.type == EventType.PUMP_FUN_CREATE and ix_ev.type == EventType.PUMP_FUN_CREATE:
         _merge_pumpfun_create(log, ix)
     elif log_ev.type == EventType.PUMP_FUN_CREATE_V2 and ix_ev.type == EventType.PUMP_FUN_CREATE_V2:
@@ -253,6 +311,20 @@ def _merge_grpc_instruction_into_log(log_ev: DexEvent, ix_ev: DexEvent) -> None:
             "coin_creator",
         ):
             _fill_attr(log, attr, ix)
+        if getattr(log, "creator_fee_bps", 0) == 0 and getattr(ix, "creator_fee_bps", 0) != 0:
+            log.creator_fee_bps = ix.creator_fee_bps
+        log.is_mayhem_mode = bool(getattr(log, "is_mayhem_mode", False)) or bool(
+            getattr(ix, "is_mayhem_mode", False)
+        )
+        log.is_cashback_coin = bool(getattr(log, "is_cashback_coin", False)) or bool(
+            getattr(ix, "is_cashback_coin", False)
+        )
+        log.can_edit_creator_fee = bool(getattr(log, "can_edit_creator_fee", False)) or bool(
+            getattr(ix, "can_edit_creator_fee", False)
+        )
+        log.is_holder_reward = bool(getattr(log, "is_holder_reward", False)) or bool(
+            getattr(ix, "is_holder_reward", False)
+        )
     elif (
         log_ev.type == EventType.PUMP_SWAP_LIQUIDITY_ADDED
         and ix_ev.type == EventType.PUMP_SWAP_LIQUIDITY_ADDED
@@ -282,6 +354,8 @@ def _merge_grpc_instruction_into_log(log_ev: DexEvent, ix_ev: DexEvent) -> None:
             "serum_vault_signer",
             "user_source_token_account",
             "user_destination_token_account",
+            "user_source_owner",
+            "amm",
         ):
             _fill_attr(log, attr, ix)
     elif log_ev.type == EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE and ix_ev.type == EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE:
@@ -299,17 +373,17 @@ def dedupe_log_instruction_events(
 ) -> List[DexEvent]:
     out: List[DexEvent] = []
     index_by_key: Dict[str, int] = {}
-    log_pumpfun_counts: Dict[PumpfunLaneBase, int] = {}
-    ix_pumpfun_counts: Dict[PumpfunLaneBase, int] = {}
+    log_occurrences: Dict[OccurrenceBase, int] = {}
+    ix_occurrences: Dict[OccurrenceBase, int] = {}
 
     for ev in log_events:
-        key = _dedupe_key(ev, log_pumpfun_counts)
+        key = _dedupe_key(ev, log_occurrences)
         if key is not None:
             index_by_key[key] = len(out)
         out.append(ev)
 
     for ev in instruction_events:
-        key = _dedupe_key(ev, ix_pumpfun_counts)
+        key = _dedupe_key(ev, ix_occurrences)
         if key is None:
             out.append(ev)
             continue

sol_parser/merger.py

@@ -32,6 +32,14 @@ from .event_types import (
     MeteoraDammV2CreatePositionEvent,
     MeteoraDammV2RemoveLiquidityEvent,
     MeteoraDammV2SwapEvent,
+    MeteoraDlmmAddLiquidityEvent,
+    MeteoraDlmmClaimFeeEvent,
+    MeteoraDlmmClosePositionEvent,
+    MeteoraDlmmCreatePositionEvent,
+    MeteoraDlmmInitializeBinArrayEvent,
+    MeteoraDlmmInitializePoolEvent,
+    MeteoraDlmmRemoveLiquidityEvent,
+    MeteoraDlmmSwapEvent,
     MeteoraPoolsAddLiquidityEvent,
     MeteoraPoolsRemoveLiquidityEvent,
     MeteoraPoolsSwapEvent,
@@ -44,6 +52,40 @@ from .grpc_types import EventType
 
 ZERO = "11111111111111111111111111111111"
 
+GENERIC_MERGE_TYPES = (
+    PumpSwapCreatePoolEvent,
+    PumpSwapLiquidityAddedEvent,
+    PumpSwapLiquidityRemovedEvent,
+    RaydiumClmmSwapEvent,
+    RaydiumClmmIncreaseLiquidityEvent,
+    RaydiumClmmDecreaseLiquidityEvent,
+    RaydiumClmmCreatePoolEvent,
+    RaydiumClmmCollectFeeEvent,
+    RaydiumCpmmSwapEvent,
+    RaydiumCpmmDepositEvent,
+    RaydiumCpmmWithdrawEvent,
+    RaydiumAmmV4SwapEvent,
+    RaydiumAmmV4DepositEvent,
+    RaydiumAmmV4WithdrawEvent,
+    OrcaWhirlpoolSwapEvent,
+    OrcaWhirlpoolLiquidityIncreasedEvent,
+    OrcaWhirlpoolLiquidityDecreasedEvent,
+    MeteoraPoolsSwapEvent,
+    MeteoraPoolsAddLiquidityEvent,
+    MeteoraPoolsRemoveLiquidityEvent,
+    MeteoraDammV2SwapEvent,
+    MeteoraDammV2AddLiquidityEvent,
+    MeteoraDammV2RemoveLiquidityEvent,
+    MeteoraDammV2CreatePositionEvent,
+    MeteoraDammV2ClosePositionEvent,
+    MeteoraDlmmSwapEvent,
+    MeteoraDlmmAddLiquidityEvent,
+    MeteoraDlmmRemoveLiquidityEvent,
+    MeteoraDlmmInitializeBinArrayEvent,
+    MeteoraDlmmClaimFeeEvent,
+    RaydiumLaunchlabTradeEvent,
+)
+
 
 def _merge_generic(base: Any, inner: Any) -> None:
     for f in dataclasses.fields(type(base)):
@@ -60,48 +102,125 @@ def _fill_attr_if_empty(base: Any, attr: str, source: Any) -> None:
         setattr(base, attr, value)
 
 
+def _put_attr_if_set(base: Any, attr: str, source: Any) -> None:
+    value = getattr(source, attr, None)
+    if not _empty(value):
+        setattr(base, attr, value)
+
+
+def _put_num_if_nonzero(base: Any, attr: str, source: Any) -> None:
+    value = getattr(source, attr, 0)
+    if value:
+        setattr(base, attr, value)
+
+
 def merge_pumpfun_trade(base: PumpFunTradeEvent, inner: PumpFunTradeEvent) -> None:
-    base.mint = inner.mint
-    base.sol_amount = inner.sol_amount
-    base.token_amount = inner.token_amount
-    base.is_buy = inner.is_buy
-    base.user = inner.user
-    base.timestamp = inner.timestamp
-    base.virtual_sol_reserves = inner.virtual_sol_reserves
-    base.virtual_token_reserves = inner.virtual_token_reserves
-    base.real_sol_reserves = inner.real_sol_reserves
-    base.real_token_reserves = inner.real_token_reserves
-    base.fee_recipient = inner.fee_recipient
-    base.fee_basis_points = inner.fee_basis_points
-    base.fee = inner.fee
-    base.creator = inner.creator
-    base.creator_fee_basis_points = inner.creator_fee_basis_points
-    base.creator_fee = inner.creator_fee
-    base.track_volume = inner.track_volume
-    base.total_unclaimed_tokens = inner.total_unclaimed_tokens
-    base.total_claimed_tokens = inner.total_claimed_tokens
-    base.current_sol_volume = inner.current_sol_volume
-    base.last_update_timestamp = inner.last_update_timestamp
-    base.ix_name = inner.ix_name
-    base.is_created_buy = inner.is_created_buy
-    base.mayhem_mode = inner.mayhem_mode
-    base.cashback_fee_basis_points = inner.cashback_fee_basis_points
-    base.cashback = inner.cashback
-    if inner.buyback_fee_basis_points != 0:
-        base.buyback_fee_basis_points = inner.buyback_fee_basis_points
-    if inner.buyback_fee != 0:
-        base.buyback_fee = inner.buyback_fee
-    if inner.shareholders:
+    leg = inner.sol_amount != 0 or inner.token_amount != 0
+
+    for attr in ("mint", "user", "fee_recipient", "creator"):
+        _put_attr_if_set(base, attr, inner)
+
+    if leg:
+        for attr in (
+            "sol_amount",
+            "token_amount",
+            "timestamp",
+            "virtual_sol_reserves",
+            "virtual_token_reserves",
+            "real_sol_reserves",
+            "real_token_reserves",
+            "fee_basis_points",
+            "fee",
+            "creator_fee_basis_points",
+            "creator_fee",
+            "total_unclaimed_tokens",
+            "total_claimed_tokens",
+            "current_sol_volume",
+            "last_update_timestamp",
+        ):
+            setattr(base, attr, getattr(inner, attr))
+        base.is_buy = inner.is_buy
+        base.track_volume = bool(base.track_volume) or bool(inner.track_volume)
+        base.mayhem_mode = bool(base.mayhem_mode) or bool(inner.mayhem_mode)
+        if inner.ix_name:
+            base.ix_name = inner.ix_name
+        base.is_cashback_coin = bool(base.is_cashback_coin) or bool(inner.is_cashback_coin)
+    else:
+        for attr in (
+            "fee",
+            "creator_fee",
+            "fee_basis_points",
+            "creator_fee_basis_points",
+            "virtual_sol_reserves",
+            "virtual_token_reserves",
+            "real_sol_reserves",
+            "real_token_reserves",
+            "total_unclaimed_tokens",
+            "total_claimed_tokens",
+            "current_sol_volume",
+            "timestamp",
+            "last_update_timestamp",
+        ):
+            _put_num_if_nonzero(base, attr, inner)
+        base.track_volume = bool(base.track_volume) or bool(inner.track_volume)
+        base.mayhem_mode = bool(base.mayhem_mode) or bool(inner.mayhem_mode)
+        if inner.ix_name:
+            base.ix_name = inner.ix_name
+        base.is_cashback_coin = bool(base.is_cashback_coin) or bool(inner.is_cashback_coin)
+
+    for attr in (
+        "cashback_fee_basis_points",
+        "cashback",
+        "buyback_fee_basis_points",
+        "buyback_fee",
+        "quote_amount",
+        "virtual_quote_reserves",
+        "real_quote_reserves",
+        "holder_rewards_bps",
+        "holder_rewards",
+        "amount",
+        "max_sol_cost",
+        "min_sol_output",
+        "spendable_sol_in",
+        "spendable_quote_in",
+        "min_tokens_out",
+    ):
+        _put_num_if_nonzero(base, attr, inner)
+
+    if inner.shareholders and not base.shareholders:
         base.shareholders = inner.shareholders
-    if not _empty(inner.quote_mint):
-        base.quote_mint = inner.quote_mint
-    if inner.quote_amount != 0:
-        base.quote_amount = inner.quote_amount
-    if inner.virtual_quote_reserves != 0:
-        base.virtual_quote_reserves = inner.virtual_quote_reserves
-    if inner.real_quote_reserves != 0:
-        base.real_quote_reserves = inner.real_quote_reserves
-    base.is_cashback_coin = inner.is_cashback_coin
+
+    for attr in (
+        "quote_mint",
+        "global_account",
+        "bonding_curve",
+        "bonding_curve_v2",
+        "associated_bonding_curve",
+        "associated_user",
+        "system_program",
+        "token_program",
+        "quote_token_program",
+        "associated_token_program",
+        "creator_vault",
+        "associated_quote_fee_recipient",
+        "buyback_fee_recipient",
+        "associated_quote_buyback_fee_recipient",
+        "associated_quote_bonding_curve",
+        "associated_quote_user",
+        "associated_creator_vault",
+        "sharing_config",
+        "event_authority",
+        "program",
+        "global_volume_accumulator",
+        "user_volume_accumulator",
+        "associated_user_volume_accumulator",
+        "fee_config",
+        "fee_program",
+        "extra_instruction_account",
+    ):
+        _put_attr_if_set(base, attr, inner)
+
+    base.is_created_buy = bool(base.is_created_buy) or bool(inner.is_created_buy)
 
 
 def merge_pumpswap_buy(base: PumpSwapBuyEvent, inner: PumpSwapBuyEvent) -> None:
@@ -168,6 +287,8 @@ def merge_pumpfun_create(base: PumpFunCreateEvent, inner: PumpFunCreateEvent) ->
     base.is_cashback_enabled = inner.is_cashback_enabled
     base.quote_mint = inner.quote_mint
     base.virtual_quote_reserves = inner.virtual_quote_reserves
+    base.creator_fee_bps = inner.creator_fee_bps
+    base.is_holder_reward = bool(base.is_holder_reward) or bool(inner.is_holder_reward)
 
 
 def merge_pumpfun_migrate(base: PumpFunMigrateEvent, inner: PumpFunMigrateEvent) -> None:
@@ -183,6 +304,11 @@ def merge_pumpfun_migrate(base: PumpFunMigrateEvent, inner: PumpFunMigrateEvent)
 
 def merge_dex_events(base: DexEvent, inner: DexEvent) -> None:
     """将 ``inner`` 合并进 ``base``（就地修改 ``base.data``）。"""
+    try_merge_dex_events(base, inner)
+
+
+def try_merge_dex_events(base: DexEvent, inner: DexEvent) -> bool:
+    """Merge compatible events and report success so unmatched events are retained."""
     bd = base.data
     ind = inner.data
 
@@ -199,109 +325,45 @@ def merge_dex_events(base: DexEvent, inner: DexEvent) -> None:
             EventType.PUMP_FUN_BUY_EXACT_SOL_IN,
         ):
             merge_pumpfun_trade(bd, ind)
-            base.type = inner.type
-        return
+            return True
+        return False
 
     if isinstance(bd, PumpFunCreateEvent) and isinstance(ind, PumpFunCreateEvent):
         merge_pumpfun_create(bd, ind)
-        return
+        return True
 
     if isinstance(bd, PumpFunCreateV2TokenEvent) and isinstance(ind, PumpFunCreateV2TokenEvent):
         _merge_generic(bd, ind)
-        return
+        return True
 
     if isinstance(bd, PumpFunMigrateEvent) and isinstance(ind, PumpFunMigrateEvent):
         merge_pumpfun_migrate(bd, ind)
-        return
+        return True
 
     if isinstance(bd, PumpSwapBuyEvent) and isinstance(ind, PumpSwapBuyEvent):
         merge_pumpswap_buy(bd, ind)
-        return
+        return True
     if isinstance(bd, PumpSwapSellEvent) and isinstance(ind, PumpSwapSellEvent):
         merge_pumpswap_sell(bd, ind)
-        return
-    if isinstance(bd, PumpSwapCreatePoolEvent) and isinstance(ind, PumpSwapCreatePoolEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, PumpSwapLiquidityAddedEvent) and isinstance(ind, PumpSwapLiquidityAddedEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, PumpSwapLiquidityRemovedEvent) and isinstance(ind, PumpSwapLiquidityRemovedEvent):
-        _merge_generic(bd, ind)
-        return
-
-    if isinstance(bd, RaydiumClmmSwapEvent) and isinstance(ind, RaydiumClmmSwapEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumClmmIncreaseLiquidityEvent) and isinstance(ind, RaydiumClmmIncreaseLiquidityEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumClmmDecreaseLiquidityEvent) and isinstance(ind, RaydiumClmmDecreaseLiquidityEvent):
+        return True
+    if isinstance(bd, MeteoraDlmmInitializePoolEvent) and isinstance(ind, MeteoraDlmmInitializePoolEvent):
+        creator, active_bin_id = bd.creator, bd.active_bin_id
         _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumClmmCreatePoolEvent) and isinstance(ind, RaydiumClmmCreatePoolEvent):
+        bd.creator, bd.active_bin_id = creator, active_bin_id
+        return True
+    if isinstance(bd, MeteoraDlmmCreatePositionEvent) and isinstance(ind, MeteoraDlmmCreatePositionEvent):
+        lower_bin_id, width = bd.lower_bin_id, bd.width
         _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumClmmCollectFeeEvent) and isinstance(ind, RaydiumClmmCollectFeeEvent):
+        bd.lower_bin_id, bd.width = lower_bin_id, width
+        return True
+    if isinstance(bd, MeteoraDlmmClosePositionEvent) and isinstance(ind, MeteoraDlmmClosePositionEvent):
+        pool = bd.pool
         _merge_generic(bd, ind)
-        return
+        bd.pool = pool
+        return True
 
-    if isinstance(bd, RaydiumCpmmSwapEvent) and isinstance(ind, RaydiumCpmmSwapEvent):
+    if base.type == inner.type and type(bd) is type(ind) and isinstance(bd, GENERIC_MERGE_TYPES):
         _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumCpmmDepositEvent) and isinstance(ind, RaydiumCpmmDepositEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumCpmmWithdrawEvent) and isinstance(ind, RaydiumCpmmWithdrawEvent):
-        _merge_generic(bd, ind)
-        return
-
-    if isinstance(bd, RaydiumAmmV4SwapEvent) and isinstance(ind, RaydiumAmmV4SwapEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumAmmV4DepositEvent) and isinstance(ind, RaydiumAmmV4DepositEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, RaydiumAmmV4WithdrawEvent) and isinstance(ind, RaydiumAmmV4WithdrawEvent):
-        _merge_generic(bd, ind)
-        return
+        return True
 
-    if isinstance(bd, OrcaWhirlpoolSwapEvent) and isinstance(ind, OrcaWhirlpoolSwapEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, OrcaWhirlpoolLiquidityIncreasedEvent) and isinstance(ind, OrcaWhirlpoolLiquidityIncreasedEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, OrcaWhirlpoolLiquidityDecreasedEvent) and isinstance(ind, OrcaWhirlpoolLiquidityDecreasedEvent):
-        _merge_generic(bd, ind)
-        return
-
-    if isinstance(bd, MeteoraPoolsSwapEvent) and isinstance(ind, MeteoraPoolsSwapEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, MeteoraPoolsAddLiquidityEvent) and isinstance(ind, MeteoraPoolsAddLiquidityEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, MeteoraPoolsRemoveLiquidityEvent) and isinstance(ind, MeteoraPoolsRemoveLiquidityEvent):
-        _merge_generic(bd, ind)
-        return
-
-    if isinstance(bd, MeteoraDammV2SwapEvent) and isinstance(ind, MeteoraDammV2SwapEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, MeteoraDammV2AddLiquidityEvent) and isinstance(ind, MeteoraDammV2AddLiquidityEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, MeteoraDammV2RemoveLiquidityEvent) and isinstance(ind, MeteoraDammV2RemoveLiquidityEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, MeteoraDammV2CreatePositionEvent) and isinstance(ind, MeteoraDammV2CreatePositionEvent):
-        _merge_generic(bd, ind)
-        return
-    if isinstance(bd, MeteoraDammV2ClosePositionEvent) and isinstance(ind, MeteoraDammV2ClosePositionEvent):
-        _merge_generic(bd, ind)
-        return
-
-    if isinstance(bd, RaydiumLaunchlabTradeEvent) and isinstance(ind, RaydiumLaunchlabTradeEvent):
-        _merge_generic(bd, ind)
-        return
+    return False

sol_parser/parser.py

@@ -8,12 +8,16 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
 from .dex_parsers import (
     DexEvent,
+    PUMPFUN_PROGRAM_ID,
+    PUMP_TRADE,
     apply_event_type_filter,
     dispatch_program_data,
     event_type_for_discriminator,
     event_type_for_program_discriminator,
     filter_allows_unknown_log_event,
+    filter_allows_unscoped_discriminator,
     filter_includes_program,
+    filter_wants_pumpfun_trade,
     parse_trade_from_data,
 )
 
@@ -32,13 +36,11 @@ def decode_program_data_line(log: str) -> Optional[bytes]:
     if i < 0:
         return None
     s = log[i + len(p) :].strip()
-    if len(s) > 2700:
-        return None
     try:
         raw = base64.standard_b64decode(s)
     except Exception:
         return None
-    if len(raw) < 8 or len(raw) > 2048:
+    if len(raw) < 8:
         return None
     return raw
 
@@ -77,24 +79,53 @@ def parse_log_optimized(
 ) -> Optional[DexEvent]:
     """单次 base64 decode 后按 discriminator 做 early filter，再按实际事件类型二次过滤。"""
     grpc = int(time.time() * 1_000_000) if grpc_recv_us is None else grpc_recv_us
+    if program_id == "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8" and "ray_log: " in log:
+        from .dex_parsers import parse_amm_ray_log_swap
+        from .grpc_types import EventType
+
+        if event_type_filter is not None and not event_type_filter.should_include(
+            EventType.RAYDIUM_AMM_V4_SWAP
+        ):
+            return None
+        return parse_amm_ray_log_swap(
+            log, _meta(signature, slot, tx_index, block_time_us, grpc, recent_blockhash)
+        )
     buf = decode_program_data_line(log)
     if not buf:
         return None
     disc = _disc8(buf[:8])
     if event_type_filter is not None:
+        is_unscoped_shared_discriminator = program_id is None and disc in (
+            _disc8(bytes([189, 219, 127, 211, 78, 230, 97, 238])),
+            _disc8(bytes([143, 190, 90, 218, 196, 30, 51, 222])),
+        )
         event_type = event_type_for_program_discriminator(program_id, disc)
-        if event_type is not None:
+        if is_unscoped_shared_discriminator:
+            if not filter_allows_unscoped_discriminator(event_type_filter, disc):
+                return None
+        elif program_id == PUMPFUN_PROGRAM_ID and disc == PUMP_TRADE:
+            if not filter_wants_pumpfun_trade(event_type_filter):
+                return None
+        elif event_type is not None:
             if not event_type_filter.should_include(event_type):
                 return None
         elif program_id:
             if not filter_includes_program(event_type_filter, program_id):
                 return None
-        elif not filter_allows_unknown_log_event(event_type_filter):
+        elif not filter_allows_unscoped_discriminator(event_type_filter, disc):
             return None
     data = buf[8:]
     meta = _meta(signature, slot, tx_index, block_time_us, grpc, recent_blockhash)
     return apply_event_type_filter(
-        dispatch_program_data(disc, data, buf, meta, is_created_buy, program_id),
+        dispatch_program_data(
+            disc,
+            data,
+            buf,
+            meta,
+            is_created_buy,
+            program_id,
+            event_type_filter,
+        ),
         event_type_filter,
     )