sol-parser-sdk-python 0.4.4__py3-none-any.whl

sol_parser/accounts/__init__.py

@@ -0,0 +1,461 @@
+"""账户解析器 — 对齐 Rust ``accounts`` 模块（含 ``utils`` / ``rpc_wallet`` 子模块）。"""
+
+from __future__ import annotations
+
+import struct
+from typing import Optional
+from dataclasses import dataclass
+
+import base58
+
+from ..grpc_types import EventTypeFilter, EventType, EventMetadata
+from ..dex_parsers import DexEvent
+
+from . import rpc_wallet
+from . import utils as acc_utils
+
+# 程序 ID（与 Rust ``accounts/program_ids`` / ``instr/program_ids`` 一致）
+PUMPFUN_PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
+PUMPSWAP_PROGRAM_ID = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"
+
+_DISC_PUMPFUN_GLOBAL = bytes([167, 232, 232, 177, 200, 108, 114, 127])
+_DISC_GLOBAL_CONFIG = bytes([149, 8, 156, 202, 160, 252, 176, 217])
+_DISC_POOL = bytes([241, 154, 109, 4, 17, 177, 109, 188])
+_DISC_NONCE = bytes([1, 0, 0, 0, 1, 0, 0, 0])
+
+MINT_SIZE = 82
+TOKEN_ACCOUNT_SIZE = 165
+NONCE_ACCOUNT_SIZE = 80
+PUMPFUN_GLOBAL_BODY = 1021
+GLOBAL_CONFIG_BODY = 634
+POOL_BODY = 244
+
+SUPPLY_OFFSET = 36
+DECIMALS_OFFSET = 44
+AMOUNT_OFFSET = 64
+NONCE_AUTHORITY_OFFSET = 8
+NONCE_NONCE_OFFSET = 40
+
+EMPTY_PUBKEY = ""
+
+
+def _account_event(event_type: EventType, data: dict) -> DexEvent:
+    return DexEvent(type=event_type, data=data)
+
+
+@dataclass
+class AccountData:
+    pubkey: str
+    executable: bool
+    lamports: int
+    owner: str
+    rent_epoch: int
+    data: bytes
+
+
+def has_discriminator(data: bytes, discriminator: bytes) -> bool:
+    return acc_utils.has_discriminator(data, discriminator)
+
+
+def base58_encode_32(data: bytes) -> str:
+    return base58.b58encode(data).decode("ascii")
+
+
+def read_pubkey_fast(data: bytes, offset: int) -> str:
+    if offset + 32 > len(data):
+        return EMPTY_PUBKEY
+    return base58.b58encode(data[offset : offset + 32]).decode("ascii")
+
+
+def read_u64_fast(data: bytes, offset: int) -> int:
+    return struct.unpack_from("<Q", data, offset)[0]
+
+
+def read_u16_fast(data: bytes, offset: int) -> int:
+    return struct.unpack_from("<H", data, offset)[0]
+
+
+def parse_account_unified(
+    account: AccountData,
+    metadata: EventMetadata,
+    event_type_filter: Optional[EventTypeFilter] = None,
+) -> Optional[DexEvent]:
+    """对齐 Rust ``parse_account_unified``（含 ``Option<EventTypeFilter>`` 语义）。"""
+    data = account.data
+    if not data:
+        return None
+
+    if event_type_filter is not None:
+        inc = getattr(event_type_filter, "include_only", None)
+        if inc is not None and len(inc) > 0:
+            need = {
+                EventType.TOKEN_ACCOUNT,
+                EventType.TOKEN_INFO,
+                EventType.NONCE_ACCOUNT,
+                EventType.ACCOUNT_PUMP_FUN_GLOBAL,
+                EventType.ACCOUNT_PUMP_SWAP_GLOBAL_CONFIG,
+                EventType.ACCOUNT_PUMP_SWAP_POOL,
+            }
+            if not any(t in need for t in inc):
+                return None
+
+    if account.owner == PUMPSWAP_PROGRAM_ID and event_type_filter is not None:
+        if event_type_filter.should_include(
+            EventType.ACCOUNT_PUMP_SWAP_GLOBAL_CONFIG
+        ) or event_type_filter.should_include(EventType.ACCOUNT_PUMP_SWAP_POOL):
+            ev = _parse_pumpswap_account(account, metadata)
+            if ev is not None:
+                return ev
+
+    if account.owner == PUMPFUN_PROGRAM_ID and event_type_filter is not None:
+        if event_type_filter.should_include(EventType.ACCOUNT_PUMP_FUN_GLOBAL):
+            ev = _parse_pumpfun_account(account, metadata)
+            if ev is not None:
+                return ev
+
+    if acc_utils.is_nonce_account(data):
+        if event_type_filter is not None:
+            if not event_type_filter.should_include(EventType.NONCE_ACCOUNT):
+                return None
+        return _parse_nonce_fast(account, metadata)
+
+    if event_type_filter is not None:
+        if not event_type_filter.should_include(EventType.TOKEN_ACCOUNT):
+            return None
+    return parse_token_account(account, metadata)
+
+
+def _parse_pumpswap_account(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if acc_utils.has_discriminator(account.data, _DISC_GLOBAL_CONFIG):
+        return parse_pumpswap_global_config(account, metadata)
+    if acc_utils.has_discriminator(account.data, _DISC_POOL):
+        return parse_pumpswap_pool(account, metadata)
+    return None
+
+
+def _parse_pumpfun_account(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if acc_utils.has_discriminator(account.data, _DISC_PUMPFUN_GLOBAL):
+        return parse_pumpfun_global(account, metadata)
+    return None
+
+
+def _parse_mint_fast(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    data = account.data
+    return _account_event(
+        EventType.TOKEN_INFO,
+        {
+            "metadata": metadata,
+            "pubkey": account.pubkey,
+            "executable": account.executable,
+            "lamports": account.lamports,
+            "owner": account.owner,
+            "rent_epoch": account.rent_epoch,
+            "supply": struct.unpack_from("<Q", data, SUPPLY_OFFSET)[0],
+            "decimals": data[DECIMALS_OFFSET],
+        },
+    )
+
+
+def _parse_token_fast(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    data = account.data
+    return _account_event(
+        EventType.TOKEN_ACCOUNT,
+        {
+            "metadata": metadata,
+            "pubkey": account.pubkey,
+            "executable": account.executable,
+            "lamports": account.lamports,
+            "owner": account.owner,
+            "rent_epoch": account.rent_epoch,
+            "amount": struct.unpack_from("<Q", data, AMOUNT_OFFSET)[0],
+        },
+    )
+
+
+def _parse_nonce_fast(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    data = account.data
+    authority = base58_encode_32(data[NONCE_AUTHORITY_OFFSET : NONCE_AUTHORITY_OFFSET + 32])
+    nonce = base58_encode_32(data[NONCE_NONCE_OFFSET : NONCE_NONCE_OFFSET + 32])
+    return _account_event(
+        EventType.NONCE_ACCOUNT,
+        {
+            "metadata": metadata,
+            "pubkey": account.pubkey,
+            "executable": account.executable,
+            "lamports": account.lamports,
+            "owner": account.owner,
+            "rent_epoch": account.rent_epoch,
+            "nonce": nonce,
+            "authority": authority,
+        },
+    )
+
+
+def _parse_pumpfun_global_fast(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    data = account.data[8:]
+    o = 0
+    initialized = data[o] != 0
+    o += 1
+    authority = read_pubkey_fast(data, o)
+    o += 32
+    fee_recipient = read_pubkey_fast(data, o)
+    o += 32
+    initial_virtual_token_reserves = read_u64_fast(data, o)
+    o += 8
+    initial_virtual_sol_reserves = read_u64_fast(data, o)
+    o += 8
+    initial_real_token_reserves = read_u64_fast(data, o)
+    o += 8
+    token_total_supply = read_u64_fast(data, o)
+    o += 8
+    fee_basis_points = read_u64_fast(data, o)
+    o += 8
+    withdraw_authority = read_pubkey_fast(data, o)
+    o += 32
+    enable_migrate = data[o] != 0
+    o += 1
+    pool_migration_fee = read_u64_fast(data, o)
+    o += 8
+    creator_fee_basis_points = read_u64_fast(data, o)
+    o += 8
+    fee_recipients = []
+    for _ in range(8):
+        fee_recipients.append(read_pubkey_fast(data, o))
+        o += 32
+    set_creator_authority = read_pubkey_fast(data, o)
+    o += 32
+    admin_set_creator_authority = read_pubkey_fast(data, o)
+    o += 32
+    create_v2_enabled = data[o] != 0
+    o += 1
+    whitelist_pda = read_pubkey_fast(data, o)
+    o += 32
+    reserved_fee_recipient = read_pubkey_fast(data, o)
+    o += 32
+    mayhem_mode_enabled = data[o] != 0
+    o += 1
+    reserved_fee_recipients = []
+    for _ in range(7):
+        reserved_fee_recipients.append(read_pubkey_fast(data, o))
+        o += 32
+    return _account_event(
+        EventType.ACCOUNT_PUMP_FUN_GLOBAL,
+        {
+            "metadata": metadata,
+            "pubkey": account.pubkey,
+            "global": {
+                "initialized": initialized,
+                "authority": authority,
+                "fee_recipient": fee_recipient,
+                "initial_virtual_token_reserves": initial_virtual_token_reserves,
+                "initial_virtual_sol_reserves": initial_virtual_sol_reserves,
+                "initial_real_token_reserves": initial_real_token_reserves,
+                "token_total_supply": token_total_supply,
+                "fee_basis_points": fee_basis_points,
+                "withdraw_authority": withdraw_authority,
+                "enable_migrate": enable_migrate,
+                "pool_migration_fee": pool_migration_fee,
+                "creator_fee_basis_points": creator_fee_basis_points,
+                "fee_recipients": fee_recipients,
+                "set_creator_authority": set_creator_authority,
+                "admin_set_creator_authority": admin_set_creator_authority,
+                "create_v2_enabled": create_v2_enabled,
+                "whitelist_pda": whitelist_pda,
+                "reserved_fee_recipient": reserved_fee_recipient,
+                "mayhem_mode_enabled": mayhem_mode_enabled,
+                "reserved_fee_recipients": reserved_fee_recipients,
+            },
+        },
+    )
+
+
+def _parse_pumpswap_global_config_fast(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    data = account.data[8:]
+    o = 0
+    admin = read_pubkey_fast(data, o)
+    o += 32
+    lp_fee = read_u64_fast(data, o)
+    o += 8
+    protocol_fee = read_u64_fast(data, o)
+    o += 8
+    disable_flags = data[o]
+    o += 1
+    recipients = [
+        read_pubkey_fast(data, o),
+        read_pubkey_fast(data, o + 32),
+        read_pubkey_fast(data, o + 64),
+        read_pubkey_fast(data, o + 96),
+        read_pubkey_fast(data, o + 128),
+        read_pubkey_fast(data, o + 160),
+        read_pubkey_fast(data, o + 192),
+        read_pubkey_fast(data, o + 224),
+    ]
+    o += 256
+    coin_creator_fee = read_u64_fast(data, o)
+    o += 8
+    admin_auth = read_pubkey_fast(data, o)
+    o += 32
+    whitelist = read_pubkey_fast(data, o)
+    o += 32
+    reserved = read_pubkey_fast(data, o)
+    o += 32
+    mayhem = data[o] != 0
+    o += 1
+    reserved_list = [
+        read_pubkey_fast(data, o),
+        read_pubkey_fast(data, o + 32),
+        read_pubkey_fast(data, o + 64),
+        read_pubkey_fast(data, o + 96),
+        read_pubkey_fast(data, o + 128),
+        read_pubkey_fast(data, o + 160),
+        read_pubkey_fast(data, o + 192),
+    ]
+    return _account_event(
+        EventType.ACCOUNT_PUMP_SWAP_GLOBAL_CONFIG,
+        {
+            "metadata": metadata,
+            "pubkey": account.pubkey,
+            "config": {
+                "admin": admin,
+                "lp_fee_basis_points": lp_fee,
+                "protocol_fee_basis_points": protocol_fee,
+                "disable_flags": disable_flags,
+                "protocol_fee_recipients": recipients,
+                "coin_creator_fee_basis_points": coin_creator_fee,
+                "admin_set_coin_creator_authority": admin_auth,
+                "whitelist_pda": whitelist,
+                "reserved_fee_recipient": reserved,
+                "mayhem_mode_enabled": mayhem,
+                "reserved_fee_recipients": reserved_list,
+            },
+        },
+    )
+
+
+def _parse_pumpswap_pool_fast(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    data = account.data[8:]
+    o = 0
+    pool_bump = data[o]
+    o += 1
+    index = read_u16_fast(data, o)
+    o += 2
+    creator = read_pubkey_fast(data, o)
+    base_mint = read_pubkey_fast(data, o + 32)
+    quote_mint = read_pubkey_fast(data, o + 64)
+    lp_mint = read_pubkey_fast(data, o + 96)
+    pool_base = read_pubkey_fast(data, o + 128)
+    pool_quote = read_pubkey_fast(data, o + 160)
+    o += 192
+    lp_supply = read_u64_fast(data, o)
+    o += 8
+    coin_creator = read_pubkey_fast(data, o)
+    o += 32
+    is_mayhem = data[o] != 0
+    is_cashback = data[o + 1] != 0
+    return _account_event(
+        EventType.ACCOUNT_PUMP_SWAP_POOL,
+        {
+            "metadata": metadata,
+            "pubkey": account.pubkey,
+            "pool": {
+                "pool_bump": pool_bump,
+                "index": index,
+                "creator": creator,
+                "base_mint": base_mint,
+                "quote_mint": quote_mint,
+                "lp_mint": lp_mint,
+                "pool_base_token_account": pool_base,
+                "pool_quote_token_account": pool_quote,
+                "lp_supply": lp_supply,
+                "coin_creator": coin_creator,
+                "is_mayhem_mode": is_mayhem,
+                "is_cashback_coin": is_cashback,
+            },
+        },
+    )
+
+
+def parse_token_account(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if len(account.data) <= 100:
+        event = _parse_mint_fast(account, metadata)
+        if event:
+            return event
+    return _parse_token_fast(account, metadata)
+
+
+def parse_nonce_account(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if len(account.data) != NONCE_ACCOUNT_SIZE:
+        return None
+    if not has_discriminator(account.data, _DISC_NONCE):
+        return None
+    return _parse_nonce_fast(account, metadata)
+
+
+def parse_pumpfun_global(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if len(account.data) < 8 + PUMPFUN_GLOBAL_BODY:
+        return None
+    if not has_discriminator(account.data, _DISC_PUMPFUN_GLOBAL):
+        return None
+    return _parse_pumpfun_global_fast(account, metadata)
+
+
+def is_nonce_account(data: bytes) -> bool:
+    return acc_utils.is_nonce_account(data)
+
+
+def parse_pumpswap_global_config(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if len(account.data) < 8 + GLOBAL_CONFIG_BODY:
+        return None
+    if not has_discriminator(account.data, _DISC_GLOBAL_CONFIG):
+        return None
+    return _parse_pumpswap_global_config_fast(account, metadata)
+
+
+def parse_pumpswap_pool(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if len(account.data) < 8 + POOL_BODY:
+        return None
+    if not has_discriminator(account.data, _DISC_POOL):
+        return None
+    return _parse_pumpswap_pool_fast(account, metadata)
+
+
+def is_global_config_account(data: bytes) -> bool:
+    return has_discriminator(data, _DISC_GLOBAL_CONFIG)
+
+
+def is_pool_account(data: bytes) -> bool:
+    return has_discriminator(data, _DISC_POOL)
+
+
+def is_pumpfun_global_account(data: bytes) -> bool:
+    return has_discriminator(data, _DISC_PUMPFUN_GLOBAL)
+
+
+base58_encode = base58_encode_32
+read_pubkey = read_pubkey_fast
+read_u64_le = read_u64_fast
+read_u8 = lambda data, offset: data[offset] if offset < len(data) else 0
+
+rpc_resolve_user_wallet_pubkey = rpc_wallet.rpc_resolve_user_wallet_pubkey
+user_wallet_pubkey_for_onchain_account = acc_utils.user_wallet_pubkey_for_onchain_account
+
+__all__ = [
+    "AccountData",
+    "parse_account_unified",
+    "parse_token_account",
+    "parse_nonce_account",
+    "parse_pumpfun_global",
+    "is_nonce_account",
+    "is_pumpfun_global_account",
+    "parse_pumpswap_global_config",
+    "parse_pumpswap_pool",
+    "is_global_config_account",
+    "is_pool_account",
+    "has_discriminator",
+    "PUMPFUN_PROGRAM_ID",
+    "PUMPSWAP_PROGRAM_ID",
+    "rpc_resolve_user_wallet_pubkey",
+    "user_wallet_pubkey_for_onchain_account",
+    "rpc_wallet",
+    "acc_utils",
+]

sol_parser/accounts/rpc_wallet.py

@@ -0,0 +1,64 @@
+"""对齐 Rust ``accounts/rpc_wallet.rs``：RPC getAccountInfo + ``user_wallet_pubkey_for_onchain_account``。"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from typing import Any, Dict, Optional
+
+from .utils import user_wallet_pubkey_for_onchain_account
+
+
+def _get_account_info(rpc_url: str, address_bs58: str, timeout_s: float = 15.0) -> Optional[Dict[str, Any]]:
+    import base64
+
+    body = json.dumps(
+        {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "getAccountInfo",
+            "params": [address_bs58, {"encoding": "base64"}],
+        }
+    ).encode("utf-8")
+    req = urllib.request.Request(
+        rpc_url,
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout_s) as resp:
+            raw = json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return None
+    err = raw.get("error")
+    if err:
+        return None
+    val = (raw.get("result") or {}).get("value")
+    if not val:
+        return None
+    data_b64 = val.get("data")
+    if isinstance(data_b64, list) and data_b64:
+        data_b64 = data_b64[0]
+    if not isinstance(data_b64, str):
+        return None
+    try:
+        data = base64.b64decode(data_b64)
+    except Exception:
+        return None
+    owner = val.get("owner") or ""
+    exe = bool(val.get("executable", False))
+    return {"data": data, "owner": owner, "executable": exe}
+
+
+def rpc_resolve_user_wallet_pubkey(rpc_url: str, address_bs58: str) -> Optional[str]:
+    """同步 JSON-RPC：``getAccountInfo`` → 用户钱包公钥 base58（与 Rust 语义一致）。"""
+    info = _get_account_info(rpc_url, address_bs58)
+    if not info:
+        return None
+    return user_wallet_pubkey_for_onchain_account(
+        address_bs58,
+        info["owner"],
+        info["data"],
+        info["executable"],
+    )

sol_parser/accounts/utils.py

@@ -0,0 +1,71 @@
+"""对齐 Rust ``accounts/utils.rs`` 的通用工具。"""
+
+from __future__ import annotations
+
+import struct
+from typing import Optional
+
+# Solana 系统程序、SPL Token / Token-2022（与 Rust 一致）
+SYSTEM_PROGRAM_ID = "11111111111111111111111111111111"
+SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+SPL_TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+
+SPL_TOKEN_ACCOUNT_LEN = 165
+
+
+def read_pubkey(data: bytes, offset: int) -> Optional[str]:
+    """32 字节 → base58；越界返回 None。"""
+    import base58
+
+    if len(data) < offset + 32:
+        return None
+    return base58.b58encode(data[offset : offset + 32]).decode("ascii")
+
+
+def read_u64_le(data: bytes, offset: int) -> Optional[int]:
+    if len(data) < offset + 8:
+        return None
+    return struct.unpack_from("<Q", data, offset)[0]
+
+
+def read_u16_le(data: bytes, offset: int) -> Optional[int]:
+    if len(data) < offset + 2:
+        return None
+    return struct.unpack_from("<H", data, offset)[0]
+
+
+def read_u8(data: bytes, offset: int) -> Optional[int]:
+    if offset >= len(data):
+        return None
+    return data[offset]
+
+
+def is_nonce_account(data: bytes) -> bool:
+    return len(data) >= 8 and data[:8] == bytes([1, 0, 0, 0, 1, 0, 0, 0])
+
+
+def is_token_program_account(owner: str) -> bool:
+    return owner in (SPL_TOKEN_PROGRAM_ID, SPL_TOKEN_2022_PROGRAM_ID)
+
+
+def has_discriminator(data: bytes, discriminator: bytes) -> bool:
+    if len(data) < len(discriminator):
+        return False
+    return data[: len(discriminator)] == discriminator
+
+
+def user_wallet_pubkey_for_onchain_account(
+    address: str,
+    owner: str,
+    data: bytes,
+    executable: bool,
+) -> Optional[str]:
+    """对齐 Rust ``user_wallet_pubkey_for_onchain_account``：系统钱包或 SPL token 账户 owner。"""
+    if executable:
+        return None
+    if owner == SYSTEM_PROGRAM_ID:
+        return address if len(data) == 0 else None
+    if is_token_program_account(owner) and len(data) == SPL_TOKEN_ACCOUNT_LEN:
+        # spl_token::state::Account: owner at offset 32
+        return read_pubkey(data, 32)
+    return None

sol_parser/check_migration.py

@@ -0,0 +1,18 @@
+"""Python 迁移门禁入口（与 TS `npm run check:migration` 中的 discriminator 交叉校验步骤对应）。"""
+
+from __future__ import annotations
+
+import sys
+
+from .u128_parity import run_all_u128_checks
+from .verify_discriminators import main as _verify_main
+
+
+def main() -> None:
+    if _verify_main() != 0:
+        sys.exit(1)
+    sys.exit(run_all_u128_checks())
+
+
+if __name__ == "__main__":
+    main()

sol_parser/clock.py

@@ -0,0 +1,10 @@
+"""高性能时间源（对齐 Rust ``sol_parser_sdk::core::now_micros`` 语义）。"""
+
+from __future__ import annotations
+
+import time
+
+
+def now_micros() -> int:
+    """当前时间（微秒），单调性与 ``time.time_ns()`` 一致。"""
+    return time.time_ns() // 1000

sol_parser/common/__init__.py

@@ -0,0 +1,27 @@
+"""对齐 Rust ``common`` 模块：常量与共享类型占位。"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+AnyResult = Any  # Rust: Result<T, Box<dyn Error + Send + Sync>>
+
+DEFAULT_CONNECT_TIMEOUT = 10
+DEFAULT_REQUEST_TIMEOUT = 60
+DEFAULT_CHANNEL_SIZE = 1000
+DEFAULT_MAX_DECODING_MESSAGE_SIZE = 10 * 1024 * 1024
+DEFAULT_METRICS_WINDOW_SECONDS = 5
+DEFAULT_METRICS_PRINT_INTERVAL_SECONDS = 10
+SLOW_PROCESSING_THRESHOLD_US = 3000.0
+
+__all__ = [
+    "AnyResult",
+    "DEFAULT_CONNECT_TIMEOUT",
+    "DEFAULT_REQUEST_TIMEOUT",
+    "DEFAULT_CHANNEL_SIZE",
+    "DEFAULT_MAX_DECODING_MESSAGE_SIZE",
+    "DEFAULT_METRICS_WINDOW_SECONDS",
+    "DEFAULT_METRICS_PRINT_INTERVAL_SECONDS",
+    "SLOW_PROCESSING_THRESHOLD_US",
+]