sol-parser-sdk-python 0.5.9__py3-none-any.whl → 0.5.11__py3-none-any.whl

sol_parser/dex_parsers.py

@@ -43,12 +43,20 @@ from .event_types import (
     MeteoraDlmmClaimFeeEvent, MeteoraPoolsSetPoolFeesEvent, MeteoraPoolsSwapEvent,
     MeteoraPoolsAddLiquidityEvent, MeteoraPoolsRemoveLiquidityEvent,
     MeteoraPoolsBootstrapLiquidityEvent, MeteoraPoolsPoolCreatedEvent, MeteoraDammV2SwapEvent,
+    MeteoraDammV2ClaimPositionFeeEvent,
+    MeteoraDammV2ClaimRewardEvent,
+    MeteoraDlmmClaimRewardEvent,
     MeteoraDammV2CreatePositionEvent, MeteoraDammV2ClosePositionEvent,
     MeteoraDammV2AddLiquidityEvent, MeteoraDammV2RemoveLiquidityEvent,
     MeteoraDammV2InitializePoolEvent,
     MeteoraDammV2DynamicFeeParameters,
     MeteoraDammV2UpdateDelegatePermissionEvent,
     MeteoraDammV2WithdrawDeadLiquidityRewardEvent,
+    MeteoraDammV2WithdrawIneligibleRewardEvent,
+    MeteoraDammV2UpdateRewardFunderEvent,
+    MeteoraDammV2UpdateRewardDurationEvent,
+    MeteoraDammV2InitializeRewardEvent,
+    MeteoraDammV2FundRewardEvent,
     MeteoraDammV2CreateConfigEvent,
     MeteoraDammV2CreateDynamicConfigEvent,
     MeteoraDbcCurveCompleteEvent, MeteoraDbcInitializePoolEvent, MeteoraDbcSwapEvent,
@@ -260,8 +268,10 @@ def parse_trade_from_data(data: bytes, meta: dict, is_created_buy: bool) -> DexE
     real_quote_reserves = _optional_u64(data, tail)
     holder_rewards_bps = _optional_u64(data, tail)
     holder_rewards = _optional_u64(data, tail)
+    creator_fee_unclaimed=_optional_u64(data,tail)
     
     event_data = PumpFunTradeEvent(
+        creator_fee_unclaimed=creator_fee_unclaimed,
         metadata=_make_meta(meta),
         mint=mint,
         sol_amount=sol_amount,
@@ -324,6 +334,10 @@ def parse_create_from_data(data: bytes, meta: dict) -> DexEvent:
         uri, o = _borsh_str(data, o)
     except Exception:
         return DexEvent()
+    if len(data) - o == 96:
+        return DexEvent(type=EventType.PUMP_FUN_CREATE, data=PumpFunCreateEvent(
+            metadata=_make_meta(meta), name=name, symbol=sym, uri=uri,
+            mint=_pub(data, o), bonding_curve=_pub(data, o + 32), user=_pub(data, o + 64)))
     if len(data) < o + 32 * 4 + 8 * 5 + 32 + 1:
         return DexEvent()
     mint = _pub(data, o)
@@ -381,6 +395,7 @@ def parse_create_from_data(data: bytes, meta: dict) -> DexEvent:
             virtual_quote_reserves=virtual_quote_reserves,
             creator_fee_bps=creator_fee_bps,
             is_holder_reward=is_holder_reward,
+            depth=data[o+1] if o+1<len(data) else 0,
         ),
     )
 
@@ -1442,7 +1457,7 @@ def parse_amm_init2_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
 
 
 def parse_cpmm_swap_event_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 32 + 6 * 8 + 1:
+    if len(data) < 81 or (81 < len(data) < 162) or data[80] > 1 or (len(data) >= 162 and data[161] > 1):
         return None
     o = 0
     pool = _pub(data, o)
