yellowstone-fumarole-client 0.1.0rc2__py3-none-any.whl → 0.2.1__py3-none-any.whl

yellowstone_fumarole_client/__init__.py

@@ -3,18 +3,21 @@ import logging
 from yellowstone_fumarole_client.grpc_connectivity import (
     FumaroleGrpcConnector,
 )
-from typing import Dict, Optional
+from typing import AsyncGenerator, Optional
 from dataclasses import dataclass
-from . import config
+from yellowstone_fumarole_client.config import FumaroleConfig
 from yellowstone_fumarole_client.runtime.aio import (
     AsyncioFumeDragonsmouthRuntime,
-    FumaroleSM,
     DEFAULT_GC_INTERVAL,
     DEFAULT_SLOT_MEMORY_RETENTION,
     GrpcSlotDownloader,
 )
+from yellowstone_fumarole_client.runtime.state_machine import (
+    FumaroleSM,
+    FumeOffset,
+)
 from yellowstone_fumarole_proto.geyser_pb2 import SubscribeRequest, SubscribeUpdate
-from yellowstone_fumarole_proto.fumarole_v2_pb2 import (
+from yellowstone_fumarole_proto.fumarole_pb2 import (
     ControlResponse,
     VersionRequest,
     VersionResponse,
@@ -29,9 +32,11 @@ from yellowstone_fumarole_proto.fumarole_v2_pb2 import (
     CreateConsumerGroupRequest,
     CreateConsumerGroupResponse,
 )
-from yellowstone_fumarole_proto.fumarole_v2_pb2_grpc import FumaroleStub
+from yellowstone_fumarole_proto.fumarole_pb2_grpc import FumaroleStub
 import grpc
 
+from yellowstone_fumarole_client import config
+
 __all__ = [
     "FumaroleClient",
     "FumaroleConfig",
@@ -44,7 +49,7 @@ __all__ = [
 ]
 
 # Constants
-DEFAULT_DRAGONSMOUTH_CAPACITY = 10000
+DEFAULT_DRAGONSMOUTH_CAPACITY = 100000
 DEFAULT_COMMIT_INTERVAL = 5.0  # seconds
 DEFAULT_MAX_SLOT_DOWNLOAD_ATTEMPT = 3
 DEFAULT_CONCURRENT_DOWNLOAD_LIMIT_PER_TCP = 10
@@ -72,10 +77,23 @@ class FumaroleSubscribeConfig:
     # The interval at which to perform garbage collection on the slot memory.
     gc_interval: int = DEFAULT_GC_INTERVAL
 
-    # The retention period for slot memory in seconds.
+    # How many processed slot numbers to retain in memory to avoid duplication.
     slot_memory_retention: int = DEFAULT_SLOT_MEMORY_RETENTION
 
 
+@dataclass
+class FumaroleSubscribeStats:
+    """Commit/slot statistics for the Fumarole subscribe session."""
+
+    # Last committed log offset in Fumarole -- this is a low-level, implementation detail.
+    # NOTE: this should not be part as business logic, can change any time.
+    log_committed_offset: FumeOffset
+    # NOTE:: this is a low-level information, can change any time.
+    log_committable_offset: FumeOffset
+    # Max slot seen by the in the current session - does not mean it has been processed.
+    max_slot_seen: int
+
+
 # DragonsmouthAdapterSession
 @dataclass
 class DragonsmouthAdapterSession:
@@ -85,10 +103,31 @@ class DragonsmouthAdapterSession:
     sink: asyncio.Queue
 
     # The queue for receiving SubscribeUpdate from the dragonsmouth stream.
-    source: asyncio.Queue
+    source: AsyncGenerator[SubscribeUpdate, None]
 
     # The task handle for the fumarole runtime.
-    fumarole_handle: asyncio.Task
+    _fumarole_handle: asyncio.Task
+
+    _sm: FumaroleSM
+
+    async def __aenter__(self):
+        """Enter the session context."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        self.sink.shutdown()
+        self._fumarole_handle.cancel()
+
+    def stats(self) -> FumaroleSubscribeStats:
+        """Get low-level statistics of the Fumarole state-machine."""
+        commitable = self._sm.committable_offset
+        committed = self._sm.last_committed_offset
+        max_slot = self._sm.max_slot_detected
+        return FumaroleSubscribeStats(
+            log_committed_offset=committed,
+            log_committable_offset=commitable,
+            max_slot_seen=max_slot,
+        )
 
 
 # FumaroleClient
@@ -117,7 +156,7 @@ class FumaroleClient:
     async def version(self) -> VersionResponse:
         """Get the version of the Fumarole server."""
         request = VersionRequest()
-        response = await self.stub.version(request)
+        response = await self.stub.Version(request)
         return response
 
     async def dragonsmouth_subscribe(
@@ -162,12 +201,12 @@ class FumaroleClient:
                 try:
                     update = await fume_control_plane_q.get()
                     yield update
-                except asyncio.QueueShutDown:
+                except (asyncio.CancelledError, asyncio.QueueShutDown):
                     break
 
-        fume_control_plane_stream_rx: grpc.aio.StreamStreamMultiCallable = (
-            self.stub.Subscribe(control_plane_sink())
-        )
+        fume_control_plane_stream_rx: grpc.aio.StreamStreamCall = self.stub.Subscribe(
+            control_plane_sink()
+        )  # it's actually InterceptedStreamStreamCall, but grpc lib doesn't export it
 
         control_response: ControlResponse = await fume_control_plane_stream_rx.read()
         init = control_response.init
@@ -187,8 +226,12 @@ class FumaroleClient:
                         await fume_control_plane_rx_q.put(update)
                 except asyncio.QueueShutDown:
                     break
+                except asyncio.CancelledError:
+                    break
+                finally:
+                    fume_control_plane_rx_q.shutdown()
 
-        _cp_src_task = asyncio.create_task(control_plane_source())
+        control_plane_src_task = asyncio.create_task(control_plane_source())
 
         FumaroleClient.logger.debug(f"Control response: {control_response}")
 
@@ -219,12 +262,36 @@ class FumaroleClient:
             max_concurrent_download=config.concurrent_download_limit,
         )
 
-        fumarole_handle = asyncio.create_task(rt.run())
-        FumaroleClient.logger.debug(f"Fumarole handle created: {fumarole_handle}")
+        async def rt_run(rt):
+            async with rt as rt:
+                await rt.run()
+
+        rt_task = asyncio.create_task(rt_run(rt))
+
+        async def fumarole_overseer():
+            done, pending = await asyncio.wait(
+                [rt_task, control_plane_src_task], return_when=asyncio.FIRST_COMPLETED
+            )
+            for t in pending:
+                t.cancel()
+
+        fumarole_handle = asyncio.create_task(fumarole_overseer())
+
+        async def source_gen() -> AsyncGenerator[SubscribeUpdate, None]:
+            try:
+                while True:
+                    update = await dragonsmouth_outlet.get()
+                    yield update
+            except (asyncio.CancelledError, asyncio.QueueShutDown):
+                pass
+            finally:
+                dragonsmouth_outlet.shutdown()
+
         return DragonsmouthAdapterSession(
             sink=subscribe_request_queue,
-            source=dragonsmouth_outlet,
-            fumarole_handle=fumarole_handle,
+            source=source_gen(),
+            _fumarole_handle=fumarole_handle,
+            _sm=sm,
         )
 
     async def list_consumer_groups(

yellowstone_fumarole_client/config.py

@@ -1,14 +1,19 @@
 from dataclasses import dataclass
-from typing import Dict, Optional
+from typing import Dict, Literal, Optional
 import yaml
 
 
+SUPPORTED_COMPRESSION = ["gzip"]
+SupportedCompression = Literal["gzip"]
+
+
 @dataclass
 class FumaroleConfig:
     endpoint: str
     x_token: Optional[str] = None
     max_decoding_message_size_bytes: int = 512_000_000
     x_metadata: Dict[str, str] = None
+    response_compression: Optional[SupportedCompression] = None
 
     def __post_init__(self):
         self.x_metadata = self.x_metadata or {}
@@ -16,6 +21,14 @@ class FumaroleConfig:
     @classmethod
     def from_yaml(cls, fileobj) -> "FumaroleConfig":
         data = yaml.safe_load(fileobj)
+        response_compression = data.get(
+            "response_compression", cls.response_compression
+        )
+        if (
+            response_compression is not None
+            and response_compression not in SUPPORTED_COMPRESSION
+        ):
+            raise ValueError(f"response_compression must be in {SUPPORTED_COMPRESSION}")
         return cls(
             endpoint=data["endpoint"],
             x_token=data.get("x-token") or data.get("x_token"),
@@ -23,4 +36,7 @@ class FumaroleConfig:
                 "max_decoding_message_size_bytes", cls.max_decoding_message_size_bytes
             ),
             x_metadata=data.get("x-metadata", {}),
+            response_compression=data.get(
+                "response_compression", cls.response_compression
+            ),
         )

yellowstone_fumarole_client/grpc_connectivity.py

@@ -2,7 +2,7 @@ import logging
 from typing import Optional
 import grpc
 from yellowstone_fumarole_client.config import FumaroleConfig
-from yellowstone_fumarole_proto.fumarole_v2_pb2_grpc import FumaroleStub
+from yellowstone_fumarole_proto.fumarole_pb2_grpc import FumaroleStub
 
 X_TOKEN_HEADER = "x-token"
 
@@ -31,34 +31,8 @@ class TritonAuthMetadataPlugin(grpc.AuthMetadataPlugin):
         return _triton_sign_request(callback, self.x_token, None)
 
 
-def grpc_channel(endpoint: str, x_token=None, compression=None, *grpc_options):
-    options = [("grpc.max_receive_message_length", 111111110), *grpc_options]
-    if x_token is not None:
-        auth = TritonAuthMetadataPlugin(x_token)
-        # ssl_creds allow you to use our https endpoint
-        # grpc.ssl_channel_credentials with no arguments will look through your CA trust store.
-        ssl_creds = grpc.ssl_channel_credentials()
-
-        # call credentials will be sent on each request if setup with composite_channel_credentials.
-        call_creds: grpc.CallCredentials = grpc.metadata_call_credentials(auth)
-
-        # Combined creds will store the channel creds aswell as the call credentials
-        combined_creds = grpc.composite_channel_credentials(ssl_creds, call_creds)
-
-        return grpc.secure_channel(
-            endpoint,
-            credentials=combined_creds,
-            compression=compression,
-            options=options,
-        )
-    else:
-        return grpc.insecure_channel(endpoint, compression=compression, options=options)
-
-
 # Because of a bug in grpcio library, multiple inheritance of ClientInterceptor subclasses does not work.
 # You have to create a new class for each type of interceptor you want to use.
-
-
 class MetadataInterceptor(
     grpc.aio.UnaryStreamClientInterceptor,
     grpc.aio.StreamUnaryClientInterceptor,
@@ -166,6 +140,11 @@ class FumaroleGrpcConnector:
     async def connect(self, *grpc_options) -> FumaroleStub:
         options = [("grpc.max_receive_message_length", 111111110), *grpc_options]
         interceptors = MetadataInterceptor(self.config.x_metadata).interceptors()
+        compression = (
+            grpc.Compression.Gzip
+            if self.config.response_compression == "gzip"
+            else None
+        )
         if self.config.x_token is not None:
             auth = TritonAuthMetadataPlugin(self.config.x_token)
             # ssl_creds allow you to use our https endpoint
@@ -184,6 +163,7 @@ class FumaroleGrpcConnector:
                 self.endpoint,
                 credentials=combined_creds,
                 options=options,
+                compression=compression,
                 interceptors=interceptors,
             )
         else:
@@ -191,7 +171,10 @@ class FumaroleGrpcConnector:
                 "Using insecure channel without authentication"
             )
             channel = grpc.aio.insecure_channel(
-                self.endpoint, options=options, interceptors=interceptors
+                self.endpoint,
+                options=options,
+                interceptors=interceptors,
+                compression=compression,
             )
 
         return FumaroleStub(channel)

yellowstone_fumarole_client/runtime/aio.py

@@ -1,10 +1,9 @@
 # DataPlaneConn
 from abc import abstractmethod, ABC
 import asyncio
-import uuid
 import grpc
-from typing import Optional, List
-from collections import abc, deque
+from typing import Optional
+from collections import deque
 from dataclasses import dataclass
 import time
 from yellowstone_fumarole_client.runtime.state_machine import (
@@ -19,7 +18,7 @@ from yellowstone_fumarole_proto.geyser_pb2 import (
     SubscribeUpdateSlot,
     CommitmentLevel as ProtoCommitmentLevel,
 )
-from yellowstone_fumarole_proto.fumarole_v2_pb2 import (
+from yellowstone_fumarole_proto.fumarole_pb2 import (
     ControlCommand,
     PollBlockchainHistory,
     CommitOffset,
@@ -27,8 +26,8 @@ from yellowstone_fumarole_proto.fumarole_v2_pb2 import (
     DownloadBlockShard,
     BlockFilters,
 )
-from yellowstone_fumarole_proto.fumarole_v2_pb2_grpc import (
-    Fumarole as GrpcFumaroleClient,
+from yellowstone_fumarole_proto.fumarole_pb2_grpc import (
+    FumaroleStub,
 )
 from yellowstone_fumarole_client.utils.aio import Interval
 from yellowstone_fumarole_client.grpc_connectivity import FumaroleGrpcConnector
@@ -84,6 +83,12 @@ class AsyncSlotDownloader(ABC):
         pass
 
 
+SUBSCRIBE_REQ_UPDATE_TYPE_MARKER: int = 1
+CONTROL_PLANE_RESP_TYPE_MARKER: int = 2
+COMMIT_TICK_TYPE_MARKER: int = 3
+DOWNLOAD_TASK_TYPE_MARKER: int = 4
+
+
 # TokioFumeDragonsmouthRuntime
 class AsyncioFumeDragonsmouthRuntime:
     """Asynchronous runtime for Fumarole with Dragonsmouth-like stream support."""
@@ -119,17 +124,32 @@ class AsyncioFumeDragonsmouthRuntime:
         """
         self.sm = sm
         self.slot_downloader: AsyncSlotDownloader = slot_downloader
-        self.subscribe_request_update_q = subscribe_request_update_q
+        self.subscribe_request_update_rx: asyncio.Queue = subscribe_request_update_q
         self.subscribe_request = subscribe_request
         self.consumer_group_name = consumer_group_name
-        self.control_plane_tx = control_plane_tx_q
-        self.control_plane_rx = control_plane_rx_q
-        self.dragonsmouth_outlet = dragonsmouth_outlet
+        self.control_plane_tx: asyncio.Queue = control_plane_tx_q
+        self.control_plane_rx: asyncio.Queue = control_plane_rx_q
+        self.dragonsmouth_outlet: asyncio.Queue = dragonsmouth_outlet
         self.commit_interval = commit_interval
         self.gc_interval = gc_interval
         self.max_concurrent_download = max_concurrent_download
+
+        # holds metadata about the download task
         self.download_tasks = dict()
-        self.inner_runtime_channel: asyncio.Queue = asyncio.Queue()
+        self.inflight_tasks = dict()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.aclose()
+
+    async def aclose(self):
+        self.control_plane_tx.shutdown()
+        self.dragonsmouth_outlet.shutdown()
+        for t, kind in self.inflight_tasks.items():
+            LOGGER.debug(f"closing {kind} task")
+            t.cancel()
 
     def _build_poll_history_cmd(
         self, from_offset: Optional[FumeOffset]
@@ -195,8 +215,9 @@ class AsyncioFumeDragonsmouthRuntime:
             coro = self.slot_downloader.run_download(
                 self.subscribe_request, download_task_args
             )
-            donwload_task = asyncio.create_task(coro)
-            self.download_tasks[donwload_task] = download_request
+            download_task = asyncio.create_task(coro)
+            self.download_tasks[download_task] = download_request
+            self.inflight_tasks[download_task] = DOWNLOAD_TASK_TYPE_MARKER
             LOGGER.debug(f"Scheduling download task for slot {download_request.slot}")
 
     def _handle_download_result(self, download_result: DownloadTaskResult):
@@ -219,10 +240,10 @@ class AsyncioFumeDragonsmouthRuntime:
         )
 
     async def _commit_offset(self):
+        self.last_commit = time.time()
         if self.sm.last_committed_offset < self.sm.committable_offset:
             LOGGER.debug(f"Committing offset {self.sm.committable_offset}")
             await self._force_commit_offset()
-        self.last_commit = time.time()
 
     async def _drain_slot_status(self):
         """Drains the slot status from the state machine and sends updates to the Dragonsmouth outlet."""
@@ -245,8 +266,10 @@ class AsyncioFumeDragonsmouthRuntime:
                     matched_filters.append(filter_name)
                 elif not filter.filter_by_commitment:
                     matched_filters.append(filter_name)
-
             if matched_filters:
+                LOGGER.debug(
+                    f"Matched {len(matched_filters)} filters for SlotStatus Update"
+                )
                 update = SubscribeUpdate(
                     filters=matched_filters,
                     created_at=None,
@@ -257,10 +280,7 @@ class AsyncioFumeDragonsmouthRuntime:
                         dead_error=slot_status.dead_error,
                     ),
                 )
-                try:
-                    await self.dragonsmouth_outlet.put(update)
-                except asyncio.QueueFull:
-                    return
+                await self.dragonsmouth_outlet.put(update)
 
             self.sm.mark_event_as_processed(slot_status.session_sequence)
 
@@ -286,16 +306,19 @@ class AsyncioFumeDragonsmouthRuntime:
         LOGGER.debug("Initial commit offset command sent")
         ticks = 0
 
-        task_map = {
+        self.inflight_tasks = {
+            asyncio.create_task(
+                self.subscribe_request_update_rx.get()
+            ): SUBSCRIBE_REQ_UPDATE_TYPE_MARKER,
+            asyncio.create_task(
+                self.control_plane_rx.get()
+            ): CONTROL_PLANE_RESP_TYPE_MARKER,
             asyncio.create_task(
-                self.subscribe_request_update_q.get()
-            ): "dragonsmouth_bidi",
-            asyncio.create_task(self.control_plane_rx.get()): "control_plane_rx",
-            asyncio.create_task(Interval(self.commit_interval).tick()): "commit_tick",
+                Interval(self.commit_interval).tick()
+            ): COMMIT_TICK_TYPE_MARKER,
         }
 
-        pending = set(task_map.keys())
-        while pending:
+        while self.inflight_tasks:
             ticks += 1
             LOGGER.debug(f"Runtime loop tick")
             if ticks % self.gc_interval == 0:
@@ -306,58 +329,51 @@ class AsyncioFumeDragonsmouthRuntime:
             await self.poll_history_if_needed()
             LOGGER.debug("Scheduling download tasks if any")
             self._schedule_download_task_if_any()
-            for t in self.download_tasks.keys():
-                pending.add(t)
-                task_map[t] = "download_task"
-
             download_task_inflight = len(self.download_tasks)
             LOGGER.debug(
                 f"Current download tasks in flight: {download_task_inflight} / {self.max_concurrent_download}"
             )
-            done, pending = await asyncio.wait(
-                pending, return_when=asyncio.FIRST_COMPLETED
+            done, _pending = await asyncio.wait(
+                self.inflight_tasks.keys(), return_when=asyncio.FIRST_COMPLETED
             )
             for t in done:
                 result = t.result()
-                name = task_map.pop(t)
-                match name:
-                    case "dragonsmouth_bidi":
-                        LOGGER.debug("Dragonsmouth subscribe request received")
-                        assert isinstance(
-                            result, SubscribeRequest
-                        ), "Expected SubscribeRequest"
-                        self.handle_new_subscribe_request(result)
-                        new_task = asyncio.create_task(
-                            self.subscribe_request_update_q.get()
-                        )
-                        task_map[new_task] = "dragonsmouth_bidi"
-                        pending.add(new_task)
-                        pass
-                    case "control_plane_rx":
-                        LOGGER.debug("Control plane response received")
-                        if not await self._handle_control_plane_resp(result):
-                            LOGGER.debug("Control plane error")
-                            return
-                        new_task = asyncio.create_task(self.control_plane_rx.get())
-                        task_map[new_task] = "control_plane_rx"
-                        pending.add(new_task)
-                    case "download_task":
-                        LOGGER.debug("Download task result received")
-                        assert self.download_tasks.pop(t)
-                        self._handle_download_result(result)
-                    case "commit_tick":
-                        LOGGER.debug("Commit tick reached")
-                        await self._commit_offset()
-                        new_task = asyncio.create_task(
-                            Interval(self.commit_interval).tick()
-                        )
-                        task_map[new_task] = "commit_tick"
-                        pending.add(new_task)
-                    case unknown:
-                        raise RuntimeError(f"Unexpected task name: {unknown}")
+                sigcode = self.inflight_tasks.pop(t)
+                if sigcode == SUBSCRIBE_REQ_UPDATE_TYPE_MARKER:
+                    LOGGER.debug("Dragonsmouth subscribe request received")
+                    assert isinstance(
+                        result, SubscribeRequest
+                    ), "Expected SubscribeRequest"
+                    self.handle_new_subscribe_request(result)
+                    new_task = asyncio.create_task(
+                        self.subscribe_request_update_rx.get()
+                    )
+                    self.inflight_tasks[new_task] = SUBSCRIBE_REQ_UPDATE_TYPE_MARKER
+                    pass
+                elif sigcode == CONTROL_PLANE_RESP_TYPE_MARKER:
+                    LOGGER.debug("Control plane response received")
+                    if not await self._handle_control_plane_resp(result):
+                        LOGGER.debug("Control plane error")
+                        return
+                    new_task = asyncio.create_task(self.control_plane_rx.get())
+                    self.inflight_tasks[new_task] = CONTROL_PLANE_RESP_TYPE_MARKER
+                elif sigcode == DOWNLOAD_TASK_TYPE_MARKER:
+                    LOGGER.debug("Download task result received")
+                    assert self.download_tasks.pop(t)
+                    self._handle_download_result(result)
+                elif sigcode == COMMIT_TICK_TYPE_MARKER:
+                    LOGGER.debug("Commit tick reached")
+                    await self._commit_offset()
+                    new_task = asyncio.create_task(
+                        Interval(self.commit_interval).tick()
+                    )
+                    self.inflight_tasks[new_task] = COMMIT_TICK_TYPE_MARKER
+                else:
+                    raise RuntimeError(f"Unexpected task name: {sigcode}")
 
             await self._drain_slot_status()
 
+        await self.aclose()
         LOGGER.debug("Fumarole runtime exiting")
 
 
@@ -391,7 +407,7 @@ class GrpcSlotDownloader(AsyncSlotDownloader):
 
     def __init__(
         self,
-        client: GrpcFumaroleClient,
+        client: FumaroleStub,
     ):
         self.client = client
 
@@ -420,7 +436,7 @@ class GrpcDownloadBlockTaskRun:
     def __init__(
         self,
         download_request: FumeDownloadRequest,
-        client: GrpcFumaroleClient,
+        client: FumaroleStub,
         filters: Optional[BlockFilters],
         dragonsmouth_oulet: asyncio.Queue,
     ):

yellowstone_fumarole_client/runtime/state_machine.py

@@ -1,11 +1,11 @@
-from typing import Optional, List, Dict, Set, Deque, Tuple, Any
+from typing import Optional, Set, Deque, Sequence
 from collections import deque, defaultdict
-from yellowstone_fumarole_proto.fumarole_v2_pb2 import (
+from yellowstone_fumarole_proto.fumarole_pb2 import (
     CommitmentLevel,
     BlockchainEvent,
 )
+from yellowstone_fumarole_client.utils.collections import OrderedSet
 import heapq
-import uuid
 from enum import Enum
 
 __all__ = [
@@ -107,7 +107,7 @@ class FumaroleSM:
     def __init__(self, last_committed_offset: FumeOffset, slot_memory_retention: int):
         self.last_committed_offset = last_committed_offset
         self.slot_commitment_progression = dict()  # Slot -> SlotCommitmentProgression
-        self.downloaded_slot = set()  # Set of downloaded slots
+        self.downloaded_slot = OrderedSet()  # Set of downloaded slots
         self.inflight_slot_shard_download = {}  # Slot -> SlotDownloadProgress
         self.blocked_slot_status_update = defaultdict(
             deque
@@ -121,7 +121,9 @@ class FumaroleSM:
         ] = deque()
         self.sequence = 1
         self.last_processed_fume_sequence = 0
-        self.sequence_to_offset = {}  # FumeSessionSequence -> FumeOffset
+        self.sequence_to_offset: dict[FumeSessionSequence, FumeOffset] = (
+            {}
+        )  # FumeSessionSequence -> FumeOffset
         self.slot_memory_retention = slot_memory_retention
 
     def update_committed_offset(self, offset: FumeOffset) -> None:
@@ -138,14 +140,14 @@ class FumaroleSM:
     def gc(self) -> None:
         """Garbage collect old slots to respect memory retention limit."""
         while len(self.downloaded_slot) > self.slot_memory_retention:
-            slot = self.downloaded_slot.pop(0) if self.downloaded_slot else None
+            slot = self.downloaded_slot.popfirst() if self.downloaded_slot else None
             if slot is None:
                 break
             self.slot_commitment_progression.pop(slot, None)
             self.inflight_slot_shard_download.pop(slot, None)
             self.blocked_slot_status_update.pop(slot, None)
 
-    def queue_blockchain_event(self, events: List[BlockchainEvent]) -> None:
+    def queue_blockchain_event(self, events: Sequence[BlockchainEvent]) -> None:
         """Queue blockchain events for processing."""
         for event in events:
 
@@ -232,7 +234,7 @@ class FumaroleSM:
             blockchain_event: BlockchainEvent = blockchain_event
             event_cl = blockchain_event.commitment_level
 
-            if event_cl < min_commitment:
+            if event_cl != min_commitment:
                 self.slot_status_update_queue.append(
                     FumeSlotStatus(
                         session_sequence=session_sequence,
@@ -266,6 +268,18 @@ class FumaroleSM:
             else:
                 blockchain_id = bytes(blockchain_event.blockchain_id)
                 block_uid = bytes(blockchain_event.block_uid)
+
+                self.blocked_slot_status_update[blockchain_event.slot].append(
+                    FumeSlotStatus(
+                        session_sequence=session_sequence,
+                        offset=blockchain_event.offset,
+                        slot=blockchain_event.slot,
+                        parent_slot=blockchain_event.parent_slot,
+                        commitment_level=event_cl,
+                        dead_error=blockchain_event.dead_error,
+                    )
+                )
+
                 if blockchain_event.slot not in self.inflight_slot_shard_download:
                     download_request = FumeDownloadRequest(
                         slot=blockchain_event.slot,
@@ -280,16 +294,6 @@ class FumaroleSM:
                     self.inflight_slot_shard_download[blockchain_event.slot] = (
                         download_progress
                     )
-                    self.blocked_slot_status_update[blockchain_event.slot].append(
-                        FumeSlotStatus(
-                            session_sequence=session_sequence,
-                            offset=blockchain_event.offset,
-                            slot=blockchain_event.slot,
-                            parent_slot=blockchain_event.parent_slot,
-                            commitment_level=event_cl,
-                            dead_error=blockchain_event.dead_error,
-                        )
-                    )
                     return download_request
         return None
 
@@ -298,13 +302,10 @@ class FumaroleSM:
         fume_offset = self.sequence_to_offset.pop(event_seq_number, None)
         if fume_offset is None:
             raise ValueError("Event sequence number not found")
-        heapq.heappush(
-            self.processed_offset, (-event_seq_number, -fume_offset)
-        )  # Negate for min-heap
+        heapq.heappush(self.processed_offset, (event_seq_number, fume_offset))
 
         while self.processed_offset:
             seq, offset = self.processed_offset[0]
-            seq, offset = -seq, -offset  # Convert back to positive
             if seq != self.last_processed_fume_sequence + 1:
                 break
             heapq.heappop(self.processed_offset)