sol-parser-sdk-python 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

sol_parser/__init__.py

@@ -466,3 +466,27 @@ __all__ = [
     "ShredStreamClient",
     "ShredStreamConfig",
 ]
+
+# Native route and subscription state APIs aligned with Rust 0.7.7.
+from .transaction_route import (analyze_rpc_transaction_routes, TransactionRoute, RouteSwapLeg,
+    RouteTokenTransfer, RouteUnknownInvocation, RouteNativeTokenAction, InstructionPosition,
+    stonkfun_mode_from_platform_config)
+from .stonkfun_registry import StonkFunPoolRegistry, StonkFunGraduatedPool
+from .liquidity_snapshot import RawAccountSnapshotEvent, LiquidityAccountSnapshotEvent, parse_liquidity_account
+from .wire_transaction import decode_wire_transaction
+
+from .simulation_route import analyze_simulation_routes
+
+__all__.append("analyze_simulation_routes")
+
+from .block_meta import BlockMetaEvent, parse_block_meta_update
+from .grpc.subscribe_builder import build_subscribe_request_with_event_filter
+
+from .event_types import (
+    LaunchLabPoolCreateEvent, StonkFunPoolCreateEvent,
+    LaunchLabTradeEvent, StonkFunTradeEvent,
+)
+__all__ += ["LaunchLabPoolCreateEvent", "StonkFunPoolCreateEvent", "LaunchLabTradeEvent", "StonkFunTradeEvent"]
+
+from .grpc_client import DexEventQueue, GrpcStreamStatus
+__all__ += ["DexEventQueue", "GrpcStreamStatus"]

sol_parser/account_dispatcher.py

