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

sol_parser/dex_parsers.py

@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+import base64
 import struct
 from typing import Any, Dict, List, Optional
 
@@ -27,8 +28,14 @@ from .event_types import (
     RaydiumAmmV4WithdrawPnlEvent, RaydiumAmmV4Initialize2Event,
     RaydiumClmmSwapEvent, RaydiumClmmIncreaseLiquidityEvent,
     RaydiumClmmDecreaseLiquidityEvent, RaydiumClmmCreatePoolEvent,
-    RaydiumClmmCollectFeeEvent, RaydiumCpmmSwapEvent, RaydiumCpmmDepositEvent,
-    RaydiumCpmmWithdrawEvent, OrcaWhirlpoolSwapEvent, OrcaWhirlpoolLiquidityIncreasedEvent,
+    RaydiumClmmCollectFeeEvent, RaydiumClmmLiquidityChangeEvent,
+    RaydiumClmmConfigChangeEvent, RaydiumClmmCreatePersonalPositionEvent,
+    RaydiumClmmLiquidityCalculateEvent, RaydiumClmmOpenLimitOrderEvent,
+    RaydiumClmmIncreaseLimitOrderEvent, RaydiumClmmDecreaseLimitOrderEvent,
+    RaydiumClmmSettleLimitOrderEvent, RaydiumClmmUpdateRewardInfosEvent,
+    RaydiumCpmmSwapEvent, RaydiumCpmmDepositEvent,
+    RaydiumCpmmWithdrawEvent, RaydiumCpmmInitializeEvent,
+    OrcaWhirlpoolSwapEvent, OrcaWhirlpoolLiquidityIncreasedEvent,
     OrcaWhirlpoolLiquidityDecreasedEvent, OrcaWhirlpoolPoolInitializedEvent,
     MeteoraDlmmSwapEvent, MeteoraDlmmAddLiquidityEvent, MeteoraDlmmRemoveLiquidityEvent,
     MeteoraDlmmInitializePoolEvent, MeteoraDlmmInitializeBinArrayEvent,
@@ -39,6 +46,11 @@ from .event_types import (
     MeteoraDammV2CreatePositionEvent, MeteoraDammV2ClosePositionEvent,
     MeteoraDammV2AddLiquidityEvent, MeteoraDammV2RemoveLiquidityEvent,
     MeteoraDammV2InitializePoolEvent,
+    MeteoraDammV2DynamicFeeParameters,
+    MeteoraDammV2UpdateDelegatePermissionEvent,
+    MeteoraDammV2WithdrawDeadLiquidityRewardEvent,
+    MeteoraDammV2CreateConfigEvent,
+    MeteoraDammV2CreateDynamicConfigEvent,
     MeteoraDbcCurveCompleteEvent, MeteoraDbcInitializePoolEvent, MeteoraDbcSwapEvent,
     RaydiumLaunchlabTradeEvent, RaydiumLaunchlabPoolCreateEvent,
 )
@@ -246,6 +258,8 @@ def parse_trade_from_data(data: bytes, meta: dict, is_created_buy: bool) -> DexE
     quote_amount = _optional_u64(data, tail)
     virtual_quote_reserves = _optional_u64(data, tail)
     real_quote_reserves = _optional_u64(data, tail)
+    holder_rewards_bps = _optional_u64(data, tail)
+    holder_rewards = _optional_u64(data, tail)
     
     event_data = PumpFunTradeEvent(
         metadata=_make_meta(meta),
@@ -282,6 +296,8 @@ def parse_trade_from_data(data: bytes, meta: dict, is_created_buy: bool) -> DexE
         quote_amount=quote_amount,
         virtual_quote_reserves=virtual_quote_reserves,
         real_quote_reserves=real_quote_reserves,
+        holder_rewards_bps=holder_rewards_bps,
+        holder_rewards=holder_rewards,
         is_cashback_coin=cb_bps > 0,
         bonding_curve=Z,
         associated_bonding_curve=Z,
@@ -337,6 +353,10 @@ def parse_create_from_data(data: bytes, meta: dict) -> DexEvent:
     quote_mint = _pub(data, o) if o + 32 <= len(data) else Z
     o += 32
     virtual_quote_reserves = _u64le(data, o) if o + 8 <= len(data) else 0
+    o += 8
+    creator_fee_bps = _u64le(data, o) if o + 8 <= len(data) else 0
+    o += 8
+    is_holder_reward = _bool(data, o) if o < len(data) else False
     
     return DexEvent(
         type=EventType.PUMP_FUN_CREATE,
@@ -359,6 +379,8 @@ def parse_create_from_data(data: bytes, meta: dict) -> DexEvent:
             is_cashback_enabled=ice,
             quote_mint=quote_mint,
             virtual_quote_reserves=virtual_quote_reserves,
+            creator_fee_bps=creator_fee_bps,
+            is_holder_reward=is_holder_reward,
         ),
     )
 
@@ -752,129 +774,179 @@ def parse_pump_fees_upsert_fee_tiers_from_data(data: bytes, meta: dict) -> DexEv
 
 
 def parse_clmm_swap_from_data(data: bytes, meta: dict) -> DexEvent:
-    if len(data) < 32 + 32 + 8 + 8 + 16 + 1:
+    if len(data) < 32 + 32 + 32 + 32 + 8 + 8 + 8 + 8 + 1 + 16 + 16 + 4:
         return DexEvent()
     o = 0
     ps = _pub(data, o)
     o += 32
-    user = _pub(data, o)
-    o += 32 + 8 + 8
+    sender = _pub(data, o)
+    o += 32
+    token_account_0 = _pub(data, o)
+    o += 32
+    token_account_1 = _pub(data, o)
+    o += 32
+    amount_0 = _u64le(data, o)
+    o += 8
+    transfer_fee_0 = _u64le(data, o)
+    o += 8
+    amount_1 = _u64le(data, o)
+    o += 8
+    transfer_fee_1 = _u64le(data, o)
+    o += 8
+    zfo = _bool(data, o)
+    o += 1
     sqrt = str(_u128le_int(data, o))
     o += 16
-    zfo = _bool(data, o)
+    liq = str(_u128le_int(data, o))
+    o += 16
+    tick = _i32le(data, o)
     
     return DexEvent(
         type=EventType.RAYDIUM_CLMM_SWAP,
         data=RaydiumClmmSwapEvent(
             metadata=_make_meta(meta),
             pool_state=ps,
-            sender=user,
-            token_account_0=Z,
-            token_account_1=Z,
-            amount_0=0,
-            amount_1=0,
+            sender=sender,
+            token_account_0=token_account_0,
+            token_account_1=token_account_1,
+            amount_0=amount_0,
+            amount_1=amount_1,
             zero_for_one=zfo,
             sqrt_price_x64=sqrt,
-            liquidity="0",
-            transfer_fee_0=0,
-            transfer_fee_1=0,
-            tick=0,
+            liquidity=liq,
+            transfer_fee_0=transfer_fee_0,
+            transfer_fee_1=transfer_fee_1,
+            tick=tick,
         ),
     )
 
 
 def parse_clmm_inc_from_data(data: bytes, meta: dict) -> DexEvent:
-    if len(data) < 32 + 32 + 16 + 8 + 8:
+    if len(data) < 32 + 16 + 8 + 8 + 8 + 8:
         return DexEvent()
     o = 0
-    pool = _pub(data, o)
-    o += 32
-    user = _pub(data, o)
+    position_nft_mint = _pub(data, o)
     o += 32
     liq = str(_u128le_int(data, o))
     o += 16
-    a0 = _u64le(data, o)
+    amount_0 = _u64le(data, o)
     o += 8
-    a1 = _u64le(data, o)
+    amount_1 = _u64le(data, o)
+    o += 8
+    amount_0_transfer_fee = _u64le(data, o)
+    o += 8
+    amount_1_transfer_fee = _u64le(data, o)
     
     return DexEvent(
         type=EventType.RAYDIUM_CLMM_INCREASE_LIQUIDITY,
         data=RaydiumClmmIncreaseLiquidityEvent(
             metadata=_make_meta(meta),
-            pool=pool,
-            position_nft_mint=Z,
-            user=user,
+            pool=Z,
+            position_nft_mint=position_nft_mint,
+            user=Z,
             liquidity=liq,
-            amount0_max=a0,
-            amount1_max=a1,
+            amount_0=amount_0,
+            amount_1=amount_1,
+            amount_0_transfer_fee=amount_0_transfer_fee,
+            amount_1_transfer_fee=amount_1_transfer_fee,
+            amount0_max=0,
+            amount1_max=0,
         ),
     )
 
 
 def parse_clmm_dec_from_data(data: bytes, meta: dict) -> DexEvent:
-    if len(data) < 32 + 32 + 16 + 8 + 8:
+    if len(data) < 32 + 16 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 8:
         return DexEvent()
     o = 0
-    pool = _pub(data, o)
-    o += 32
-    user = _pub(data, o)
+    position_nft_mint = _pub(data, o)
     o += 32
     liq = str(_u128le_int(data, o))
     o += 16
-    a0 = _u64le(data, o)
+    decrease_amount_0 = _u64le(data, o)
     o += 8
-    a1 = _u64le(data, o)
+    decrease_amount_1 = _u64le(data, o)
+    o += 8
+    fee_amount_0 = _u64le(data, o)
+    o += 8
+    fee_amount_1 = _u64le(data, o)
+    o += 8
+    reward_amounts = [_u64le(data, o), _u64le(data, o + 8), _u64le(data, o + 16)]
+    o += 24
+    transfer_fee_0 = _u64le(data, o)
+    o += 8
+    transfer_fee_1 = _u64le(data, o)
     
     return DexEvent(
         type=EventType.RAYDIUM_CLMM_DECREASE_LIQUIDITY,
         data=RaydiumClmmDecreaseLiquidityEvent(
             metadata=_make_meta(meta),
-            pool=pool,
-            position_nft_mint=Z,
-            user=user,
+            pool=Z,
+            position_nft_mint=position_nft_mint,
+            user=Z,
             liquidity=liq,
-            amount0_min=a0,
-            amount1_min=a1,
+            decrease_amount_0=decrease_amount_0,
+            decrease_amount_1=decrease_amount_1,
+            fee_amount_0=fee_amount_0,
+            fee_amount_1=fee_amount_1,
+            reward_amounts=reward_amounts,
+            transfer_fee_0=transfer_fee_0,
+            transfer_fee_1=transfer_fee_1,
+            amount0_min=0,
+            amount1_min=0,
         ),
     )
 
 
 def parse_clmm_create_from_data(data: bytes, meta: dict) -> DexEvent:
-    if len(data) < 32 + 32 + 16 + 8:
+    if len(data) < 32 + 32 + 2 + 32 + 16 + 4 + 32 + 32:
         return DexEvent()
     o = 0
-    pool = _pub(data, o)
+    token_0_mint = _pub(data, o)
+    o += 32
+    token_1_mint = _pub(data, o)
     o += 32
-    cr = _pub(data, o)
+    tick_spacing = _u16le(data, o)
+    o += 2
+    pool = _pub(data, o)
     o += 32
     sqrt = str(_u128le_int(data, o))
     o += 16
-    ot = _u64le(data, o)
+    tick = _i32le(data, o)
+    o += 4
+    token_vault_0 = _pub(data, o)
+    o += 32
+    token_vault_1 = _pub(data, o)
     
     return DexEvent(
         type=EventType.RAYDIUM_CLMM_CREATE_POOL,
         data=RaydiumClmmCreatePoolEvent(
             metadata=_make_meta(meta),
             pool=pool,
-            creator=cr,
-            token_0_mint=Z,
-            token_1_mint=Z,
-            tick_spacing=0,
+            creator=Z,
+            token_0_mint=token_0_mint,
+            token_1_mint=token_1_mint,
+            tick_spacing=tick_spacing,
             fee_rate=0,
             sqrt_price_x64=sqrt,
-            open_time=ot,
+            tick=tick,
+            token_vault_0=token_vault_0,
+            token_vault_1=token_vault_1,
+            open_time=0,
         ),
     )
 
 
-def parse_clmm_collect_from_data(data: bytes, meta: dict) -> DexEvent:
-    if len(data) < 32 + 32 + 8 + 8:
+def parse_clmm_collect_personal_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 32 + 32 + 8 + 8:
         return DexEvent()
     o = 0
-    ps = _pub(data, o)
-    o += 32
     pn = _pub(data, o)
     o += 32
+    recipient_0 = _pub(data, o)
+    o += 32
+    recipient_1 = _pub(data, o)
+    o += 32
     a0 = _u64le(data, o)
     o += 8
     a1 = _u64le(data, o)
@@ -883,14 +955,325 @@ def parse_clmm_collect_from_data(data: bytes, meta: dict) -> DexEvent:
         type=EventType.RAYDIUM_CLMM_COLLECT_FEE,
         data=RaydiumClmmCollectFeeEvent(
             metadata=_make_meta(meta),
-            pool_state=ps,
+            pool_state=Z,
             position_nft_mint=pn,
+            recipient_token_account_0=recipient_0,
+            recipient_token_account_1=recipient_1,
+            amount_0=a0,
+            amount_1=a1,
+        ),
+    )
+
+
+def parse_clmm_collect_protocol_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 32 + 32 + 8 + 8:
+        return DexEvent()
+    o = 0
+    ps = _pub(data, o)
+    o += 32
+    recipient_0 = _pub(data, o)
+    o += 32
+    recipient_1 = _pub(data, o)
+    o += 32
+    a0 = _u64le(data, o)
+    o += 8
+    a1 = _u64le(data, o)
+
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_COLLECT_FEE,
+        data=RaydiumClmmCollectFeeEvent(
+            metadata=_make_meta(meta),
+            pool_state=ps,
+            position_nft_mint=Z,
+            recipient_token_account_0=recipient_0,
+            recipient_token_account_1=recipient_1,
             amount_0=a0,
             amount_1=a1,
         ),
     )
 
 
