sol-parser-sdk-python 0.5.7__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
 
@@ -45,6 +46,11 @@ from .event_types import (
     MeteoraDammV2CreatePositionEvent, MeteoraDammV2ClosePositionEvent,
     MeteoraDammV2AddLiquidityEvent, MeteoraDammV2RemoveLiquidityEvent,
     MeteoraDammV2InitializePoolEvent,
+    MeteoraDammV2DynamicFeeParameters,
+    MeteoraDammV2UpdateDelegatePermissionEvent,
+    MeteoraDammV2WithdrawDeadLiquidityRewardEvent,
+    MeteoraDammV2CreateConfigEvent,
+    MeteoraDammV2CreateDynamicConfigEvent,
     MeteoraDbcCurveCompleteEvent, MeteoraDbcInitializePoolEvent, MeteoraDbcSwapEvent,
     RaydiumLaunchlabTradeEvent, RaydiumLaunchlabPoolCreateEvent,
 )
@@ -252,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),
@@ -288,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,
@@ -343,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,
@@ -365,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,
         ),
     )
 
@@ -1309,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
@@ -1404,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
@@ -1811,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)
@@ -1819,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
@@ -1842,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
 
 
@@ -2017,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
@@ -2035,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,
@@ -2340,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)
@@ -2406,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
 
@@ -2457,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,
@@ -2495,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:
@@ -2544,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,
@@ -2558,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
@@ -2618,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,
@@ -2721,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]:
@@ -2736,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
@@ -2778,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
@@ -2804,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
@@ -2831,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
@@ -2870,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
@@ -2894,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
@@ -2911,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
@@ -2935,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
 
 
@@ -2997,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,
@@ -3091,6 +3653,7 @@ def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -
         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,
@@ -3133,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:
@@ -3149,21 +3722,21 @@ def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -
             return EventType.METEORA_DBC_CURVE_COMPLETE
         return None
     if program_id == METEORA_DLMM_PROGRAM_ID:
-        if disc == DLMM_SWAP:
+        if disc in (DLMM_SWAP, DLMM_SWAP2, DLMM_LEGACY_SWAP):
             return EventType.METEORA_DLMM_SWAP
-        if disc == DLMM_ADD_LIQ:
+        if disc in (DLMM_ADD_LIQ, DLMM_LEGACY_ADD_LIQ):
             return EventType.METEORA_DLMM_ADD_LIQUIDITY
-        if disc == DLMM_REMOVE_LIQ:
+        if disc in (DLMM_REMOVE_LIQ, DLMM_LEGACY_REMOVE_LIQ):
             return EventType.METEORA_DLMM_REMOVE_LIQUIDITY
-        if disc == DLMM_INIT_POOL:
+        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 == DLMM_CREATE_POS:
+        if disc in (DLMM_CREATE_POS, DLMM_LEGACY_CREATE_POS):
             return EventType.METEORA_DLMM_CREATE_POSITION
-        if disc == DLMM_CLOSE_POS:
+        if disc in (DLMM_CLOSE_POS, DLMM_LEGACY_CLOSE_POS):
             return EventType.METEORA_DLMM_CLOSE_POSITION
-        if disc == DLMM_CLAIM_FEE:
+        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)
@@ -3194,7 +3767,7 @@ def filter_allows_unscoped_discriminator(event_type_filter: Any, disc: int) -> b
         return filter_wants_pumpfun_trade(event_type_filter) or filter_wants_raydium_launchlab_trade(
             event_type_filter
         )
-    if disc == DLMM_SWAP:
+    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
         )
@@ -3441,6 +4014,8 @@ def dispatch_program_data(
             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):
@@ -3610,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)