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

sol_parser/grpc_client.py

@@ -11,7 +11,7 @@ import asyncio
 import time
 import uuid
 from typing import Dict, List, Optional, Callable, Any, AsyncGenerator, Tuple
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from urllib.parse import urlparse
 
 import base58
@@ -97,6 +97,42 @@ class Subscription:
     callbacks: SubscribeCallbacks
 
 
+@dataclass(frozen=True)
+class GrpcStreamStatus:
+    state: str = "connecting"
+    continuity_broken: bool = False
+    reconnects: int = 0
+    dropped: int = 0
+
+class DexEventQueue(asyncio.Queue):
+    """Queue-compatible DEX subscription with observable transport failures."""
+    def __init__(self, maxsize):
+        super().__init__(maxsize=maxsize)
+        self.errors = asyncio.Queue(maxsize=maxsize)
+        self.states = asyncio.Queue(maxsize=maxsize)
+        self._status = GrpcStreamStatus()
+        self.states.put_nowait(self._status)
+
+    def status(self):
+        return self._status
+
+    def transition(self, state, *, continuity_broken=None, reconnect=False, dropped=False):
+        previous = self._status
+        self._status = replace(
+            self._status, state=state,
+            continuity_broken=self._status.continuity_broken if continuity_broken is None else continuity_broken,
+            reconnects=self._status.reconnects + int(reconnect),
+            dropped=self._status.dropped + int(dropped),
+        )
+        if self._status == previous: return
+        if self.states.full(): self.states.get_nowait()
+        self.states.put_nowait(self._status)
+
+    def report_error(self, error):
+        if self.errors.full(): self.errors.get_nowait()
+        self.errors.put_nowait(error)
+
+
 class YellowstoneGrpc:
     """Yellowstone gRPC 客户端"""
 
@@ -109,6 +145,7 @@ class YellowstoneGrpc:
         self._channel: Optional[aio.Channel] = None
         self._client: Optional[Any] = None
         self._lock = asyncio.Lock()
+        self._dex_lifecycle = asyncio.Lock()
         self._dex_event_queue: Optional[asyncio.Queue] = None
         self._dex_event_filter: Optional[Any] = None
         self._dex_cancel_event: Optional[asyncio.Event] = None
@@ -140,7 +177,27 @@ class YellowstoneGrpc:
             inst.set_x_token(token)
         return inst
 