+def parse_clmm_liquidity_change_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 4 + 4 + 4 + 16 + 16:
+        return DexEvent()
+    o = 0
+    pool_state = _pub(data, o)
+    o += 32
+    tick = _i32le(data, o)
+    o += 4
+    tick_lower = _i32le(data, o)
+    o += 4
+    tick_upper = _i32le(data, o)
+    o += 4
+    before = str(_u128le_int(data, o))
+    o += 16
+    after = str(_u128le_int(data, o))
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_LIQUIDITY_CHANGE,
+        data=RaydiumClmmLiquidityChangeEvent(
+            metadata=_make_meta(meta),
+            pool_state=pool_state,
+            tick=tick,
+            tick_lower=tick_lower,
+            tick_upper=tick_upper,
+            liquidity_before=before,
+            liquidity_after=after,
+        ),
+    )
+
+
+def parse_clmm_config_change_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 2 + 32 + 4 + 4 + 2 + 4 + 32:
+        return DexEvent()
+    o = 0
+    index = _u16le(data, o)
+    o += 2
+    owner = _pub(data, o)
+    o += 32
+    protocol_fee_rate = _u32le(data, o)
+    o += 4
+    trade_fee_rate = _u32le(data, o)
+    o += 4
+    tick_spacing = _u16le(data, o)
+    o += 2
+    fund_fee_rate = _u32le(data, o)
+    o += 4
+    fund_owner = _pub(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_CONFIG_CHANGE,
+        data=RaydiumClmmConfigChangeEvent(
+            metadata=_make_meta(meta),
+            index=index,
+            owner=owner,
+            protocol_fee_rate=protocol_fee_rate,
+            trade_fee_rate=trade_fee_rate,
+            tick_spacing=tick_spacing,
+            fund_fee_rate=fund_fee_rate,
+            fund_owner=fund_owner,
+        ),
+    )
+
+
+def parse_clmm_create_personal_position_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 32 + 32 + 4 + 4 + 16 + 8 + 8 + 8 + 8:
+        return DexEvent()
+    o = 0
+    pool_state = _pub(data, o)
+    o += 32
+    minter = _pub(data, o)
+    o += 32
+    nft_owner = _pub(data, o)
+    o += 32
+    tick_lower_index = _i32le(data, o)
+    o += 4
+    tick_upper_index = _i32le(data, o)
+    o += 4
+    liquidity = str(_u128le_int(data, o))
+    o += 16
+    deposit_amount_0 = _u64le(data, o)
+    o += 8
+    deposit_amount_1 = _u64le(data, o)
+    o += 8
+    deposit_amount_0_transfer_fee = _u64le(data, o)
+    o += 8
+    deposit_amount_1_transfer_fee = _u64le(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_CREATE_PERSONAL_POSITION,
+        data=RaydiumClmmCreatePersonalPositionEvent(
+            metadata=_make_meta(meta),
+            pool_state=pool_state,
+            minter=minter,
+            nft_owner=nft_owner,
+            tick_lower_index=tick_lower_index,
+            tick_upper_index=tick_upper_index,
+            liquidity=liquidity,
+            deposit_amount_0=deposit_amount_0,
+            deposit_amount_1=deposit_amount_1,
+            deposit_amount_0_transfer_fee=deposit_amount_0_transfer_fee,
+            deposit_amount_1_transfer_fee=deposit_amount_1_transfer_fee,
+        ),
+    )
+
+
+def parse_clmm_liquidity_calculate_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 16 + 16 + 4 + 8 + 8 + 8 + 8 + 8 + 8:
+        return DexEvent()
+    o = 0
+    pool_liquidity = str(_u128le_int(data, o))
+    o += 16
+    pool_sqrt_price_x64 = str(_u128le_int(data, o))
+    o += 16
+    pool_tick = _i32le(data, o)
+    o += 4
+    calc_amount_0 = _u64le(data, o)
+    o += 8
+    calc_amount_1 = _u64le(data, o)
+    o += 8
+    trade_fee_owed_0 = _u64le(data, o)
+    o += 8
+    trade_fee_owed_1 = _u64le(data, o)
+    o += 8
+    transfer_fee_0 = _u64le(data, o)
+    o += 8
+    transfer_fee_1 = _u64le(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_LIQUIDITY_CALCULATE,
+        data=RaydiumClmmLiquidityCalculateEvent(
+            metadata=_make_meta(meta),
+            pool_liquidity=pool_liquidity,
+            pool_sqrt_price_x64=pool_sqrt_price_x64,
+            pool_tick=pool_tick,
+            calc_amount_0=calc_amount_0,
+            calc_amount_1=calc_amount_1,
+            trade_fee_owed_0=trade_fee_owed_0,
+            trade_fee_owed_1=trade_fee_owed_1,
+            transfer_fee_0=transfer_fee_0,
+            transfer_fee_1=transfer_fee_1,
+        ),
+    )
+
+
+def parse_clmm_open_limit_order_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 32 + 1 + 4 + 8 + 8:
+        return DexEvent()
+    o = 0
+    pool_id = _pub(data, o)
+    o += 32
+    limit_order = _pub(data, o)
+    o += 32
+    zero_for_one = _bool(data, o)
+    o += 1
+    tick_index = _i32le(data, o)
+    o += 4
+    total_amount = _u64le(data, o)
+    o += 8
+    transfer_fee = _u64le(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_OPEN_LIMIT_ORDER,
+        data=RaydiumClmmOpenLimitOrderEvent(
+            metadata=_make_meta(meta),
+            pool_id=pool_id,
+            limit_order=limit_order,
+            zero_for_one=zero_for_one,
+            tick_index=tick_index,
+            total_amount=total_amount,
+            transfer_fee=transfer_fee,
+        ),
+    )
+
+
+def parse_clmm_increase_limit_order_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 32 + 1 + 4 + 8 + 8 + 8:
+        return DexEvent()
+    o = 0
+    pool_id = _pub(data, o)
+    o += 32
+    limit_order = _pub(data, o)
+    o += 32
+    zero_for_one = _bool(data, o)
+    o += 1
+    tick_index = _i32le(data, o)
+    o += 4
+    total_amount = _u64le(data, o)
+    o += 8
+    increased_amount = _u64le(data, o)
+    o += 8
+    transfer_fee = _u64le(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_INCREASE_LIMIT_ORDER,
+        data=RaydiumClmmIncreaseLimitOrderEvent(
+            metadata=_make_meta(meta),
+            pool_id=pool_id,
+            limit_order=limit_order,
+            zero_for_one=zero_for_one,
+            tick_index=tick_index,
+            total_amount=total_amount,
+            increased_amount=increased_amount,
+            transfer_fee=transfer_fee,
+        ),
+    )
+
+
+def parse_clmm_decrease_limit_order_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 32 + 1 + 4 + 8 + 8 + 8 + 8:
+        return DexEvent()
+    o = 0
+    pool_id = _pub(data, o)
+    o += 32
+    limit_order = _pub(data, o)
+    o += 32
+    zero_for_one = _bool(data, o)
+    o += 1
+    tick_index = _i32le(data, o)
+    o += 4
+    total_amount = _u64le(data, o)
+    o += 8
+    filled_amount = _u64le(data, o)
+    o += 8
+    settled_output_amount = _u64le(data, o)
+    o += 8
+    decreased_amount = _u64le(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_DECREASE_LIMIT_ORDER,
+        data=RaydiumClmmDecreaseLimitOrderEvent(
+            metadata=_make_meta(meta),
+            pool_id=pool_id,
+            limit_order=limit_order,
+            zero_for_one=zero_for_one,
+            tick_index=tick_index,
+            total_amount=total_amount,
+            filled_amount=filled_amount,
+            settled_output_amount=settled_output_amount,
+            decreased_amount=decreased_amount,
+        ),
+    )
+
+
+def parse_clmm_settle_limit_order_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 32 + 32 + 1 + 4 + 8 + 8 + 8:
+        return DexEvent()
+    o = 0
+    pool_id = _pub(data, o)
+    o += 32
+    limit_order = _pub(data, o)
+    o += 32
+    zero_for_one = _bool(data, o)
+    o += 1
+    tick_index = _i32le(data, o)
+    o += 4
+    total_amount = _u64le(data, o)
+    o += 8
+    filled_amount = _u64le(data, o)
+    o += 8
+    settled_amount_out = _u64le(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_SETTLE_LIMIT_ORDER,
+        data=RaydiumClmmSettleLimitOrderEvent(
+            metadata=_make_meta(meta),
+            pool_id=pool_id,
+            limit_order=limit_order,
+            zero_for_one=zero_for_one,
+            tick_index=tick_index,
+            total_amount=total_amount,
+            filled_amount=filled_amount,
+            settled_amount_out=settled_amount_out,
+        ),
+    )
+
+
+def parse_clmm_update_reward_infos_from_data(data: bytes, meta: dict) -> DexEvent:
+    if len(data) < 16 * 3:
+        return DexEvent()
+    rewards = [str(_u128le_int(data, i * 16)) for i in range(3)]
+    return DexEvent(
+        type=EventType.RAYDIUM_CLMM_UPDATE_REWARD_INFOS,
+        data=RaydiumClmmUpdateRewardInfosEvent(
+            metadata=_make_meta(meta),
+            reward_growth_global_x64=rewards,
+        ),
+    )
+
+
 # --- Raydium AMM ---
 
 
@@ -942,6 +1325,27 @@ def parse_amm_swap_out_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
     )
 
 
+def parse_amm_ray_log_swap(log: str, meta: dict) -> Optional[DexEvent]:
+    prefix = "ray_log: "
+    start = log.find(prefix)
+    if start < 0:
+        return None
+    try:
+        data = base64.b64decode(log[start + len(prefix):].strip(), validate=True)
+    except Exception:
+        return None
+    if len(data) != 57 or data[0] not in (3, 4):
+        return None
+    first = _u64le(data, 1)
+    second = _u64le(data, 9)
+    actual = _u64le(data, 49)
+    if data[0] == 3:
+        event = _amm_swap_event(meta, Z, Z, first, second, 0, actual)
+    else:
+        event = _amm_swap_event(meta, Z, Z, actual, 0, first, second)
+    return DexEvent(type=EventType.RAYDIUM_AMM_V4_SWAP, data=event)
+
+
 def parse_amm_deposit_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
     if len(data) < 32 + 32 + 8 + 8 + 8:
         return None
@@ -1037,6 +1441,41 @@ def parse_amm_init2_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
 # --- Raydium CPMM ---
 
 
