sol-parser-sdk-python 0.5.7__py3-none-any.whl → 0.5.9__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,
@@ -554,6 +622,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 +659,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 +684,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 +706,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 +721,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 +737,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 +860,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 +883,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 +902,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 +916,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 +935,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 +949,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 +963,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

@@ -7,17 +7,18 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import base58
 
-from .account_dispatcher import fill_accounts_with_owned_keys, fill_data
+from .account_dispatcher import fill_accounts_with_owned_keys, fill_data, fill_token_balances
 from .event_types import DexEvent
 from .grpc_types import (
     EventMetadata,
+    EventType,
     EventTypeFilter,
     SubscribeUpdateTransactionInfo,
     event_type_filter_allows_instruction_parsing,
 )
 from .inner_instruction_parser import parse_inner_instruction
 from .instructions import parse_inner_compiled_instruction_if_supported, parse_instruction_unified
-from .merger import merge_dex_events
+from .merger import try_merge_dex_events
 from .pumpfun_fee_enrich import enrich_pumpfun_same_tx_post_merge
 
 
@@ -73,6 +74,7 @@ def apply_account_fill_to_events(
     for ev in events:
         fill_accounts_with_owned_keys(ev, meta_pb, tx_pb, invokes_raw)
         fill_data(ev, meta_pb, tx_pb, invokes_str)
+        fill_token_balances(ev, meta_pb, tx_pb)
     recent_bh = ""
     if msg.recent_blockhash:
         recent_bh = base58.b58encode(bytes(msg.recent_blockhash)).decode("ascii")
@@ -124,36 +126,86 @@ def should_parse_instructions(filter: Optional[EventTypeFilter]) -> bool:
     return event_type_filter_allows_instruction_parsing(list(inc))
 
 
-def merge_instruction_events(
-    events: List[Tuple[int, Optional[int], DexEvent]],
-) -> List[DexEvent]:
+_DLMM_EVENT_TYPES = {
+    EventType.METEORA_DLMM_SWAP,
+    EventType.METEORA_DLMM_ADD_LIQUIDITY,
+    EventType.METEORA_DLMM_REMOVE_LIQUIDITY,
+    EventType.METEORA_DLMM_INITIALIZE_POOL,
+    EventType.METEORA_DLMM_INITIALIZE_BIN_ARRAY,
+    EventType.METEORA_DLMM_CREATE_POSITION,
+    EventType.METEORA_DLMM_CLOSE_POSITION,
+    EventType.METEORA_DLMM_CLAIM_FEE,
+}
+
+
+def _is_dlmm_event_cpi(data: bytes) -> bool:
+    return len(data) >= 16 and (
+        data[:8] == bytes((228, 69, 165, 46, 81, 203, 154, 29))
+        or data[8:16] == bytes((155, 167, 108, 32, 122, 76, 173, 64))
+    )
+
+
+def merge_instruction_events(events: List[Tuple[Any, ...]]) -> List[DexEvent]:
     """对齐 Rust ``merge_instruction_events``。"""
     if not events:
         return []
-    events = sorted(events, key=lambda x: (x[0], 0 if x[1] is None else 1 + x[1]))
+    normalized = events if all(len(item) == 5 for item in events) else [
+        (item[0], item[1], None, False, item[2]) if len(item) == 3 else item
+        for item in events
+    ]
+    normalized.sort(key=lambda x: (x[0], 0 if x[1] is None else 1 + x[1]))
     result: List[DexEvent] = []
-    pending_outer: Optional[Tuple[int, DexEvent]] = None
+    outer_target: Optional[Tuple[int, int]] = None
+    dlmm_targets: List[Tuple[int, Optional[int], int]] = []
 
-    for outer_idx, inner_idx, event in events:
+    for outer_idx, inner_idx, stack_height, is_dlmm_event_cpi, event in normalized:
         if inner_idx is None:
-            if pending_outer is not None:
-                result.append(pending_outer[1])
-            pending_outer = (outer_idx, event)
-        else:
-            if pending_outer is not None:
-                po_idx, mut_outer = pending_outer
-                pending_outer = None
-                if po_idx == outer_idx:
-                    merge_dex_events(mut_outer, event)
-                    pending_outer = (outer_idx, mut_outer)
-                else:
-                    result.append(mut_outer)
-                    result.append(event)
+            result.append(event)
+            target_idx = len(result) - 1
+            outer_target = (outer_idx, target_idx)
+            dlmm_targets = (
+                [(outer_idx, stack_height, target_idx)] if event.type in _DLMM_EVENT_TYPES else []
+            )
+            continue
+
+        if is_dlmm_event_cpi:
+            for candidate_idx in range(len(dlmm_targets) - 1, -1, -1):
+                target_outer, target_height, target_idx = dlmm_targets[candidate_idx]
+                direct_child = (
+                    target_height is None
+                    or stack_height is None
+                    or stack_height == target_height + 1
+                )
+                if target_outer == outer_idx and direct_child:
+                    del dlmm_targets[candidate_idx + 1:]
+                    if try_merge_dex_events(result[target_idx], event):
+                        break
             else:
                 result.append(event)
+            continue
+
+        target_idx: Optional[int] = None
+        if outer_target is not None and outer_target[0] == outer_idx:
+            if try_merge_dex_events(result[outer_target[1]], event):
+                target_idx = outer_target[1]
+        if target_idx is None:
+            result.append(event)
+            target_idx = len(result) - 1
+
+        if event.type in _DLMM_EVENT_TYPES:
+            if stack_height is None:
+                dlmm_targets.clear()
+            else:
+                while dlmm_targets and (
+                    dlmm_targets[-1][0] != outer_idx
+                    or (
+                        dlmm_targets[-1][1] is not None
+                        and dlmm_targets[-1][1] >= stack_height
+                    )
+                ):
+                    dlmm_targets.pop()
+            dlmm_targets.append((outer_idx, stack_height, target_idx))
 
-    if pending_outer is not None:
-        result.append(pending_outer[1])
     return result
 
 
@@ -260,7 +312,7 @@ def parse_instructions_enhanced_from_parsed(
 
     is_created_buy = detect_pumpfun_create_from_logs(list(meta.log_messages))
 
-    result: List[Tuple[int, Optional[int], DexEvent]] = []
+    result: List[Tuple[Any, ...]] = []
 
     for i, ix in enumerate(msg.instructions):
         pid_idx = ix.program_id_index
@@ -272,7 +324,7 @@ def parse_instructions_enhanced_from_parsed(
             data, accounts, signature, slot, tx_index, block_time_us, grpc_us, filter, pid
         )
         if ev:
-            result.append((i, None, ev))
+            result.append((i, None, 1, False, ev))
 
     for inner in meta.inner_instructions:
         outer_idx = inner.index
@@ -298,7 +350,13 @@ def parse_instructions_enhanced_from_parsed(
                 is_created_buy,
             )
             if ev:
-                result.append((int(outer_idx), j, ev))
+                result.append((
+                    int(outer_idx),
+                    j,
+                    int(inner_ix.stack_height) if inner_ix.HasField("stack_height") else None,
+                    pid == METEORA_DLMM_PROGRAM_ID and _is_dlmm_event_cpi(data),
+                    ev,
+                ))
 
     merged = merge_instruction_events(result)
     enrich_pumpfun_same_tx_post_merge(merged)
@@ -310,6 +368,7 @@ def parse_instructions_enhanced_from_parsed(
     for ev in merged:
         fill_accounts_with_owned_keys(ev, meta, transaction_pb, invokes_raw)
         fill_data(ev, meta, transaction_pb, invokes_str)
+        fill_token_balances(ev, meta, transaction_pb)
 
     for ev in merged:
         if isinstance(ev.data, object) and hasattr(ev.data, "metadata"):

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"
@@ -115,6 +117,10 @@ class EventType(str, Enum):
     METEORA_DAMM_V2_INITIALIZE_POOL = "MeteoraDammV2InitializePool"
     METEORA_DAMM_V2_CREATE_POSITION = "MeteoraDammV2CreatePosition"
     METEORA_DAMM_V2_CLOSE_POSITION = "MeteoraDammV2ClosePosition"
+    METEORA_DAMM_V2_UPDATE_DELEGATE_PERMISSION = "MeteoraDammV2UpdateDelegatePermission"
+    METEORA_DAMM_V2_WITHDRAW_DEAD_LIQUIDITY_REWARD = "MeteoraDammV2WithdrawDeadLiquidityReward"
+    METEORA_DAMM_V2_CREATE_CONFIG = "MeteoraDammV2CreateConfig"
+    METEORA_DAMM_V2_CREATE_DYNAMIC_CONFIG = "MeteoraDammV2CreateDynamicConfig"
     # Meteora DBC
     METEORA_DBC_SWAP = "MeteoraDbcSwap"
     METEORA_DBC_INITIALIZE_POOL = "MeteoraDbcInitializePool"
@@ -206,6 +212,10 @@ METEORA_DAMM_V2_FILTER_TYPES = (
     EventType.METEORA_DAMM_V2_CLOSE_POSITION,
     EventType.METEORA_DAMM_V2_INITIALIZE_POOL,
     EventType.METEORA_DAMM_V2_REMOVE_LIQUIDITY,
+    EventType.METEORA_DAMM_V2_UPDATE_DELEGATE_PERMISSION,
+    EventType.METEORA_DAMM_V2_WITHDRAW_DEAD_LIQUIDITY_REWARD,
+    EventType.METEORA_DAMM_V2_CREATE_CONFIG,
+    EventType.METEORA_DAMM_V2_CREATE_DYNAMIC_CONFIG,
 )
 METEORA_DBC_FILTER_TYPES = (
     EventType.METEORA_DBC_SWAP,
@@ -372,6 +382,10 @@ def all_event_types() -> List[EventType]:
         EventType.METEORA_DAMM_V2_INITIALIZE_POOL,
         EventType.METEORA_DAMM_V2_CREATE_POSITION,
         EventType.METEORA_DAMM_V2_CLOSE_POSITION,
+        EventType.METEORA_DAMM_V2_UPDATE_DELEGATE_PERMISSION,
+        EventType.METEORA_DAMM_V2_WITHDRAW_DEAD_LIQUIDITY_REWARD,
+        EventType.METEORA_DAMM_V2_CREATE_CONFIG,
+        EventType.METEORA_DAMM_V2_CREATE_DYNAMIC_CONFIG,
         # Meteora DBC
         EventType.METEORA_DBC_SWAP,
         EventType.METEORA_DBC_INITIALIZE_POOL,
@@ -423,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:
@@ -735,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"
@@ -750,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"],
@@ -969,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/inner_instruction_parser.py

@@ -43,7 +43,7 @@ from .dex_parsers import (
     parse_cpmm_swap_in_from_data,
     parse_cpmm_swap_out_from_data,
     parse_cpmm_withdraw_from_data,
-    parse_dlmm_from_program_data,
+    parse_dlmm_event_from_data,
     parse_meteora_damm_from_buf,
     parse_meteora_add_from_data,
     parse_meteora_bootstrap_from_data,
@@ -184,11 +184,6 @@ def _damm_buf_from_inner(disc16: bytes, inner: bytes) -> bytes:
 _RAYDIUM_LAUNCHLAB_TRADE = bytes([189, 219, 127, 211, 78, 230, 97, 238, 155, 167, 108, 32, 122, 76, 173, 64])
 _RAYDIUM_LAUNCHLAB_POOL_CREATE = bytes([151, 215, 226, 9, 118, 161, 115, 174, 155, 167, 108, 32, 122, 76, 173, 64])
 
-# DLMM（8 字节 event disc + payload）
-def _dlmm_buf_from_inner(disc16: bytes, inner: bytes) -> bytes:
-    return disc16[:8] + inner
-
-
 def _meteora_pools_swap_inner(data: bytes, meta_d: dict) -> Optional[DexEvent]:
     if len(data) < 16:
         return None
@@ -440,6 +435,9 @@ def parse_inner_instruction(
     if program_id_b58 == METEORA_DLMM_PROGRAM_ID:
         if filter is not None and not event_type_filter_includes_meteora_dlmm(filter):
             return None
-        return emit(parse_dlmm_from_program_data(_dlmm_buf_from_inner(disc16, inner), meta_d))
+        event_disc = _event_cpi_disc8(disc16)
+        if event_disc is None:
+            return None
+        return emit(parse_dlmm_event_from_data(event_disc, inner, meta_d))
 
     return None