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

sol_parser/rust_event_json.py

@@ -0,0 +1,50 @@
+"""将 Rust ``serde_json`` 输出的 DexEvent 列表规范化为 Python ``legacy_dict_to_dex_event`` 可消费的 dict。"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+import base58
+
+from .event_types import DexEvent, legacy_dict_to_dex_event
+
+
+def normalize_rust_json_value(v: Any) -> Any:
+    """递归：Solana pubkey/signature 的 byte 数组 → base58 字符串。"""
+    if isinstance(v, list) and v and all(isinstance(x, int) for x in v):
+        if len(v) in (32, 64):
+            try:
+                return base58.b58encode(bytes(v)).decode("ascii")
+            except Exception:
+                return v
+    if isinstance(v, dict):
+        return {k: normalize_rust_json_value(x) for k, x in v.items()}
+    if isinstance(v, list):
+        return [normalize_rust_json_value(x) for x in v]
+    return v
+
+
+def dex_events_from_rust_json_str(s: str) -> List[DexEvent]:
+    """解析 native 扩展返回的 JSON 数组为 ``List[DexEvent]``。"""
+    raw = json.loads(s)
+    if not isinstance(raw, list):
+        return []
+    out: List[DexEvent] = []
+    for item in raw:
+        if not isinstance(item, dict) or len(item) != 1:
+            continue
+        norm = normalize_rust_json_value(item)
+        ev = legacy_dict_to_dex_event(norm)
+        if ev is not None:
+            out.append(ev)
+    return out
+
+
+def dex_event_from_log_rust_json_str(s: str) -> Optional[DexEvent]:
+    """单条日志事件 JSON → ``DexEvent``。"""
+    d = json.loads(s)
+    if not isinstance(d, dict):
+        return None
+    norm = normalize_rust_json_value(d)
+    return legacy_dict_to_dex_event(norm)

sol_parser/shredstream_client.py

@@ -0,0 +1,191 @@
+"""ShredStream gRPC 客户端：SubscribeEntries + bincode 解码 + PumpFun 外层指令（对齐 Node ``shredstream/client.ts`` 子集）。
+
+限制：与 Rust 文档一致——不解析 inner CPI 日志、不解析 ALT 展开；需安装 ``solders``（``pip install 'sol-parser-sdk-python[shredstream]'``）。
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Callable, Generator, List, Optional
+from urllib.parse import urlparse
+
+import base58
+import grpc
+
+from .entries_decode import decode_entries_bincode_flat
+from .event_types import DexEvent
+from .grpc_types import EventTypeFilter, IncludeOnlyFilter
+from .instructions import PUMPFUN_PROGRAM_ID, parse_instruction_unified
+from .pumpfun_fee_enrich import enrich_pumpfun_same_tx_post_merge
+from .shredstream_pumpfun import detect_pumpfun_create_mints, parse_pumpfun_shred_ix
+from .shredstream_pb2 import SubscribeEntriesRequest
+from .shredstream_pb2_grpc import ShredstreamProxyStub
+
+
+@dataclass
+class ShredStreamConfig:
+    """对齐 Rust ``shredstream::config::ShredStreamConfig``。"""
+
+    connection_timeout_ms: int = 8000
+    request_timeout_ms: int = 15000
+    max_decoding_message_size: int = 100 * 1024 * 1024
+    reconnect_delay_ms: int = 1000
+    max_reconnect_attempts: int = 3
+
+    @staticmethod
+    def low_latency() -> ShredStreamConfig:
+        return ShredStreamConfig(
+            connection_timeout_ms=5000,
+            request_timeout_ms=10000,
+            max_decoding_message_size=50 * 1024 * 1024,
+            reconnect_delay_ms=100,
+            max_reconnect_attempts=1,
+        )
+
+    @staticmethod
+    def high_throughput() -> ShredStreamConfig:
+        return ShredStreamConfig(
+            connection_timeout_ms=10000,
+            request_timeout_ms=30000,
+            max_decoding_message_size=200 * 1024 * 1024,
+            reconnect_delay_ms=2000,
+            max_reconnect_attempts=5,
+        )
+
+
+def _parsed_endpoint(endpoint: str) -> tuple[str, str]:
+    if "://" not in endpoint:
+        endpoint = "http://" + endpoint
+    p = urlparse(endpoint)
+    return p.scheme, p.netloc or endpoint
+
+
+def _ix_accounts_bytes(account_indices: object) -> bytes:
+    if isinstance(account_indices, (bytes, bytearray, memoryview)):
+        return bytes(account_indices)
+    return bytes(list(account_indices))
+
+
+def _events_from_versioned_tx_wire(
+    raw: bytes,
+    signature: str,
+    slot: int,
+    tx_index: int,
+    recv_us: int,
+    filter: EventTypeFilter,
+) -> List[DexEvent]:
+    try:
+        from solders.message import Message as LegacyMessage  # type: ignore
+        from solders.message import MessageV0  # type: ignore
+        from solders.transaction import VersionedTransaction  # type: ignore
+    except ImportError:
+        return []
+
+    vt = VersionedTransaction.from_bytes(raw)
+    if not vt.signatures:
+        return []
+    sig = signature or base58.b58encode(bytes(vt.signatures[0])).decode("ascii")
+    msg = vt.message
+    out: List[DexEvent] = []
+
+    if isinstance(msg, MessageV0):
+        keys = [str(k) for k in msg.account_keys]
+        ixs: List[tuple] = []
+        for cix in msg.compiled_instructions:
+            pid = keys[cix.program_id_index]
+            ixs.append((pid, bytes(cix.data), _ix_accounts_bytes(cix.accounts)))
+    elif isinstance(msg, LegacyMessage):
+        keys = [str(k) for k in msg.account_keys]
+        ixs = []
+        for ix in msg.instructions:
+            pid = keys[ix.program_id_index]
+            ixs.append((pid, bytes(ix.data), _ix_accounts_bytes(ix.accounts)))
+    else:
+        return []
+
+    created: set = set()
+    mayhem: set = set()
+    for pid, data, ix_acc in ixs:
+        c, m = detect_pumpfun_create_mints(pid, data, ix_acc, keys)
+        created |= c
+        mayhem |= m
+
+    for pid, data, ix_acc in ixs:
+        idxs = list(ix_acc)
+        accounts = [keys[i] for i in idxs if i < len(keys)]
+        if pid == PUMPFUN_PROGRAM_ID:
+            ev = parse_pumpfun_shred_ix(
+                data, keys, ix_acc, pid, sig, slot, tx_index, recv_us, created, mayhem
+            )
+            if ev:
+                out.append(ev)
+            continue
+        ev = parse_instruction_unified(
+            bytes(data), accounts, sig, slot, tx_index, None, recv_us, filter, pid
+        )
+        if ev:
+            out.append(ev)
+
+    for ev in out:
+        if hasattr(ev.data, "metadata"):
+            ev.data.metadata.grpc_recv_us = recv_us
+    enrich_pumpfun_same_tx_post_merge(out)
+    return out
+
+
+class ShredStreamClient:
+    """阻塞式 gRPC 客户端（可在 asyncio 中用 ``asyncio.to_thread`` 包装）。"""
+
+    def __init__(self, endpoint: str, config: Optional[ShredStreamConfig] = None):
+        self.endpoint = endpoint
+        self.config = config or ShredStreamConfig()
+
+    @classmethod
+    def new_with_config(cls, endpoint: str, config: ShredStreamConfig) -> ShredStreamClient:
+        """对齐 Rust ``ShredStreamClient::new_with_config``。"""
+        return cls(endpoint, config)
+
+    def iter_dex_events(
+        self,
+        filter: Optional[EventTypeFilter] = None,
+        on_error: Optional[Callable[[Exception], None]] = None,
+    ) -> Generator[DexEvent, None, None]:
+        """订阅 ``SubscribeEntries``，解码每笔线交易中的 PumpFun 外层指令事件。"""
+        f: EventTypeFilter = filter if filter is not None else IncludeOnlyFilter([])
+        scheme, target = _parsed_endpoint(self.endpoint)
+        opts = [
+            ("grpc.max_receive_message_length", self.config.max_decoding_message_size),
+            ("grpc.max_send_message_length", self.config.max_decoding_message_size),
+        ]
+        if scheme == "https":
+            channel = grpc.secure_channel(
+                target, grpc.ssl_channel_credentials(), options=opts
+            )
+        else:
+            channel = grpc.insecure_channel(target, options=opts)
+        stub = ShredstreamProxyStub(channel)
+        recv_us = int(time.time() * 1_000_000)
+        tx_counter = 0
+        try:
+            for entry in stub.SubscribeEntries(SubscribeEntriesRequest()):
+                slot = entry.slot
+                try:
+                    raws = decode_entries_bincode_flat(bytes(entry.entries))
+                except Exception as e:
+                    if on_error:
+                        on_error(e)
+                    continue
+                for raw in raws:
+                    sig0 = ""
+                    try:
+                        from solders.transaction import VersionedTransaction  # type: ignore
+
+                        sig0 = base58.b58encode(bytes(VersionedTransaction.from_bytes(raw).signatures[0])).decode("ascii")
+                    except Exception:
+                        pass
+                    for ev in _events_from_versioned_tx_wire(raw, sig0, slot, tx_counter, recv_us, f):
+                        yield ev
+                    tx_counter += 1
+        finally:
+            channel.close()