+def parse_cpmm_swap_event_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 32 + 6 * 8 + 1:
+        return None
+    o = 0
+    pool = _pub(data, o)
+    o += 32
+    input_vault_before = _u64le(data, o)
+    o += 8
+    output_vault_before = _u64le(data, o)
+    o += 8
+    input_amount = _u64le(data, o)
+    o += 8
+    output_amount = _u64le(data, o)
+    o += 8
+    input_transfer_fee = _u64le(data, o)
+    o += 8
+    output_transfer_fee = _u64le(data, o)
+    o += 8
+    base_input = _bool(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CPMM_SWAP,
+        data=RaydiumCpmmSwapEvent(
+            metadata=_make_meta(meta),
+            pool_id=pool,
+            input_vault_before=input_vault_before,
+            output_vault_before=output_vault_before,
+            input_amount=input_amount,
+            output_amount=output_amount,
+            input_transfer_fee=input_transfer_fee,
+            output_transfer_fee=output_transfer_fee,
+            base_input=base_input,
+        ),
+    )
+
+
 def parse_cpmm_swap_in_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
     if len(data) < 32 + 32 + 8 + 8 + 8 + 1:
         return None
@@ -1084,6 +1523,31 @@ def parse_cpmm_swap_out_from_data(data: bytes, meta: dict) -> Optional[DexEvent]
     )
 
 
+def parse_cpmm_create_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 32 + 32 + 32 + 32 + 8 + 8:
+        return None
+    o = 0
+    pool = _pub(data, o)
+    o += 32
+    o += 32
+    o += 32
+    creator = _pub(data, o)
+    o += 32
+    init_amount0 = _u64le(data, o)
+    o += 8
+    init_amount1 = _u64le(data, o)
+    return DexEvent(
+        type=EventType.RAYDIUM_CPMM_INITIALIZE,
+        data=RaydiumCpmmInitializeEvent(
+            metadata=_make_meta(meta),
+            pool=pool,
+            creator=creator,
+            init_amount0=init_amount0,
+            init_amount1=init_amount1,
+        ),
+    )
+
+
 def parse_cpmm_deposit_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
     if len(data) < 32 + 32 + 8 + 8 + 8:
         return None
@@ -1419,7 +1883,7 @@ def parse_meteora_pools_set_pool_fees_from_data(data: bytes, meta: dict) -> Opti
     )
 
 
-# --- Meteora DAMM (Swap / Swap2 only，与 Go/TS 一致) ---
+# --- Meteora DAMM (对齐 Rust/Node logs/meteora_damm) ---
 
 DAMM_SWAP = _d(27, 60, 21, 213, 138, 170, 187, 147)
 DAMM_SWAP2 = _d(189, 66, 51, 168, 38, 80, 117, 153)
@@ -1427,12 +1891,31 @@ DAMM_CREATE_POSITION = _d(156, 15, 119, 198, 29, 181, 221, 55)
 DAMM_CLOSE_POSITION = _d(20, 145, 144, 68, 143, 142, 214, 178)
 DAMM_ADD_LIQUIDITY = _d(175, 242, 8, 157, 30, 247, 185, 169)
 DAMM_REMOVE_LIQUIDITY = _d(87, 46, 88, 98, 175, 96, 34, 91)
+DAMM_LIQUIDITY_CHANGE = _d(197, 171, 78, 127, 224, 211, 87, 13)
 DAMM_INIT_POOL = _d(228, 50, 246, 85, 203, 66, 134, 37)
+DAMM_UPDATE_DELEGATE_PERMISSION = _d(66, 188, 75, 151, 150, 232, 87, 93)
+DAMM_WITHDRAW_DEAD_LIQUIDITY_REWARD = _d(228, 66, 150, 195, 42, 62, 163, 13)
+DAMM_CREATE_CONFIG = _d(131, 207, 180, 174, 180, 73, 165, 54)
+DAMM_CREATE_DYNAMIC_CONFIG = _d(231, 197, 13, 164, 248, 213, 133, 152)
+# Mainnet upgrade: trading_fee/partner_fee → claiming_fee/compounding_fee in EvtSwap2
+COMPOUNDING_FEE_LAYOUT_ACTIVATION_SLOT = 406_048_752
 DBC_SWAP = DAMM_SWAP
 DBC_INIT_POOL = DAMM_INIT_POOL
 DBC_CURVE_COMPLETE = _d(229, 231, 86, 84, 156, 134, 75, 24)
 
 
+def _uses_compounding_fee_layout(slot: int) -> bool:
+    return slot == 0 or slot >= COMPOUNDING_FEE_LAYOUT_ACTIVATION_SLOT
+
+
+def _meta_slot(meta: dict) -> int:
+    if isinstance(meta, EventMetadata):
+        return int(meta.slot or 0)
+    if isinstance(meta, dict):
+        return int(meta.get("slot", 0) or 0)
+    return 0
+
+
 def parse_meteora_damm_from_buf(buf: bytes, meta: dict) -> Optional[DexEvent]:
     if len(buf) < 8:
         return None
@@ -1450,8 +1933,18 @@ def parse_meteora_damm_from_buf(buf: bytes, meta: dict) -> Optional[DexEvent]:
         return _parse_damm_add_liquidity(data, meta)
     if d == DAMM_REMOVE_LIQUIDITY:
         return _parse_damm_remove_liquidity(data, meta)
+    if d == DAMM_LIQUIDITY_CHANGE:
+        return _parse_damm_liquidity_change(data, meta)
     if d == DAMM_INIT_POOL:
         return _parse_damm_initialize_pool(data, meta)
+    if d == DAMM_UPDATE_DELEGATE_PERMISSION:
+        return _parse_damm_update_delegate_permission(data, meta)
+    if d == DAMM_WITHDRAW_DEAD_LIQUIDITY_REWARD:
+        return _parse_damm_withdraw_dead_liquidity_reward(data, meta)
+    if d == DAMM_CREATE_CONFIG:
+        return _parse_damm_create_config(data, meta)
+    if d == DAMM_CREATE_DYNAMIC_CONFIG:
+        return _parse_damm_create_dynamic_config(data, meta)
     return None
 
 
