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

sol_parser/__init__.py

@@ -466,3 +466,27 @@ __all__ = [
     "ShredStreamClient",
     "ShredStreamConfig",
 ]
+
+# Native route and subscription state APIs aligned with Rust 0.7.7.
+from .transaction_route import (analyze_rpc_transaction_routes, TransactionRoute, RouteSwapLeg,
+    RouteTokenTransfer, RouteUnknownInvocation, RouteNativeTokenAction, InstructionPosition,
+    stonkfun_mode_from_platform_config)
+from .stonkfun_registry import StonkFunPoolRegistry, StonkFunGraduatedPool
+from .liquidity_snapshot import RawAccountSnapshotEvent, LiquidityAccountSnapshotEvent, parse_liquidity_account
+from .wire_transaction import decode_wire_transaction
+
+from .simulation_route import analyze_simulation_routes
+
+__all__.append("analyze_simulation_routes")
+
+from .block_meta import BlockMetaEvent, parse_block_meta_update
+from .grpc.subscribe_builder import build_subscribe_request_with_event_filter
+
+from .event_types import (
+    LaunchLabPoolCreateEvent, StonkFunPoolCreateEvent,
+    LaunchLabTradeEvent, StonkFunTradeEvent,
+)
+__all__ += ["LaunchLabPoolCreateEvent", "StonkFunPoolCreateEvent", "LaunchLabTradeEvent", "StonkFunTradeEvent"]
+
+from .grpc_client import DexEventQueue, GrpcStreamStatus
+__all__ += ["DexEventQueue", "GrpcStreamStatus"]

sol_parser/account_dispatcher.py