@@ -82,11 +82,26 @@ def fill_accounts_with_owned_keys(
     w = [bytes(x) for x in meta_pb.loaded_writable_addresses]
     r = [bytes(x) for x in meta_pb.loaded_readonly_addresses]
 
-    def run(program_b58: str, filler) -> None:
+    def run(program_b58: str, filler, anchor=None, unambiguous=False) -> None:
         pid = base58.b58decode(program_b58)
         inv = invokes.get(pid)
         if not inv:
             return
+        if anchor is not None or unambiguous:
+            pool, index = anchor or (None,1)
+            has_anchor=pool and pool != "11111111111111111111111111111111"
+            if not has_anchor and not unambiguous:return
+            selected = None
+            for invocation in inv:
+                candidate = get_instruction_account_getter(meta_pb, transaction_pb, static_keys, w, r, invocation)
+                if candidate is None or (has_anchor and candidate(index) != pool):
+                    continue
+                if selected is not None and any(selected(i) != candidate(i) for i in range(18)):
+                    return  # Same pool, conflicting wallet/account context: do not guess.
+                selected = candidate
+            if selected is not None:
+                filler(selected)
+            return
         ix = find_instruction_invoke(inv, meta_pb, transaction_pb)
         if ix is None:
             return
@@ -95,6 +110,31 @@ def fill_accounts_with_owned_keys(
             return
         filler(get)
 
+    def fill_create(v2_only=False):
+        selected = None
+        for ix in invokes.get(base58.b58decode(PUMPFUN_PROGRAM_ID), []):
+            raw = get_instruction_data(meta_pb, transaction_pb, ix)
+            if raw is None:
+                continue
+            v2 = raw[:8] == bytes([214,144,76,236,95,139,49,180])
+            legacy = raw[:8] == bytes([24,30,200,40,5,28,7,119])
+            if not v2 and (v2_only or not legacy):
+                continue
+            get = get_instruction_account_getter(meta_pb, transaction_pb, static_keys, w, r, ix)
+            oi, ii = ix
+            instruction = (transaction_pb.message.instructions[oi] if ii < 0 else
+                           next(g for g in meta_pb.inner_instructions if g.index == oi).instructions[ii])
+            if len(instruction.accounts) < (16 if v2 else 14) or get is None:
+                continue
+            if data.mint and data.mint != "11111111111111111111111111111111" and get(0) != data.mint:
+                continue
+            if selected is not None:
+                return  # Multiple matching creates: do not guess.
+            selected = (get, v2)
+        if selected:
+            get, v2 = selected
+            (pumpfun.fill_create_v2_accounts if v2 else pumpfun.fill_create_accounts)(data, get)
+
     et = event.type
     data = event.data
 
@@ -106,9 +146,9 @@ def fill_accounts_with_owned_keys(
     ):
         run(PUMPFUN_PROGRAM_ID, lambda g: pumpfun.fill_trade_accounts(data, g))
     elif et == EventType.PUMP_FUN_CREATE:
-        run(PUMPFUN_PROGRAM_ID, lambda g: pumpfun.fill_create_accounts(data, g))
+        fill_create()
     elif et == EventType.PUMP_FUN_CREATE_V2:
-        run(PUMPFUN_PROGRAM_ID, lambda g: pumpfun.fill_create_v2_accounts(data, g))
+        fill_create(True)
     elif et == EventType.PUMP_FUN_MIGRATE:
         run(PUMPFUN_PROGRAM_ID, lambda g: pumpfun.fill_migrate_accounts(data, g))
     elif et == EventType.PUMP_SWAP_BUY:
@@ -146,7 +186,7 @@ def fill_accounts_with_owned_keys(
     elif et == EventType.RAYDIUM_CPMM_INITIALIZE:
         run(RAYDIUM_CPMM_PROGRAM_ID, lambda g: raydium.fill_cpmm_initialize_accounts(data, g))
     elif et == EventType.RAYDIUM_AMM_V4_SWAP:
-        run(RAYDIUM_AMM_V4_PROGRAM_ID, lambda g: raydium.fill_amm_v4_swap_accounts(data, g))
+        run(RAYDIUM_AMM_V4_PROGRAM_ID, lambda g: raydium.fill_amm_v4_swap_accounts(data, g), (data.amm,1), True)
     elif et == EventType.RAYDIUM_AMM_V4_DEPOSIT:
         run(RAYDIUM_AMM_V4_PROGRAM_ID, lambda g: raydium.fill_amm_v4_deposit_accounts(data, g))
     elif et == EventType.RAYDIUM_AMM_V4_WITHDRAW:
@@ -182,9 +222,9 @@ def fill_accounts_with_owned_keys(
     elif et == EventType.METEORA_DLMM_REMOVE_LIQUIDITY:
         run(METEORA_DLMM_PROGRAM_ID, lambda g: meteora.fill_dlmm_remove_liquidity_accounts(data, g))
     elif et == EventType.RAYDIUM_LAUNCHLAB_TRADE:
-        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_trade_accounts(data, g))
+        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_trade_accounts(data, g), (data.pool_state,4))
     elif et == EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE:
-        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_pool_create_accounts(data, g))
+        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_pool_create_accounts(data, g), (data.pool_state,5))
 
 
 def fill_data(

sol_parser/account_fillers/pumpfun.py

@@ -113,15 +113,12 @@ def fill_trade_accounts(e: PumpFunTradeEvent, get: AccountGetter) -> None:
 
 
 def fill_create_accounts(e: PumpFunCreateEvent, get: AccountGetter) -> None:
-    if get(15) == "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P":
-        fill_create_v2_accounts(e, get)  # type: ignore[arg-type]
-        return
-    if _empty(e.mint):
-        e.mint = get(0)
-    if _empty(e.bonding_curve):
-        e.bonding_curve = get(2)
-    if _empty(e.user):
-        e.user = get(7)
+    for field, index in (("mint",0),("mint_authority",1),("bonding_curve",2),
+                         ("associated_bonding_curve",3),("global_account",4),("user",7),
+                         ("system_program",8),("token_program",9),("associated_token_program",10),
+                         ("event_authority",12),("program",13)):
+        if _empty(getattr(e, field, "")):
+            setattr(e, field, get(index))
 
 
 def fill_create_v2_accounts(e: PumpFunCreateV2TokenEvent, get: AccountGetter) -> None:
@@ -157,12 +154,6 @@ def fill_create_v2_accounts(e: PumpFunCreateV2TokenEvent, get: AccountGetter) ->
         e.event_authority = get(14)
     if _empty(e.program):
         e.program = get(15)
-    if _empty(e.quote_mint) or e.quote_mint == "So11111111111111111111111111111111111111111":
-        e.quote_mint = get(16)
-    if _empty(e.quote_vault):
-        e.quote_vault = get(17)
-    if _empty(e.quote_token_program):
-        e.quote_token_program = get(18)
     if getattr(e, "ix_name", "") in ("", "create"):
         e.ix_name = "create_v2"
 

sol_parser/account_fillers/raydium.py

@@ -100,8 +100,12 @@ def fill_cpmm_initialize_accounts(e: RaydiumCpmmInitializeEvent, get: AccountGet
 
 
 def fill_amm_v4_swap_accounts(e: RaydiumAmmV4SwapEvent, get: AccountGetter) -> None:
-    if _empty(e.amm):
-        e.amm = get(1)
+    if _empty(e.amm):e.amm=get(1)
+    modern=_empty(get(8)) and not _empty(get(7))
+    if modern:
+        for field,index in [('token_program',0),('amm_authority',2),('pool_coin_token_account',3),('pool_pc_token_account',4),('user_source_token_account',5),('user_destination_token_account',6),('user_source_owner',7)]:
+            if _empty(getattr(e,field)):setattr(e,field,get(index))
+    elif _empty(e.user_source_owner):e.user_source_owner=get(16) if _empty(get(17)) else get(17)
 
 
 def fill_amm_v4_deposit_accounts(e: RaydiumAmmV4DepositEvent, get: AccountGetter) -> None:

sol_parser/account_fillers/raydium_launchlab.py

@@ -43,6 +43,10 @@ def fill_trade_accounts(e: RaydiumLaunchlabTradeEvent, get: AccountGetter) -> No
     if _empty(e.quote_token_program):
         e.quote_token_program = get(12)
 
+    for name, index in [("system_program", 15), ("platform_associated_account", 16), ("creator_associated_account", 17)]:
+        if _empty(getattr(e,name,"")):
+            setattr(e,name,get(index))
+
 
 def fill_pool_create_accounts(e: RaydiumLaunchlabPoolCreateEvent, get: AccountGetter) -> None:
     if _empty(e.pool_state):

sol_parser/accounts/__init__.py

@@ -206,6 +206,11 @@ def parse_account_unified(
     event_type_filter: Optional[EventTypeFilter] = None,
 ) -> Optional[DexEvent]:
     """对齐 Rust ``parse_account_unified``（含 ``Option<EventTypeFilter>`` 语义）。"""
+    from ..liquidity_snapshot import parse_liquidity_account
+    if event_type_filter is None or event_type_filter.should_include(EventType.ACCOUNT_LIQUIDITY_SNAPSHOT):
+        snapshot = parse_liquidity_account(account, metadata)
+        if snapshot is not None:
+            return DexEvent(type=EventType.ACCOUNT_LIQUIDITY_SNAPSHOT, data=snapshot)
     data = account.data
     if not data:
         return None

sol_parser/block_meta.py

@@ -0,0 +1,29 @@
+"""Local BlockMeta adapter, matching Rust's saturated timestamp conversion."""
+
+from dataclasses import dataclass
+from .grpc_types import EventType, EventMetadata
+from .event_types import DexEvent
+
+
+@dataclass
+class BlockMetaEvent:
+    metadata: EventMetadata
+
+
+def parse_block_meta_update(meta, grpc_recv_us, fallback_block_us=None):
+    block_us = fallback_block_us or 0
+    if meta.block_time is not None:
+        block_us = max(-(1 << 63), min((1 << 63) - 1, meta.block_time * 1_000_000))
+    return DexEvent(
+        EventType.BLOCK_META,
+        BlockMetaEvent(
+            EventMetadata(
+                signature="1" * 64,
+                slot=meta.slot,
+                tx_index=0,
+                block_time_us=block_us,
+                grpc_recv_us=grpc_recv_us,
+                recent_blockhash=meta.blockhash,
+            )
+        ),
+    )

sol_parser/dex_parsers.py

@@ -324,6 +324,10 @@ def parse_create_from_data(data: bytes, meta: dict) -> DexEvent:
         uri, o = _borsh_str(data, o)
     except Exception:
         return DexEvent()
+    if len(data) - o == 96:
+        return DexEvent(type=EventType.PUMP_FUN_CREATE, data=PumpFunCreateEvent(
+            metadata=_make_meta(meta), name=name, symbol=sym, uri=uri,
+            mint=_pub(data, o), bonding_curve=_pub(data, o + 32), user=_pub(data, o + 64)))
     if len(data) < o + 32 * 4 + 8 * 5 + 32 + 1:
         return DexEvent()
     mint = _pub(data, o)
@@ -2727,7 +2731,7 @@ def parse_raydium_launchlab_from_discriminator(disc: int, data: bytes, meta: dic
 
 
 def _parse_raydium_launchlab_trade(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 139:
+    if len(data) != 139 or data[136] > 1 or data[137] > 2 or data[138] > 1:
         return None
     pool = _pub(data, 0)
     ai = _u64le(data, 88)
@@ -2746,6 +2750,19 @@ def _parse_raydium_launchlab_trade(data: bytes, meta: dict) -> Optional[DexEvent
             is_buy=is_buy,
             trade_direction=d,
             exact_in=ex_in,
+            pool_status=("Fund","Migrate","Trade")[data[137]],
+            total_base_sell=_u64le(data,32),
+            virtual_base=_u64le(data,40),
+            virtual_quote=_u64le(data,48),
+            real_base_before=_u64le(data,56),
+            real_quote_before=_u64le(data,64),
+            real_base_after=_u64le(data,72),
+            real_quote_after=_u64le(data,80),
+            protocol_fee=_u64le(data,104),
+            platform_fee=_u64le(data,112),
+            creator_fee=_u64le(data,120),
+            share_fee=_u64le(data,128),
+
         ),
     )
 

sol_parser/entries_decode.py

@@ -46,87 +46,13 @@ class _ParsedTx:
 
 
 def parse_transaction_wire(buf: bytes, pos: int) -> Optional[_ParsedTx]:
-    start = pos
-    if pos >= len(buf):
-        return None
-    sig_count_enc = decode_compact_u16(buf, pos)
-    if not sig_count_enc:
-        return None
-    p = pos + sig_count_enc[1]
-    sig_count = sig_count_enc[0]
-    sigs_end = p + sig_count * 64
-    if sigs_end > len(buf):
-        return None
-    sigs: List[bytes] = []
-    for _ in range(sig_count):
-        sigs.append(buf[p : p + 64])
-        p += 64
-    if p >= len(buf):
-        return None
-    msg_first = buf[p]
-    is_v0 = msg_first >= 0x80
-    if is_v0:
-        p += 1
-    p += 3
-    if p > len(buf):
-        return None
-    acct_enc = decode_compact_u16(buf, p)
-    if not acct_enc:
-        return None
-    p += acct_enc[1]
-    p += acct_enc[0] * 32
-    if p > len(buf):
-        return None
-    ix_count_enc = decode_compact_u16(buf, p)
-    if not ix_count_enc:
+    from .wire_transaction import decode_wire_transaction
+    import base58
+    try:
+        transaction, length = decode_wire_transaction(buf, pos, require_complete=False)
+        return _ParsedTx(length, [base58.b58decode(s) for s in transaction['signatures']])
+    except (ValueError, IndexError):
         return None
-    p += ix_count_enc[1]
-    ix_count = ix_count_enc[0]
-    for _ in range(ix_count):
-        p += 1
-        if p > len(buf):
-            return None
-        acct_len_enc = decode_compact_u16(buf, p)
-        if not acct_len_enc:
-            return None
-        p += acct_len_enc[1]
-        p += acct_len_enc[0]
-        if p > len(buf):
-            return None
-        data_len_enc = decode_compact_u16(buf, p)
-        if not data_len_enc:
-            return None
-        p += data_len_enc[1]
-        p += data_len_enc[0]
-        if p > len(buf):
-            return None
-    if is_v0:
-        if p >= len(buf):
-            return None
-        atl_count_enc = decode_compact_u16(buf, p)
-        if not atl_count_enc:
-            return None
-        p += atl_count_enc[1]
-        atl_count = atl_count_enc[0]
-        for _ in range(atl_count):
-            p += 32
-            if p > len(buf):
-                return None
-            w_len_enc = decode_compact_u16(buf, p)
-            if not w_len_enc:
-                return None
-            p += w_len_enc[1]
-            p += w_len_enc[0]
-            if p > len(buf):
-                return None
-            r_len_enc = decode_compact_u16(buf, p)
-            if not r_len_enc:
-                return None
-            p += r_len_enc[1]
-            p += r_len_enc[0]
-            if p > len(buf):
-                return None
-    return _ParsedTx(tx_len=p - start, signatures=sigs)
 
 
 class _BatchDecoder:

sol_parser/event_types.py

@@ -219,6 +219,20 @@ class PumpFunCreateEvent(DexEventBase):
     virtual_quote_reserves: int = 0
     creator_fee_bps: int = 0
     is_holder_reward: bool = False
+    mint_authority: str = ""
+    associated_bonding_curve: str = ""
+    global_account: str = ""  # Rust `global` PumpFun global config
+    system_program: str = ""
+    associated_token_program: str = ""
+    mayhem_program_id: str = ""
+    global_params: str = ""
+    sol_vault: str = ""
+    mayhem_state: str = ""
+    mayhem_token_vault: str = ""
+    event_authority: str = ""
+    program: str = ""
+    observed_fee_recipient: str = ""
+    ix_name: str = "create"
 
 
 @dataclass
@@ -1410,6 +1424,28 @@ class RaydiumLaunchlabTradeEvent(DexEventBase):
     base_token_program: str = ""
     quote_token_program: str = ""
 
+    total_base_sell: int = 0
+    virtual_base: int = 0
+    virtual_quote: int = 0
+    real_base_before: int = 0
+    real_quote_before: int = 0
+    real_base_after: int = 0
+    real_quote_after: int = 0
+    protocol_fee: int = 0
+    platform_fee: int = 0
+    creator_fee: int = 0
+    share_fee: int = 0
+    pool_status: str = "Fund"
+    system_program: str = ""
+    platform_associated_account: str = ""
+    creator_associated_account: str = ""
+
+    def stonkfun_mode(self):
+        from .transaction_route import stonkfun_mode_from_platform_config
+        return stonkfun_mode_from_platform_config(self.platform_config)
+
+    def is_stonkfun(self):
+        return self.stonkfun_mode() is not None
 
 @dataclass
 class RaydiumLaunchlabPoolCreateEvent(DexEventBase):
@@ -1428,6 +1464,14 @@ class RaydiumLaunchlabPoolCreateEvent(DexEventBase):
     quote_token_program: str = ""
 
 
+
+    def stonkfun_mode(self):
+        from .transaction_route import stonkfun_mode_from_platform_config
+        return stonkfun_mode_from_platform_config(self.platform_config)
+
+    def is_stonkfun(self):
+        return self.stonkfun_mode() is not None
+
 @dataclass
 class RaydiumLaunchlabMigrateAmmEvent(DexEventBase):
     """RaydiumLaunchlab 迁移 AMM 事件"""
@@ -1436,6 +1480,18 @@ class RaydiumLaunchlabMigrateAmmEvent(DexEventBase):
     user: str = ""
     liquidity_amount: int = 0
 
+    liquidity_amount_known: bool = False
+    base_mint: str = ""
+    quote_mint: str = ""
+    platform_config: str = ""
+    destination_program: str = ""
+
+    def stonkfun_mode(self):
+        from .transaction_route import stonkfun_mode_from_platform_config
+        return stonkfun_mode_from_platform_config(self.platform_config)
+
+    def is_stonkfun(self):
+        return self.stonkfun_mode() is not None
 
 # ============================================================
 # 类型联合
@@ -2379,3 +2435,9 @@ def legacy_dict_to_dex_event(d: dict) -> Optional[DexEvent]:
     except ValueError:
         return None
     return DexEvent(type=et, data=typed)
+
+# Same classes: preserve isinstance, serialization and platform attribution.
+LaunchLabPoolCreateEvent = RaydiumLaunchlabPoolCreateEvent
+StonkFunPoolCreateEvent = RaydiumLaunchlabPoolCreateEvent
+LaunchLabTradeEvent = RaydiumLaunchlabTradeEvent
+StonkFunTradeEvent = RaydiumLaunchlabTradeEvent

sol_parser/grpc/subscribe_builder.py

@@ -131,3 +131,11 @@ __all__ = [
     "build_subscribe_request_with_commitment",
     "build_subscribe_transaction_filters_named",
 ]
+
+
+def build_subscribe_request_with_event_filter(tx_filters, acc_filters, event_type_filter=None):
+    from ..grpc_types import EventType
+    request=build_subscribe_request(tx_filters,acc_filters)
+    if event_type_filter is not None and event_type_filter.should_include(EventType.BLOCK_META):
+        request.blocks_meta["block_meta"].CopyFrom(geyser_pb2.SubscribeRequestFilterBlocksMeta())
+    return request