sol-parser-sdk-python 0.5.7__py3-none-any.whl → 0.5.9__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)
@@ -322,9 +368,10 @@ def normal_instruction_data_may_parse(program_id: str, instruction_data: bytes)
     if not instruction_data:
         return False
     if program_id == RAYDIUM_AMM_V4_PROGRAM_ID:
-        return instruction_data[0] in (1, 3, 4, 7, 9, 11)
+        return instruction_data[0] in (1, 3, 4, 7, 9, 11, 16, 17)
     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,
@@ -1555,21 +1710,35 @@ def parse_raydium_amm_v4_instruction(
     instr_type = data[0]
     meta = _make_meta(signature, slot, tx_index, block_time_us, grpc_recv_us)
 
-    if instr_type in (9, 11):  # SwapBaseIn / SwapBaseOut
+    if instr_type in (9, 11, 16, 17):  # SwapBaseIn / SwapBaseOut
+        if len(data) < 17:
+            return None
+        modern = instr_type in (16,17)
+        if modern and len(accounts)<8:return None
+        first, second = struct.unpack_from("<QQ", data, 1)
+        shift = 1 if len(accounts) == 17 else 0
+        def g(index: int) -> str:
+            if modern:
+                index = {0:0,1:1,2:2,5:3,6:4,15:5,16:6,17:7}.get(index,-1)
+            else:
+                index = index-shift if index>=5 else index
+            return _get_account_safe(accounts,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 in (9,16) else 0,
+            "minimum_amount_out": second if instr_type in (9,16) else 0,
+            "max_amount_in": first if instr_type in (11,17) else 0,
+            "amount_out": second if instr_type in (11,17) 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 +1768,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,
@@ -1679,7 +1849,7 @@ def parse_raydium_launchlab_instruction(
     payload = data[8:]
 
     if discriminator == _DISC_RAYDIUM_LAUNCHLAB_TRADE:
-        if len(payload) < 139:
+        if len(payload) != 139 or payload[136] > 1 or payload[137] > 2 or payload[138] > 1:
             return None
         return legacy_dict_to_dex_event({"RaydiumLaunchlabTrade": {
             "metadata": meta,
@@ -1690,6 +1860,19 @@ def parse_raydium_launchlab_instruction(
             "is_buy": payload[136] == 0,
             "trade_direction": "Buy" if payload[136] == 0 else "Sell",
             "exact_in": payload[138] == 1,
+            "pool_status": ("Fund","Migrate","Trade")[payload[137]],
+            "total_base_sell": _u64_payload(payload,32),
+            "virtual_base": _u64_payload(payload,40),
+            "virtual_quote": _u64_payload(payload,48),
+            "real_base_before": _u64_payload(payload,56),
+            "real_quote_before": _u64_payload(payload,64),
+            "real_base_after": _u64_payload(payload,72),
+            "real_quote_after": _u64_payload(payload,80),
+            "protocol_fee": _u64_payload(payload,104),
+            "platform_fee": _u64_payload(payload,112),
+            "creator_fee": _u64_payload(payload,120),
+            "share_fee": _u64_payload(payload,128),
+
         }})
     if discriminator == _DISC_RAYDIUM_LAUNCHLAB_POOL_CREATE:
         if len(payload) < 97:
@@ -1733,6 +1916,20 @@ def parse_raydium_launchlab_instruction(
             "is_buy": is_buy,
             "trade_direction": "Buy" if is_buy else "Sell",
             "exact_in": exact_in,
+            "global_config": _get_account_safe(accounts,2),
+            "platform_config": _get_account_safe(accounts,3),
+            "user_base_token": _get_account_safe(accounts,5),
+            "user_quote_token": _get_account_safe(accounts,6),
+            "base_vault": _get_account_safe(accounts,7),
+            "quote_vault": _get_account_safe(accounts,8),
+            "base_mint": _get_account_safe(accounts,9),
+            "quote_mint": _get_account_safe(accounts,10),
+            "base_token_program": _get_account_safe(accounts,11),
+            "quote_token_program": _get_account_safe(accounts,12),
+            "system_program": _get_account_safe(accounts,15),
+            "platform_associated_account": _get_account_safe(accounts,16),
+            "creator_associated_account": _get_account_safe(accounts,17),
+
         }})
     if discriminator in (
         _IX_RAYDIUM_LAUNCHLAB_INITIALIZE,
@@ -1758,7 +1955,16 @@ def parse_raydium_launchlab_instruction(
         _IX_RAYDIUM_LAUNCHLAB_MIGRATE_TO_AMM,
         _IX_RAYDIUM_LAUNCHLAB_MIGRATE_TO_CPSWAP,
     ):
-        return None
+        cp = discriminator == _IX_RAYDIUM_LAUNCHLAB_MIGRATE_TO_CPSWAP
+        if len(accounts) < (28 if cp else 32) or (not cp and len(payload) < 9): return None
+        return legacy_dict_to_dex_event({"RaydiumLaunchlabMigrateAmm": {
+            "metadata": meta, "old_pool": _get_account_safe(accounts,17 if cp else 23),
+            "new_pool": _get_account_safe(accounts,5 if cp else 13), "user": _get_account_safe(accounts,0),
+            "liquidity_amount": 0, "liquidity_amount_known": False,
+            "base_mint": _get_account_safe(accounts,1), "quote_mint": _get_account_safe(accounts,2),
+            "platform_config": _get_account_safe(accounts,3) if cp else Z,
+            "destination_program": _get_account_safe(accounts,4 if cp else 12),
+        }})
 
     return None
 

sol_parser/json_util.py

@@ -11,7 +11,7 @@ from .grpc_types import EventType
 
 
 def dex_event_json_dumps(obj: Any, **kwargs: Any) -> str:
-    return json.dumps(obj, default=str, **kwargs)
+    return json.dumps(_precise_metadata(dex_event_to_jsonable(obj)), default=str, **kwargs)
 
 
 def dex_event_to_jsonable(ev: Any) -> Any:
@@ -39,3 +39,17 @@ def format_dex_event_json(ev: Any, *, indent: int = 2, ensure_ascii: bool = Fals
         indent=indent,
         ensure_ascii=ensure_ascii,
     )
+
+
+def _precise_metadata(obj):
+    """Match Node exact metadata JSON without changing floating latency metrics."""
+    if isinstance(obj,dict):
+        result={k:_precise_metadata(v) for k,v in obj.items()}
+        if "signature" in obj and all(k in obj for k in ("slot","tx_index","block_time_us","grpc_recv_us")):
+            from .grpc_types import EventMetadata
+            validated=EventMetadata(**{k:obj[k] for k in ("signature","slot","tx_index","block_time_us","grpc_recv_us")})
+            for k in ("slot","tx_index","block_time_us","grpc_recv_us"):result[k]=str(getattr(validated,k))
+        return result
+    if isinstance(obj,(tuple,list)):return [_precise_metadata(v) for v in obj]
+    if is_dataclass(obj):return _precise_metadata(asdict(obj))
+    return obj

sol_parser/liquidity_snapshot.py

@@ -0,0 +1,101 @@
+"""Native liquidity identity decoders and immutable raw subscription snapshots."""
+
+from __future__ import annotations
+from dataclasses import dataclass
+import base58
+from .accounts import AccountData
+from .grpc_types import EventMetadata
+from .transaction_route import PROGRAMS
+
+
+@dataclass
+class RawAccountSnapshotEvent:
+    metadata: EventMetadata
+    account: AccountData
+    write_version: int
+    is_startup: bool
+
+
+@dataclass
+class LiquidityAccountSnapshotEvent:
+    metadata: EventMetadata
+    pubkey: str
+    owner: str
+    kind: dict | str
+    data: bytes
+
+
+def parse_liquidity_account(account: AccountData, metadata: EventMetadata):
+    if account.lamports <= 0 or account.executable:
+        return None
+    d, owner = bytes(account.data), account.owner
+    disc = d[:8]
+
+    def key(o):
+        return base58.b58encode(d[o : o + 32]).decode()
+
+    def number(o, n, signed=False):
+        return int.from_bytes(d[o : o + n], "little", signed=signed)
+
+    kind = None
+    if owner == PROGRAMS["LaunchLab"]:
+        if disc == bytes([247, 237, 227, 245, 215, 195, 222, 70]) and len(d) >= 429:
+            kind = {
+                "LaunchLabPool": dict(
+                    base_mint=key(205),
+                    quote_mint=key(237),
+                    global_config=key(141),
+                    platform_config=key(173),
+                )
+            }
+        elif disc == bytes([149, 8, 156, 202, 160, 252, 176, 217]) and len(d) >= 35:
+            kind = "LaunchLabGlobalConfig"
+        elif disc == bytes([160, 78, 128, 0, 248, 83, 230, 160]) and len(d) >= 728:
+            kind = "LaunchLabPlatformConfig"
+    elif owner == PROGRAMS["MeteoraDlmm"]:
+        if disc == bytes([33, 11, 49, 98, 181, 101, 177, 13]) and len(d) >= 904:
+            kind = {
+                "DlmmPool": dict(
+                    token_x_mint=key(88),
+                    token_y_mint=key(120),
+                    active_id=number(76, 4, True),
+                    bin_step=number(80, 2),
+                )
+            }
+        elif disc == bytes([92, 142, 92, 220, 5, 148, 70, 181]) and len(d) >= 10136:
+            kind = {"DlmmBinArray": dict(pool=key(24), index=number(8, 8, True))}
+        elif disc == bytes([80, 111, 124, 113, 55, 237, 18, 5]) and len(d) >= 1576:
+            kind = {"DlmmBitmap": dict(pool=key(8))}
+    elif owner == PROGRAMS["OrcaWhirlpool"]:
+        if disc == bytes([17, 216, 246, 142, 225, 199, 218, 56]) and len(d) >= 148:
+            bitmap, offset = number(44, 16), 60
+            if bitmap >> 88:
+                return None
+            for i in range(88):
+                if (
+                    offset >= len(d)
+                    or d[offset] not in (0, 1)
+                    or d[offset] != (bitmap >> i) & 1
+                ):
+                    return None
+                offset += 1 + (112 if d[offset] else 0)
+                if offset > len(d):
+                    return None
+            kind = {
+                "OrcaDynamicTickArray": dict(
+                    pool=key(12),
+                    start_tick_index=number(8, 4, True),
+                    tick_bitmap=bitmap,
+                )
+            }
+        elif disc == bytes([139, 194, 131, 179, 140, 179, 229, 244]) and len(d) >= 254:
+            kind = {"OrcaAdaptiveOracle": dict(pool=key(8))}
+    elif (
+        owner == PROGRAMS["RaydiumClmm"]
+        and disc == bytes([60, 150, 36, 219, 97, 128, 139, 153])
+        and len(d) >= 1832
+    ):
+        kind = {"ClmmBitmap": dict(pool=key(8))}
+    if kind is None:
+        return None
+    return LiquidityAccountSnapshotEvent(metadata, account.pubkey, owner, kind, d)