sol-parser-sdk-python 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

sol_parser/merger.py

@@ -60,48 +60,123 @@ def _fill_attr_if_empty(base: Any, attr: str, source: Any) -> None:
         setattr(base, attr, value)
 
 
+def _put_attr_if_set(base: Any, attr: str, source: Any) -> None:
+    value = getattr(source, attr, None)
+    if not _empty(value):
+        setattr(base, attr, value)
+
+
+def _put_num_if_nonzero(base: Any, attr: str, source: Any) -> None:
+    value = getattr(source, attr, 0)
+    if value:
+        setattr(base, attr, value)
+
+
 def merge_pumpfun_trade(base: PumpFunTradeEvent, inner: PumpFunTradeEvent) -> None:
-    base.mint = inner.mint
-    base.sol_amount = inner.sol_amount
-    base.token_amount = inner.token_amount
-    base.is_buy = inner.is_buy
-    base.user = inner.user
-    base.timestamp = inner.timestamp
-    base.virtual_sol_reserves = inner.virtual_sol_reserves
-    base.virtual_token_reserves = inner.virtual_token_reserves
-    base.real_sol_reserves = inner.real_sol_reserves
-    base.real_token_reserves = inner.real_token_reserves
-    base.fee_recipient = inner.fee_recipient
-    base.fee_basis_points = inner.fee_basis_points
-    base.fee = inner.fee
-    base.creator = inner.creator
-    base.creator_fee_basis_points = inner.creator_fee_basis_points
-    base.creator_fee = inner.creator_fee
-    base.track_volume = inner.track_volume
-    base.total_unclaimed_tokens = inner.total_unclaimed_tokens
-    base.total_claimed_tokens = inner.total_claimed_tokens
-    base.current_sol_volume = inner.current_sol_volume
-    base.last_update_timestamp = inner.last_update_timestamp
-    base.ix_name = inner.ix_name
-    base.is_created_buy = inner.is_created_buy
-    base.mayhem_mode = inner.mayhem_mode
-    base.cashback_fee_basis_points = inner.cashback_fee_basis_points
-    base.cashback = inner.cashback
-    if inner.buyback_fee_basis_points != 0:
-        base.buyback_fee_basis_points = inner.buyback_fee_basis_points
-    if inner.buyback_fee != 0:
-        base.buyback_fee = inner.buyback_fee
-    if inner.shareholders:
+    leg = inner.sol_amount != 0 or inner.token_amount != 0
+
+    for attr in ("mint", "user", "fee_recipient", "creator"):
+        _put_attr_if_set(base, attr, inner)
+
+    if leg:
+        for attr in (
+            "sol_amount",
+            "token_amount",
+            "timestamp",
+            "virtual_sol_reserves",
+            "virtual_token_reserves",
+            "real_sol_reserves",
+            "real_token_reserves",
+            "fee_basis_points",
+            "fee",
+            "creator_fee_basis_points",
+            "creator_fee",
+            "total_unclaimed_tokens",
+            "total_claimed_tokens",
+            "current_sol_volume",
+            "last_update_timestamp",
+        ):
+            setattr(base, attr, getattr(inner, attr))
+        base.is_buy = inner.is_buy
+        base.track_volume = bool(base.track_volume) or bool(inner.track_volume)
+        base.mayhem_mode = bool(base.mayhem_mode) or bool(inner.mayhem_mode)
+        if inner.ix_name:
+            base.ix_name = inner.ix_name
+        base.is_cashback_coin = bool(base.is_cashback_coin) or bool(inner.is_cashback_coin)
+    else:
+        for attr in (
+            "fee",
+            "creator_fee",
+            "fee_basis_points",
+            "creator_fee_basis_points",
+            "virtual_sol_reserves",
+            "virtual_token_reserves",
+            "real_sol_reserves",
+            "real_token_reserves",
+            "total_unclaimed_tokens",
+            "total_claimed_tokens",
+            "current_sol_volume",
+            "timestamp",
+            "last_update_timestamp",
+        ):
+            _put_num_if_nonzero(base, attr, inner)
+        base.track_volume = bool(base.track_volume) or bool(inner.track_volume)
+        base.mayhem_mode = bool(base.mayhem_mode) or bool(inner.mayhem_mode)
+        if inner.ix_name:
+            base.ix_name = inner.ix_name
+        base.is_cashback_coin = bool(base.is_cashback_coin) or bool(inner.is_cashback_coin)
+
+    for attr in (
+        "cashback_fee_basis_points",
+        "cashback",
+        "buyback_fee_basis_points",
+        "buyback_fee",
+        "quote_amount",
+        "virtual_quote_reserves",
+        "real_quote_reserves",
+        "amount",
+        "max_sol_cost",
+        "min_sol_output",
+        "spendable_sol_in",
+        "spendable_quote_in",
+        "min_tokens_out",
+    ):
+        _put_num_if_nonzero(base, attr, inner)
+
+    if inner.shareholders and not base.shareholders:
         base.shareholders = inner.shareholders
