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

sol_parser/instructions.py

@@ -43,6 +43,7 @@ from .event_types import (
     PumpFunCreateV2TokenEvent,
     PumpFunTradeEvent,
     PumpSwapBuyEvent,
+    PumpSwapCreatePoolEvent,
     PumpSwapSellEvent,
     MeteoraDlmmAddLiquidityEvent,
     MeteoraDlmmClaimFeeEvent,
@@ -83,6 +84,7 @@ def _d(*xs: int) -> int:
 _DISC_PUMPSWAP_BUY = _d(102, 6, 61, 18, 1, 218, 235, 234)
 _DISC_PUMPSWAP_SELL = _d(51, 230, 133, 164, 1, 127, 131, 173)
 _DISC_PUMPSWAP_BUY_EXACT_QUOTE_IN = _d(198, 46, 21, 82, 180, 217, 232, 112)
+_DISC_PUMPSWAP_CREATE_POOL = _d(233, 146, 209, 142, 207, 104, 64, 188)
 
 _DISC_DAMM_SWAP    = _d(27, 60, 21, 213, 138, 170, 187, 147)
 _DISC_DAMM_SWAP2   = _d(189, 66, 51, 168, 38, 80, 117, 153)
@@ -97,6 +99,50 @@ _DISC_METEORA_POOLS_ADD_LIQUIDITY = _d(181, 157, 89, 67, 143, 182, 52, 72)
 _DISC_METEORA_POOLS_REMOVE_LIQUIDITY = _d(80, 85, 209, 72, 24, 206, 177, 108)
 _DISC_METEORA_POOLS_CREATE_POOL = _d(95, 180, 10, 172, 84, 174, 232, 40)
 
+_DISC_DLMM_ADD_LIQUIDITY = _d(181, 157, 89, 67, 143, 182, 52, 72)
+_DISC_DLMM_ADD_LIQUIDITY2 = _d(228, 162, 78, 28, 70, 219, 116, 115)
+_DISC_DLMM_CLAIM_FEE = _d(169, 32, 79, 137, 136, 232, 70, 137)
+_DISC_DLMM_CLAIM_FEE2 = _d(112, 191, 101, 171, 28, 144, 127, 187)
+_DISC_DLMM_CLOSE_POSITION = _d(123, 134, 81, 0, 49, 68, 98, 98)
+_DISC_DLMM_CLOSE_POSITION2 = _d(174, 90, 35, 115, 186, 40, 147, 226)
+_DISC_DLMM_INITIALIZE_BIN_ARRAY = _d(35, 86, 19, 185, 78, 212, 75, 211)
+_DISC_DLMM_INITIALIZE_LB_PAIR = _d(45, 154, 237, 210, 221, 15, 166, 92)
+_DISC_DLMM_INITIALIZE_LB_PAIR2 = _d(73, 59, 36, 120, 237, 83, 108, 198)
+_DISC_DLMM_INITIALIZE_POSITION = _d(219, 192, 234, 71, 190, 191, 102, 80)
+_DISC_DLMM_INITIALIZE_POSITION2 = _d(143, 19, 242, 145, 213, 15, 104, 115)
+_DISC_DLMM_INITIALIZE_POSITION_PDA = _d(46, 82, 125, 146, 85, 141, 228, 153)
+_DISC_DLMM_REMOVE_LIQUIDITY = _d(80, 85, 209, 72, 24, 206, 177, 108)
+_DISC_DLMM_REMOVE_LIQUIDITY2 = _d(230, 215, 82, 127, 241, 101, 227, 146)
+_DISC_DLMM_SWAP = _d(248, 198, 158, 145, 225, 117, 135, 200)
+_DISC_DLMM_SWAP2 = _d(65, 75, 63, 76, 235, 91, 91, 136)
+_DISC_DLMM_SWAP_EXACT_OUT = _d(250, 73, 101, 33, 38, 207, 75, 184)
+_DISC_DLMM_SWAP_EXACT_OUT2 = _d(43, 215, 247, 132, 137, 60, 243, 81)
+_DISC_DLMM_SWAP_WITH_PRICE_IMPACT = _d(56, 173, 230, 208, 173, 228, 156, 205)
+_DISC_DLMM_SWAP_WITH_PRICE_IMPACT2 = _d(74, 98, 192, 214, 177, 51, 75, 51)
+
+_DLMM_INSTRUCTION_DISCS = (
+    _DISC_DLMM_INITIALIZE_LB_PAIR,
+    _DISC_DLMM_INITIALIZE_LB_PAIR2,
+    _DISC_DLMM_INITIALIZE_BIN_ARRAY,
+    _DISC_DLMM_ADD_LIQUIDITY,
+    _DISC_DLMM_ADD_LIQUIDITY2,
+    _DISC_DLMM_REMOVE_LIQUIDITY,
+    _DISC_DLMM_REMOVE_LIQUIDITY2,
+    _DISC_DLMM_INITIALIZE_POSITION,
+    _DISC_DLMM_INITIALIZE_POSITION2,
+    _DISC_DLMM_INITIALIZE_POSITION_PDA,
+    _DISC_DLMM_SWAP,
+    _DISC_DLMM_SWAP2,
+    _DISC_DLMM_SWAP_EXACT_OUT,
+    _DISC_DLMM_SWAP_EXACT_OUT2,
+    _DISC_DLMM_SWAP_WITH_PRICE_IMPACT,
+    _DISC_DLMM_SWAP_WITH_PRICE_IMPACT2,
+    _DISC_DLMM_CLAIM_FEE,
+    _DISC_DLMM_CLAIM_FEE2,
+    _DISC_DLMM_CLOSE_POSITION,
+    _DISC_DLMM_CLOSE_POSITION2,
+)
+
 _DISC_CLMM_SWAP    = _d(248, 198, 158, 145, 225, 117, 135, 200)
 _DISC_CLMM_SWAP_V2 = _d(43, 4, 237, 11, 26, 201, 30, 98)
 _DISC_CLMM_INC_LIQ = _d(133, 29, 89, 223, 69, 238, 176, 10)
@@ -324,7 +370,8 @@ def normal_instruction_data_may_parse(program_id: str, instruction_data: bytes)
     if program_id == RAYDIUM_AMM_V4_PROGRAM_ID:
         return instruction_data[0] in (1, 3, 4, 7, 9, 11)
     if program_id == METEORA_DLMM_PROGRAM_ID:
-        return instruction_data[0] in (0, 1, 2, 7, 8, 11, 13, 14)
+        disc = _disc8(instruction_data)
+        return disc in _DLMM_INSTRUCTION_DISCS if disc is not None else False
     disc = _disc8(instruction_data)
     if disc is None:
         return False
@@ -345,7 +392,7 @@ def normal_instruction_data_may_parse(program_id: str, instruction_data: bytes)
         return disc in (
             _DISC_PUMPSWAP_BUY,
             _DISC_PUMPSWAP_SELL,
-            _d(233, 146, 209, 142, 207, 104, 64, 188),
+            _DISC_PUMPSWAP_CREATE_POOL,
             _DISC_PUMPSWAP_BUY_EXACT_QUOTE_IN,
             _d(242, 35, 198, 137, 82, 225, 242, 182),
             _d(183, 18, 70, 156, 148, 109, 161, 34),
@@ -764,6 +811,12 @@ def _parse_pumpfun_create_v2(data: bytes, accounts: List[str], meta: EventMetada
     is_mayhem_mode = data[offset] == 1
     offset += 1
     is_cashback_enabled = data[offset] == 1 if offset < len(data) else False
+    if offset < len(data):
+        offset += 1
+    creator_fee_bps = struct.unpack_from("<Q", data, offset)[0] if offset + 8 <= len(data) else 0
+    if offset + 8 <= len(data):
+        offset += 8
+    is_holder_reward = data[offset] == 1 if offset < len(data) else False
 
     return DexEvent(
         type=EventType.PUMP_FUN_CREATE_V2,
@@ -796,6 +849,8 @@ def _parse_pumpfun_create_v2(data: bytes, accounts: List[str], meta: EventMetada
             token_total_supply=0,
             is_mayhem_mode=is_mayhem_mode,
             is_cashback_enabled=is_cashback_enabled,
+            creator_fee_bps=creator_fee_bps,
+            is_holder_reward=is_holder_reward,
             quote_mint=_get_account_safe(accounts, 16) or Z,
             quote_vault=_get_account_safe(accounts, 17),
             quote_token_program=_get_account_safe(accounts, 18),
@@ -906,6 +961,38 @@ def parse_pumpswap_instruction(
         fill_sell_tail(ev)
         return DexEvent(type=EventType.PUMP_SWAP_SELL, data=ev)
 
+    if discriminator == _DISC_PUMPSWAP_CREATE_POOL:
+        if len(accounts) < 8:
+            return None
+        return DexEvent(
+            type=EventType.PUMP_SWAP_CREATE_POOL,
+            data=PumpSwapCreatePoolEvent(
+                metadata=meta,
+                index=struct.unpack_from("<H", payload, 0)[0] if len(payload) >= 2 else 0,
+                pool=_get_account_safe(accounts, 0),
+                creator=_get_account_safe(accounts, 2),
+                base_mint=_get_account_safe(accounts, 3),
+                quote_mint=_get_account_safe(accounts, 4),
+                base_amount_in=struct.unpack_from("<Q", payload, 2)[0] if len(payload) >= 10 else 0,
+                quote_amount_in=struct.unpack_from("<Q", payload, 10)[0] if len(payload) >= 18 else 0,
+                lp_mint=_get_account_safe(accounts, 5),
+                user_base_token_account=_get_account_safe(accounts, 6),
+                user_quote_token_account=_get_account_safe(accounts, 7),
+                coin_creator=(
+                    base58.b58encode(payload[18:50]).decode("ascii")
+                    if len(payload) >= 50
+                    else Z
+                ),
+                is_mayhem_mode=len(payload) > 50 and payload[50] == 1,
+                is_cashback_coin=len(payload) > 51 and payload[51] == 1,
+                creator_fee_bps=(
+                    struct.unpack_from("<Q", payload, 52)[0] if len(payload) >= 60 else 0
+                ),
+                can_edit_creator_fee=len(payload) > 60 and payload[60] == 1,
+                is_holder_reward=len(payload) > 61 and payload[61] == 1,
+            ),
+        )
+
     return None
 
 
@@ -1024,94 +1111,124 @@ def parse_meteora_dlmm_instruction(
     block_time_us: Optional[int],
     grpc_recv_us: int,
 ) -> Optional[DexEvent]:
-    if not data or not accounts:
+    if len(data) < 8 or not accounts:
         return None
-    instruction_type = data[0]
-    payload = data[1:]
+    discriminator = struct.unpack_from("<Q", data, 0)[0]
+    payload = data[8:]
     meta = _make_meta(signature, slot, tx_index, block_time_us, grpc_recv_us)
-    pool = accounts[0]
 
-    if instruction_type == 0:
+    if discriminator == _DISC_DLMM_INITIALIZE_LB_PAIR:
         if len(payload) < 6:
             return None
+        pool = _get_account_safe(accounts, 0)
         return DexEvent(
             type=EventType.METEORA_DLMM_INITIALIZE_POOL,
             data=MeteoraDlmmInitializePoolEvent(
                 metadata=meta,
                 pool=pool,
-                creator=_get_account_safe(accounts, 1),
+                creator=_get_account_safe(accounts, 8),
                 active_bin_id=struct.unpack_from("<i", payload, 0)[0],
                 bin_step=struct.unpack_from("<H", payload, 4)[0],
             ),
         )
 
-    if instruction_type == 1:
+    if discriminator == _DISC_DLMM_INITIALIZE_LB_PAIR2:
+        if len(payload) < 4:
+            return None
+        pool = _get_account_safe(accounts, 0)
+        return DexEvent(
+            type=EventType.METEORA_DLMM_INITIALIZE_POOL,
+            data=MeteoraDlmmInitializePoolEvent(
+                metadata=meta,
+                pool=pool,
+                creator=_get_account_safe(accounts, 8),
+                active_bin_id=struct.unpack_from("<i", payload, 0)[0],
+                bin_step=0,
+            ),
+        )
+
+    if discriminator == _DISC_DLMM_INITIALIZE_BIN_ARRAY:
         if len(payload) < 8:
             return None
+        pool = _get_account_safe(accounts, 0)
         return DexEvent(
             type=EventType.METEORA_DLMM_INITIALIZE_BIN_ARRAY,
             data=MeteoraDlmmInitializeBinArrayEvent(
                 metadata=meta,
                 pool=pool,
                 bin_array=_get_account_safe(accounts, 1),
-                index=struct.unpack_from("<Q", payload, 0)[0],
+                index=struct.unpack_from("<q", payload, 0)[0],
             ),
         )
 
-    if instruction_type == 2:
-        if len(payload) < 32:
-            return None
+    if discriminator in (_DISC_DLMM_ADD_LIQUIDITY, _DISC_DLMM_ADD_LIQUIDITY2):
+        pool = _get_account_safe(accounts, 1)
+        sender_index = 9 if discriminator == _DISC_DLMM_ADD_LIQUIDITY2 else 11
         return DexEvent(
             type=EventType.METEORA_DLMM_ADD_LIQUIDITY,
             data=MeteoraDlmmAddLiquidityEvent(
                 metadata=meta,
                 pool=pool,
-                from_addr=_get_account_safe(accounts, 1),
-                position=_get_account_safe(accounts, 2),
+                from_addr=_get_account_safe(accounts, sender_index),
+                position=_get_account_safe(accounts, 0),
                 amounts=[0, 0],
                 active_bin_id=0,
             ),
         )
 
-    if instruction_type == 7:
-        if len(payload) < 32:
-            return None
+    if discriminator in (_DISC_DLMM_REMOVE_LIQUIDITY, _DISC_DLMM_REMOVE_LIQUIDITY2):
+        pool = _get_account_safe(accounts, 1)
+        sender_index = 9 if discriminator == _DISC_DLMM_REMOVE_LIQUIDITY2 else 11
         return DexEvent(
             type=EventType.METEORA_DLMM_REMOVE_LIQUIDITY,
             data=MeteoraDlmmRemoveLiquidityEvent(
                 metadata=meta,
                 pool=pool,
-                from_addr=_get_account_safe(accounts, 1),
-                position=_get_account_safe(accounts, 2),
+                from_addr=_get_account_safe(accounts, sender_index),
+                position=_get_account_safe(accounts, 0),
                 amounts=[0, 0],
                 active_bin_id=0,
             ),
         )
 
-    if instruction_type == 8:
+    if discriminator in (
+        _DISC_DLMM_INITIALIZE_POSITION,
+        _DISC_DLMM_INITIALIZE_POSITION2,
+        _DISC_DLMM_INITIALIZE_POSITION_PDA,
+    ):
         if len(payload) < 8:
             return None
+        lower_bin_id, width = struct.unpack_from("<ii", payload, 0)
+        if width < 0:
+            return None
+        pda = discriminator == _DISC_DLMM_INITIALIZE_POSITION_PDA
+        position_index, pool_index, owner_index = (2, 3, 4) if pda else (1, 2, 3)
         return DexEvent(
             type=EventType.METEORA_DLMM_CREATE_POSITION,
             data=MeteoraDlmmCreatePositionEvent(
                 metadata=meta,
-                pool=pool,
-                position=_get_account_safe(accounts, 1),
-                owner=_get_account_safe(accounts, 2),
-                lower_bin_id=struct.unpack_from("<i", payload, 0)[0],
-                width=struct.unpack_from("<I", payload, 4)[0],
+                pool=_get_account_safe(accounts, pool_index),
+                position=_get_account_safe(accounts, position_index),
+                owner=_get_account_safe(accounts, owner_index),
+                lower_bin_id=lower_bin_id,
+                width=width,
             ),
         )
 
-    if instruction_type == 11:
-        if len(payload) < 16:
+    if discriminator in (_DISC_DLMM_SWAP, _DISC_DLMM_SWAP2):
+        if len(payload) < 8:
             return None
+        min_out = struct.unpack_from("<Q", payload, 8)[0] if len(payload) >= 16 else 0
+        pool = _get_account_safe(accounts, 0)
         return DexEvent(
             type=EventType.METEORA_DLMM_SWAP,
             data=MeteoraDlmmSwapEvent(
                 metadata=meta,
                 pool=pool,
-                from_addr=_get_account_safe(accounts, 1),
+                from_addr=_get_account_safe(accounts, 10),
+                user_token_in=_get_account_safe(accounts, 4),
+                user_token_out=_get_account_safe(accounts, 5),
+                min_amount_out=min_out,
                 start_bin_id=0,
                 end_bin_id=0,
                 amount_in=struct.unpack_from("<Q", payload, 0)[0],
@@ -1124,27 +1241,65 @@ def parse_meteora_dlmm_instruction(
             ),
         )
 
-    if instruction_type == 13:
+    if discriminator in (
+        _DISC_DLMM_SWAP_EXACT_OUT,
+        _DISC_DLMM_SWAP_EXACT_OUT2,
+        _DISC_DLMM_SWAP_WITH_PRICE_IMPACT,
+        _DISC_DLMM_SWAP_WITH_PRICE_IMPACT2,
+    ):
+        exact_out = discriminator in (_DISC_DLMM_SWAP_EXACT_OUT, _DISC_DLMM_SWAP_EXACT_OUT2)
+        if len(payload) < (16 if exact_out else 8):
+            return None
+        amount_out = 0
+        if exact_out:
+            amount_out = struct.unpack_from("<Q", payload, 8)[0]
+        pool = _get_account_safe(accounts, 0)
+        return DexEvent(
+            type=EventType.METEORA_DLMM_SWAP,
+            data=MeteoraDlmmSwapEvent(
+                metadata=meta,
+                pool=pool,
+                from_addr=_get_account_safe(accounts, 10),
+                user_token_in=_get_account_safe(accounts, 4),
+                user_token_out=_get_account_safe(accounts, 5),
+                min_amount_out=0,
+                start_bin_id=0,
+                end_bin_id=0,
+                amount_in=struct.unpack_from("<Q", payload, 0)[0],
+                amount_out=amount_out,
+                swap_for_y=False,
+                fee=0,
+                protocol_fee=0,
+                fee_bps="0",
+                host_fee=0,
+            ),
+        )
+
+    if discriminator in (_DISC_DLMM_CLAIM_FEE, _DISC_DLMM_CLAIM_FEE2):
+        pool = _get_account_safe(accounts, 0)
+        owner_index = 2 if discriminator == _DISC_DLMM_CLAIM_FEE2 else 4
         return DexEvent(
             type=EventType.METEORA_DLMM_CLAIM_FEE,
             data=MeteoraDlmmClaimFeeEvent(
                 metadata=meta,
                 pool=pool,
                 position=_get_account_safe(accounts, 1),
-                owner=_get_account_safe(accounts, 2),
+                owner=_get_account_safe(accounts, owner_index),
                 fee_x=0,
                 fee_y=0,
             ),
         )
 
-    if instruction_type == 14:
+    if discriminator in (_DISC_DLMM_CLOSE_POSITION, _DISC_DLMM_CLOSE_POSITION2):
+        position = _get_account_safe(accounts, 0)
+        v2 = discriminator == _DISC_DLMM_CLOSE_POSITION2
         return DexEvent(
             type=EventType.METEORA_DLMM_CLOSE_POSITION,
             data=MeteoraDlmmClosePositionEvent(
                 metadata=meta,
-                pool=pool,
-                position=_get_account_safe(accounts, 1),
-                owner=_get_account_safe(accounts, 2),
+                pool=Z if v2 else _get_account_safe(accounts, 1),
+                position=position,
+                owner=_get_account_safe(accounts, 1 if v2 else 4),
             ),
         )
 
@@ -1486,7 +1641,7 @@ def parse_raydium_cpmm_instruction(
             return None
         return legacy_dict_to_dex_event({"RaydiumCpmmSwap": {
             "metadata": meta,
-            "pool_id": Z,
+            "pool_id": _get_account_safe(accounts, 3),
             "input_amount": 0, "output_amount": 0,
             "input_vault_before": 0, "output_vault_before": 0,
             "input_transfer_fee": 0, "output_transfer_fee": 0,
@@ -1497,7 +1652,7 @@ def parse_raydium_cpmm_instruction(
             return None
         return legacy_dict_to_dex_event({"RaydiumCpmmSwap": {
             "metadata": meta,
-            "pool_id": Z,
+            "pool_id": _get_account_safe(accounts, 3),
             "input_amount": 0, "output_amount": 0,
             "input_vault_before": 0, "output_vault_before": 0,
             "input_transfer_fee": 0, "output_transfer_fee": 0,
@@ -1556,20 +1711,28 @@ def parse_raydium_amm_v4_instruction(
     meta = _make_meta(signature, slot, tx_index, block_time_us, grpc_recv_us)
 
     if instr_type in (9, 11):  # SwapBaseIn / SwapBaseOut
+        if len(data) < 17:
+            return None
+        first, second = struct.unpack_from("<QQ", data, 1)
+        shift = 1 if len(accounts) == 17 else 0
+        def g(index: int) -> str:
+            return _get_account_safe(accounts, index - shift if index >= 5 else index)
         return legacy_dict_to_dex_event({"RaydiumAmmV4Swap": {
             "metadata": meta,
             "amm": _get_account_safe(accounts, 1),
-            "user_source_owner": _get_account_safe(accounts, 17),
-            "amount_in": 0, "minimum_amount_out": 0,
-            "max_amount_in": 0, "amount_out": 0,
-            "token_program": Z, "amm_authority": Z, "amm_open_orders": Z,
-            "pool_coin_token_account": Z, "pool_pc_token_account": Z,
-            "serum_program": Z, "serum_market": Z, "serum_bids": Z,
-            "serum_asks": Z, "serum_event_queue": Z,
-            "serum_coin_vault_account": Z, "serum_pc_vault_account": Z,
-            "serum_vault_signer": Z,
-            "user_source_token_account": Z,
-            "user_destination_token_account": Z,
+            "user_source_owner": g(17),
+            "amount_in": first if instr_type == 9 else 0,
+            "minimum_amount_out": second if instr_type == 9 else 0,
+            "max_amount_in": first if instr_type == 11 else 0,
+            "amount_out": second if instr_type == 11 else 0,
+            "token_program": g(0), "amm_authority": g(2), "amm_open_orders": g(3),
+            "pool_coin_token_account": g(5), "pool_pc_token_account": g(6),
+            "serum_program": g(7), "serum_market": g(8), "serum_bids": g(9),
+            "serum_asks": g(10), "serum_event_queue": g(11),
+            "serum_coin_vault_account": g(12), "serum_pc_vault_account": g(13),
+            "serum_vault_signer": g(14),
+            "user_source_token_account": g(15),
+            "user_destination_token_account": g(16),
         }})
 
     return None
@@ -1599,9 +1762,10 @@ def parse_orca_whirlpool_instruction(
         sqrt_price_limit = int.from_bytes(data[24:40], "little")
         amount_specified_is_input = data[40] != 0
         a_to_b = data[41] != 0
+        whirlpool_index = 4 if discriminator == _DISC_ORCA_SWAP_V2 else 2
         return legacy_dict_to_dex_event({"OrcaWhirlpoolSwap": {
             "metadata": meta,
-            "whirlpool": _get_account_safe(accounts, 1),
+            "whirlpool": _get_account_safe(accounts, whirlpool_index),
             "a_to_b": a_to_b,
             "pre_sqrt_price": str(sqrt_price_limit), "post_sqrt_price": "0",
             "input_amount": amount if amount_specified_is_input else 0,

sol_parser/log_instr_dedup.py

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