@@ -1463,6 +1478,11 @@ def parse_cpmm_swap_event_from_data(data: bytes, meta: dict) -> Optional[DexEven
     return DexEvent(
         type=EventType.RAYDIUM_CPMM_SWAP,
         data=RaydiumCpmmSwapEvent(
+            input_mint=_pub(data,81) if len(data)>=162 else "",
+            output_mint=_pub(data,113) if len(data)>=162 else "",
+            trade_fee=_u64le(data,145) if len(data)>=162 else 0,
+            creator_fee=_u64le(data,153) if len(data)>=162 else 0,
+            creator_fee_on_input=len(data)>=162 and bool(data[161]),
             metadata=_make_meta(meta),
             pool_id=pool,
             input_vault_before=input_vault_before,
@@ -1888,6 +1908,8 @@ def parse_meteora_pools_set_pool_fees_from_data(data: bytes, meta: dict) -> Opti
 DAMM_SWAP = _d(27, 60, 21, 213, 138, 170, 187, 147)
 DAMM_SWAP2 = _d(189, 66, 51, 168, 38, 80, 117, 153)
 DAMM_CREATE_POSITION = _d(156, 15, 119, 198, 29, 181, 221, 55)
+DAMM_CLAIM_POSITION_FEE = _d(198, 182, 183, 52, 97, 12, 49, 56)
+DAMM_CLAIM_REWARD = _d(218, 86, 147, 200, 235, 188, 215, 231)
 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)
@@ -1895,10 +1917,17 @@ 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_WITHDRAW_INELIGIBLE_REWARD = _d(248, 215, 184, 78, 31, 180, 179, 168)
+DAMM_UPDATE_REWARD_FUNDER = _d(76, 154, 208, 13, 40, 115, 246, 146)
+DAMM_UPDATE_REWARD_DURATION = _d(149, 135, 65, 231, 129, 153, 65, 57)
+DAMM_INITIALIZE_REWARD = _d(129, 91, 188, 3, 246, 52, 185, 249)
+DAMM_FUND_REWARD = _d(104, 233, 237, 122, 199, 191, 121, 85)
 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_SWAP2 = _d(189, 66, 51, 168, 38, 80, 117, 153)
+DBC_SWAP2_TRANSFER_HOOK = _d(134, 59, 168, 120, 94, 51, 114, 231)
 DBC_SWAP = DAMM_SWAP
 DBC_INIT_POOL = DAMM_INIT_POOL
 DBC_CURVE_COMPLETE = _d(229, 231, 86, 84, 156, 134, 75, 24)
@@ -1925,6 +1954,10 @@ def parse_meteora_damm_from_buf(buf: bytes, meta: dict) -> Optional[DexEvent]:
         return _parse_damm_swap(data, meta)
     if d == DAMM_SWAP2:
         return _parse_damm_swap2(data, meta)
+    if d == DAMM_CLAIM_POSITION_FEE:
+        return _parse_damm_claim_position_fee(data, meta)
+    if d == DAMM_CLAIM_REWARD:
+        return _parse_damm_claim_reward(data, meta)
     if d == DAMM_CREATE_POSITION:
         return _parse_damm_create_position(data, meta)
     if d == DAMM_CLOSE_POSITION:
@@ -1941,6 +1974,16 @@ def parse_meteora_damm_from_buf(buf: bytes, meta: dict) -> Optional[DexEvent]:
         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_WITHDRAW_INELIGIBLE_REWARD:
+        return _parse_damm_withdraw_ineligible_reward(data, meta)
+    if d == DAMM_UPDATE_REWARD_FUNDER:
+        return _parse_damm_update_reward_funder(data, meta)
+    if d == DAMM_UPDATE_REWARD_DURATION:
+        return _parse_damm_update_reward_duration(data, meta)
+    if d == DAMM_INITIALIZE_REWARD:
+        return _parse_damm_initialize_reward(data, meta)
+    if d == DAMM_FUND_REWARD:
+        return _parse_damm_fund_reward(data, meta)
     if d == DAMM_CREATE_CONFIG:
         return _parse_damm_create_config(data, meta)
     if d == DAMM_CREATE_DYNAMIC_CONFIG:
@@ -1949,6 +1992,8 @@ def parse_meteora_damm_from_buf(buf: bytes, meta: dict) -> Optional[DexEvent]:
 
 
 def parse_meteora_dbc_from_discriminator(disc: int, data: bytes, meta: dict) -> Optional[DexEvent]:
+    if disc in (DBC_SWAP2, DBC_SWAP2_TRANSFER_HOOK):
+        return _parse_dbc_swap2(data, meta, disc == DBC_SWAP2_TRANSFER_HOOK)
     if disc == DBC_SWAP:
         return _parse_dbc_swap(data, meta)
     if disc == DBC_INIT_POOL:
@@ -2595,6 +2640,90 @@ def _parse_damm_withdraw_dead_liquidity_reward(data: bytes, meta: dict) -> Optio
     )
 
 
+def _parse_damm_withdraw_ineligible_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_INELIGIBLE_REWARD,
+        data=MeteoraDammV2WithdrawIneligibleRewardEvent(
+            metadata=_make_meta(meta),
+            pool=pool,
+            reward_mint=reward_mint,
+            amount=amount,
+        ),
+    )
+
+
+def _parse_damm_update_reward_funder(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 97:
+        return None
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_UPDATE_REWARD_FUNDER,
+        data=MeteoraDammV2UpdateRewardFunderEvent(
+            metadata=_make_meta(meta),
+            pool=_pub(data, 0),
+            reward_index=data[32],
+            old_funder=_pub(data, 33),
+            new_funder=_pub(data, 65),
+        ),
+    )
+
+def _parse_damm_update_reward_duration(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 49:
+        return None
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_UPDATE_REWARD_DURATION,
+        data=MeteoraDammV2UpdateRewardDurationEvent(
+            metadata=_make_meta(meta),
+            pool=_pub(data, 0),
+            reward_index=data[32],
+            old_reward_duration=_u64le(data, 33),
+            new_reward_duration=_u64le(data, 41),
+        ),
+    )
+
+def _parse_damm_initialize_reward(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 137:
+        return None
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_INITIALIZE_REWARD,
+        data=MeteoraDammV2InitializeRewardEvent(
+            metadata=_make_meta(meta),
+            pool=_pub(data, 0),
+            reward_mint=_pub(data, 32),
+            funder=_pub(data, 64),
+            creator=_pub(data, 96),
+            reward_index=data[128],
+            reward_duration=_u64le(data, 129),
+        ),
+    )
+
+def _parse_damm_fund_reward(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 153:
+        return None
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_FUND_REWARD,
+        data=MeteoraDammV2FundRewardEvent(
+            metadata=_make_meta(meta),
+            pool=_pub(data, 0),
+            funder=_pub(data, 32),
+            mint_reward=_pub(data, 64),
+            reward_index=data[96],
+            amount=_u64le(data, 97),
+            transfer_fee_excluded_amount_in=_u64le(data, 105),
+            reward_duration_end=_u64le(data, 113),
+            pre_reward_rate=_u128le_int(data, 121),
+            post_reward_rate=_u128le_int(data, 137),
+        ),
+    )
+
+
 def _parse_damm_create_config_dynamic_fee(
     data: bytes, o: int
 ) -> Optional[tuple[MeteoraDammV2DynamicFeeParameters, int]]:
@@ -2802,6 +2931,7 @@ def _parse_pumpswap_trade_tail(data: bytes) -> Optional[Dict[str, Any]]:
         "base_supply": 0,
         "holder_rewards_bps": 0,
         "holder_rewards": 0,
+        "creator_fee_unclaimed":0,
     }
     if not data:
         return tail
@@ -2832,6 +2962,9 @@ def _parse_pumpswap_trade_tail(data: bytes) -> Optional[Dict[str, Any]]:
     if len(data) >= 73:
         tail["holder_rewards_bps"] = _u64le(data, 57)
         tail["holder_rewards"] = _u64le(data, 65)
+    if 73<len(data)<81:
+        return None
+    tail["creator_fee_unclaimed"]=_u64le(data,73) if len(data)>=81 else 0
     return tail
 
 
@@ -3061,7 +3194,7 @@ def parse_ps_create_pool_from_data(data: bytes, meta: dict) -> Optional[DexEvent
 
 
 def parse_ps_add_liq_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 10 * 8 + 5 * 32:
+    if len(data) < 11 * 8 + 5 * 32:
         return None
     o = 0
 
@@ -3108,7 +3241,7 @@ def parse_ps_add_liq_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
 
 
 def parse_ps_remove_liq_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 10 * 8 + 5 * 32:
+    if len(data) < 11 * 8 + 5 * 32:
         return None
     o = 0
 
@@ -3164,6 +3297,7 @@ 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(144, 142, 252, 84, 157, 53, 37, 121)
 DLMM_CLOSE_POS = _d(255, 196, 16, 107, 28, 202, 53, 128)
+DLMM_CLAIM_REWARD2 = _d(27, 143, 244, 33, 80, 43, 110, 146)
 DLMM_CLAIM_FEE = _d(75, 122, 154, 48, 140, 74, 123, 163)
 DLMM_CLAIM_FEE2 = _d(232, 171, 242, 97, 58, 77, 35, 45)
 
@@ -3230,6 +3364,8 @@ def parse_dlmm_event_from_data(d: int, data: bytes, meta: dict) -> Optional[DexE
     if d == DLMM_SWAP2:
         if len(data) < 32 + 32 + 4 + 4 + 1 + 16 + 8 + 8 + 8 + 8 + 8 + 8 + 8 + 1 + 1:
             return None
+        if any(data[x] > 1 for x in (72, 145, 146)):
+            return None
         o = 0
         pool = _pub(data, o)
         o += 32
@@ -3245,19 +3381,26 @@ def parse_dlmm_event_from_data(d: int, data: bytes, meta: dict) -> Optional[DexE
         o += 16
         ai = _u64le(data, o)
         o += 8
+        amount_left = _u64le(data, o)
         o += 8
         ao = _u64le(data, o)
         o += 8
-        fee = _u64le(data, o)
+        mm_fee = _u64le(data, o)
         o += 8
         pf = _u64le(data, o)
         o += 8
+        limit_order_fee = _u64le(data, o)
         o += 8
         hf = _u64le(data, o)
+        fee = mm_fee + pf + limit_order_fee
+        if fee > (1 << 64) - 1:
+            return None
         return DexEvent(
             type=EventType.METEORA_DLMM_SWAP,
             data=MeteoraDlmmSwapEvent(
                 metadata=_make_meta(meta),
+                event_version=2, amount_left=amount_left, mm_fee=mm_fee, limit_order_fee=limit_order_fee,
+                fees_on_input=bool(data[145]), fees_on_token_x=bool(data[146]),
                 pool=pool,
                 from_addr=frm,
                 start_bin_id=sb,
@@ -3457,6 +3600,11 @@ def parse_dlmm_event_from_data(d: int, data: bytes, meta: dict) -> Optional[DexE
                 owner=owner,
             ),
         )
+    if d == DLMM_CLAIM_REWARD2:
+        if len(data) < 116:
+            return None
+        return DexEvent(type=EventType.METEORA_DLMM_CLAIM_REWARD,
+            data=MeteoraDlmmClaimRewardEvent(metadata=_make_meta(meta),pool=_pub(data,0),position=_pub(data,32),owner=_pub(data,64),reward_index=_u64le(data,96),total_reward=_u64le(data,104),active_bin_id=int.from_bytes(data[112:116],"little",signed=True)))
     if d in (DLMM_CLAIM_FEE, DLMM_LEGACY_CLAIM_FEE):
         if len(data) < 32 + 32 + 32 + 8 + 8:
             return None
@@ -3572,9 +3720,16 @@ _LOG_DISCRIMINATOR_EVENT_TYPES = {
     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_CLAIM_POSITION_FEE: EventType.METEORA_DAMM_V2_CLAIM_POSITION_FEE,
+    DAMM_CLAIM_REWARD: EventType.METEORA_DAMM_V2_CLAIM_REWARD,
     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_WITHDRAW_INELIGIBLE_REWARD: EventType.METEORA_DAMM_V2_WITHDRAW_INELIGIBLE_REWARD,
+    DAMM_UPDATE_REWARD_FUNDER: EventType.METEORA_DAMM_V2_UPDATE_REWARD_FUNDER,
+    DAMM_UPDATE_REWARD_DURATION: EventType.METEORA_DAMM_V2_UPDATE_REWARD_DURATION,
+    DAMM_INITIALIZE_REWARD: EventType.METEORA_DAMM_V2_INITIALIZE_REWARD,
+    DAMM_FUND_REWARD: EventType.METEORA_DAMM_V2_FUND_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,
@@ -3585,6 +3740,7 @@ _LOG_DISCRIMINATOR_EVENT_TYPES = {
     DLMM_CREATE_POS: EventType.METEORA_DLMM_CREATE_POSITION,
     DLMM_CLOSE_POS: EventType.METEORA_DLMM_CLOSE_POSITION,
     DLMM_CLAIM_FEE: EventType.METEORA_DLMM_CLAIM_FEE,
+    DLMM_CLAIM_REWARD2: EventType.METEORA_DLMM_CLAIM_REWARD,
 }
 
 
@@ -3607,6 +3763,10 @@ METEORA_DLMM_PROGRAM_ID = "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo"
 
 
 def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -> Optional[EventType]:
+    from .pump_upgrade import pump_upgrade_event_type
+    upgrade=pump_upgrade_event_type(disc,program_id)
+    if upgrade is not None:
+        return upgrade
     if program_id == PUMPFUN_PROGRAM_ID:
         if disc == PUMP_CREATE:
             return EventType.PUMP_FUN_CREATE
@@ -3713,6 +3873,10 @@ def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -
             return EventType.METEORA_DAMM_V2_ADD_LIQUIDITY
         if disc == DAMM_INIT_POOL:
             return EventType.METEORA_DAMM_V2_INITIALIZE_POOL
+        if disc == DAMM_CLAIM_POSITION_FEE:
+            return EventType.METEORA_DAMM_V2_CLAIM_POSITION_FEE
+        if disc == DAMM_CLAIM_REWARD:
+            return EventType.METEORA_DAMM_V2_CLAIM_REWARD
         if disc == DAMM_CREATE_POSITION:
             return EventType.METEORA_DAMM_V2_CREATE_POSITION
         if disc == DAMM_CLOSE_POSITION:
@@ -3721,13 +3885,23 @@ def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -
             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_WITHDRAW_INELIGIBLE_REWARD:
+            return EventType.METEORA_DAMM_V2_WITHDRAW_INELIGIBLE_REWARD
+        if disc == DAMM_UPDATE_REWARD_FUNDER:
+            return EventType.METEORA_DAMM_V2_UPDATE_REWARD_FUNDER
+        if disc == DAMM_UPDATE_REWARD_DURATION:
+            return EventType.METEORA_DAMM_V2_UPDATE_REWARD_DURATION
+        if disc == DAMM_INITIALIZE_REWARD:
+            return EventType.METEORA_DAMM_V2_INITIALIZE_REWARD
+        if disc == DAMM_FUND_REWARD:
+            return EventType.METEORA_DAMM_V2_FUND_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:
+        if disc in (DBC_SWAP, DBC_SWAP2, DBC_SWAP2_TRANSFER_HOOK):
             return EventType.METEORA_DBC_SWAP
         if disc == DBC_INIT_POOL:
             return EventType.METEORA_DBC_INITIALIZE_POOL
@@ -3749,6 +3923,8 @@ def event_type_for_program_discriminator(program_id: Optional[str], disc: int) -
             return EventType.METEORA_DLMM_CREATE_POSITION
         if disc in (DLMM_CLOSE_POS, DLMM_LEGACY_CLOSE_POS):
             return EventType.METEORA_DLMM_CLOSE_POSITION
+        if disc == DLMM_CLAIM_REWARD2:
+            return EventType.METEORA_DLMM_CLAIM_REWARD
         if disc in (DLMM_CLAIM_FEE, DLMM_CLAIM_FEE2, DLMM_LEGACY_CLAIM_FEE):
             return EventType.METEORA_DLMM_CLAIM_FEE
         return None
@@ -3986,6 +4162,9 @@ def dispatch_program_data(
     program_id: Optional[str] = None,
     event_type_filter: Any = None,
 ) -> Optional[DexEvent]:
+    from .pump_upgrade import pump_upgrade_event_type,parse_pump_upgrade_event
+    if pump_upgrade_event_type(disc,program_id) is not None:
+        return apply_event_type_filter(parse_pump_upgrade_event(disc,data,_make_meta(meta),program_id),event_type_filter)
     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:
@@ -4203,9 +4382,16 @@ def dispatch_program_data(
         DAMM_LIQUIDITY_CHANGE,
         DAMM_INIT_POOL,
         DAMM_CREATE_POSITION,
+        DAMM_CLAIM_POSITION_FEE,
+        DAMM_CLAIM_REWARD,
         DAMM_CLOSE_POSITION,
         DAMM_UPDATE_DELEGATE_PERMISSION,
         DAMM_WITHDRAW_DEAD_LIQUIDITY_REWARD,
+        DAMM_WITHDRAW_INELIGIBLE_REWARD,
+        DAMM_UPDATE_REWARD_FUNDER,
+        DAMM_UPDATE_REWARD_DURATION,
+        DAMM_INITIALIZE_REWARD,
+        DAMM_FUND_REWARD,
         DAMM_CREATE_CONFIG,
         DAMM_CREATE_DYNAMIC_CONFIG,
     ):
@@ -4214,3 +4400,54 @@ def dispatch_program_data(
     if raydium_launchlab:
         return raydium_launchlab
     return parse_dlmm_from_program_data(buf, meta)
+
+
+def _parse_dbc_swap2(data: bytes, meta: dict, has_transfer_hook: bool) -> Optional[DexEvent]:
+    if len(data) < 179 or data[82] > 2 or data[64] > 1 or data[65] > 1:
+        return None
+    mode = data[82]
+    amount_0, amount_1 = _u64le(data,66), _u64le(data,74)
+    included = _u64le(data,83)
+    return DexEvent(EventType.METEORA_DBC_SWAP, MeteoraDbcSwapEvent(
+        metadata=_make_meta(meta), pool=_pub(data,0), config=_pub(data,32),
+        trade_direction=data[64], has_referral=bool(data[65]), event_version=2,
+        swap_mode=mode, amount_0=amount_0, amount_1=amount_1, has_transfer_hook=has_transfer_hook,
+        amount_in=included, minimum_amount_out=0 if mode == 2 else amount_1,
+        maximum_amount_in=amount_1 if mode == 2 else 0,
+        included_fee_input_amount=included, actual_input_amount=_u64le(data,91),
+        amount_left=_u64le(data,99), output_amount=_u64le(data,107), next_sqrt_price=_u128le_int(data,115),
+        trading_fee=_u64le(data,131), protocol_fee=_u64le(data,139), referral_fee=_u64le(data,147),
+        quote_reserve_amount=_u64le(data,155), migration_threshold=_u64le(data,163), current_timestamp=_u64le(data,171)))
+
+
+def _parse_damm_claim_position_fee(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 112:
+        return None
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_CLAIM_POSITION_FEE,
+        data=MeteoraDammV2ClaimPositionFeeEvent(
+            metadata=_make_meta(meta),
+            pool=_pub(data, 0),
+            position=_pub(data, 32),
+            owner=_pub(data, 64),
+            fee_a_claimed=int.from_bytes(data[96:104], "little"),
+            fee_b_claimed=int.from_bytes(data[104:112], "little"),
+        ),
+    )
+
+
+def _parse_damm_claim_reward(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 137:
+        return None
+    return DexEvent(
+        type=EventType.METEORA_DAMM_V2_CLAIM_REWARD,
+        data=MeteoraDammV2ClaimRewardEvent(
+            metadata=_make_meta(meta),
+            pool=_pub(data, 0),
+            position=_pub(data, 32),
+            owner=_pub(data, 64),
+            mint_reward=_pub(data, 96),
+            reward_index=data[128],
+            total_reward=int.from_bytes(data[129:137], "little"),
+        ),
+    )

sol_parser/event_type_parity.py

@@ -74,9 +74,17 @@ RUST_EVENT_TYPES = [
     "MeteoraDammV2RemoveLiquidity",
     "MeteoraDammV2InitializePool",
     "MeteoraDammV2CreatePosition",
+    "MeteoraDammV2ClaimPositionFee",
+    "MeteoraDammV2ClaimReward",
+    "MeteoraDlmmClaimReward",
     "MeteoraDammV2ClosePosition",
     "MeteoraDammV2UpdateDelegatePermission",
     "MeteoraDammV2WithdrawDeadLiquidityReward",
+    "MeteoraDammV2WithdrawIneligibleReward",
+    "MeteoraDammV2UpdateRewardFunder",
+    "MeteoraDammV2UpdateRewardDuration",
+    "MeteoraDammV2InitializeReward",
+    "MeteoraDammV2FundReward",
     "MeteoraDammV2CreateConfig",
     "MeteoraDammV2CreateDynamicConfig",
     "MeteoraDbcSwap",