-    if not _empty(inner.quote_mint):
-        base.quote_mint = inner.quote_mint
-    if inner.quote_amount != 0:
-        base.quote_amount = inner.quote_amount
-    if inner.virtual_quote_reserves != 0:
-        base.virtual_quote_reserves = inner.virtual_quote_reserves
-    if inner.real_quote_reserves != 0:
-        base.real_quote_reserves = inner.real_quote_reserves
-    base.is_cashback_coin = inner.is_cashback_coin
+
+    for attr in (
+        "quote_mint",
+        "global_account",
+        "bonding_curve",
+        "bonding_curve_v2",
+        "associated_bonding_curve",
+        "associated_user",
+        "system_program",
+        "token_program",
+        "quote_token_program",
+        "associated_token_program",
+        "creator_vault",
+        "associated_quote_fee_recipient",
+        "buyback_fee_recipient",
+        "associated_quote_buyback_fee_recipient",
+        "associated_quote_bonding_curve",
+        "associated_quote_user",
+        "associated_creator_vault",
+        "sharing_config",
+        "event_authority",
+        "program",
+        "global_volume_accumulator",
+        "user_volume_accumulator",
+        "associated_user_volume_accumulator",
+        "fee_config",
+        "fee_program",
+        "extra_instruction_account",
+    ):
+        _put_attr_if_set(base, attr, inner)
+
+    base.is_created_buy = bool(base.is_created_buy) or bool(inner.is_created_buy)
 
 
 def merge_pumpswap_buy(base: PumpSwapBuyEvent, inner: PumpSwapBuyEvent) -> None:
@@ -199,7 +274,6 @@ def merge_dex_events(base: DexEvent, inner: DexEvent) -> None:
             EventType.PUMP_FUN_BUY_EXACT_SOL_IN,
         ):
             merge_pumpfun_trade(bd, ind)
-            base.type = inner.type
         return
 
     if isinstance(bd, PumpFunCreateEvent) and isinstance(ind, PumpFunCreateEvent):

sol_parser/parser.py

@@ -8,10 +8,16 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
 from .dex_parsers import (
     DexEvent,
+    PUMPFUN_PROGRAM_ID,
+    PUMP_TRADE,
     apply_event_type_filter,
     dispatch_program_data,
     event_type_for_discriminator,
+    event_type_for_program_discriminator,
     filter_allows_unknown_log_event,
+    filter_allows_unscoped_discriminator,
+    filter_includes_program,
+    filter_wants_pumpfun_trade,
     parse_trade_from_data,
 )
 
@@ -30,13 +36,11 @@ def decode_program_data_line(log: str) -> Optional[bytes]:
     if i < 0:
         return None
     s = log[i + len(p) :].strip()
