sol-parser-sdk-python 0.4.4__tar.gz → 0.4.5__tar.gz

{sol_parser_sdk_python-0.4.4 → sol_parser_sdk_python-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sol-parser-sdk-python
-Version: 0.4.4
+Version: 0.4.5
 Summary: Solana DEX program log parsing (pure Python, API aligned with sol-parser-sdk)
 Requires-Python: >=3.10
 Requires-Dist: base58>=2.0

{sol_parser_sdk_python-0.4.4 → sol_parser_sdk_python-0.4.5}/README.md

@@ -56,7 +56,7 @@
 **From PyPI**
 
 ```bash
-pip install sol-parser-sdk-python
+pip install sol-parser-sdk-python==0.4.5
 ```
 
 **From source**

{sol_parser_sdk_python-0.4.4 → sol_parser_sdk_python-0.4.5}/README_CN.md

@@ -56,7 +56,7 @@
 **PyPI**
 
 ```bash
-pip install sol-parser-sdk-python
+pip install sol-parser-sdk-python==0.4.5
 ```
 
 **源码**

sol_parser_sdk_python-0.4.5/examples/meteora_damm_grpc.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Meteora DAMM gRPC — latest ``subscribe_dex_events`` queue API.
+
+Run: ``python examples/meteora_damm_grpc.py``
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from sol_parser import now_micros
+from sol_parser.env_config import load_dotenv_silent, parse_grpc_credentials
+from sol_parser.event_types import DexEvent
+from sol_parser.grpc_client import YellowstoneGrpc
+from sol_parser.grpc_types import (
+    ClientConfig,
+    EventType,
+    OrderMode,
+    Protocol,
+    event_type_filter_include_only,
+    transaction_filter_for_protocols,
+)
+
+event_count = 0
+swap_count = 0
+add_liquidity_count = 0
+remove_liquidity_count = 0
+create_position_count = 0
+close_position_count = 0
+
+
+def _metadata(ev: DexEvent):
+    return getattr(ev.data, "metadata", None) if ev.data is not None else None
+
+
+def _latency_us(ev: DexEvent) -> int:
+    meta = _metadata(ev)
+    grpc_recv_us = int(getattr(meta, "grpc_recv_us", 0) or 0) if meta else 0
+    return max(0, now_micros() - grpc_recv_us) if grpc_recv_us else 0
+
+
+async def main() -> None:
+    global event_count, swap_count, add_liquidity_count, remove_liquidity_count
+    global create_position_count, close_position_count
+
+    load_dotenv_silent()
+    endpoint, token = parse_grpc_credentials(
+        sys.argv[1:],
+        default_endpoint="solana-yellowstone-grpc.publicnode.com:443",
+    )
+
+    print("🚀 Meteora DAMM gRPC Streaming Example")
+    print("========================================\n")
+
+    config = ClientConfig.default()
+    config.enable_metrics = True
+    config.connection_timeout_ms = 10000
+    config.request_timeout_ms = 30000
+    config.enable_tls = True
+    config.order_mode = OrderMode.UNORDERED
+
+    client = YellowstoneGrpc.new_with_config(endpoint, token or None, config)
+    protocols = [Protocol.METEORA_DAMM_V2]
+    print(f"📊 Protocols: {[p.value for p in protocols]}")
+
+    tx_filter = transaction_filter_for_protocols(protocols)
+    tx_filter.vote = False
+    tx_filter.failed = False
+    event_filter = event_type_filter_include_only(
+        [
+            EventType.METEORA_DAMM_V2_SWAP,
+            EventType.METEORA_DAMM_V2_ADD_LIQUIDITY,
+            EventType.METEORA_DAMM_V2_REMOVE_LIQUIDITY,
+            EventType.METEORA_DAMM_V2_CREATE_POSITION,
+            EventType.METEORA_DAMM_V2_CLOSE_POSITION,
+        ]
+    )
+
+    queue: asyncio.Queue[DexEvent] = await client.subscribe_dex_events(
+        [tx_filter],
+        [],
+        event_filter,
+    )
+
+    print("🎯 Event Filter: Swap, AddLiquidity, RemoveLiquidity, CreatePosition, ClosePosition")
+    print("🛑 Press Ctrl+C to stop...\n")
+
+    try:
+        while True:
+            ev = await queue.get()
+            if not isinstance(ev, DexEvent) or ev.data is None:
+                continue
+            event_count += 1
+            d = ev.data
+            meta = _metadata(ev)
+            sig = getattr(meta, "signature", "") if meta else ""
+            slot = int(getattr(meta, "slot", 0) or 0) if meta else 0
+            latency_us = _latency_us(ev)
+
+            if ev.type == EventType.METEORA_DAMM_V2_SWAP:
+                swap_count += 1
+                direction = "A->B" if getattr(d, "trade_direction", 0) == 0 else "B->A"
+                print("┌─────────────────────────────────────────────────────────────")
+                print(f"│ 🔄 Meteora DAMM SWAP (V2) #{event_count}")
+                print("├─────────────────────────────────────────────────────────────")
+                print(f"│ Signature  : {sig}")
+                print(f"│ Slot       : {slot}")
+                print("├─────────────────────────────────────────────────────────────")
+                print(f"│ Pool       : {getattr(d, 'pool', '')}")
+                print(f"│ Direction  : {direction}")
+                print(f"│ Amount In  : {getattr(d, 'amount_in', 0)}")
+                print(f"│ Actual Out : {getattr(d, 'output_amount', 0)}")
+                print(f"│ Protocol   : {getattr(d, 'protocol_fee', 0)}")
+                print("├─────────────────────────────────────────────────────────────")
+                print(f"│ 📊 Latency : {latency_us} μs")
+                print(
+                    f"│ 📊 Stats   : Swap={swap_count} AddLiq={add_liquidity_count} RemLiq={remove_liquidity_count}"
+                )
+                print("└─────────────────────────────────────────────────────────────\n")
+            elif ev.type == EventType.METEORA_DAMM_V2_ADD_LIQUIDITY:
+                add_liquidity_count += 1
+                print(f"➕ ADD_LIQUIDITY #{add_liquidity_count} sig={sig} slot={slot} latency={latency_us}μs")
+            elif ev.type == EventType.METEORA_DAMM_V2_REMOVE_LIQUIDITY:
+                remove_liquidity_count += 1
+                print(f"➖ REMOVE_LIQUIDITY #{remove_liquidity_count} sig={sig} slot={slot} latency={latency_us}μs")
+            elif ev.type == EventType.METEORA_DAMM_V2_CREATE_POSITION:
+                create_position_count += 1
+                print(f"📌 CREATE_POSITION #{create_position_count} sig={sig} slot={slot} latency={latency_us}μs")
+            elif ev.type == EventType.METEORA_DAMM_V2_CLOSE_POSITION:
+                close_position_count += 1
+                print(f"❌ CLOSE_POSITION #{close_position_count} sig={sig} slot={slot} latency={latency_us}μs")
+    finally:
+        await client.disconnect()
+        print("\n👋 Shutting down gracefully...")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass

{sol_parser_sdk_python-0.4.4 → sol_parser_sdk_python-0.4.5}/examples/multi_protocol_grpc.py

@@ -10,18 +10,17 @@ import asyncio
 import os
 import sys
 
-import base58
-
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
-from sol_parser import format_dex_event_json, parse_logs_only
+from sol_parser import format_dex_event_json
 from sol_parser.env_config import load_dotenv_silent, parse_grpc_credentials
 from sol_parser.event_types import DexEvent
 from sol_parser.grpc_client import YellowstoneGrpc
 from sol_parser.grpc_types import (
     ClientConfig,
+    OrderMode,
     Protocol,
-    SubscribeCallbacks,
+    account_filter_for_protocols,
     transaction_filter_for_protocols,
 )
 
@@ -64,50 +63,32 @@ async def main() -> None:
 
     cfg = ClientConfig.default()
     cfg.enable_metrics = True
+    cfg.order_mode = OrderMode.UNORDERED
     client = YellowstoneGrpc.new_with_config(endpoint, token or None, cfg)
 
-    await client.connect()
     asyncio.create_task(stats_reporter())
 
-    def on_update(update):
-        if update.transaction is None or update.transaction.transaction is None:
-            return
-        tx_info = update.transaction.transaction
-        slot = update.transaction.slot
-        logs = tx_info.log_messages
-        if not logs:
-            return
-
-        sb = bytes(tx_info.signature) if tx_info.signature else b""
-        sig_b58 = base58.b58encode(sb).decode("ascii") if len(sb) == 64 else ""
-
-        for ev in parse_logs_only(
-            logs, sig_b58, slot, None, subscribe_tx_info=tx_info
-        ):
-            if not isinstance(ev, DexEvent):
-                continue
-            key = str(ev.type.value)
-            stats[key] = stats.get(key, 0) + 1
-            print(format_dex_event_json(ev))
-
     tx_filter = transaction_filter_for_protocols(PROTOCOLS)
     tx_filter.vote = False
     tx_filter.failed = False
+    account_filter = account_filter_for_protocols(PROTOCOLS)
 
-    await client.subscribe_transactions(
-        tx_filter,
-        SubscribeCallbacks(
-            on_update=on_update,
-            on_error=lambda e: print(f"Stream error: {e}", file=sys.stderr),
-            on_end=lambda: print("Stream ended"),
-        ),
+    queue: asyncio.Queue[DexEvent] = await client.subscribe_dex_events(
+        [tx_filter],
+        [account_filter],
     )
 
     print(f"✅ Subscribed")
     print("🛑 Press Ctrl+C to stop...\n")
 
     try:
-        await asyncio.Event().wait()
+        while True:
+            ev = await queue.get()
+            if not isinstance(ev, DexEvent):
+                continue
+            key = str(ev.type.value)
+            stats[key] = stats.get(key, 0) + 1
+            print(format_dex_event_json(ev))
     except KeyboardInterrupt:
         pass
     finally:
@@ -118,4 +99,4 @@ async def main() -> None:
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

sol_parser_sdk_python-0.4.5/examples/pumpfun_quick_test.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Quick Test — 对齐最新 ``subscribe_dex_events`` 队列 API。
+
+Run: ``python examples/pumpfun_quick_test.py``
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from sol_parser.env_config import load_dotenv_silent, parse_grpc_credentials
+from sol_parser.event_types import DexEvent
+from sol_parser.grpc_client import YellowstoneGrpc
+from sol_parser.grpc_types import ClientConfig, Protocol, transaction_filter_for_protocols
+
+
+async def main() -> None:
+    load_dotenv_silent()
+    endpoint, token = parse_grpc_credentials(
+        sys.argv[1:],
+        default_endpoint="solana-yellowstone-grpc.publicnode.com:443",
+    )
+
+    print("🚀 Quick Test - Subscribing to ALL PumpFun events...")
+
+    config = ClientConfig.default()
+    config.enable_metrics = True
+    client = YellowstoneGrpc.new_with_config(endpoint, token or None, config)
+
+    protocols = [Protocol.PUMP_FUN]
+    tx_filter = transaction_filter_for_protocols(protocols)
+    tx_filter.vote = False
+    tx_filter.failed = False
+
+    queue: asyncio.Queue[DexEvent] = await client.subscribe_dex_events([tx_filter], [])
+
+    print("✅ Subscribing... (no event filter - will show ALL PumpFun events)")
+    print("🎧 Listening for events... (waiting up to 60 seconds)\n")
+
+    event_count = 0
+    try:
+        while event_count < 10:
+            ev = await asyncio.wait_for(queue.get(), timeout=60.0)
+            if not isinstance(ev, DexEvent) or not str(ev.type.value).startswith("PumpFun"):
+                continue
+            event_count += 1
+            meta = getattr(ev.data, "metadata", None)
+            slot = int(getattr(meta, "slot", 0) or 0) if meta else 0
+            print(f"✅ Event #{event_count}: {ev.type.value} (slot={slot})")
+
+        print(f"\n🎉 Received {event_count} events! Test successful!")
+    except asyncio.TimeoutError:
+        if event_count == 0:
+            print("⏰ Timeout: No events received in 60 seconds.")
+            print("   This might indicate:")
+            print("   - Network connectivity issues")
+            print("   - gRPC endpoint is down")
+            print("   - Very low market activity (rare)")
+        else:
+            print(f"\n✅ Received {event_count} events in 60 seconds")
+    finally:
+        await client.disconnect()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sol_parser_sdk_python-0.4.5/examples/pumpfun_trade_filter.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""PumpFun Trade Event Filter Example — latest ``subscribe_dex_events`` API.
+
+Run: ``python examples/pumpfun_trade_filter.py``
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from sol_parser import now_micros
+from sol_parser.env_config import load_dotenv_silent, parse_grpc_credentials
+from sol_parser.event_types import DexEvent
+from sol_parser.grpc_client import YellowstoneGrpc
+from sol_parser.grpc_types import (
+    ClientConfig,
+    EventType,
+    OrderMode,
+    Protocol,
+    event_type_filter_include_only,
+    transaction_filter_for_protocols,
+)
+
+event_count = 0
+buy_count = 0
+sell_count = 0
+buy_exact_count = 0
+create_count = 0
+
+
+def _metadata(ev: DexEvent):
+    return getattr(ev.data, "metadata", None) if ev.data is not None else None
+
+
+def _latency_us(ev: DexEvent) -> int:
+    meta = _metadata(ev)
+    grpc_recv_us = int(getattr(meta, "grpc_recv_us", 0) or 0) if meta else 0
+    return max(0, now_micros() - grpc_recv_us) if grpc_recv_us else 0
+
+
+def _print_trade(title: str, ev: DexEvent, latency_us: int) -> None:
+    meta = _metadata(ev)
+    d = ev.data
+    print("┌─────────────────────────────────────────────────────────────")
+    print(f"│ {title} #{event_count}")
+    print("├─────────────────────────────────────────────────────────────")
+    print(f"│ Signature  : {getattr(meta, 'signature', '') if meta else ''}")
+    print(f"│ Slot       : {getattr(meta, 'slot', 0) if meta else 0}")
+    print("├─────────────────────────────────────────────────────────────")
+    print(f"│ Mint       : {getattr(d, 'mint', '')}")
+    print(f"│ SOL Amount : {getattr(d, 'sol_amount', 0)} lamports")
+    print(f"│ Token Amt  : {getattr(d, 'token_amount', 0)}")
+    print(f"│ User       : {getattr(d, 'user', '')}")
+    print("├─────────────────────────────────────────────────────────────")
+    print(f"│ 📊 Latency : {latency_us} μs")
+
+
+async def main() -> None:
+    global event_count, buy_count, sell_count, buy_exact_count, create_count
+
+    load_dotenv_silent()
+    endpoint, token = parse_grpc_credentials(
+        sys.argv[1:],
+        default_endpoint="solana-yellowstone-grpc.publicnode.com:443",
+    )
+
+    print("🚀 PumpFun Trade Event Filter Example")
+    print("======================================\n")
+
+    config = ClientConfig.default()
+    config.enable_metrics = True
+    config.connection_timeout_ms = 10000
+    config.request_timeout_ms = 30000
+    config.enable_tls = True
+    config.order_mode = OrderMode.UNORDERED
+
+    client = YellowstoneGrpc.new_with_config(endpoint, token or None, config)
+    protocols = [Protocol.PUMP_FUN]
+    print(f"📊 Protocols: {[p.value for p in protocols]}")
+
+    tx_filter = transaction_filter_for_protocols(protocols)
+    tx_filter.vote = False
+    tx_filter.failed = False
+    event_filter = event_type_filter_include_only(
+        [
+            EventType.PUMP_FUN_BUY,
+            EventType.PUMP_FUN_SELL,
+            EventType.PUMP_FUN_BUY_EXACT_SOL_IN,
+            EventType.PUMP_FUN_CREATE,
+            EventType.PUMP_FUN_CREATE_V2,
+        ]
+    )
+
+    queue: asyncio.Queue[DexEvent] = await client.subscribe_dex_events(
+        [tx_filter],
+        [],
+        event_filter,
+    )
+
+    print("🎯 Event Filter: Buy, Sell, BuyExactSolIn, Create")
+    print("🛑 Press Ctrl+C to stop...\n")
+
+    try:
+        while True:
+            ev = await queue.get()
+            if not isinstance(ev, DexEvent) or ev.data is None:
+                continue
+            latency_us = _latency_us(ev)
+            event_count += 1
+
+            if ev.type == EventType.PUMP_FUN_BUY:
+                buy_count += 1
+                _print_trade("🟢 PumpFun BUY", ev, latency_us)
+                print(f"│ 📊 Stats   : Buy={buy_count} Sell={sell_count} BuyExact={buy_exact_count}")
+                print("└─────────────────────────────────────────────────────────────\n")
+            elif ev.type == EventType.PUMP_FUN_SELL:
+                sell_count += 1
+                _print_trade("🔴 PumpFun SELL", ev, latency_us)
+                print(f"│ 📊 Stats   : Buy={buy_count} Sell={sell_count} BuyExact={buy_exact_count}")
+                print("└─────────────────────────────────────────────────────────────\n")
+            elif ev.type == EventType.PUMP_FUN_BUY_EXACT_SOL_IN:
+                buy_exact_count += 1
+                _print_trade("🟡 PumpFun BUY_EXACT_SOL_IN", ev, latency_us)
+                print(f"│ 📊 Stats   : Buy={buy_count} Sell={sell_count} BuyExact={buy_exact_count}")
+                print("└─────────────────────────────────────────────────────────────\n")
+            elif ev.type in (EventType.PUMP_FUN_CREATE, EventType.PUMP_FUN_CREATE_V2):
+                create_count += 1
+                meta = _metadata(ev)
+                d = ev.data
+                print("┌─────────────────────────────────────────────────────────────")
+                print(f"│ 🆕 PumpFun CREATE #{event_count}")
+                print("├─────────────────────────────────────────────────────────────")
+                print(f"│ Signature  : {getattr(meta, 'signature', '') if meta else ''}")
+                print(f"│ Slot       : {getattr(meta, 'slot', 0) if meta else 0}")
+                print("├─────────────────────────────────────────────────────────────")
+                print(f"│ Name       : {getattr(d, 'name', '')}")
+                print(f"│ Symbol     : {getattr(d, 'symbol', '')}")
+                print(f"│ Mint       : {getattr(d, 'mint', '')}")
+                print(f"│ Creator    : {getattr(d, 'creator', '')}")
+                print("├─────────────────────────────────────────────────────────────")
+                print(f"│ 📊 Latency : {latency_us} μs")
+                print(f"│ 📊 Creates : {create_count}")
+                print("└─────────────────────────────────────────────────────────────\n")
+    finally:
+        await client.disconnect()
+        print(
+            f"\n👋 Total events: {event_count} "
+            f"(Buy={buy_count} Sell={sell_count} BuyExact={buy_exact_count} Create={create_count})"
+        )
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass

{sol_parser_sdk_python-0.4.4 → sol_parser_sdk_python-0.4.5}/examples/pumpfun_with_metrics.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""PumpFun + 性能指标 — 对齐 ``sol-parser-sdk/examples/pumpfun_with_metrics.rs``。
+"""PumpFun + performance metrics — latest ``subscribe_dex_events`` API.
 
 Run: ``python examples/pumpfun_with_metrics.py``
 """
@@ -10,19 +10,17 @@ import asyncio
 import os
 import sys
 
-import base58
-
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
-from sol_parser import format_dex_event_json, now_micros, parse_logs_only
+from sol_parser import format_dex_event_json, now_micros
 from sol_parser.env_config import load_dotenv_silent, parse_grpc_credentials
 from sol_parser.event_types import DexEvent
 from sol_parser.grpc_client import YellowstoneGrpc
 from sol_parser.grpc_types import (
     ClientConfig,
     EventType,
+    OrderMode,
     Protocol,
-    SubscribeCallbacks,
     event_type_filter_include_only,
     transaction_filter_for_protocols,
 )
@@ -34,42 +32,31 @@ max_latency = 0
 last_count = 0
 
 
-async def stats_reporter():
+async def stats_reporter(queue: asyncio.Queue[DexEvent]):
     global last_count
     while True:
         await asyncio.sleep(10)
         if event_count == 0:
             continue
         count = event_count
-        total = total_latency
-        min_l = min_latency if min_latency < 2**62 else 0
-        max_l = max_latency
-        queue_len = 0
-        avg = total // count if count else 0
+        avg = total_latency // count if count else 0
         events_per_sec = (count - last_count) / 10.0
-
+        min_l = min_latency if min_latency < 2**62 else 0
         print("\n╔════════════════════════════════════════════════════╗")
         print("║          性能统计 (10秒间隔)                       ║")
         print("╠════════════════════════════════════════════════════╣")
         print(f"║  事件总数: {count:>10}                              ║")
         print(f"║  事件速率: {events_per_sec:>10.1f} events/sec                  ║")
-        print(f"║  队列长度: {queue_len:>10}                              ║")
+        print(f"║  队列长度: {queue.qsize():>10}                              ║")
         print(f"║  平均延迟: {avg:>10} μs                           ║")
         print(f"║  最小延迟: {min_l:>10} μs                           ║")
-        print(f"║  最大延迟: {max_l:>10} μs                           ║")
+        print(f"║  最大延迟: {max_latency:>10} μs                           ║")
         print("╚════════════════════════════════════════════════════╝\n")
-
-        if queue_len > 1000:
-            print(f"⚠️  警告: 队列堆积 ({queue_len}), 消费速度 < 生产速度")
-
         last_count = count
 
 
 def _grpc_recv_us(ev: DexEvent) -> int | None:
-    d = ev.data
-    if d is None:
-        return None
-    meta = getattr(d, "metadata", None)
+    meta = getattr(ev.data, "metadata", None) if ev.data is not None else None
     if meta is None:
         return None
     v = int(getattr(meta, "grpc_recv_us", 0) or 0)
@@ -93,9 +80,9 @@ async def main() -> None:
     config.connection_timeout_ms = 10000
     config.request_timeout_ms = 30000
     config.enable_tls = True
+    config.order_mode = OrderMode.UNORDERED
 
     client = YellowstoneGrpc.new_with_config(endpoint, token or None, config)
-    print("✅ gRPC client created successfully")
 
     protocols = [Protocol.PUMP_FUN]
     print(f"📊 Protocols to monitor: {[p.value for p in protocols]}")
@@ -103,10 +90,6 @@ async def main() -> None:
     tx_filter = transaction_filter_for_protocols(protocols)
     tx_filter.vote = False
     tx_filter.failed = False
-
-    print("🎧 Starting subscription...")
-    print("🔍 Monitoring programs for DEX events...")
-
     event_filter = event_type_filter_include_only(
         [
             EventType.PUMP_FUN_BUY,
@@ -117,71 +100,40 @@ async def main() -> None:
         ]
     )
 
-    print("📋 Event Filter: Buy, Sell, BuyExactSolIn, Create")
-
-    await client.connect()
-    asyncio.create_task(stats_reporter())
-
-    def on_update(update):
-        global event_count, total_latency, min_latency, max_latency
-
-        if update.transaction is None or update.transaction.transaction is None:
-            return
-        tx_info = update.transaction.transaction
-        slot = update.transaction.slot
-        logs = tx_info.log_messages
-        if not logs:
-            return
+    queue: asyncio.Queue[DexEvent] = await client.subscribe_dex_events(
+        [tx_filter],
+        [],
+        event_filter,
+    )
+    asyncio.create_task(stats_reporter(queue))
 
-        sb = bytes(tx_info.signature) if tx_info.signature else b""
-        sig = base58.b58encode(sb).decode("ascii") if len(sb) == 64 else ""
+    print("📋 Event Filter: Buy, Sell, BuyExactSolIn, Create")
+    print("🛑 Press Ctrl+C to stop...")
 
-        for ev in parse_logs_only(
-            logs, sig, slot, None, subscribe_tx_info=tx_info
-        ):
+    try:
+        while True:
+            ev = await queue.get()
             if not isinstance(ev, DexEvent) or ev.data is None:
                 continue
-            if not event_filter.should_include(ev.type):
+            grpc_recv_us = _grpc_recv_us(ev)
+            if grpc_recv_us is None:
                 continue
-
-            grpc_recv_us_opt = _grpc_recv_us(ev)
-            if grpc_recv_us_opt is None:
-                continue
-
             queue_recv_us = now_micros()
-            latency_us = queue_recv_us - grpc_recv_us_opt
-            if latency_us < 0:
-                latency_us = 0
+            latency_us = max(0, queue_recv_us - grpc_recv_us)
 
             event_count += 1
             total_latency += latency_us
             min_latency = min(min_latency, latency_us)
             max_latency = max(max_latency, latency_us)
 
-            queue_len = 0
-
             print("\n================================================")
-            print(f"gRPC接收时间: {grpc_recv_us_opt} μs")
+            print(f"gRPC接收时间: {grpc_recv_us} μs")
             print(f"事件接收时间: {queue_recv_us} μs")
             print(f"延迟时间: {latency_us} μs")
-            print(f"队列长度: {queue_len}")
+            print(f"队列长度: {queue.qsize()}")
             print("================================================")
             print(format_dex_event_json(ev))
             print()
-
-    await client.subscribe_transactions(
-        tx_filter,
-        SubscribeCallbacks(
-            on_update=on_update,
-            on_error=lambda e: print(f"Stream error: {e}", file=sys.stderr),
-            on_end=lambda: None,
-        ),
-    )
-
-    print("🛑 Press Ctrl+C to stop...")
-
-    try:
-        await asyncio.Event().wait()
     finally:
         await client.disconnect()
         print("👋 Shutting down gracefully...")