@@ -1625,13 +2118,15 @@ def _parse_damm_swap(data: bytes, meta: dict) -> Optional[DexEvent]:
 
 
 def _parse_damm_swap2(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 32 + 1 + 1 + 1 + 8 * 2 + 1 + 8 * 6 + 16 + 8 * 4 + 8 * 3:
+    # Full 180-byte EvtSwap2 layout (Rust/Node parity)
+    if len(data) < 180:
         return None
     o = 0
     pool = _pub(data, o)
     o += 32
     td = _u8(data, o)
     o += 1
+    collect_fee_mode = _u8(data, o)
     o += 1
     hr = _bool(data, o)
     o += 1
@@ -1643,38 +2138,82 @@ def _parse_damm_swap2(data: bytes, meta: dict) -> Optional[DexEvent]:
     o += 1
     ifi = _u64le(data, o)
     o += 8
-    o += 16
+    efi = _u64le(data, o)
+    o += 8
+    amount_left = _u64le(data, o)
+    o += 8
     oa = _u64le(data, o)
     o += 8
     nsp = str(_u128le_int(data, o))
     o += 16
-    lpf = _u64le(data, o)
+    claiming_or_trading = _u64le(data, o)
     o += 8
     pf = _u64le(data, o)
     o += 8
+    compounding_or_partner = _u64le(data, o)
+    o += 8
     rf = _u64le(data, o)
     o += 8
+    itf_in = _u64le(data, o)
+    o += 8
+    itf_out = _u64le(data, o)
     o += 8
+    etf_out = _u64le(data, o)
     o += 8
     ct = _u64le(data, o)
-    ai, mo = (a0, a1) if sm == 0 else (a1, a0)
+    o += 8
+    reserve_a = _u64le(data, o)
+    o += 8
+    reserve_b = _u64le(data, o)
+
+    if sm in (0, 1):
+        ai, mo = a0, a1
+    elif sm == 2:
+        ai, mo = a1, a0
+    else:
+        return None
+
+    if _uses_compounding_fee_layout(_meta_slot(meta)):
+        lpf = claiming_or_trading + compounding_or_partner
+        partner_fee = compounding_or_partner
+        claiming_fee = claiming_or_trading
+        compounding_fee = compounding_or_partner
+    else:
+        lpf = claiming_or_trading
+        partner_fee = compounding_or_partner
+        claiming_fee = 0
+        compounding_fee = 0
+
     return DexEvent(
         type=EventType.METEORA_DAMM_V2_SWAP,
         data=MeteoraDammV2SwapEvent(
             metadata=_make_meta(meta),
             pool=pool,
             trade_direction=td,
+            collect_fee_mode=collect_fee_mode,
             has_referral=hr,
+            amount_0=a0,
+            amount_1=a1,
+            swap_mode=sm,
             amount_in=ai,
             minimum_amount_out=mo,
             output_amount=oa,
             next_sqrt_price=nsp,
             lp_fee=lpf,
             protocol_fee=pf,
-            partner_fee=0,
+            partner_fee=partner_fee,
             referral_fee=rf,
             actual_amount_in=ifi,
+            excluded_fee_input_amount=efi,
+            amount_left=amount_left,
+            claiming_fee=claiming_fee,
+            compounding_fee=compounding_fee,
+            included_transfer_fee_amount_in=itf_in,
+            included_transfer_fee_amount_out=itf_out,
+            excluded_transfer_fee_amount_out=etf_out,
             current_timestamp=ct,
+            reserve_a_amount=reserve_a,
+            reserve_b_amount=reserve_b,
             token_a_vault=Z,
             token_b_vault=Z,
             token_a_mint=Z,
@@ -1948,6 +2487,231 @@ def _parse_damm_remove_liquidity(data: bytes, meta: dict) -> Optional[DexEvent]:
     )
 
 
+def _parse_damm_liquidity_change(data: bytes, meta: dict) -> Optional[DexEvent]:
+    """EvtLiquidityChange; change_type 0=add, 1=remove."""
+    if len(data) < 177:
+        return None
+    pool = _pub(data, 0)
+    position = _pub(data, 32)
+    owner = _pub(data, 64)
+    ta = _u64le(data, 96)
+    tb = _u64le(data, 104)
+    tota = _u64le(data, 112)
+    totb = _u64le(data, 120)
+    ra = _u64le(data, 128)
+    rb = _u64le(data, 136)
+    ld = str(_u128le_int(data, 144))
+    tat = _u64le(data, 160)
+    tbt = _u64le(data, 168)
+    change_type = _u8(data, 176)
+    md = _make_meta(meta)
+    if change_type == 0:
+        return DexEvent(
+            type=EventType.METEORA_DAMM_V2_ADD_LIQUIDITY,
+            data=MeteoraDammV2AddLiquidityEvent(
+                metadata=md,
+                pool=pool,
+                position=position,
+                owner=owner,
+                liquidity_delta=ld,
+                token_a_amount_threshold=tat,
+                token_b_amount_threshold=tbt,
+                token_a_amount=ta,
+                token_b_amount=tb,
+                total_amount_a=tota,
+                total_amount_b=totb,
+                reserve_a_amount=ra,
+                reserve_b_amount=rb,
+            ),
+        )
+    if change_type == 1:
+        return DexEvent(
+            type=EventType.METEORA_DAMM_V2_REMOVE_LIQUIDITY,
+            data=MeteoraDammV2RemoveLiquidityEvent(
+                metadata=md,
+                pool=pool,
+                position=position,
+                owner=owner,
+                liquidity_delta=ld,
+                token_a_amount_threshold=tat,
+                token_b_amount_threshold=tbt,
+                token_a_amount=ta,
+                token_b_amount=tb,
+                total_amount_a=tota,
+                total_amount_b=totb,
+                reserve_a_amount=ra,
+                reserve_b_amount=rb,
+            ),
+        )
+    return None
+
+
+def _parse_damm_update_delegate_permission(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 32 + 32 + 4 + 1:
+        return None
+    o = 0
+    position = _pub(data, o)
+    o += 32
+    owner = _pub(data, o)
+    o += 32
+    permission = _u32le(data, o)
+    o += 4
+    has_delegate = _bool(data, o)
+    o += 1
+    delegate = None
+    if has_delegate:
+        if o + 32 > len(data):
+            return None
+        delegate = _pub(data, o)
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_UPDATE_DELEGATE_PERMISSION,
+        data=MeteoraDammV2UpdateDelegatePermissionEvent(
+            metadata=_make_meta(meta),
+            position=position,
+            owner=owner,
+            permission=permission,
+            delegate=delegate,
+        ),
+    )
+
+
+def _parse_damm_withdraw_dead_liquidity_reward(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 32 + 32 + 8:
+        return None
+    o = 0
+    pool = _pub(data, o)
+    o += 32
+    reward_mint = _pub(data, o)
+    o += 32
+    amount = _u64le(data, o)
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_WITHDRAW_DEAD_LIQUIDITY_REWARD,
+        data=MeteoraDammV2WithdrawDeadLiquidityRewardEvent(
+            metadata=_make_meta(meta),
+            pool=pool,
+            reward_mint=reward_mint,
+            amount=amount,
+        ),
+    )
+
+
+def _parse_damm_create_config_dynamic_fee(
+    data: bytes, o: int
+) -> Optional[tuple[MeteoraDammV2DynamicFeeParameters, int]]:
+    if o + 32 > len(data):
+        return None
+    bs = _u16le(data, o)
+    o += 2
+    bu = str(_u128le_int(data, o))
+    o += 16
+    fp = _u16le(data, o)
+    o += 2
+    dp = _u16le(data, o)
+    o += 2
+    rf = _u16le(data, o)
+    o += 2
+    mva = _u32le(data, o)
+    o += 4
+    vfc = _u32le(data, o)
+    o += 4
+    return (
+        MeteoraDammV2DynamicFeeParameters(
+            bin_step=bs,
+            bin_step_u128=bu,
+            filter_period=fp,
+            decay_period=dp,
+            reduction_factor=rf,
+            max_volatility_accumulator=mva,
+            variable_fee_control=vfc,
+        ),
+        o,
+    )
+
+
+def _parse_damm_create_config(data: bytes, meta: dict) -> Optional[DexEvent]:
+    o = 0
+    if len(data) < 27:
+        return None
+    base_fee_data = bytes(data[o : o + 27])
+    o += 27
+    if o + 2 + 1 + 1 > len(data):
+        return None
+    cfb = _u16le(data, o)
+    o += 2
+    pad = _u8(data, o)
+    o += 1
+    has_dyn = _bool(data, o)
+    o += 1
+    dyn = None
+    if has_dyn:
+        parsed = _parse_damm_create_config_dynamic_fee(data, o)
+        if not parsed:
+            return None
+        dyn, o = parsed
+    need = 32 + 32 + 1 + 16 + 16 + 1 + 8 + 32 + 16
+    if o + need > len(data):
+        return None
+    vault = _pub(data, o)
+    o += 32
+    pca = _pub(data, o)
+    o += 32
+    act = _u8(data, o)
+    o += 1
+    smin = str(_u128le_int(data, o))
+    o += 16
+    smax = str(_u128le_int(data, o))
+    o += 16
+    cfm = _u8(data, o)
+    o += 1
+    index = _u64le(data, o)
+    o += 8
+    config = _pub(data, o)
+    o += 32
+    permission = str(_u128le_int(data, o))
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_CREATE_CONFIG,
+        data=MeteoraDammV2CreateConfigEvent(
+            metadata=_make_meta(meta),
+            base_fee_data=base_fee_data,
+            compounding_fee_bps=cfb,
+            padding=pad,
+            dynamic_fee=dyn,
+            vault_config_key=vault,
+            pool_creator_authority=pca,
+            activation_type=act,
+            sqrt_min_price=smin,
+            sqrt_max_price=smax,
+            collect_fee_mode=cfm,
+            index=index,
+            config=config,
+            permission=permission,
+        ),
+    )
+
+
+def _parse_damm_create_dynamic_config(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 32 + 32 + 8 + 16:
+        return None
+    o = 0
+    config = _pub(data, o)
+    o += 32
+    pca = _pub(data, o)
+    o += 32
+    index = _u64le(data, o)
+    o += 8
+    permission = str(_u128le_int(data, o))
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_CREATE_DYNAMIC_CONFIG,
+        data=MeteoraDammV2CreateDynamicConfigEvent(
+            metadata=_make_meta(meta),
+            config=config,
+            pool_creator_authority=pca,
+            index=index,
+            permission=permission,
+        ),
+    )
+
+
 # --- RaydiumLaunchlab ---
 
 DISC_RAYDIUM_LAUNCHLAB_TRADE = _d(189, 219, 127, 211, 78, 230, 97, 238)
@@ -2014,9 +2778,56 @@ def _parse_raydium_launchlab_pool_create(data: bytes, meta: dict) -> Optional[De
 # --- PumpSwap ---
 
 
+def _parse_pumpswap_trade_tail(data: bytes) -> Optional[Dict[str, Any]]:
+    tail: Dict[str, Any] = {
+        "cashback_fee_basis_points": 0,
+        "cashback": 0,
+        "buyback_fee_basis_points": 0,
+        "buyback_fee": 0,
+        "virtual_quote_reserves": 0,
+        "can_boost": False,
+        "base_supply": 0,
+        "holder_rewards_bps": 0,
+        "holder_rewards": 0,
+    }
+    if not data:
+        return tail
+    if len(data) < 16:
+        return None
+
+    tail["cashback_fee_basis_points"] = _u64le(data, 0)
+    tail["cashback"] = _u64le(data, 8)
+    if len(data) == 16:
+        return tail
+    if len(data) < 32:
+        return None
+
+    tail["buyback_fee_basis_points"] = _u64le(data, 16)
+    tail["buyback_fee"] = _u64le(data, 24)
+    if len(data) == 32:
+        return tail
+    if len(data) < 57:
+        return None
+
+    tail["virtual_quote_reserves"] = int.from_bytes(data[32:48], "little", signed=True)
+    if data[48] not in (0, 1):
+        return None
+    tail["can_boost"] = data[48] == 1
+    tail["base_supply"] = _u64le(data, 49)
+    if len(data) != 57 and len(data) < 73:
+        return None
+    if len(data) >= 73:
+        tail["holder_rewards_bps"] = _u64le(data, 57)
+        tail["holder_rewards"] = _u64le(data, 65)
+    return tail
+
+
 def parse_ps_buy_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
-    min_len = 16 * 8 + 7 * 32 + 1 + 5 * 8 + 4
-    if len(data) < min_len:
+    legacy_len = 16 * 8 + 7 * 32 + 1 + 4 * 8
+    min_required_len = legacy_len + 8 + 4
+    if len(data) != legacy_len and len(data) < min_required_len:
+        return None
+    if data[352] not in (0, 1):
         return None
     o = 0
 
@@ -2065,36 +2876,36 @@ def parse_ps_buy_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
         "coin_creator_fee_basis_points": rd(),
         "coin_creator_fee": rd(),
     }
-    tv = _bool(data, o)
+    tv = data[o] == 1
     o += 1
     ev["track_volume"] = tv
     ev["total_unclaimed_tokens"] = rd()
     ev["total_claimed_tokens"] = rd()
     ev["current_sol_volume"] = rd()
     ev["last_update_timestamp"] = ri()
-    ev["min_base_amount_out"] = rd()
-    ix = ""
-    if o + 4 <= len(data):
-        ln = _u32le(data, o)
+    ev["min_base_amount_out"] = 0
+    ev["ix_name"] = ""
+    tail = _parse_pumpswap_trade_tail(b"")
+    if len(data) != legacy_len:
+        ev["min_base_amount_out"] = rd()
+        if o + 4 > len(data):
+            return None
+        name_len = _u32le(data, o)
         o += 4
-        if o + ln <= len(data):
-            ix = data[o : o + ln].decode("utf-8", errors="replace")
-    ev["ix_name"] = ix
-    # Mayhem mode and cashback fields
-    mm = False
-    if o < len(data):
-        mm = _bool(data, o)
-        o += 1
-    cb_bps = 0
-    cb = 0
-    if o + 16 <= len(data):
-        cb_bps = _u64le(data, o)
-        o += 8
-        cb = _u64le(data, o)
-    ev["mayhem_mode"] = mm
-    ev["cashback_fee_basis_points"] = cb_bps
-    ev["cashback"] = cb
-    ev["is_cashback_coin"] = cb_bps > 0
+        name_end = o + name_len
+        if name_end > len(data):
+            return None
+        try:
+            ev["ix_name"] = data[o:name_end].decode("utf-8")
+        except UnicodeDecodeError:
+            return None
+        o = name_end
+        tail = _parse_pumpswap_trade_tail(data[o:])
+        if tail is None:
+            return None
+    assert tail is not None
+    ev.update(tail)
+    ev["is_cashback_coin"] = tail["cashback_fee_basis_points"] > 0
     md = ev.pop("metadata", meta)
     return DexEvent(
         type=EventType.PUMP_SWAP_BUY,
@@ -2103,9 +2914,12 @@ def parse_ps_buy_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
 
 
 def parse_ps_sell_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
-    req = 13 * 8 + 7 * 32
+    req = 14 * 8 + 7 * 32 + 2 * 8
     if len(data) < req:
         return None
+    tail = _parse_pumpswap_trade_tail(data[req:])
+    if tail is None:
+        return None
     o = 0
 
     def rd() -> int:
@@ -2152,12 +2966,7 @@ def parse_ps_sell_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
         "coin_creator_fee_basis_points": rd(),
         "coin_creator_fee": rd(),
     }
-    cash_bps, cash = 0, 0
-    if len(data) >= 368:
-        cash_bps = _u64le(data, 352)
-        cash = _u64le(data, 360)
-    ev["cashback_fee_basis_points"] = cash_bps
-    ev["cashback"] = cash
+    ev.update(tail)
     md = ev.pop("metadata", meta)
     return DexEvent(
         type=EventType.PUMP_SWAP_SELL,
@@ -2166,9 +2975,11 @@ def parse_ps_sell_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
 
 
 def parse_ps_create_pool_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
-    req = 8 + 2 + 32 * 6 + 2 + 8 * 7 + 1
+    req = 326
     if len(data) < req:
         return None
+    if len(data) != req and len(data) < 335:
+        return None
     o = 0
     ts = _i64le(data, o)
     o += 8
@@ -2226,6 +3037,9 @@ def parse_ps_create_pool_from_data(data: bytes, meta: dict) -> Optional[DexEvent
     ev["user_quote_token_account"] = uqa
     ev["coin_creator"] = cc
     ev["is_mayhem_mode"] = len(data) > 325 and _bool(data, 325)
+    ev["creator_fee_bps"] = _u64le(data, 326) if len(data) >= 334 else 0
+    ev["can_edit_creator_fee"] = len(data) > 334 and _bool(data, 334)
+    ev["is_holder_reward"] = len(data) > 335 and _bool(data, 335)
     md = ev.pop("metadata", meta)
     return DexEvent(
         type=EventType.PUMP_SWAP_CREATE_POOL,
@@ -2329,14 +3143,24 @@ def parse_ps_remove_liq_from_data(data: bytes, meta: dict) -> Optional[DexEvent]
 
 # --- Meteora DLMM ---
 
-DLMM_SWAP = _d(143, 190, 90, 218, 196, 30, 51, 222)
-DLMM_ADD_LIQ = _d(181, 157, 89, 67, 143, 182, 52, 72)
-DLMM_REMOVE_LIQ = _d(80, 85, 209, 72, 24, 206, 35, 178)
-DLMM_INIT_POOL = _d(95, 180, 10, 172, 84, 174, 232, 40)
+DLMM_SWAP = _d(81, 108, 227, 190, 205, 208, 10, 196)
+DLMM_SWAP2 = _d(46, 116, 82, 215, 148, 27, 84, 77)
+DLMM_ADD_LIQ = _d(31, 94, 125, 90, 227, 52, 61, 186)
+DLMM_REMOVE_LIQ = _d(116, 244, 97, 232, 103, 31, 152, 58)
+DLMM_INIT_POOL = _d(185, 74, 252, 125, 27, 215, 188, 111)
 DLMM_INIT_BIN = _d(11, 18, 155, 194, 33, 115, 238, 119)
-DLMM_CREATE_POS = _d(123, 233, 11, 43, 146, 180, 97, 119)
-DLMM_CLOSE_POS = _d(94, 168, 102, 45, 59, 122, 137, 54)
-DLMM_CLAIM_FEE = _d(152, 70, 208, 111, 104, 91, 44, 1)
+DLMM_CREATE_POS = _d(144, 142, 252, 84, 157, 53, 37, 121)
+DLMM_CLOSE_POS = _d(255, 196, 16, 107, 28, 202, 53, 128)
+DLMM_CLAIM_FEE = _d(75, 122, 154, 48, 140, 74, 123, 163)
+DLMM_CLAIM_FEE2 = _d(232, 171, 242, 97, 58, 77, 35, 45)
+
+DLMM_LEGACY_SWAP = _d(143, 190, 90, 218, 196, 30, 51, 222)
+DLMM_LEGACY_ADD_LIQ = _d(181, 157, 89, 67, 143, 182, 52, 72)
+DLMM_LEGACY_REMOVE_LIQ = _d(80, 85, 209, 72, 24, 206, 35, 178)
+DLMM_LEGACY_INIT_POOL = _d(95, 180, 10, 172, 84, 174, 232, 40)
+DLMM_LEGACY_CREATE_POS = _d(123, 233, 11, 43, 146, 180, 97, 119)
+DLMM_LEGACY_CLOSE_POS = _d(94, 168, 102, 45, 59, 122, 137, 54)
+DLMM_LEGACY_CLAIM_FEE = _d(152, 70, 208, 111, 104, 91, 44, 1)
 
 
 def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
@@ -2344,7 +3168,11 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
         return None
     d = _disc8(buf[:8])
     data = buf[8:]
-    if d == DLMM_SWAP:
+    return parse_dlmm_event_from_data(d, data, meta)
+
+
+def parse_dlmm_event_from_data(d: int, data: bytes, meta: dict) -> Optional[DexEvent]:
+    if d in (DLMM_SWAP, DLMM_LEGACY_SWAP):
         if len(data) < 32 + 32 + 4 + 4 + 8 + 8 + 1 + 8 + 8 + 16 + 8:
             return None
         o = 0
@@ -2386,7 +3214,51 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
                 host_fee=hf,
             ),
         )
-    if d == DLMM_ADD_LIQ:
+    if d == DLMM_SWAP2:
+        if len(data) < 32 + 32 + 4 + 4 + 1 + 16 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 1 + 1:
+            return None
+        o = 0
+        pool = _pub(data, o)
+        o += 32
+        frm = _pub(data, o)
+        o += 32
+        sb = _i32le(data, o)
+        o += 4
+        eb = _i32le(data, o)
+        o += 4
+        sy = _bool(data, o)
+        o += 1
+        fbps = str(_u128le_int(data, o))
+        o += 16
+        ai = _u64le(data, o)
+        o += 8
+        o += 8
+        ao = _u64le(data, o)
+        o += 8
+        fee = _u64le(data, o)
+        o += 8
+        pf = _u64le(data, o)
+        o += 8
+        o += 8
+        hf = _u64le(data, o)
+        return DexEvent(
+            type=EventType.METEORA_DLMM_SWAP,
+            data=MeteoraDlmmSwapEvent(
+                metadata=_make_meta(meta),
+                pool=pool,
+                from_addr=frm,
+                start_bin_id=sb,
+                end_bin_id=eb,
+                amount_in=ai,
+                amount_out=ao,
+                swap_for_y=sy,
+                fee=fee,
+                protocol_fee=pf,
+                fee_bps=fbps,
+                host_fee=hf,
+            ),
+        )
+    if d in (DLMM_ADD_LIQ, DLMM_LEGACY_ADD_LIQ):
         if len(data) < 32 + 32 + 32 + 8 + 8 + 4:
             return None
         o = 0
@@ -2412,7 +3284,7 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
                 active_bin_id=ab,
             ),
         )