-    if len(s) > 2700:
-        return None
     try:
         raw = base64.standard_b64decode(s)
     except Exception:
         return None
-    if len(raw) < 8 or len(raw) > 2048:
+    if len(raw) < 8:
         return None
     return raw
 
@@ -71,6 +75,7 @@ def parse_log_optimized(
     event_type_filter: Any = None,
     is_created_buy: bool = False,
     recent_blockhash: str = "",
+    program_id: Optional[str] = None,
 ) -> Optional[DexEvent]:
     """单次 base64 decode 后按 discriminator 做 early filter，再按实际事件类型二次过滤。"""
     grpc = int(time.time() * 1_000_000) if grpc_recv_us is None else grpc_recv_us
@@ -79,20 +84,103 @@ def parse_log_optimized(
         return None
     disc = _disc8(buf[:8])
     if event_type_filter is not None:
-        event_type = event_type_for_discriminator(disc)
-        if event_type is not None:
+        is_unscoped_shared_discriminator = program_id is None and disc in (
+            _disc8(bytes([189, 219, 127, 211, 78, 230, 97, 238])),
+            _disc8(bytes([143, 190, 90, 218, 196, 30, 51, 222])),
+        )
+        event_type = event_type_for_program_discriminator(program_id, disc)
+        if is_unscoped_shared_discriminator:
+            if not filter_allows_unscoped_discriminator(event_type_filter, disc):
+                return None
+        elif program_id == PUMPFUN_PROGRAM_ID and disc == PUMP_TRADE:
+            if not filter_wants_pumpfun_trade(event_type_filter):
+                return None
+        elif event_type is not None:
             if not event_type_filter.should_include(event_type):
                 return None
-        elif not filter_allows_unknown_log_event(event_type_filter):
+        elif program_id:
+            if not filter_includes_program(event_type_filter, program_id):
+                return None
+        elif not filter_allows_unscoped_discriminator(event_type_filter, disc):
             return None
     data = buf[8:]
     meta = _meta(signature, slot, tx_index, block_time_us, grpc, recent_blockhash)
     return apply_event_type_filter(
-        dispatch_program_data(disc, data, buf, meta, is_created_buy),
+        dispatch_program_data(
+            disc,
+            data,
+            buf,
+            meta,
+            is_created_buy,
+            program_id,
+            event_type_filter,
+        ),
+        event_type_filter,
+    )
+
+
+def parse_log_optimized_with_program_id(
+    log: str,
+    signature: str,
+    slot: int,
+    tx_index: int = 0,
+    block_time_us: Optional[int] = None,
+    grpc_recv_us: Optional[int] = None,
+    event_type_filter: Any = None,
+    is_created_buy: bool = False,
+    recent_blockhash: str = "",
+    program_id: Optional[str] = None,
+) -> Optional[DexEvent]:
+    return parse_log_optimized(
+        log,
+        signature,
+        slot,
+        tx_index,
+        block_time_us,
+        grpc_recv_us,
         event_type_filter,
+        is_created_buy,
+        recent_blockhash,
+        program_id,
     )
 
 
+def parse_invoke_info(log: str) -> Optional[tuple[str, int]]:
+    prefix = "Program "
+    start = log.find(prefix)
+    if start < 0:
+        return None
+    marker = " invoke ["
+    mid = log.find(marker, start + len(prefix))
+    if mid < 0:
+        return None
+    end = log.find("]", mid + len(marker))
+    if end < 0:
+        return None
+    program_id = log[start + len(prefix):mid]
+    try:
+        depth = int(log[mid + len(marker):end])
+    except ValueError:
+        return None
+    if not program_id or depth <= 0:
+        return None
+    return program_id, depth
+
+
+def parse_program_complete_info(log: str) -> Optional[str]:
+    prefix = "Program "
+    start = log.find(prefix)
+    if start < 0:
+        return None
+    success = log.find(" success", start + len(prefix))
+    if success >= 0:
+        return log[start + len(prefix):success]
+    failed = log.find(" failed:", start + len(prefix))
+    if failed >= 0:
+        return log[start + len(prefix):failed]
+    return None
+
+
 def parse_log_unified(
     log: str,
     signature: str,

sol_parser/pumpfun_fee_enrich.py

@@ -82,7 +82,18 @@ def enrich_create_v2_from_create_events(events: List[DexEvent]) -> None:
         if c is None:
             continue
 
-        for attr in ("name", "symbol", "uri", "bonding_curve", "user", "creator", "token_program", "quote_mint"):
+        for attr in (
+            "name",
+            "symbol",
+            "uri",
+            "bonding_curve",
+            "user",
+            "creator",
+            "token_program",
+            "quote_mint",
+            "quote_vault",
+            "quote_token_program",
+        ):
             _fill_str_if_empty(c2, attr, getattr(c, attr))
         for attr in (
             "timestamp",

sol_parser/rpc_parser.py

@@ -8,9 +8,10 @@ from dataclasses import dataclass
 
 import base58
 
-from .dex_parsers import DexEvent, dispatch_program_data, parse_trade_from_data
-from .grpc_types import EventTypeFilter, EventType, IncludeOnlyFilter
-from .instructions import parse_instruction_unified
+from .dex_parsers import DexEvent
+from .grpc_types import EventTypeFilter, EventType, event_type_filter_allows_instruction_parsing
+from .inner_instruction_parser import parse_inner_instruction
+from .instructions import parse_inner_compiled_instruction_if_supported, parse_instruction_unified
 from .log_instr_dedup import dedupe_log_instruction_events
 from .pumpfun_fee_enrich import enrich_pumpfun_same_tx_post_merge
 
@@ -112,6 +113,31 @@ class RpcTransactionResponse:
     transaction_index: int = 0
 
 
+def _merge_rpc_full_account_keys(
+    account_keys: List[str],
+    meta: Optional[RpcTransactionMeta],
+) -> List[str]:
+    """Merge static keys with ALT loaded writable + readonly keys in Solana runtime order."""
+    if meta is None or meta.loaded_addresses is None:
+        return list(account_keys)
+    return [
+        *account_keys,
+        *meta.loaded_addresses.writable,
+        *meta.loaded_addresses.readonly,
+    ]
+
+
+def _should_parse_rpc_instructions(filter: Optional[EventTypeFilter]) -> bool:
+    if filter is None:
+        return True
+    include_only = getattr(filter, "include_only", None)
+    if include_only is None:
+        return True
+    if not include_only:
+        return False
+    return event_type_filter_allows_instruction_parsing(list(include_only))
+
+
 class RpcClient:
     """RPC 客户端接口"""
     def get_transaction(
@@ -185,51 +211,75 @@ def parse_rpc_transaction(
         )
 
     slot = tx.slot
-    block_time_us = tx.block_time * 1_000_000 if tx.block_time else None
+    block_time_us = tx.block_time * 1_000_000 if tx.block_time is not None else None
     block_tx_index = int(getattr(tx, "transaction_index", 0) or 0)
+    full_account_keys = _merge_rpc_full_account_keys(msg.account_keys, meta)
 
-    instruction_events: List[DexEvent] = []
-
-    # 解析外层指令
-    for i, ix in enumerate(msg.instructions):
-        ev = _parse_rpc_instruction(
-            ix,
-            msg.account_keys,
-            signature,
-            slot,
-            block_tx_index,
-            block_time_us,
-            grpc_recv_us,
-            filter,
-        )
-        if ev:
-            instruction_events.append(ev)
+    indexed_instruction_events: List[Tuple[int, Optional[int], DexEvent]] = []
+    from .grpc_instruction_parser import (
+        detect_pumpfun_create_from_logs,
+        merge_instruction_events,
+    )
+    has_pumpfun_create_log = detect_pumpfun_create_from_logs(list(meta.log_messages))
 
-    # 解析内层指令
-    for group in meta.inner_instructions:
-        for ix in group.instructions:
+    if _should_parse_rpc_instructions(filter):
+        # 解析外层指令
+        for outer_idx, ix in enumerate(msg.instructions):
             ev = _parse_rpc_instruction(
                 ix,
-                msg.account_keys,
+                full_account_keys,
                 signature,
                 slot,
                 block_tx_index,
                 block_time_us,
                 grpc_recv_us,
                 filter,
+                inner=False,
+                is_created_buy=has_pumpfun_create_log,
             )
             if ev:
-                instruction_events.append(ev)
+                indexed_instruction_events.append((outer_idx, None, ev))
+
+        # 解析内层指令
+        for group in meta.inner_instructions:
+            for inner_idx, ix in enumerate(group.instructions):
+                ev = _parse_rpc_instruction(
+                    ix,
+                    full_account_keys,
+                    signature,
+                    slot,
+                    block_tx_index,
+                    block_time_us,
+                    grpc_recv_us,
+                    filter,
+                    inner=True,
+                    is_created_buy=has_pumpfun_create_log,
+                )
+                if ev:
+                    indexed_instruction_events.append((int(group.index), inner_idx, ev))
+
+    instruction_events = merge_instruction_events(indexed_instruction_events)
+    enrich_pumpfun_same_tx_post_merge(instruction_events)
+    if msg.recent_blockhash:
+        for ev in instruction_events:
+            if hasattr(ev.data, "metadata"):
+                ev.data.metadata.recent_blockhash = msg.recent_blockhash
 
     # 解析日志
-    is_created_buy = False
     recent_blockhash = msg.recent_blockhash
     log_events: List[DexEvent] = []
 
-    from .parser import parse_log_optimized
+    from .parser import parse_invoke_info, parse_log_optimized_with_program_id, parse_program_complete_info
 
+    active_program_stack: List[str] = []
     for log in meta.log_messages:
-        ev = parse_log_optimized(
+        invoke = parse_invoke_info(log)
+        if invoke is not None:
+            program_id, depth = invoke
+            del active_program_stack[max(0, depth - 1):]
+            active_program_stack.append(program_id)
+
+        ev = parse_log_optimized_with_program_id(
             log,
             signature,
             slot,
@@ -237,14 +287,20 @@ def parse_rpc_transaction(
             block_time_us,
             grpc_recv_us,
             filter,
-            is_created_buy,
+            has_pumpfun_create_log,
             recent_blockhash,
+            active_program_stack[-1] if active_program_stack else None,
         )
         if ev:
-            if ev.type in (EventType.PUMP_FUN_CREATE, EventType.PUMP_FUN_CREATE_V2):
-                is_created_buy = True
             log_events.append(ev)
 
+        completed = parse_program_complete_info(log)
+        if completed is not None:
+            for i in range(len(active_program_stack) - 1, -1, -1):
+                if active_program_stack[i] == completed:
+                    del active_program_stack[i:]
+                    break
+
     tx_pb, meta_pb = rpc_response_to_solana_storage(tx)
     if tx_pb is not None and meta_pb is not None:
         from .grpc_instruction_parser import apply_account_fill_to_events
@@ -273,6 +329,8 @@ def _parse_rpc_instruction(
     block_time_us: Optional[int],
     grpc_recv_us: int,
     filter: Optional[EventTypeFilter],
+    inner: bool = False,
+    is_created_buy: bool = False,
 ) -> Optional[DexEvent]:
     """解析 RPC 指令"""
     # 获取程序 ID
@@ -292,9 +350,37 @@ def _parse_rpc_instruction(
         if acc_idx < len(account_keys):
             accounts.append(account_keys[acc_idx])
 
-    f: EventTypeFilter = filter if filter is not None else IncludeOnlyFilter([])
+    if inner:
+        ev = parse_inner_compiled_instruction_if_supported(
+            data,
+            accounts,
+            signature,
+            slot,
+            tx_index,
+            block_time_us,
+            grpc_recv_us,
+            filter,
+            program_id,
+        )
+        if ev:
+            return ev
+        return parse_inner_instruction(
+            data,
+            program_id,
+            {
+                "signature": signature,
+                "slot": slot,
+                "tx_index": tx_index,
+                "block_time_us": 0 if block_time_us is None else block_time_us,
+                "grpc_recv_us": grpc_recv_us,
+                "recent_blockhash": "",
+            },
+            filter,
+            is_created_buy,
+        )
+
     return parse_instruction_unified(
-        data, accounts, signature, slot, tx_index, block_time_us, grpc_recv_us, f, program_id
+        data, accounts, signature, slot, tx_index, block_time_us, grpc_recv_us, filter, program_id
     )
 
 

sol_parser/shredstream_client.py

@@ -18,7 +18,11 @@ import grpc
 from .entries_decode import decode_entries_bincode_flat
 from .event_types import DexEvent
 from .dex_parsers import Z
-from .grpc_types import EventTypeFilter, event_type_filter_includes_pumpfun
+from .grpc_types import (
+    EventTypeFilter,
+    event_type_filter_allows_instruction_parsing,
+    event_type_filter_includes_pumpfun,
+)
 from .instructions import (
     METEORA_DAMM_V2_PROGRAM_ID,
     METEORA_DLMM_PROGRAM_ID,
@@ -118,6 +122,17 @@ def _filter_parsed_event(ev: Optional[DexEvent], filter: Optional[EventTypeFilte
     return ev if filter.should_include(ev.type) else None
 
 
+def _should_parse_shred_instructions(filter: Optional[EventTypeFilter]) -> bool:
+    if filter is None:
+        return True
+    include_only = getattr(filter, "include_only", None)
+    if include_only is None:
+        return True
+    if not include_only:
+        return False
+    return event_type_filter_allows_instruction_parsing(list(include_only))
+
+
 def _events_from_versioned_tx_wire(
     raw: bytes,
     signature: str,
@@ -126,6 +141,9 @@ def _events_from_versioned_tx_wire(
     recv_us: int,
     filter: Optional[EventTypeFilter],
 ) -> List[DexEvent]:
+    if not _should_parse_shred_instructions(filter):
+        return []
+
     try:
         from solders.message import Message as LegacyMessage  # type: ignore
         from solders.message import MessageV0  # type: ignore

{sol_parser_sdk_python-0.5.5.dist-info → sol_parser_sdk_python-0.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sol-parser-sdk-python
-Version: 0.5.5
+Version: 0.5.7
 Summary: Solana DEX program log parsing (pure Python, API aligned with sol-parser-sdk)
 Requires-Python: >=3.10
 Requires-Dist: base58>=2.0
@@ -67,6 +67,14 @@ Description-Content-Type: text/markdown
 
 ## Release notes
 
+### v0.5.6
+
+- Adds Meteora DBC log parsing with program-context routing and filter parity.
+- Adds Raydium CLMM/CPMM and Orca account parsers and exports.
+- Fixes default no-filter RPC/Yellowstone instruction parsing so it no longer behaves like an empty include-only filter.
+- Merges RPC ALT loaded writable/readonly keys into the full instruction account table.
+- Skips ShredStream/RPC instruction parsing early for account-only or empty include-only filters.
+
 ### v0.5.5
 
 - Aligns ShredStream parsing with Rust/Node.js/Go for low-latency static-account paths.
@@ -84,7 +92,7 @@ Description-Content-Type: text/markdown
 **From PyPI**
 
 ```bash
-pip install sol-parser-sdk-python==0.5.5
+pip install sol-parser-sdk-python==0.5.7
 ```
 
 **From source**