-    async def subscribe_dex_events(
+    async def stop(self):
+        async with self._dex_lifecycle:
+            await self._stop_dex_unlocked()
+
+    async def _stop_dex_unlocked(self):
+        if self._dex_cancel_event is not None: self._dex_cancel_event.set()
+        task = self._dex_task
+        if task is not None:
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+        self._dex_task = None
+        self._dex_cancel_event = None
+        self._dex_request_queue = None
+        self._dex_current_req = None
+
+    async def subscribe_dex_events(self, transaction_filters, account_filters, event_type_filter=None):
+        async with self._dex_lifecycle:
+            await self._stop_dex_unlocked()
+            return await self._subscribe_dex_events(transaction_filters, account_filters, event_type_filter)
+
+    async def _subscribe_dex_events(
         self,
         transaction_filters: List[TransactionFilter],
         account_filters: List[Any],
@@ -156,10 +213,10 @@ class YellowstoneGrpc:
         if not self._client:
             raise RuntimeError("Client not connected")
 
-        from .grpc.subscribe_builder import build_subscribe_request
+        from .grpc.subscribe_builder import build_subscribe_request_with_event_filter
 
-        req = build_subscribe_request(transaction_filters, account_filters)
-        queue: asyncio.Queue = asyncio.Queue(maxsize=max(1, int(self.config.buffer_size or 100_000)))
+        req = build_subscribe_request_with_event_filter(transaction_filters, account_filters, event_type_filter)
+        queue: asyncio.Queue = DexEventQueue(maxsize=max(1, int(self.config.buffer_size or 100_000)))
 
         if self._dex_cancel_event is not None:
             self._dex_cancel_event.set()
@@ -178,15 +235,19 @@ class YellowstoneGrpc:
         )
         return queue
 
-    async def update_subscription(
+    async def update_subscription(self, transaction_filters, account_filters):
+        async with self._dex_lifecycle:
+            return await self._update_subscription(transaction_filters, account_filters)
+
+    async def _update_subscription(
         self,
         transaction_filters: List[TransactionFilter],
         account_filters: List[Any],
     ) -> None:
         """动态更新 DEX 订阅。
 
-        Python gRPC runtime 不暴露当前双向流的发送端给外部 API；这里保留原队列，
-        取消旧后台流并用新过滤器立即重建，调用方无需替换消费队列。
+        通过原双向流发送最新过滤器，保留事件消费队列。
+        重连后使用最新请求，调用方无需替换消费队列。
         """
         if self._dex_event_queue is None:
             raise RuntimeError("No active DEX subscription")
@@ -195,9 +256,9 @@ class YellowstoneGrpc:
         if not self._client:
             raise RuntimeError("Client not connected")
 
-        from .grpc.subscribe_builder import build_subscribe_request
+        from .grpc.subscribe_builder import build_subscribe_request_with_event_filter
 
-        req = build_subscribe_request(transaction_filters, account_filters)
+        req = build_subscribe_request_with_event_filter(transaction_filters, account_filters, self._dex_event_filter)
         self._dex_current_req = req
         if self._dex_request_queue is None:
             raise RuntimeError("No active DEX subscription")
@@ -294,6 +355,11 @@ class YellowstoneGrpc:
             self._connected = True
 
     async def disconnect(self) -> None:
+        async with self._dex_lifecycle:
+            await self._stop_dex_unlocked()
+            await self._disconnect()
+
+    async def _disconnect(self) -> None:
         """断开连接"""
         if not self._connected:
             return
@@ -413,7 +479,8 @@ class YellowstoneGrpc:
                 blockhash=meta.blockhash,
                 parent_slot=meta.parent_slot,
                 parent_blockhash=meta.parent_blockhash,
-                executed_transaction_count=meta.executed_transaction_count
+                executed_transaction_count=meta.executed_transaction_count,
+                block_time=meta.block_time.timestamp if meta.HasField("block_time") else None
             )
 
         # 转换 Ping
@@ -432,7 +499,8 @@ class YellowstoneGrpc:
             queue.put_nowait(event)
         except asyncio.QueueFull:
             # 与 Rust 有界 ArrayQueue 的低延迟取舍一致：消费端落后时丢弃新事件，避免阻塞 gRPC 流。
-            pass
+            if isinstance(queue, DexEventQueue):
+                queue.transition(queue.status().state, continuity_broken=True, dropped=True)
 
     async def _enqueue_transaction_dex_events(
         self,
@@ -449,6 +517,7 @@ class YellowstoneGrpc:
         signature = base58.b58encode(bytes(info.signature)).decode("ascii") if info.signature else ""
 
         from .grpc_instruction_parser import (
+            subscribe_transaction_failed,
             detect_pumpfun_create_from_logs,
             enrich_dex_events_with_subscribe_tx_info,
             parse_instructions_enhanced_from_subscribe_tx_info,
@@ -458,6 +527,9 @@ class YellowstoneGrpc:
         from .pumpfun_fee_enrich import enrich_pumpfun_same_tx_post_merge
         from .grpc_types import EventType
 
+        if subscribe_transaction_failed(info):
+            return  # Suppress both instruction events and rolled-back log events.
+
         instruction_events = parse_instructions_enhanced_from_subscribe_tx_info(
             info,
             slot,
@@ -554,6 +626,15 @@ class YellowstoneGrpc:
             block_time_us=0 if block_time_us is None else block_time_us,
             grpc_recv_us=grpc_recv_us,
         )
+        # Raw snapshots are opt-in, including closure updates with empty bytes.
+        from .event_types import DexEvent
+        from .grpc_types import EventType
+        from .liquidity_snapshot import RawAccountSnapshotEvent
+        if EventType.ACCOUNT_RAW_SNAPSHOT in (getattr(event_type_filter, "include_only", None) or []):
+            self._queue_event_nowait(queue, DexEvent(
+                type=EventType.ACCOUNT_RAW_SNAPSHOT,
+                data=RawAccountSnapshotEvent(metadata, account, int(acc.write_version), bool(update.account.is_startup)),
+            ))
         ev = parse_account_unified(account, metadata, event_type_filter)
         if ev is not None:
             self._queue_event_nowait(queue, ev)
@@ -582,6 +663,7 @@ class YellowstoneGrpc:
 
         try:
             while not cancel_event.is_set():
+                if isinstance(queue, DexEventQueue): queue.transition("connecting")
                 outgoing: asyncio.Queue = asyncio.Queue()
 
                 async def request_iterator():
@@ -606,6 +688,7 @@ class YellowstoneGrpc:
                     async for pb_update in self._client.Subscribe(request_iterator(), metadata=metadata):
                         if cancel_event.is_set():
                             break
+                        if isinstance(queue, DexEventQueue): queue.transition("connected")
                         if pb_update.HasField("ping"):
                             await outgoing.put(
                                 geyser_pb2.SubscribeRequest(
@@ -627,6 +710,13 @@ class YellowstoneGrpc:
                                 block_time_us,
                                 order_dispatcher,
                             )
+                        if update.block_meta:
+                            from .block_meta import parse_block_meta_update
+                            from .grpc_types import EventType
+                            if event_type_filter is None or event_type_filter.should_include(EventType.BLOCK_META):
+                                # Match transaction/account overflow semantics. A full
+                                # consumer queue must not stall gRPC reads and pings.
+                                self._queue_event_nowait(queue, parse_block_meta_update(update.block_meta,grpc_recv_us,block_time_us))
                         if update.account:
                             await self._enqueue_account_dex_event(
                                 queue,
@@ -635,10 +725,15 @@ class YellowstoneGrpc:
                                 grpc_recv_us,
                                 block_time_us,
                             )
+                    if not cancel_event.is_set():
+                        raise ConnectionError("Yellowstone DEX stream ended")
                     delay = 1.0
                 except asyncio.CancelledError:
                     break
-                except Exception:
+                except Exception as error:
+                    if isinstance(queue, DexEventQueue):
+                        queue.report_error(error)
+                        queue.transition("reconnecting", continuity_broken=True, reconnect=True)
                     order_dispatcher.flush_all(lambda ev: self._queue_event_nowait(queue, ev))
                     if cancel_event.is_set():
                         break
@@ -646,10 +741,13 @@ class YellowstoneGrpc:
                     delay = min(delay * 2.0, 60.0)
                 finally:
                     pump_task.cancel()
+                    await asyncio.gather(pump_task, return_exceptions=True)
                     await outgoing.put(None)
         finally:
             if flush_task is not None:
                 flush_task.cancel()
+                await asyncio.gather(flush_task, return_exceptions=True)
+            if isinstance(queue, DexEventQueue): queue.transition("stopped", continuity_broken=True)
             order_dispatcher.flush_all(lambda ev: self._queue_event_nowait(queue, ev))
 
     async def subscribe_transactions(
@@ -766,7 +864,7 @@ class YellowstoneGrpc:
             req.commitment = commitment.value
 
         metadata = self._get_metadata()
-        resp = await self._client.get_latest_blockhash(req, metadata=metadata)
+        resp = await self._client.GetLatestBlockhash(req, metadata=metadata)
 
         return GetLatestBlockhashResponse(
             slot=resp.slot,
@@ -789,7 +887,7 @@ class YellowstoneGrpc:
             req.commitment = commitment.value
 
         metadata = self._get_metadata()
-        resp = await self._client.get_block_height(req, metadata=metadata)
+        resp = await self._client.GetBlockHeight(req, metadata=metadata)
 
         return GetBlockHeightResponse(block_height=resp.block_height)
 
@@ -808,7 +906,7 @@ class YellowstoneGrpc:
             req.commitment = commitment.value
 
         metadata = self._get_metadata()
-        resp = await self._client.get_slot(req, metadata=metadata)
+        resp = await self._client.GetSlot(req, metadata=metadata)
 
         return GetSlotResponse(slot=resp.slot)
 
@@ -822,7 +920,7 @@ class YellowstoneGrpc:
 
         req = geyser_pb2.GetVersionRequest()
         metadata = self._get_metadata()
-        resp = await self._client.get_version(req, metadata=metadata)
+        resp = await self._client.GetVersion(req, metadata=metadata)
 
         return GetVersionResponse(version=resp.version)
 
@@ -841,7 +939,7 @@ class YellowstoneGrpc:
             req.commitment = commitment.value
 
         metadata = self._get_metadata()
-        resp = await self._client.is_blockhash_valid(req, metadata=metadata)
+        resp = await self._client.IsBlockhashValid(req, metadata=metadata)
 
         return IsBlockhashValidResponse(slot=resp.slot, valid=resp.valid)
 
@@ -855,7 +953,7 @@ class YellowstoneGrpc:
 
         req = geyser_pb2.PingRequest(count=count)
         metadata = self._get_metadata()
-        resp = await self._client.ping(req, metadata=metadata)
+        resp = await self._client.Ping(req, metadata=metadata)
 
         return PongResponse(count=resp.count)
 
@@ -869,7 +967,7 @@ class YellowstoneGrpc:
 
         req = geyser_pb2.SubscribeReplayInfoRequest()
         metadata = self._get_metadata()
-        resp = await self._client.subscribe_replay_info(req, metadata=metadata)
+        resp = await self._client.SubscribeReplayInfo(req, metadata=metadata)
 
         result = SubscribeReplayInfoResponse()
         if resp.HasField('first_available'):

sol_parser/grpc_instruction_parser.py

@@ -229,6 +229,16 @@ def _meta_dict(
     return m
 
 
+def subscribe_transaction_failed(info: SubscribeUpdateTransactionInfo) -> bool:
+    """Read protobuf error presence, including errors with an empty encoded payload."""
+    if not info.meta_raw:
+        return False
+    from . import solana_storage_pb2 as sol_pb
+    meta = sol_pb.TransactionStatusMeta()
+    meta.ParseFromString(info.meta_raw)
+    return meta.HasField("err")
+
+
 def parse_instructions_enhanced_from_subscribe_tx_info(
     info: SubscribeUpdateTransactionInfo,
     slot: int,
@@ -268,7 +278,7 @@ def parse_instructions_enhanced_from_parsed(
     transaction_pb: Any = None,
 ) -> List[DexEvent]:
     """接受已 Parse 的 ``Message`` 与 ``TransactionStatusMeta``（来自 ``solana_storage_pb2``）。"""
-    if not should_parse_instructions(filter):
+    if meta.HasField("err") or not should_parse_instructions(filter):
         return []
 
     grpc_us = int(time.time() * 1_000_000) if grpc_recv_us is None else grpc_recv_us

sol_parser/grpc_types.py

@@ -37,6 +37,8 @@ class EventType(str, Enum):
     """事件类型"""
     # Block
     BLOCK_META = "BlockMeta"
+    ACCOUNT_RAW_SNAPSHOT = "AccountRawSnapshot"
+    ACCOUNT_LIQUIDITY_SNAPSHOT = "AccountLiquiditySnapshot"
     # RaydiumLaunchlab
     RAYDIUM_LAUNCHLAB_TRADE = "RaydiumLaunchlabTrade"
     RAYDIUM_LAUNCHLAB_POOL_CREATE = "RaydiumLaunchlabPoolCreate"
@@ -435,6 +437,18 @@ class EventMetadata:
     recent_blockhash: str = ""
     is_created_buy: bool = False
 
+    def __post_init__(self):
+        for name,signed in (("slot",False),("tx_index",False),("block_time_us",True),("grpc_recv_us",True)):
+            value=getattr(self,name)
+            if isinstance(value,str):
+                import re
+                if not re.fullmatch(r"-?\d+",value):raise ValueError(f"Invalid {name} integer")
+                value=int(value)
+            minimum=-(1<<63) if signed else 0
+            maximum=(1<<63)-1 if signed else (1<<64)-1
+            if type(value) is not int or not minimum<=value<=maximum:raise ValueError(f"{name} outside {'i64' if signed else 'u64'}")
+            setattr(self,name,value)
+
 
 @dataclass
 class ClientConfig:
@@ -747,6 +761,8 @@ class Protocol(str, Enum):
     PUMP_SWAP = "PumpSwap"
     PUMP_FEES = "PumpFees"
     RAYDIUM_LAUNCHLAB = "RaydiumLaunchlab"
+    LAUNCH_LAB = "LaunchLab"
+    STONK_FUN = "StonkFun"
     RAYDIUM_CPMM = "RaydiumCpmm"
     RAYDIUM_CLMM = "RaydiumClmm"
     RAYDIUM_AMM_V4 = "RaydiumAmmV4"
@@ -762,6 +778,8 @@ _PROTOCOL_PROGRAM_IDS: Dict[Protocol, List[str]] = {
     Protocol.PUMP_FUN: ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],
     Protocol.PUMP_SWAP: ["pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"],
     Protocol.PUMP_FEES: ["pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ"],
+    Protocol.LAUNCH_LAB: ["LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj"],
+    Protocol.STONK_FUN: ["LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj"],
     Protocol.RAYDIUM_LAUNCHLAB: ["LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj"],
     Protocol.RAYDIUM_CPMM: ["CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C"],
     Protocol.RAYDIUM_CLMM: ["CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK"],
@@ -981,6 +999,7 @@ class SubscribeUpdateBlockMeta:
     parent_slot: int = 0
     parent_blockhash: str = ""
     executed_transaction_count: int = 0
+    block_time: Optional[int] = None
 
 
 @dataclass

sol_parser/instructions.py

@@ -368,7 +368,7 @@ 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:
         disc = _disc8(instruction_data)
         return disc in _DLMM_INSTRUCTION_DISCS if disc is not None else False
@@ -851,9 +851,9 @@ def _parse_pumpfun_create_v2(data: bytes, accounts: List[str], meta: EventMetada
             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),
+            quote_mint=Z,
+            quote_vault=Z,
+            quote_token_program=Z,
             virtual_quote_reserves=0,
             observed_fee_recipient="",
         ),
@@ -1710,21 +1710,27 @@ 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:
-            return _get_account_safe(accounts, index - shift if index >= 5 else index)
+            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": 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,
+            "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),
@@ -1843,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,
@@ -1854,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:
@@ -1897,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,
@@ -1922,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)