-    if d == DLMM_REMOVE_LIQ:
+    if d in (DLMM_REMOVE_LIQ, DLMM_LEGACY_REMOVE_LIQ):
         if len(data) < 32 + 32 + 32 + 8 + 8 + 4:
             return None
         o = 0
@@ -2439,6 +3311,23 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
             ),
         )
     if d == DLMM_INIT_POOL:
+        if len(data) < 32 + 2 + 32 + 32:
+            return None
+        o = 0
+        pool = _pub(data, o)
+        o += 32
+        bs = _u16le(data, o)
+        return DexEvent(
+            type=EventType.METEORA_DLMM_INITIALIZE_POOL,
+            data=MeteoraDlmmInitializePoolEvent(
+                metadata=_make_meta(meta),
+                pool=pool,
+                creator=Z,
+                active_bin_id=0,
+                bin_step=bs,
+            ),
+        )
+    if d == DLMM_LEGACY_INIT_POOL:
         if len(data) < 32 + 32 + 4 + 2:
             return None
         o = 0
@@ -2478,6 +3367,26 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
             ),
         )
     if d == DLMM_CREATE_POS:
+        if len(data) < 32 + 32 + 32:
+            return None
+        o = 0
+        pool = _pub(data, o)
+        o += 32
+        pos = _pub(data, o)
+        o += 32
+        owner = _pub(data, o)
+        return DexEvent(
+            type=EventType.METEORA_DLMM_CREATE_POSITION,
+            data=MeteoraDlmmCreatePositionEvent(
+                metadata=_make_meta(meta),
+                pool=pool,
+                position=pos,
+                owner=owner,
+                lower_bin_id=0,
+                width=0,
+            ),
+        )
+    if d == DLMM_LEGACY_CREATE_POS:
         if len(data) < 32 + 32 + 32 + 4 + 4:
             return None
         o = 0
@@ -2502,6 +3411,22 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
             ),
         )
     if d == DLMM_CLOSE_POS:
+        if len(data) < 32 + 32:
+            return None
+        o = 0
+        pos = _pub(data, o)
+        o += 32
+        owner = _pub(data, o)
+        return DexEvent(
+            type=EventType.METEORA_DLMM_CLOSE_POSITION,
+            data=MeteoraDlmmClosePositionEvent(
+                metadata=_make_meta(meta),
+                pool=Z,
+                position=pos,
+                owner=owner,
+            ),
+        )
+    if d == DLMM_LEGACY_CLOSE_POS:
         if len(data) < 32 + 32 + 32:
             return None
         o = 0
@@ -2519,7 +3444,7 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
                 owner=owner,
             ),
         )
-    if d == DLMM_CLAIM_FEE:
+    if d in (DLMM_CLAIM_FEE, DLMM_LEGACY_CLAIM_FEE):
         if len(data) < 32 + 32 + 32 + 8 + 8:
             return None
         o = 0
@@ -2543,6 +3468,30 @@ def parse_dlmm_from_program_data(buf: bytes, meta: dict) -> Optional[DexEvent]:
                 fee_y=fy,
             ),
         )
+    if d == DLMM_CLAIM_FEE2:
+        if len(data) < 32 + 32 + 32 + 8 + 8 + 4:
+            return None
+        o = 0
+        pool = _pub(data, o)
+        o += 32
+        pos = _pub(data, o)
+        o += 32
+        owner = _pub(data, o)
+        o += 32
+        fx = _u64le(data, o)
+        o += 8
+        fy = _u64le(data, o)
+        return DexEvent(
+            type=EventType.METEORA_DLMM_CLAIM_FEE,
+            data=MeteoraDlmmClaimFeeEvent(
+                metadata=_make_meta(meta),
+                pool=pool,
+                position=pos,
+                owner=owner,
+                fee_x=fx,
+                fee_y=fy,
+            ),
+        )
     return None
 
 