sol_parser/shredstream_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: shredstream.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    'shredstream.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x11shredstream.proto\x12\x0bshredstream\"\x19\n\x17SubscribeEntriesRequest\"&\n\x05\x45ntry\x12\x0c\n\x04slot\x18\x01 \x01(\x04\x12\x0f\n\x07\x65ntries\x18\x02 \x01(\x0c\x32\x62\n\x10ShredstreamProxy\x12N\n\x10SubscribeEntries\x12$.shredstream.SubscribeEntriesRequest\x1a\x12.shredstream.Entry0\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'shredstream_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_SUBSCRIBEENTRIESREQUEST']._serialized_start=34
+  _globals['_SUBSCRIBEENTRIESREQUEST']._serialized_end=59
+  _globals['_ENTRY']._serialized_start=61
+  _globals['_ENTRY']._serialized_end=99
+  _globals['_SHREDSTREAMPROXY']._serialized_start=101
+  _globals['_SHREDSTREAMPROXY']._serialized_end=199
+# @@protoc_insertion_point(module_scope)

sol_parser/shredstream_pb2_grpc.py

@@ -0,0 +1,81 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import shredstream_pb2 as shredstream__pb2
+
+
+class ShredstreamProxyStub(object):
+    """与 Rust `shredstream/proto/mod.rs` 内嵌定义一致；路径 /shredstream.ShredstreamProxy/SubscribeEntries
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.SubscribeEntries = channel.unary_stream(
+                '/shredstream.ShredstreamProxy/SubscribeEntries',
+                request_serializer=shredstream__pb2.SubscribeEntriesRequest.SerializeToString,
+                response_deserializer=shredstream__pb2.Entry.FromString,
+                _registered_method=True)
+
+
+class ShredstreamProxyServicer(object):
+    """与 Rust `shredstream/proto/mod.rs` 内嵌定义一致；路径 /shredstream.ShredstreamProxy/SubscribeEntries
+    """
+
+    def SubscribeEntries(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_ShredstreamProxyServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'SubscribeEntries': grpc.unary_stream_rpc_method_handler(
+                    servicer.SubscribeEntries,
+                    request_deserializer=shredstream__pb2.SubscribeEntriesRequest.FromString,
+                    response_serializer=shredstream__pb2.Entry.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'shredstream.ShredstreamProxy', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('shredstream.ShredstreamProxy', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class ShredstreamProxy(object):
+    """与 Rust `shredstream/proto/mod.rs` 内嵌定义一致；路径 /shredstream.ShredstreamProxy/SubscribeEntries
+    """
+
+    @staticmethod
+    def SubscribeEntries(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/shredstream.ShredstreamProxy/SubscribeEntries',
+            shredstream__pb2.SubscribeEntriesRequest.SerializeToString,
+            shredstream__pb2.Entry.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

sol_parser/shredstream_pumpfun.py

@@ -0,0 +1,296 @@
+"""ShredStream 路径下的 PumpFun 外层指令：mint 检测与 Buy/Sell/BuyExactSolIn（对齐 Rust ``shredstream/client``）。"""
+
+from __future__ import annotations
+
+import struct
+from typing import List, Set, Tuple
+
+from .event_types import DexEvent, PumpFunTradeEvent
+from .grpc_types import EventMetadata, EventType
+from .instructions import PUMPFUN_PROGRAM_ID, parse_pumpfun_instruction
+
+_DISC_CREATE = bytes([24, 30, 200, 40, 5, 28, 7, 119])
+_DISC_CREATE_V2 = bytes([214, 144, 76, 236, 95, 139, 49, 180])
+_DISC_BUY = bytes([102, 6, 61, 18, 1, 218, 235, 234])
+_DISC_SELL = bytes([51, 230, 133, 164, 1, 127, 131, 173])
+_DISC_BUY_EXACT_SOL_IN = bytes([56, 252, 116, 8, 158, 223, 205, 95])
+_DISC_BUY_V2 = bytes([184, 23, 238, 97, 103, 197, 211, 61])
+_DISC_SELL_V2 = bytes([93, 246, 130, 60, 231, 233, 64, 178])
+_DISC_BUY_EXACT_QUOTE_IN_V2 = bytes([194, 171, 28, 70, 104, 77, 91, 47])
+
+
+def _get_acct(accounts: List[str], ix_accounts: bytes, idx: int) -> str:
+    if idx >= len(ix_accounts):
+        return ""
+    ai = ix_accounts[idx]
+    if ai >= len(accounts):
+        return ""
+    return accounts[ai]
+
+
+def _parse_create_v2_mayhem(data_after_disc: bytes) -> bool:
+    o = 0
+    for _ in range(3):
+        if len(data_after_disc) < o + 4:
+            return False
+        (ln,) = struct.unpack_from("<I", data_after_disc, o)
+        o += 4 + int(ln)
+    if len(data_after_disc) < o + 32 + 1:
+        return False
+    o += 32
+    return data_after_disc[o] != 0
+
+
+def detect_pumpfun_create_mints(
+    program_id: str,
+    data: bytes,
+    ix_accounts: bytes,
+    accounts: List[str],
+) -> Tuple[Set[str], Set[str]]:
+    """返回 ``(created_mints, mayhem_mints)``。"""
+    created: Set[str] = set()
+    mayhem: Set[str] = set()
+    if program_id != PUMPFUN_PROGRAM_ID or len(data) < 8:
+        return created, mayhem
+    disc = data[:8]
+    if disc == _DISC_CREATE or disc == _DISC_CREATE_V2:
+        if not ix_accounts:
+            return created, mayhem
+        mint = _get_acct(accounts, ix_accounts, 0)
+        if mint:
+            created.add(mint)
+        if disc == _DISC_CREATE_V2:
+            if _parse_create_v2_mayhem(data[8:]):
+                mayhem.add(mint)
+    return created, mayhem
+
+
+def _meta(sig: str, slot: int, tx_index: int, recv_us: int) -> EventMetadata:
+    return EventMetadata(
+        signature=sig,
+        slot=slot,
+        tx_index=tx_index,
+        block_time_us=0,
+        grpc_recv_us=recv_us,
+    )
+
+
+def _token_program_default(tp: str) -> str:
+    if not tp or tp == "11111111111111111111111111111111":
+        return "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+    return tp
+
+
+def parse_pumpfun_buy(
+    data: bytes,
+    accounts: List[str],
+    ix_accounts: bytes,
+    sig: str,
+    slot: int,
+    tx_index: int,
+    recv_us: int,
+    created_mints: Set[str],
+    mayhem_mints: Set[str],
+) -> DexEvent | None:
+    if len(ix_accounts) < 7 or len(data) < 8:
+        return None
+    payload = data[8:]
+    ta = struct.unpack_from("<Q", payload, 0)[0] if len(payload) >= 8 else 0
+    sa = struct.unpack_from("<Q", payload, 8)[0] if len(payload) >= 16 else 0
+    mint = _get_acct(accounts, ix_accounts, 2)
+    if not mint:
+        return None
+    m = _meta(sig, slot, tx_index, recv_us)
+    return DexEvent(
+        type=EventType.PUMP_FUN_TRADE,
+        data=PumpFunTradeEvent(
+            metadata=m,
+            mint=mint,
+            bonding_curve=_get_acct(accounts, ix_accounts, 3),
+            user=_get_acct(accounts, ix_accounts, 6),
+            sol_amount=sa,
+            token_amount=ta,
+            fee_recipient=_get_acct(accounts, ix_accounts, 1),
+            is_buy=True,
+            is_created_buy=mint in created_mints,
+            ix_name="buy",
+            mayhem_mode=mint in mayhem_mints,
+            associated_bonding_curve=_get_acct(accounts, ix_accounts, 4),
+            token_program=_token_program_default(_get_acct(accounts, ix_accounts, 8)),
+            creator_vault=_get_acct(accounts, ix_accounts, 9),
+        ),
+    )
+
+
+def parse_pumpfun_sell(
+    data: bytes,
+    accounts: List[str],
+    ix_accounts: bytes,
+    sig: str,
+    slot: int,
+    tx_index: int,
+    recv_us: int,
+) -> DexEvent | None:
+    if len(ix_accounts) < 7 or len(data) < 8:
+        return None
+    payload = data[8:]
+    ta = struct.unpack_from("<Q", payload, 0)[0] if len(payload) >= 8 else 0
+    sa = struct.unpack_from("<Q", payload, 8)[0] if len(payload) >= 16 else 0
+    mint = _get_acct(accounts, ix_accounts, 2)
+    if not mint:
+        return None
+    m = _meta(sig, slot, tx_index, recv_us)
+    return DexEvent(
+        type=EventType.PUMP_FUN_TRADE,
+        data=PumpFunTradeEvent(
+            metadata=m,
+            mint=mint,
+            bonding_curve=_get_acct(accounts, ix_accounts, 3),
+            user=_get_acct(accounts, ix_accounts, 6),
+            sol_amount=sa,
+            token_amount=ta,
+            fee_recipient=_get_acct(accounts, ix_accounts, 1),
+            is_buy=False,
+            is_created_buy=False,
+            ix_name="sell",
+            associated_bonding_curve=_get_acct(accounts, ix_accounts, 4),
+            token_program=_token_program_default(_get_acct(accounts, ix_accounts, 9)),
+            creator_vault=_get_acct(accounts, ix_accounts, 8),
+        ),
+    )
+
+
+def parse_pumpfun_buy_exact_sol_in(
+    data: bytes,
+    accounts: List[str],
+    ix_accounts: bytes,
+    sig: str,
+    slot: int,
+    tx_index: int,
+    recv_us: int,
+    created_mints: Set[str],
+    mayhem_mints: Set[str],
+) -> DexEvent | None:
+    if len(ix_accounts) < 7 or len(data) < 8:
+        return None
+    payload = data[8:]
+    sa = struct.unpack_from("<Q", payload, 0)[0] if len(payload) >= 8 else 0
+    ta = struct.unpack_from("<Q", payload, 8)[0] if len(payload) >= 16 else 0
+    mint = _get_acct(accounts, ix_accounts, 2)
+    if not mint:
+        return None
+    m = _meta(sig, slot, tx_index, recv_us)
+    return DexEvent(
+        type=EventType.PUMP_FUN_TRADE,
+        data=PumpFunTradeEvent(
+            metadata=m,
+            mint=mint,
+            bonding_curve=_get_acct(accounts, ix_accounts, 3),
+            user=_get_acct(accounts, ix_accounts, 6),
+            sol_amount=sa,
+            token_amount=ta,
+            fee_recipient=_get_acct(accounts, ix_accounts, 1),
+            is_buy=True,
+            is_created_buy=mint in created_mints,
+            ix_name="buy_exact_sol_in",
+            mayhem_mode=mint in mayhem_mints,
+            associated_bonding_curve=_get_acct(accounts, ix_accounts, 4),
+            token_program=_token_program_default(_get_acct(accounts, ix_accounts, 8)),
+            creator_vault=_get_acct(accounts, ix_accounts, 9),
+        ),
+    )
+
+
+def parse_pumpfun_trade_v2(
+    ix_name: str,
+    data: bytes,
+    accounts: List[str],
+    ix_accounts: bytes,
+    sig: str,
+    slot: int,
+    tx_index: int,
+    recv_us: int,
+    created_mints: Set[str],
+    mayhem_mints: Set[str],
+) -> DexEvent | None:
+    min_accounts = 26 if ix_name == "sell_v2" else 27
+    if len(ix_accounts) < min_accounts or len(data) < 8:
+        return None
+    payload = data[8:]
+    first = struct.unpack_from("<Q", payload, 0)[0] if len(payload) >= 8 else 0
+    second = struct.unpack_from("<Q", payload, 8)[0] if len(payload) >= 16 else 0
+    if ix_name == "buy_exact_quote_in_v2":
+        sol_amount, token_amount = first, second
+    else:
+        token_amount, sol_amount = first, second
+    mint = _get_acct(accounts, ix_accounts, 1)
+    if not mint:
+        return None
+    return DexEvent(
+        type=EventType.PUMP_FUN_TRADE,
+        data=PumpFunTradeEvent(
+            metadata=_meta(sig, slot, tx_index, recv_us),
+            mint=mint,
+            bonding_curve=_get_acct(accounts, ix_accounts, 10),
+            user=_get_acct(accounts, ix_accounts, 13),
+            sol_amount=sol_amount,
+            token_amount=token_amount,
+            fee_recipient=_get_acct(accounts, ix_accounts, 6),
+            is_buy=ix_name != "sell_v2",
+            is_created_buy=mint in created_mints,
+            ix_name=ix_name,
+            mayhem_mode=mint in mayhem_mints,
+            associated_bonding_curve=_get_acct(accounts, ix_accounts, 11),
+            token_program=_token_program_default(_get_acct(accounts, ix_accounts, 3)),
+            creator_vault=_get_acct(accounts, ix_accounts, 16),
+        ),
+    )
+
+
+def parse_pumpfun_shred_ix(
+    data: bytes,
+    accounts: List[str],
+    ix_accounts: bytes,
+    program_id: str,
+    sig: str,
+    slot: int,
+    tx_index: int,
+    recv_us: int,
+    created_mints: Set[str],
+    mayhem_mints: Set[str],
+) -> DexEvent | None:
+    if program_id != PUMPFUN_PROGRAM_ID or len(data) < 8:
+        return None
+    disc = data[:8]
+    if disc == _DISC_BUY:
+        return parse_pumpfun_buy(
+            data, accounts, ix_accounts, sig, slot, tx_index, recv_us, created_mints, mayhem_mints
+        )
+    if disc == _DISC_SELL:
+        return parse_pumpfun_sell(data, accounts, ix_accounts, sig, slot, tx_index, recv_us)
+    if disc == _DISC_BUY_EXACT_SOL_IN:
+        return parse_pumpfun_buy_exact_sol_in(
+            data, accounts, ix_accounts, sig, slot, tx_index, recv_us, created_mints, mayhem_mints
+        )
+    if disc == _DISC_BUY_V2:
+        return parse_pumpfun_trade_v2(
+            "buy_v2", data, accounts, ix_accounts, sig, slot, tx_index, recv_us, created_mints, mayhem_mints
+        )
+    if disc == _DISC_BUY_EXACT_QUOTE_IN_V2:
+        return parse_pumpfun_trade_v2(
+            "buy_exact_quote_in_v2",
+            data,
+            accounts,
+            ix_accounts,
+            sig,
+            slot,
+            tx_index,
+            recv_us,
+            created_mints,
+            mayhem_mints,
+        )
+    if disc == _DISC_SELL_V2:
+        return parse_pumpfun_trade_v2(
+            "sell_v2", data, accounts, ix_accounts, sig, slot, tx_index, recv_us, created_mints, mayhem_mints
+        )
+    return parse_pumpfun_instruction(data, accounts, sig, slot, tx_index, None, recv_us)