@@ -82,11 +82,26 @@ def fill_accounts_with_owned_keys(
     w = [bytes(x) for x in meta_pb.loaded_writable_addresses]
     r = [bytes(x) for x in meta_pb.loaded_readonly_addresses]
 
-    def run(program_b58: str, filler) -> None:
+    def run(program_b58: str, filler, anchor=None, unambiguous=False) -> None:
         pid = base58.b58decode(program_b58)
         inv = invokes.get(pid)
         if not inv:
             return
+        if anchor is not None or unambiguous:
+            pool, index = anchor or (None,1)
+            has_anchor=pool and pool != "11111111111111111111111111111111"
+            if not has_anchor and not unambiguous:return
+            selected = None
+            for invocation in inv:
+                candidate = get_instruction_account_getter(meta_pb, transaction_pb, static_keys, w, r, invocation)
+                if candidate is None or (has_anchor and candidate(index) != pool):
+                    continue
+                if selected is not None and any(selected(i) != candidate(i) for i in range(18)):
+                    return  # Same pool, conflicting wallet/account context: do not guess.
+                selected = candidate
+            if selected is not None:
+                filler(selected)
+            return
         ix = find_instruction_invoke(inv, meta_pb, transaction_pb)
         if ix is None:
             return
@@ -146,7 +161,7 @@ def fill_accounts_with_owned_keys(
     elif et == EventType.RAYDIUM_CPMM_INITIALIZE:
         run(RAYDIUM_CPMM_PROGRAM_ID, lambda g: raydium.fill_cpmm_initialize_accounts(data, g))
     elif et == EventType.RAYDIUM_AMM_V4_SWAP:
-        run(RAYDIUM_AMM_V4_PROGRAM_ID, lambda g: raydium.fill_amm_v4_swap_accounts(data, g))
+        run(RAYDIUM_AMM_V4_PROGRAM_ID, lambda g: raydium.fill_amm_v4_swap_accounts(data, g), (data.amm,1), True)
     elif et == EventType.RAYDIUM_AMM_V4_DEPOSIT:
         run(RAYDIUM_AMM_V4_PROGRAM_ID, lambda g: raydium.fill_amm_v4_deposit_accounts(data, g))
     elif et == EventType.RAYDIUM_AMM_V4_WITHDRAW:
@@ -182,9 +197,9 @@ def fill_accounts_with_owned_keys(
     elif et == EventType.METEORA_DLMM_REMOVE_LIQUIDITY:
         run(METEORA_DLMM_PROGRAM_ID, lambda g: meteora.fill_dlmm_remove_liquidity_accounts(data, g))
     elif et == EventType.RAYDIUM_LAUNCHLAB_TRADE:
-        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_trade_accounts(data, g))
+        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_trade_accounts(data, g), (data.pool_state,4))
     elif et == EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE:
-        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_pool_create_accounts(data, g))
+        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_pool_create_accounts(data, g), (data.pool_state,5))
 
 
 def fill_data(

sol_parser/account_fillers/raydium.py

@@ -100,8 +100,12 @@ def fill_cpmm_initialize_accounts(e: RaydiumCpmmInitializeEvent, get: AccountGet
 
 
 def fill_amm_v4_swap_accounts(e: RaydiumAmmV4SwapEvent, get: AccountGetter) -> None:
-    if _empty(e.amm):
-        e.amm = get(1)
+    if _empty(e.amm):e.amm=get(1)
+    modern=_empty(get(8)) and not _empty(get(7))
+    if modern:
+        for field,index in [('token_program',0),('amm_authority',2),('pool_coin_token_account',3),('pool_pc_token_account',4),('user_source_token_account',5),('user_destination_token_account',6),('user_source_owner',7)]:
+            if _empty(getattr(e,field)):setattr(e,field,get(index))
+    elif _empty(e.user_source_owner):e.user_source_owner=get(16) if _empty(get(17)) else get(17)
 
 
 def fill_amm_v4_deposit_accounts(e: RaydiumAmmV4DepositEvent, get: AccountGetter) -> None:

sol_parser/account_fillers/raydium_launchlab.py

@@ -43,6 +43,10 @@ def fill_trade_accounts(e: RaydiumLaunchlabTradeEvent, get: AccountGetter) -> No
     if _empty(e.quote_token_program):
         e.quote_token_program = get(12)
 
+    for name, index in [("system_program", 15), ("platform_associated_account", 16), ("creator_associated_account", 17)]:
+        if _empty(getattr(e,name,"")):
+            setattr(e,name,get(index))
+
 
 def fill_pool_create_accounts(e: RaydiumLaunchlabPoolCreateEvent, get: AccountGetter) -> None:
     if _empty(e.pool_state):

sol_parser/accounts/__init__.py

@@ -206,6 +206,11 @@ def parse_account_unified(
     event_type_filter: Optional[EventTypeFilter] = None,
 ) -> Optional[DexEvent]:
     """对齐 Rust ``parse_account_unified``（含 ``Option<EventTypeFilter>`` 语义）。"""
+    from ..liquidity_snapshot import parse_liquidity_account
+    if event_type_filter is None or event_type_filter.should_include(EventType.ACCOUNT_LIQUIDITY_SNAPSHOT):
+        snapshot = parse_liquidity_account(account, metadata)
+        if snapshot is not None:
+            return DexEvent(type=EventType.ACCOUNT_LIQUIDITY_SNAPSHOT, data=snapshot)
     data = account.data
     if not data:
         return None

sol_parser/block_meta.py

@@ -0,0 +1,29 @@
+"""Local BlockMeta adapter, matching Rust's saturated timestamp conversion."""
+
+from dataclasses import dataclass
+from .grpc_types import EventType, EventMetadata
+from .event_types import DexEvent
+
+
+@dataclass
+class BlockMetaEvent:
+    metadata: EventMetadata
+
+
+def parse_block_meta_update(meta, grpc_recv_us, fallback_block_us=None):
+    block_us = fallback_block_us or 0
+    if meta.block_time is not None:
+        block_us = max(-(1 << 63), min((1 << 63) - 1, meta.block_time * 1_000_000))
+    return DexEvent(
+        EventType.BLOCK_META,
+        BlockMetaEvent(
+            EventMetadata(
+                signature="1" * 64,
+                slot=meta.slot,
+                tx_index=0,
+                block_time_us=block_us,
+                grpc_recv_us=grpc_recv_us,
+                recent_blockhash=meta.blockhash,
+            )
+        ),
+    )

sol_parser/dex_parsers.py

@@ -2727,7 +2727,7 @@ def parse_raydium_launchlab_from_discriminator(disc: int, data: bytes, meta: dic
 
 
 def _parse_raydium_launchlab_trade(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 139:
+    if len(data) != 139 or data[136] > 1 or data[137] > 2 or data[138] > 1:
         return None
     pool = _pub(data, 0)
     ai = _u64le(data, 88)
@@ -2746,6 +2746,19 @@ def _parse_raydium_launchlab_trade(data: bytes, meta: dict) -> Optional[DexEvent
             is_buy=is_buy,
             trade_direction=d,
             exact_in=ex_in,
+            pool_status=("Fund","Migrate","Trade")[data[137]],
+            total_base_sell=_u64le(data,32),
+            virtual_base=_u64le(data,40),
+            virtual_quote=_u64le(data,48),
+            real_base_before=_u64le(data,56),
+            real_quote_before=_u64le(data,64),
+            real_base_after=_u64le(data,72),
+            real_quote_after=_u64le(data,80),
+            protocol_fee=_u64le(data,104),
+            platform_fee=_u64le(data,112),
+            creator_fee=_u64le(data,120),
+            share_fee=_u64le(data,128),
+
         ),
     )
 

sol_parser/entries_decode.py

@@ -46,87 +46,13 @@ class _ParsedTx:
 
 
 def parse_transaction_wire(buf: bytes, pos: int) -> Optional[_ParsedTx]:
-    start = pos
-    if pos >= len(buf):
-        return None
-    sig_count_enc = decode_compact_u16(buf, pos)
-    if not sig_count_enc:
-        return None
-    p = pos + sig_count_enc[1]
-    sig_count = sig_count_enc[0]
-    sigs_end = p + sig_count * 64
-    if sigs_end > len(buf):
-        return None
-    sigs: List[bytes] = []
-    for _ in range(sig_count):
-        sigs.append(buf[p : p + 64])
-        p += 64
-    if p >= len(buf):
-        return None
-    msg_first = buf[p]
-    is_v0 = msg_first >= 0x80
-    if is_v0:
-        p += 1
-    p += 3
-    if p > len(buf):
-        return None
-    acct_enc = decode_compact_u16(buf, p)
-    if not acct_enc:
-        return None
-    p += acct_enc[1]
-    p += acct_enc[0] * 32
-    if p > len(buf):
-        return None
-    ix_count_enc = decode_compact_u16(buf, p)
-    if not ix_count_enc:
+    from .wire_transaction import decode_wire_transaction
+    import base58
+    try:
+        transaction, length = decode_wire_transaction(buf, pos, require_complete=False)
+        return _ParsedTx(length, [base58.b58decode(s) for s in transaction['signatures']])
+    except (ValueError, IndexError):
         return None
-    p += ix_count_enc[1]
-    ix_count = ix_count_enc[0]
-    for _ in range(ix_count):
-        p += 1
-        if p > len(buf):
-            return None
-        acct_len_enc = decode_compact_u16(buf, p)
-        if not acct_len_enc:
-            return None
-        p += acct_len_enc[1]
-        p += acct_len_enc[0]
-        if p > len(buf):
-            return None
-        data_len_enc = decode_compact_u16(buf, p)
-        if not data_len_enc:
-            return None
-        p += data_len_enc[1]
-        p += data_len_enc[0]
-        if p > len(buf):
-            return None
-    if is_v0:
-        if p >= len(buf):
-            return None
-        atl_count_enc = decode_compact_u16(buf, p)
-        if not atl_count_enc:
-            return None
-        p += atl_count_enc[1]
-        atl_count = atl_count_enc[0]
-        for _ in range(atl_count):
-            p += 32
-            if p > len(buf):
-                return None
-            w_len_enc = decode_compact_u16(buf, p)
-            if not w_len_enc:
-                return None
-            p += w_len_enc[1]
-            p += w_len_enc[0]
-            if p > len(buf):
-                return None
-            r_len_enc = decode_compact_u16(buf, p)
-            if not r_len_enc:
-                return None
-            p += r_len_enc[1]
-            p += r_len_enc[0]
-            if p > len(buf):
-                return None
-    return _ParsedTx(tx_len=p - start, signatures=sigs)
 
 
 class _BatchDecoder:

sol_parser/event_types.py

@@ -1410,6 +1410,28 @@ class RaydiumLaunchlabTradeEvent(DexEventBase):
     base_token_program: str = ""
     quote_token_program: str = ""
 
+    total_base_sell: int = 0
+    virtual_base: int = 0
+    virtual_quote: int = 0
+    real_base_before: int = 0
+    real_quote_before: int = 0
+    real_base_after: int = 0
+    real_quote_after: int = 0
+    protocol_fee: int = 0
+    platform_fee: int = 0
+    creator_fee: int = 0
+    share_fee: int = 0
+    pool_status: str = "Fund"
+    system_program: str = ""
+    platform_associated_account: str = ""
+    creator_associated_account: str = ""
+
+    def stonkfun_mode(self):
+        from .transaction_route import stonkfun_mode_from_platform_config
+        return stonkfun_mode_from_platform_config(self.platform_config)
+
+    def is_stonkfun(self):
+        return self.stonkfun_mode() is not None
 
 @dataclass
 class RaydiumLaunchlabPoolCreateEvent(DexEventBase):
@@ -1428,6 +1450,14 @@ class RaydiumLaunchlabPoolCreateEvent(DexEventBase):
     quote_token_program: str = ""
 
 
+
+    def stonkfun_mode(self):
+        from .transaction_route import stonkfun_mode_from_platform_config
+        return stonkfun_mode_from_platform_config(self.platform_config)
+
+    def is_stonkfun(self):
+        return self.stonkfun_mode() is not None
+
 @dataclass
 class RaydiumLaunchlabMigrateAmmEvent(DexEventBase):
     """RaydiumLaunchlab 迁移 AMM 事件"""
@@ -1436,6 +1466,18 @@ class RaydiumLaunchlabMigrateAmmEvent(DexEventBase):
     user: str = ""
     liquidity_amount: int = 0
 
+    liquidity_amount_known: bool = False
+    base_mint: str = ""
+    quote_mint: str = ""
+    platform_config: str = ""
+    destination_program: str = ""
+
+    def stonkfun_mode(self):
+        from .transaction_route import stonkfun_mode_from_platform_config
+        return stonkfun_mode_from_platform_config(self.platform_config)
+
+    def is_stonkfun(self):
+        return self.stonkfun_mode() is not None
 
 # ============================================================
 # 类型联合
@@ -2379,3 +2421,9 @@ def legacy_dict_to_dex_event(d: dict) -> Optional[DexEvent]:
     except ValueError:
         return None
     return DexEvent(type=et, data=typed)
+
+# Same classes: preserve isinstance, serialization and platform attribution.
+LaunchLabPoolCreateEvent = RaydiumLaunchlabPoolCreateEvent
+StonkFunPoolCreateEvent = RaydiumLaunchlabPoolCreateEvent
+LaunchLabTradeEvent = RaydiumLaunchlabTradeEvent
+StonkFunTradeEvent = RaydiumLaunchlabTradeEvent

sol_parser/grpc/subscribe_builder.py

@@ -131,3 +131,11 @@ __all__ = [
     "build_subscribe_request_with_commitment",
     "build_subscribe_transaction_filters_named",
 ]
+
+
+def build_subscribe_request_with_event_filter(tx_filters, acc_filters, event_type_filter=None):
+    from ..grpc_types import EventType
+    request=build_subscribe_request(tx_filters,acc_filters)
+    if event_type_filter is not None and event_type_filter.should_include(EventType.BLOCK_META):
+        request.blocks_meta["block_meta"].CopyFrom(geyser_pb2.SubscribeRequestFilterBlocksMeta())
+    return request

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'):