@@ -2567,13 +3516,24 @@ _LOG_DISCRIMINATOR_EVENT_TYPES = {
     _d(177, 49, 12, 210, 160, 118, 167, 116): EventType.PUMP_SWAP_CREATE_POOL,
     _d(120, 248, 61, 83, 31, 142, 107, 144): EventType.PUMP_SWAP_LIQUIDITY_ADDED,
     _d(22, 9, 133, 26, 160, 44, 71, 192): EventType.PUMP_SWAP_LIQUIDITY_REMOVED,
-    _d(248, 198, 158, 145, 225, 117, 135, 200): EventType.RAYDIUM_CLMM_SWAP,
-    _d(133, 29, 89, 223, 69, 238, 176, 10): EventType.RAYDIUM_CLMM_INCREASE_LIQUIDITY,
-    _d(160, 38, 208, 111, 104, 91, 44, 1): EventType.RAYDIUM_CLMM_DECREASE_LIQUIDITY,
-    _d(233, 146, 209, 142, 207, 104, 64, 188): EventType.RAYDIUM_CLMM_CREATE_POOL,
-    _d(164, 152, 207, 99, 187, 104, 171, 119): EventType.RAYDIUM_CLMM_COLLECT_FEE,
+    _d(64, 198, 205, 232, 38, 8, 113, 226): EventType.RAYDIUM_CLMM_SWAP,
+    _d(49, 79, 105, 212, 32, 34, 30, 84): EventType.RAYDIUM_CLMM_INCREASE_LIQUIDITY,
+    _d(58, 222, 86, 58, 68, 50, 85, 56): EventType.RAYDIUM_CLMM_DECREASE_LIQUIDITY,
+    _d(126, 240, 175, 206, 158, 88, 153, 107): EventType.RAYDIUM_CLMM_LIQUIDITY_CHANGE,
+    _d(247, 189, 7, 119, 106, 112, 95, 151): EventType.RAYDIUM_CLMM_CONFIG_CHANGE,
+    _d(100, 30, 87, 249, 196, 223, 154, 206): EventType.RAYDIUM_CLMM_CREATE_PERSONAL_POSITION,
+    _d(237, 112, 148, 230, 57, 84, 180, 162): EventType.RAYDIUM_CLMM_LIQUIDITY_CALCULATE,
+    _d(106, 24, 71, 85, 57, 169, 158, 216): EventType.RAYDIUM_CLMM_OPEN_LIMIT_ORDER,
+    _d(11, 120, 13, 204, 199, 87, 19, 200): EventType.RAYDIUM_CLMM_INCREASE_LIMIT_ORDER,
+    _d(70, 48, 40, 221, 219, 237, 212, 163): EventType.RAYDIUM_CLMM_DECREASE_LIMIT_ORDER,
+    _d(88, 119, 77, 164, 125, 124, 10, 194): EventType.RAYDIUM_CLMM_SETTLE_LIMIT_ORDER,
+    _d(109, 127, 186, 78, 114, 65, 37, 236): EventType.RAYDIUM_CLMM_UPDATE_REWARD_INFOS,
+    _d(25, 94, 75, 47, 112, 99, 53, 63): EventType.RAYDIUM_CLMM_CREATE_POOL,
+    _d(166, 174, 105, 192, 81, 161, 83, 105): EventType.RAYDIUM_CLMM_COLLECT_FEE,
+    _d(206, 87, 17, 79, 45, 41, 213, 61): EventType.RAYDIUM_CLMM_COLLECT_FEE,
     _d(143, 190, 90, 218, 196, 30, 51, 222): EventType.RAYDIUM_CPMM_SWAP,
     _d(55, 217, 98, 86, 163, 74, 180, 173): EventType.RAYDIUM_CPMM_SWAP,
+    _d(233, 146, 209, 142, 207, 104, 64, 188): EventType.RAYDIUM_CPMM_INITIALIZE,
     _d(242, 35, 198, 137, 82, 225, 242, 182): EventType.RAYDIUM_CPMM_DEPOSIT,
     _d(183, 18, 70, 156, 148, 109, 161, 34): EventType.RAYDIUM_CPMM_WITHDRAW,
     _d(0, 0, 0, 0, 0, 0, 0, 9): EventType.RAYDIUM_AMM_V4_SWAP,
@@ -2594,11 +3554,16 @@ _LOG_DISCRIMINATOR_EVENT_TYPES = {
     _d(245, 26, 198, 164, 88, 18, 75, 9): EventType.METEORA_POOLS_SET_POOL_FEES,
     DAMM_SWAP: EventType.METEORA_DAMM_V2_SWAP,
     DAMM_SWAP2: EventType.METEORA_DAMM_V2_SWAP,
-    _d(175, 242, 8, 157, 30, 247, 185, 169): EventType.METEORA_DAMM_V2_ADD_LIQUIDITY,
-    _d(87, 46, 88, 98, 175, 96, 34, 91): EventType.METEORA_DAMM_V2_REMOVE_LIQUIDITY,
-    _d(228, 50, 246, 85, 203, 66, 134, 37): EventType.METEORA_DAMM_V2_INITIALIZE_POOL,
-    _d(156, 15, 119, 198, 29, 181, 221, 55): EventType.METEORA_DAMM_V2_CREATE_POSITION,
-    _d(20, 145, 144, 68, 143, 142, 214, 178): EventType.METEORA_DAMM_V2_CLOSE_POSITION,
+    DAMM_ADD_LIQUIDITY: EventType.METEORA_DAMM_V2_ADD_LIQUIDITY,
+    DAMM_REMOVE_LIQUIDITY: EventType.METEORA_DAMM_V2_REMOVE_LIQUIDITY,
+    DAMM_LIQUIDITY_CHANGE: EventType.METEORA_DAMM_V2_ADD_LIQUIDITY,  # routed by change_type in parser
+    DAMM_INIT_POOL: EventType.METEORA_DAMM_V2_INITIALIZE_POOL,
+    DAMM_CREATE_POSITION: EventType.METEORA_DAMM_V2_CREATE_POSITION,
+    DAMM_CLOSE_POSITION: EventType.METEORA_DAMM_V2_CLOSE_POSITION,
+    DAMM_UPDATE_DELEGATE_PERMISSION: EventType.METEORA_DAMM_V2_UPDATE_DELEGATE_PERMISSION,
+    DAMM_WITHDRAW_DEAD_LIQUIDITY_REWARD: EventType.METEORA_DAMM_V2_WITHDRAW_DEAD_LIQUIDITY_REWARD,
+    DAMM_CREATE_CONFIG: EventType.METEORA_DAMM_V2_CREATE_CONFIG,
+    DAMM_CREATE_DYNAMIC_CONFIG: EventType.METEORA_DAMM_V2_CREATE_DYNAMIC_CONFIG,
     DISC_RAYDIUM_LAUNCHLAB_POOL_CREATE: EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE,
     DLMM_ADD_LIQ: EventType.METEORA_DLMM_ADD_LIQUIDITY,
     DLMM_REMOVE_LIQ: EventType.METEORA_DLMM_REMOVE_LIQUIDITY,
@@ -2615,18 +3580,115 @@ def event_type_for_discriminator(disc: int) -> Optional[EventType]:
 
 
 RAYDIUM_LAUNCHLAB_PROGRAM_ID = "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj"
+PUMPFUN_PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
+PUMP_FEES_PROGRAM_ID = "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ"
+PUMPSWAP_PROGRAM_ID = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"
+RAYDIUM_CLMM_PROGRAM_ID = "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK"
+RAYDIUM_CPMM_PROGRAM_ID = "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C"
+RAYDIUM_AMM_V4_PROGRAM_ID = "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
+ORCA_WHIRLPOOL_PROGRAM_ID = "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
+METEORA_POOLS_PROGRAM_ID = "Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB"
 METEORA_DAMM_V2_PROGRAM_ID = "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
 METEORA_DBC_PROGRAM_ID = "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN"
 METEORA_DLMM_PROGRAM_ID = "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo"
 
 
 def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -> Optional[EventType]:
+    if program_id == PUMPFUN_PROGRAM_ID:
+        if disc == PUMP_CREATE:
+            return EventType.PUMP_FUN_CREATE
+        if disc == PUMP_TRADE:
+            return EventType.PUMP_FUN_TRADE
+        if disc == PUMP_MIGRATE:
+            return EventType.PUMP_FUN_MIGRATE
+        if disc == PUMP_MIGRATE_BONDING_CURVE_CREATOR:
+            return EventType.PUMP_FUN_MIGRATE_BONDING_CURVE_CREATOR
+        return None
+    if program_id == PUMP_FEES_PROGRAM_ID:
+        mapping = {
+            PUMP_FEES_CREATE_FEE_SHARING_CONFIG: EventType.PUMP_FEES_CREATE_FEE_SHARING_CONFIG,
+            PUMP_FEES_INITIALIZE_FEE_CONFIG: EventType.PUMP_FEES_INITIALIZE_FEE_CONFIG,
+            PUMP_FEES_RESET_FEE_SHARING_CONFIG: EventType.PUMP_FEES_RESET_FEE_SHARING_CONFIG,
+            PUMP_FEES_REVOKE_FEE_SHARING_AUTHORITY: EventType.PUMP_FEES_REVOKE_FEE_SHARING_AUTHORITY,
+            PUMP_FEES_TRANSFER_FEE_SHARING_AUTHORITY: EventType.PUMP_FEES_TRANSFER_FEE_SHARING_AUTHORITY,
+            PUMP_FEES_UPDATE_ADMIN: EventType.PUMP_FEES_UPDATE_ADMIN,
+            PUMP_FEES_UPDATE_FEE_CONFIG: EventType.PUMP_FEES_UPDATE_FEE_CONFIG,
+            PUMP_FEES_UPDATE_FEE_SHARES: EventType.PUMP_FEES_UPDATE_FEE_SHARES,
+            PUMP_FEES_UPSERT_FEE_TIERS: EventType.PUMP_FEES_UPSERT_FEE_TIERS,
+        }
+        return mapping.get(disc)
+    if program_id == PUMPSWAP_PROGRAM_ID:
+        mapping = {
+            _d(103, 244, 82, 31, 44, 245, 119, 119): EventType.PUMP_SWAP_BUY,
+            _d(62, 47, 55, 10, 165, 3, 220, 42): EventType.PUMP_SWAP_SELL,
+            _d(177, 49, 12, 210, 160, 118, 167, 116): EventType.PUMP_SWAP_CREATE_POOL,
+            _d(120, 248, 61, 83, 31, 142, 107, 144): EventType.PUMP_SWAP_LIQUIDITY_ADDED,
+            _d(22, 9, 133, 26, 160, 44, 71, 192): EventType.PUMP_SWAP_LIQUIDITY_REMOVED,
+        }
+        return mapping.get(disc)
     if program_id == RAYDIUM_LAUNCHLAB_PROGRAM_ID:
         if disc == DISC_RAYDIUM_LAUNCHLAB_TRADE:
             return EventType.RAYDIUM_LAUNCHLAB_TRADE
         if disc == DISC_RAYDIUM_LAUNCHLAB_POOL_CREATE:
             return EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE
         return None
+    if program_id == RAYDIUM_CLMM_PROGRAM_ID:
+        mapping = {
+            _d(64, 198, 205, 232, 38, 8, 113, 226): EventType.RAYDIUM_CLMM_SWAP,
+            _d(49, 79, 105, 212, 32, 34, 30, 84): EventType.RAYDIUM_CLMM_INCREASE_LIQUIDITY,
+            _d(58, 222, 86, 58, 68, 50, 85, 56): EventType.RAYDIUM_CLMM_DECREASE_LIQUIDITY,
+            _d(126, 240, 175, 206, 158, 88, 153, 107): EventType.RAYDIUM_CLMM_LIQUIDITY_CHANGE,
+            _d(247, 189, 7, 119, 106, 112, 95, 151): EventType.RAYDIUM_CLMM_CONFIG_CHANGE,
+            _d(100, 30, 87, 249, 196, 223, 154, 206): EventType.RAYDIUM_CLMM_CREATE_PERSONAL_POSITION,
+            _d(237, 112, 148, 230, 57, 84, 180, 162): EventType.RAYDIUM_CLMM_LIQUIDITY_CALCULATE,
+            _d(106, 24, 71, 85, 57, 169, 158, 216): EventType.RAYDIUM_CLMM_OPEN_LIMIT_ORDER,
+            _d(11, 120, 13, 204, 199, 87, 19, 200): EventType.RAYDIUM_CLMM_INCREASE_LIMIT_ORDER,
+            _d(70, 48, 40, 221, 219, 237, 212, 163): EventType.RAYDIUM_CLMM_DECREASE_LIMIT_ORDER,
+            _d(88, 119, 77, 164, 125, 124, 10, 194): EventType.RAYDIUM_CLMM_SETTLE_LIMIT_ORDER,
+            _d(109, 127, 186, 78, 114, 65, 37, 236): EventType.RAYDIUM_CLMM_UPDATE_REWARD_INFOS,
+            _d(25, 94, 75, 47, 112, 99, 53, 63): EventType.RAYDIUM_CLMM_CREATE_POOL,
+            _d(166, 174, 105, 192, 81, 161, 83, 105): EventType.RAYDIUM_CLMM_COLLECT_FEE,
+            _d(206, 87, 17, 79, 45, 41, 213, 61): EventType.RAYDIUM_CLMM_COLLECT_FEE,
+        }
+        return mapping.get(disc)
+    if program_id == RAYDIUM_CPMM_PROGRAM_ID:
+        mapping = {
+            _d(64, 198, 205, 232, 38, 8, 113, 226): EventType.RAYDIUM_CPMM_SWAP,
+            _d(143, 190, 90, 218, 196, 30, 51, 222): EventType.RAYDIUM_CPMM_SWAP,
+            _d(55, 217, 98, 86, 163, 74, 180, 173): EventType.RAYDIUM_CPMM_SWAP,
+            _d(233, 146, 209, 142, 207, 104, 64, 188): EventType.RAYDIUM_CPMM_INITIALIZE,
+            _d(242, 35, 198, 137, 82, 225, 242, 182): EventType.RAYDIUM_CPMM_DEPOSIT,
+            _d(183, 18, 70, 156, 148, 109, 161, 34): EventType.RAYDIUM_CPMM_WITHDRAW,
+        }
+        return mapping.get(disc)
+    if program_id == RAYDIUM_AMM_V4_PROGRAM_ID:
+        mapping = {
+            _d(0, 0, 0, 0, 0, 0, 0, 9): EventType.RAYDIUM_AMM_V4_SWAP,
+            _d(0, 0, 0, 0, 0, 0, 0, 11): EventType.RAYDIUM_AMM_V4_SWAP,
+            _d(0, 0, 0, 0, 0, 0, 0, 3): EventType.RAYDIUM_AMM_V4_DEPOSIT,
+            _d(0, 0, 0, 0, 0, 0, 0, 4): EventType.RAYDIUM_AMM_V4_WITHDRAW,
+            _d(0, 0, 0, 0, 0, 0, 0, 1): EventType.RAYDIUM_AMM_V4_INITIALIZE2,
+            _d(0, 0, 0, 0, 0, 0, 0, 7): EventType.RAYDIUM_AMM_V4_WITHDRAW_PNL,
+        }
+        return mapping.get(disc)
+    if program_id == ORCA_WHIRLPOOL_PROGRAM_ID:
+        mapping = {
+            _d(225, 202, 73, 175, 147, 43, 160, 150): EventType.ORCA_WHIRLPOOL_SWAP,
+            _d(30, 7, 144, 181, 102, 254, 155, 161): EventType.ORCA_WHIRLPOOL_LIQUIDITY_INCREASED,
+            _d(166, 1, 36, 71, 112, 202, 181, 171): EventType.ORCA_WHIRLPOOL_LIQUIDITY_DECREASED,
+            _d(100, 118, 173, 87, 12, 198, 254, 229): EventType.ORCA_WHIRLPOOL_POOL_INITIALIZED,
+        }
+        return mapping.get(disc)
+    if program_id == METEORA_POOLS_PROGRAM_ID:
+        mapping = {
+            _d(81, 108, 227, 190, 205, 208, 10, 196): EventType.METEORA_POOLS_SWAP,
+            _d(31, 94, 125, 90, 227, 52, 61, 186): EventType.METEORA_POOLS_ADD_LIQUIDITY,
+            _d(116, 244, 97, 232, 103, 31, 152, 58): EventType.METEORA_POOLS_REMOVE_LIQUIDITY,
+            _d(121, 127, 38, 136, 92, 55, 14, 247): EventType.METEORA_POOLS_BOOTSTRAP_LIQUIDITY,
+            _d(202, 44, 41, 88, 104, 220, 157, 82): EventType.METEORA_POOLS_POOL_CREATED,
+            _d(245, 26, 198, 164, 88, 18, 75, 9): EventType.METEORA_POOLS_SET_POOL_FEES,
+        }
+        return mapping.get(disc)
     if program_id == METEORA_DAMM_V2_PROGRAM_ID:
         if disc in (DAMM_SWAP, DAMM_SWAP2):
             return EventType.METEORA_DAMM_V2_SWAP
@@ -2634,12 +3696,22 @@ def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -
             return EventType.METEORA_DAMM_V2_ADD_LIQUIDITY
         if disc == DAMM_REMOVE_LIQUIDITY:
             return EventType.METEORA_DAMM_V2_REMOVE_LIQUIDITY
+        if disc == DAMM_LIQUIDITY_CHANGE:
+            return EventType.METEORA_DAMM_V2_ADD_LIQUIDITY
         if disc == DAMM_INIT_POOL:
             return EventType.METEORA_DAMM_V2_INITIALIZE_POOL
         if disc == DAMM_CREATE_POSITION:
             return EventType.METEORA_DAMM_V2_CREATE_POSITION
         if disc == DAMM_CLOSE_POSITION:
             return EventType.METEORA_DAMM_V2_CLOSE_POSITION
+        if disc == DAMM_UPDATE_DELEGATE_PERMISSION:
+            return EventType.METEORA_DAMM_V2_UPDATE_DELEGATE_PERMISSION
+        if disc == DAMM_WITHDRAW_DEAD_LIQUIDITY_REWARD:
+            return EventType.METEORA_DAMM_V2_WITHDRAW_DEAD_LIQUIDITY_REWARD
+        if disc == DAMM_CREATE_CONFIG:
+            return EventType.METEORA_DAMM_V2_CREATE_CONFIG
+        if disc == DAMM_CREATE_DYNAMIC_CONFIG:
+            return EventType.METEORA_DAMM_V2_CREATE_DYNAMIC_CONFIG
         return None
     if program_id == METEORA_DBC_PROGRAM_ID:
         if disc == DBC_SWAP:
@@ -2649,19 +3721,221 @@ def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -
         if disc == DBC_CURVE_COMPLETE:
             return EventType.METEORA_DBC_CURVE_COMPLETE
         return None
+    if program_id == METEORA_DLMM_PROGRAM_ID:
+        if disc in (DLMM_SWAP, DLMM_SWAP2, DLMM_LEGACY_SWAP):
+            return EventType.METEORA_DLMM_SWAP
+        if disc in (DLMM_ADD_LIQ, DLMM_LEGACY_ADD_LIQ):
+            return EventType.METEORA_DLMM_ADD_LIQUIDITY
+        if disc in (DLMM_REMOVE_LIQ, DLMM_LEGACY_REMOVE_LIQ):
+            return EventType.METEORA_DLMM_REMOVE_LIQUIDITY
+        if disc in (DLMM_INIT_POOL, DLMM_LEGACY_INIT_POOL):
+            return EventType.METEORA_DLMM_INITIALIZE_POOL
+        if disc == DLMM_INIT_BIN:
+            return EventType.METEORA_DLMM_INITIALIZE_BIN_ARRAY
+        if disc in (DLMM_CREATE_POS, DLMM_LEGACY_CREATE_POS):
+            return EventType.METEORA_DLMM_CREATE_POSITION
+        if disc in (DLMM_CLOSE_POS, DLMM_LEGACY_CLOSE_POS):
+            return EventType.METEORA_DLMM_CLOSE_POSITION
+        if disc in (DLMM_CLAIM_FEE, DLMM_CLAIM_FEE2, DLMM_LEGACY_CLAIM_FEE):
+            return EventType.METEORA_DLMM_CLAIM_FEE
+        return None
     return event_type_for_discriminator(disc)
 
 
+def filter_wants_pumpfun_trade(event_type_filter: Any) -> bool:
+    return event_type_filter is None or any(
+        event_type_filter.should_include(t)
+        for t in (
+            EventType.PUMP_FUN_TRADE,
+            EventType.PUMP_FUN_BUY,
+            EventType.PUMP_FUN_SELL,
+            EventType.PUMP_FUN_BUY_EXACT_SOL_IN,
+        )
+    )
+
+
+def filter_wants_raydium_launchlab_trade(event_type_filter: Any) -> bool:
+    return event_type_filter is None or event_type_filter.should_include(
+        EventType.RAYDIUM_LAUNCHLAB_TRADE
+    )
+
+
+def filter_allows_unscoped_discriminator(event_type_filter: Any, disc: int) -> bool:
+    if event_type_filter is None:
+        return True
+    if disc == PUMP_TRADE:
+        return filter_wants_pumpfun_trade(event_type_filter) or filter_wants_raydium_launchlab_trade(
+            event_type_filter
+        )
+    if disc in (DLMM_SWAP, DLMM_SWAP2, DLMM_LEGACY_SWAP):
+        return event_type_filter.should_include(EventType.RAYDIUM_CPMM_SWAP) or event_type_filter.should_include(
+            EventType.METEORA_DLMM_SWAP
+        )
+    event_type = event_type_for_discriminator(disc)
+    if event_type is not None:
+        return event_type_filter.should_include(event_type)
+    return filter_wants_supported_logs(event_type_filter)
+
+
+def filter_wants_supported_logs(event_type_filter: Any) -> bool:
+    return any(
+        filter_includes_program(event_type_filter, program_id)
+        for program_id in (
+            PUMPFUN_PROGRAM_ID,
+            PUMP_FEES_PROGRAM_ID,
+            PUMPSWAP_PROGRAM_ID,
+            RAYDIUM_LAUNCHLAB_PROGRAM_ID,
+            RAYDIUM_CLMM_PROGRAM_ID,
+            RAYDIUM_CPMM_PROGRAM_ID,
+            RAYDIUM_AMM_V4_PROGRAM_ID,
+            ORCA_WHIRLPOOL_PROGRAM_ID,
+            METEORA_POOLS_PROGRAM_ID,
+            METEORA_DAMM_V2_PROGRAM_ID,
+            METEORA_DLMM_PROGRAM_ID,
+            METEORA_DBC_PROGRAM_ID,
+        )
+    )
+
+
+def dispatch_unscoped_pumpfun_launchlab_trade(
+    data: bytes,
+    meta: dict,
+    is_created_buy: bool,
+    event_type_filter: Any = None,
+) -> Optional[DexEvent]:
+    if filter_wants_pumpfun_trade(event_type_filter):
+        pumpfun = apply_event_type_filter(
+            parse_trade_from_data(data, meta, is_created_buy),
+            event_type_filter,
+        )
+        if pumpfun is not None:
+            return pumpfun
+    if filter_wants_raydium_launchlab_trade(event_type_filter):
+        return apply_event_type_filter(
+            parse_raydium_launchlab_from_discriminator(PUMP_TRADE, data, meta),
+            event_type_filter,
+        )
+    return None
+
+
+def _pumpfun_trade_matches_include_only(ev: DexEvent, include_only: List[EventType]) -> bool:
+    if ev.type == EventType.PUMP_FUN_BUY:
+        return EventType.PUMP_FUN_BUY in include_only or EventType.PUMP_FUN_BUY_EXACT_SOL_IN in include_only
+    if ev.type == EventType.PUMP_FUN_SELL:
+        return EventType.PUMP_FUN_SELL in include_only
+    if ev.type == EventType.PUMP_FUN_BUY_EXACT_SOL_IN:
+        return EventType.PUMP_FUN_BUY in include_only or EventType.PUMP_FUN_BUY_EXACT_SOL_IN in include_only
+    if ev.type == EventType.PUMP_FUN_TRADE:
+        return EventType.PUMP_FUN_TRADE in include_only
+    if ev.type in (EventType.PUMP_FUN_CREATE, EventType.PUMP_FUN_CREATE_V2):
+        return EventType.PUMP_FUN_CREATE in include_only or EventType.PUMP_FUN_CREATE_V2 in include_only
+    return False
+
+
+def apply_pumpfun_secondary_filter(ev: Optional[DexEvent], event_type_filter: Any) -> Optional[DexEvent]:
+    if ev is None or not ev.is_valid():
+        return None
+    include_only = getattr(event_type_filter, "include_only", None)
+    if include_only:
+        has_specific = any(
+            t
+            in (
+                EventType.PUMP_FUN_BUY,
+                EventType.PUMP_FUN_SELL,
+                EventType.PUMP_FUN_BUY_EXACT_SOL_IN,
+                EventType.PUMP_FUN_CREATE,
+                EventType.PUMP_FUN_CREATE_V2,
+            )
+            for t in include_only
+        )
+        if has_specific and not _pumpfun_trade_matches_include_only(ev, include_only):
+            return None
+    return apply_event_type_filter(ev, event_type_filter)
+
+
+def dispatch_scoped_pumpfun_data(
+    disc: int,
+    data: bytes,
+    meta: dict,
+    is_created_buy: bool,
+    event_type_filter: Any = None,
+) -> Optional[DexEvent]:
+    if disc == PUMP_TRADE:
+        return apply_pumpfun_secondary_filter(
+            parse_trade_from_data(data, meta, is_created_buy),
+            event_type_filter,
+        )
+    if disc == PUMP_CREATE:
+        return parse_create_from_data(data, meta)
+    if disc == PUMP_MIGRATE:
+        return parse_migrate_from_data(data, meta)
+    if disc == PUMP_MIGRATE_BONDING_CURVE_CREATOR:
+        return parse_migrate_bonding_curve_creator_from_data(data, meta)
+    return None
+
+
+def dispatch_scoped_pump_fees_data(disc: int, data: bytes, meta: dict) -> Optional[DexEvent]:
+    if disc == PUMP_FEES_CREATE_FEE_SHARING_CONFIG:
+        return parse_pump_fees_create_fee_sharing_config_from_data(data, meta)
+    if disc == PUMP_FEES_INITIALIZE_FEE_CONFIG:
+        return parse_pump_fees_initialize_fee_config_from_data(data, meta)
+    if disc == PUMP_FEES_RESET_FEE_SHARING_CONFIG:
+        return parse_pump_fees_reset_fee_sharing_config_from_data(data, meta)
+    if disc == PUMP_FEES_REVOKE_FEE_SHARING_AUTHORITY:
+        return parse_pump_fees_revoke_fee_sharing_authority_from_data(data, meta)
+    if disc == PUMP_FEES_TRANSFER_FEE_SHARING_AUTHORITY:
+        return parse_pump_fees_transfer_fee_sharing_authority_from_data(data, meta)
+    if disc == PUMP_FEES_UPDATE_ADMIN:
+        return parse_pump_fees_update_admin_from_data(data, meta)
+    if disc == PUMP_FEES_UPDATE_FEE_CONFIG:
+        return parse_pump_fees_update_fee_config_from_data(data, meta)
+    if disc == PUMP_FEES_UPDATE_FEE_SHARES:
+        return parse_pump_fees_update_fee_shares_from_data(data, meta)
+    if disc == PUMP_FEES_UPSERT_FEE_TIERS:
+        return parse_pump_fees_upsert_fee_tiers_from_data(data, meta)
+    return None
+
+
+def dispatch_scoped_pumpswap_data(disc: int, data: bytes, meta: dict) -> Optional[DexEvent]:
+    if disc == _d(103, 244, 82, 31, 44, 245, 119, 119):
+        return parse_ps_buy_from_data(data, meta)
+    if disc == _d(62, 47, 55, 10, 165, 3, 220, 42):
+        return parse_ps_sell_from_data(data, meta)
+    if disc == _d(177, 49, 12, 210, 160, 118, 167, 116):
+        return parse_ps_create_pool_from_data(data, meta)
+    if disc == _d(120, 248, 61, 83, 31, 142, 107, 144):
+        return parse_ps_add_liq_from_data(data, meta)
+    if disc == _d(22, 9, 133, 26, 160, 44, 71, 192):
+        return parse_ps_remove_liq_from_data(data, meta)
+    return None
+
+
 def filter_includes_program(event_type_filter: Any, program_id: Optional[str]) -> bool:
     from .grpc_types import (
         METEORA_DAMM_V2_FILTER_TYPES,
         METEORA_DBC_FILTER_TYPES,
         METEORA_DLMM_FILTER_TYPES,
+        METEORA_POOLS_FILTER_TYPES,
+        ORCA_WHIRLPOOL_FILTER_TYPES,
+        PUMP_FEES_EVENT_TYPES,
+        PUMPFUN_FILTER_TYPES,
+        PUMPSWAP_FILTER_TYPES,
+        RAYDIUM_AMM_V4_FILTER_TYPES,
+        RAYDIUM_CLMM_FILTER_TYPES,
+        RAYDIUM_CPMM_FILTER_TYPES,
         RAYDIUM_LAUNCHLAB_FILTER_TYPES,
     )
 
     groups = {
+        PUMPFUN_PROGRAM_ID: PUMPFUN_FILTER_TYPES,
+        PUMP_FEES_PROGRAM_ID: PUMP_FEES_EVENT_TYPES,
+        PUMPSWAP_PROGRAM_ID: PUMPSWAP_FILTER_TYPES,
         RAYDIUM_LAUNCHLAB_PROGRAM_ID: RAYDIUM_LAUNCHLAB_FILTER_TYPES,
+        RAYDIUM_CLMM_PROGRAM_ID: RAYDIUM_CLMM_FILTER_TYPES,
+        RAYDIUM_CPMM_PROGRAM_ID: RAYDIUM_CPMM_FILTER_TYPES,
+        RAYDIUM_AMM_V4_PROGRAM_ID: RAYDIUM_AMM_V4_FILTER_TYPES,
+        ORCA_WHIRLPOOL_PROGRAM_ID: ORCA_WHIRLPOOL_FILTER_TYPES,
+        METEORA_POOLS_PROGRAM_ID: METEORA_POOLS_FILTER_TYPES,
         METEORA_DAMM_V2_PROGRAM_ID: METEORA_DAMM_V2_FILTER_TYPES,
         METEORA_DBC_PROGRAM_ID: METEORA_DBC_FILTER_TYPES,
         METEORA_DLMM_PROGRAM_ID: METEORA_DLMM_FILTER_TYPES,
@@ -2697,16 +3971,114 @@ def dispatch_program_data(
     meta: dict,
     is_created_buy: bool,
     program_id: Optional[str] = None,
+    event_type_filter: Any = None,
 ) -> Optional[DexEvent]:
+    if program_id == PUMPFUN_PROGRAM_ID:
+        return dispatch_scoped_pumpfun_data(disc, data, meta, is_created_buy, event_type_filter)
+    if program_id == PUMP_FEES_PROGRAM_ID:
+        return dispatch_scoped_pump_fees_data(disc, data, meta)
+    if program_id == PUMPSWAP_PROGRAM_ID:
+        return dispatch_scoped_pumpswap_data(disc, data, meta)
     if program_id == RAYDIUM_LAUNCHLAB_PROGRAM_ID:
         return parse_raydium_launchlab_from_discriminator(disc, data, meta)
+    if program_id == RAYDIUM_CLMM_PROGRAM_ID:
+        if disc == _d(64, 198, 205, 232, 38, 8, 113, 226):
+            return parse_clmm_swap_from_data(data, meta)
+        if disc == _d(49, 79, 105, 212, 32, 34, 30, 84):
+            return parse_clmm_inc_from_data(data, meta)
+        if disc == _d(58, 222, 86, 58, 68, 50, 85, 56):
+            return parse_clmm_dec_from_data(data, meta)
+        if disc == _d(126, 240, 175, 206, 158, 88, 153, 107):
+            return parse_clmm_liquidity_change_from_data(data, meta)
+        if disc == _d(247, 189, 7, 119, 106, 112, 95, 151):
+            return parse_clmm_config_change_from_data(data, meta)
+        if disc == _d(100, 30, 87, 249, 196, 223, 154, 206):
+            return parse_clmm_create_personal_position_from_data(data, meta)
+        if disc == _d(237, 112, 148, 230, 57, 84, 180, 162):
+            return parse_clmm_liquidity_calculate_from_data(data, meta)
+        if disc == _d(106, 24, 71, 85, 57, 169, 158, 216):
+            return parse_clmm_open_limit_order_from_data(data, meta)
+        if disc == _d(11, 120, 13, 204, 199, 87, 19, 200):
+            return parse_clmm_increase_limit_order_from_data(data, meta)
+        if disc == _d(70, 48, 40, 221, 219, 237, 212, 163):
+            return parse_clmm_decrease_limit_order_from_data(data, meta)
+        if disc == _d(88, 119, 77, 164, 125, 124, 10, 194):
+            return parse_clmm_settle_limit_order_from_data(data, meta)
+        if disc == _d(109, 127, 186, 78, 114, 65, 37, 236):
+            return parse_clmm_update_reward_infos_from_data(data, meta)
+        if disc == _d(25, 94, 75, 47, 112, 99, 53, 63):
+            return parse_clmm_create_from_data(data, meta)
+        if disc == _d(166, 174, 105, 192, 81, 161, 83, 105):
+            return parse_clmm_collect_personal_from_data(data, meta)
+        if disc == _d(206, 87, 17, 79, 45, 41, 213, 61):
+            return parse_clmm_collect_protocol_from_data(data, meta)
+        return None
+    if program_id == RAYDIUM_CPMM_PROGRAM_ID:
+        if disc == _d(64, 198, 205, 232, 38, 8, 113, 226):
+            return parse_cpmm_swap_event_from_data(data, meta)
+        if disc == _d(143, 190, 90, 218, 196, 30, 51, 222):
+            return parse_cpmm_swap_in_from_data(data, meta)
+        if disc == _d(55, 217, 98, 86, 163, 74, 180, 173):
+            return parse_cpmm_swap_out_from_data(data, meta)
+        if disc == _d(233, 146, 209, 142, 207, 104, 64, 188):
+            return parse_cpmm_create_from_data(data, meta)
+        if disc == _d(242, 35, 198, 137, 82, 225, 242, 182):
+            return parse_cpmm_deposit_from_data(data, meta)
+        if disc == _d(183, 18, 70, 156, 148, 109, 161, 34):
+            return parse_cpmm_withdraw_from_data(data, meta)
+        return None
+    if program_id == RAYDIUM_AMM_V4_PROGRAM_ID:
+        if disc == _d(0, 0, 0, 0, 0, 0, 0, 9):
+            return parse_amm_swap_in_from_data(data, meta)
+        if disc == _d(0, 0, 0, 0, 0, 0, 0, 11):
+            return parse_amm_swap_out_from_data(data, meta)
+        if disc == _d(0, 0, 0, 0, 0, 0, 0, 3):
+            return parse_amm_deposit_from_data(data, meta)
+        if disc == _d(0, 0, 0, 0, 0, 0, 0, 4):
+            return parse_amm_withdraw_from_data(data, meta)
+        if disc == _d(0, 0, 0, 0, 0, 0, 0, 1):
+            return parse_amm_init2_from_data(data, meta)
+        if disc == _d(0, 0, 0, 0, 0, 0, 0, 7):
+            return parse_amm_withdraw_pnl_from_data(data, meta)
+        return None
+    if program_id == ORCA_WHIRLPOOL_PROGRAM_ID:
+        if disc == _d(225, 202, 73, 175, 147, 43, 160, 150):
+            return parse_orca_traded_from_data(data, meta)
+        if disc == _d(30, 7, 144, 181, 102, 254, 155, 161):
+            return parse_orca_liq_inc_from_data(data, meta)
+        if disc == _d(166, 1, 36, 71, 112, 202, 181, 171):
+            return parse_orca_liq_dec_from_data(data, meta)
+        if disc == _d(100, 118, 173, 87, 12, 198, 254, 229):
+            return parse_orca_pool_init_from_data(data, meta)
+        return None
+    if program_id == METEORA_POOLS_PROGRAM_ID:
+        if disc == _d(81, 108, 227, 190, 205, 208, 10, 196):
+            return parse_meteora_swap_from_data(data, meta)
+        if disc == _d(31, 94, 125, 90, 227, 52, 61, 186):
+            return parse_meteora_add_from_data(data, meta)
+        if disc == _d(116, 244, 97, 232, 103, 31, 152, 58):
+            return parse_meteora_remove_from_data(data, meta)
+        if disc == _d(121, 127, 38, 136, 92, 55, 14, 247):
+            return parse_meteora_bootstrap_from_data(data, meta)
+        if disc == _d(202, 44, 41, 88, 104, 220, 157, 82):
+            return parse_meteora_pool_created_from_data(data, meta)
+        if disc == _d(245, 26, 198, 164, 88, 18, 75, 9):
+            return parse_meteora_pools_set_pool_fees_from_data(data, meta)
+        return None
+    if program_id == METEORA_DAMM_V2_PROGRAM_ID:
+        return parse_meteora_damm_from_buf(buf, meta)
     if program_id == METEORA_DBC_PROGRAM_ID:
         return parse_meteora_dbc_from_discriminator(disc, data, meta)
     if program_id == METEORA_DLMM_PROGRAM_ID:
         return parse_dlmm_from_program_data(buf, meta)
     if disc == PUMP_TRADE:
-        return parse_trade_from_data(data, meta, is_created_buy)
-    if disc == _d(248, 198, 158, 145, 225, 117, 135, 200):
+        return dispatch_unscoped_pumpfun_launchlab_trade(
+            data,
+            meta,
+            is_created_buy,
+            event_type_filter,
+        )
+    if disc == _d(64, 198, 205, 232, 38, 8, 113, 226):
         return parse_clmm_swap_from_data(data, meta)
     if disc == _d(0, 0, 0, 0, 0, 0, 0, 9):
         return parse_amm_swap_in_from_data(data, meta)
@@ -2744,16 +4116,36 @@ def dispatch_program_data(
         return parse_ps_add_liq_from_data(data, meta)
     if disc == _d(22, 9, 133, 26, 160, 44, 71, 192):
         return parse_ps_remove_liq_from_data(data, meta)
-    if disc == _d(133, 29, 89, 223, 69, 238, 176, 10):
+    if disc == _d(49, 79, 105, 212, 32, 34, 30, 84):
         return parse_clmm_inc_from_data(data, meta)
-    if disc == _d(160, 38, 208, 111, 104, 91, 44, 1):
+    if disc == _d(58, 222, 86, 58, 68, 50, 85, 56):
         return parse_clmm_dec_from_data(data, meta)
-    if disc == _d(233, 146, 209, 142, 207, 104, 64, 188):
+    if disc == _d(126, 240, 175, 206, 158, 88, 153, 107):
+        return parse_clmm_liquidity_change_from_data(data, meta)
+    if disc == _d(247, 189, 7, 119, 106, 112, 95, 151):
+        return parse_clmm_config_change_from_data(data, meta)
+    if disc == _d(100, 30, 87, 249, 196, 223, 154, 206):
+        return parse_clmm_create_personal_position_from_data(data, meta)
+    if disc == _d(237, 112, 148, 230, 57, 84, 180, 162):
+        return parse_clmm_liquidity_calculate_from_data(data, meta)
+    if disc == _d(106, 24, 71, 85, 57, 169, 158, 216):
+        return parse_clmm_open_limit_order_from_data(data, meta)
+    if disc == _d(11, 120, 13, 204, 199, 87, 19, 200):
+        return parse_clmm_increase_limit_order_from_data(data, meta)
+    if disc == _d(70, 48, 40, 221, 219, 237, 212, 163):
+        return parse_clmm_decrease_limit_order_from_data(data, meta)
+    if disc == _d(88, 119, 77, 164, 125, 124, 10, 194):
+        return parse_clmm_settle_limit_order_from_data(data, meta)
+    if disc == _d(109, 127, 186, 78, 114, 65, 37, 236):
+        return parse_clmm_update_reward_infos_from_data(data, meta)
+    if disc == _d(25, 94, 75, 47, 112, 99, 53, 63):
         return parse_clmm_create_from_data(data, meta)
-    if disc == _d(164, 152, 207, 99, 187, 104, 171, 119):
-        return parse_clmm_collect_from_data(data, meta)
+    if disc == _d(166, 174, 105, 192, 81, 161, 83, 105):
+        return parse_clmm_collect_personal_from_data(data, meta)
+    if disc == _d(206, 87, 17, 79, 45, 41, 213, 61):
+        return parse_clmm_collect_protocol_from_data(data, meta)
     if disc == _d(143, 190, 90, 218, 196, 30, 51, 222):
-        return parse_cpmm_swap_in_from_data(data, meta)
+        return apply_event_type_filter(parse_cpmm_swap_in_from_data(data, meta), event_type_filter)
     if disc == _d(55, 217, 98, 86, 163, 74, 180, 173):
         return parse_cpmm_swap_out_from_data(data, meta)
     if disc == _d(242, 35, 198, 137, 82, 225, 242, 182):
@@ -2793,11 +4185,16 @@ def dispatch_program_data(
     if disc in (
         DAMM_SWAP,
         DAMM_SWAP2,
-        _d(175, 242, 8, 157, 30, 247, 185, 169),
-        _d(87, 46, 88, 98, 175, 96, 34, 91),
-        _d(228, 50, 246, 85, 203, 66, 134, 37),
-        _d(156, 15, 119, 198, 29, 181, 221, 55),
-        _d(20, 145, 144, 68, 143, 142, 214, 178),
+        DAMM_ADD_LIQUIDITY,
+        DAMM_REMOVE_LIQUIDITY,
+        DAMM_LIQUIDITY_CHANGE,
+        DAMM_INIT_POOL,
+        DAMM_CREATE_POSITION,
+        DAMM_CLOSE_POSITION,
+        DAMM_UPDATE_DELEGATE_PERMISSION,
+        DAMM_WITHDRAW_DEAD_LIQUIDITY_REWARD,
+        DAMM_CREATE_CONFIG,
+        DAMM_CREATE_DYNAMIC_CONFIG,
     ):
         return parse_meteora_damm_from_buf(buf, meta)
     raydium_launchlab = parse_raydium_launchlab_from_discriminator(disc, data, meta)