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

sol_parser/__init__.py

@@ -16,6 +16,12 @@ from .parser import (
     warmup_parser,
 )
 from .clock import now_micros
+from .market import (
+    sqrt_price_x64_to_price,
+    vault_price_from_balances,
+    normalize_buy_sell_from_token_delta,
+    normalize_buy_sell_from_input_mint,
+)
 from .grpc_types import (
     OrderMode,
     CommitmentLevel,
@@ -46,6 +52,14 @@ from .grpc_types import (
     event_type_filter_includes_pumpfun,
     event_type_filter_includes_pumpswap,
     event_type_filter_includes_meteora_damm_v2,
+    event_type_filter_includes_meteora_dbc,
+    event_type_filter_includes_meteora_pools,
+    event_type_filter_includes_meteora_dlmm,
+    event_type_filter_includes_raydium_clmm,
+    event_type_filter_includes_raydium_cpmm,
+    event_type_filter_includes_raydium_amm_v4,
+    event_type_filter_includes_orca_whirlpool,
+    event_type_filter_includes_raydium_launchlab,
     event_type_filter_includes_pump_fees,
     event_type_filter_allows_instruction_parsing,
     all_event_types,
@@ -128,16 +142,17 @@ from .event_types import (
     MeteoraDammV2AddLiquidityEvent,
     MeteoraDammV2RemoveLiquidityEvent,
     MeteoraDammV2InitializePoolEvent,
-    # Bonk events
-    BonkTradeEvent,
-    BonkPoolCreateEvent,
-    BonkMigrateAmmEvent,
+    # RaydiumLaunchlab events
+    RaydiumLaunchlabTradeEvent,
+    RaydiumLaunchlabPoolCreateEvent,
+    RaydiumLaunchlabMigrateAmmEvent,
     # Union type and helper
     TypedDexEvent,
     to_typed_event,
     legacy_dict_to_dex_event,
 )
 from .pumpfun_fee_enrich import (
+    enrich_create_v2_from_create_events,
     enrich_create_v2_observed_fee_recipient,
     enrich_pumpfun_same_tx_post_merge,
     enrich_pumpfun_trades_from_create_instructions,
@@ -206,6 +221,8 @@ from .instructions import (
     parse_pumpfun_instruction,
     parse_pumpswap_instruction,
     parse_meteora_damm_instruction,
+    parse_meteora_pools_instruction,
+    parse_meteora_dlmm_instruction,
     parse_pump_fees_instruction,
 )
 
@@ -229,6 +246,10 @@ __all__ = [
     "StreamingEventListener",
     "warmup_parser",
     "now_micros",
+    "sqrt_price_x64_to_price",
+    "vault_price_from_balances",
+    "normalize_buy_sell_from_token_delta",
+    "normalize_buy_sell_from_input_mint",
     # RPC parser
     "ParseError",
     "RpcClient",
@@ -264,6 +285,8 @@ __all__ = [
     "parse_pumpfun_instruction",
     "parse_pumpswap_instruction",
     "parse_meteora_damm_instruction",
+    "parse_meteora_pools_instruction",
+    "parse_meteora_dlmm_instruction",
     "parse_pump_fees_instruction",
     # gRPC types
     "OrderMode",
@@ -296,6 +319,14 @@ __all__ = [
     "event_type_filter_includes_pumpfun",
     "event_type_filter_includes_pumpswap",
     "event_type_filter_includes_meteora_damm_v2",
+    "event_type_filter_includes_meteora_dbc",
+    "event_type_filter_includes_meteora_pools",
+    "event_type_filter_includes_meteora_dlmm",
+    "event_type_filter_includes_raydium_clmm",
+    "event_type_filter_includes_raydium_cpmm",
+    "event_type_filter_includes_raydium_amm_v4",
+    "event_type_filter_includes_orca_whirlpool",
+    "event_type_filter_includes_raydium_launchlab",
     "event_type_filter_includes_pump_fees",
     "event_type_filter_allows_instruction_parsing",
     "all_event_types",
@@ -378,12 +409,13 @@ __all__ = [
     "MeteoraDammV2AddLiquidityEvent",
     "MeteoraDammV2RemoveLiquidityEvent",
     "MeteoraDammV2InitializePoolEvent",
-    "BonkTradeEvent",
-    "BonkPoolCreateEvent",
-    "BonkMigrateAmmEvent",
+    "RaydiumLaunchlabTradeEvent",
+    "RaydiumLaunchlabPoolCreateEvent",
+    "RaydiumLaunchlabMigrateAmmEvent",
     "TypedDexEvent",
     "to_typed_event",
     "legacy_dict_to_dex_event",
+    "enrich_create_v2_from_create_events",
     "enrich_create_v2_observed_fee_recipient",
     "enrich_pumpfun_same_tx_post_merge",
     "enrich_pumpfun_trades_from_create_instructions",

sol_parser/account_dispatcher.py

@@ -6,12 +6,12 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import base58
 
-from .account_fillers import bonk, meteora, orca, pumpfun, pumpswap, raydium
+from .account_fillers import raydium_launchlab, meteora, orca, pumpfun, pumpswap, raydium
 from .event_types import DexEvent
 from .grpc_types import EventType
 from .instr_account_utils import get_instruction_account_getter
 from .instructions import (
-    BONK_LAUNCHPAD_PROGRAM_ID,
+    RAYDIUM_LAUNCHLAB_PROGRAM_ID,
     METEORA_DAMM_V2_PROGRAM_ID,
     METEORA_DLMM_PROGRAM_ID,
     METEORA_POOLS_PROGRAM_ID,
@@ -179,10 +179,10 @@ def fill_accounts_with_owned_keys(
         run(METEORA_DLMM_PROGRAM_ID, lambda g: meteora.fill_dlmm_add_liquidity_accounts(data, g))
     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.BONK_TRADE:
-        run(BONK_LAUNCHPAD_PROGRAM_ID, lambda g: bonk.fill_trade_accounts(data, g))
-    elif et == EventType.BONK_POOL_CREATE:
-        run(BONK_LAUNCHPAD_PROGRAM_ID, lambda g: bonk.fill_pool_create_accounts(data, g))
+    elif et == EventType.RAYDIUM_LAUNCHLAB_TRADE:
+        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_trade_accounts(data, g))
+    elif et == EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE:
+        run(RAYDIUM_LAUNCHLAB_PROGRAM_ID, lambda g: raydium_launchlab.fill_pool_create_accounts(data, g))
 
 
 def fill_data(

sol_parser/account_fillers/__init__.py

@@ -1,5 +1,5 @@
 """账户填充子模块（对齐 Rust ``core/account_fillers``）。"""
 
-from . import bonk, meteora, orca, pumpfun, pumpswap, raydium
+from . import raydium_launchlab, meteora, orca, pumpfun, pumpswap, raydium
 
-__all__ = ["bonk", "meteora", "orca", "pumpfun", "pumpswap", "raydium"]
+__all__ = ["raydium_launchlab", "meteora", "orca", "pumpfun", "pumpswap", "raydium"]

sol_parser/account_fillers/pumpfun.py

@@ -29,9 +29,7 @@ def fill_trade_accounts(e: PumpFunTradeEvent, get: AccountGetter) -> None:
         if _empty(getattr(e, name)):
             setattr(e, name, get(idx))
 
-    is_v2 = e.ix_name in ("buy_v2", "sell_v2", "buy_exact_quote_in_v2") or (
-        e.ix_name == "buy_exact_quote_in" and account_at_matches_mint(1)
-    )
+    is_v2 = e.ix_name in ("buy_v2", "sell_v2", "buy_exact_quote_in_v2") or account_at_matches_mint(1)
     if is_v2:
         set_attr("global_account", 0)
         set_attr("quote_mint", 2)
@@ -51,7 +49,7 @@ def fill_trade_accounts(e: PumpFunTradeEvent, get: AccountGetter) -> None:
         set_attr("associated_quote_buyback_fee_recipient", 9)
         set_attr("associated_creator_vault", 17)
         set_attr("sharing_config", 18)
-        if e.ix_name == "sell_v2":
+        if e.ix_name == "sell_v2" or (e.ix_name == "sell" and not e.is_buy):
             set_attr("user_volume_accumulator", 19)
             set_attr("associated_user_volume_accumulator", 20)
             set_attr("fee_config", 21)

sol_parser/account_fillers/raydium_launchlab.py

@@ -0,0 +1,30 @@
+"""RaydiumLaunchlab 账户填充（对齐 ``account_fillers/raydium_launchlab.rs``）。"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from ..event_types import RaydiumLaunchlabPoolCreateEvent, RaydiumLaunchlabTradeEvent
+
+Z = "11111111111111111111111111111111"
+
+
+def _empty(s: str) -> bool:
+    return not s or s == Z
+
+
+AccountGetter = Callable[[int], str]
+
+
+def fill_trade_accounts(e: RaydiumLaunchlabTradeEvent, get: AccountGetter) -> None:
+    if _empty(e.user):
+        e.user = get(0)
+    if _empty(e.pool_state):
+        e.pool_state = get(4)
+
+
+def fill_pool_create_accounts(e: RaydiumLaunchlabPoolCreateEvent, get: AccountGetter) -> None:
+    if _empty(e.pool_state):
+        e.pool_state = get(5)
+    if _empty(e.creator):
+        e.creator = get(1)

sol_parser/accounts/__init__.py

@@ -151,6 +151,32 @@ def _read_pumpfun_shareholders(data: bytes, offset: int) -> Optional[tuple[list[
     return out, offset
 
 
+def _filter_account_event(
+    ev: Optional[DexEvent],
+    event_type_filter: Optional[EventTypeFilter],
+) -> Optional[DexEvent]:
+    if ev is None or event_type_filter is None:
+        return ev
+    return ev if event_type_filter.should_include(ev.type) else None
+
+
+ACCOUNT_EVENT_TYPES = frozenset(
+    (
+        EventType.TOKEN_ACCOUNT,
+        EventType.TOKEN_INFO,
+        EventType.NONCE_ACCOUNT,
+        EventType.ACCOUNT_PUMP_FUN_GLOBAL,
+        EventType.ACCOUNT_PUMP_FUN_BONDING_CURVE,
+        EventType.ACCOUNT_PUMP_FUN_FEE_CONFIG,
+        EventType.ACCOUNT_PUMP_FUN_SHARING_CONFIG,
+        EventType.ACCOUNT_PUMP_FUN_GLOBAL_VOLUME_ACCUMULATOR,
+        EventType.ACCOUNT_PUMP_FUN_USER_VOLUME_ACCUMULATOR,
+        EventType.ACCOUNT_PUMP_SWAP_GLOBAL_CONFIG,
+        EventType.ACCOUNT_PUMP_SWAP_POOL,
+    )
+)
+
+
 def parse_account_unified(
     account: AccountData,
     metadata: EventMetadata,
@@ -164,47 +190,34 @@ def parse_account_unified(
     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_FUN_BONDING_CURVE,
-                EventType.ACCOUNT_PUMP_FUN_FEE_CONFIG,
-                EventType.ACCOUNT_PUMP_FUN_SHARING_CONFIG,
-                EventType.ACCOUNT_PUMP_FUN_GLOBAL_VOLUME_ACCUMULATOR,
-                EventType.ACCOUNT_PUMP_FUN_USER_VOLUME_ACCUMULATOR,
-                EventType.ACCOUNT_PUMP_SWAP_GLOBAL_CONFIG,
-                EventType.ACCOUNT_PUMP_SWAP_POOL,
-            }
-            if not any(t in need for t in inc):
+            if not any(t in ACCOUNT_EVENT_TYPES 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):
+    if account.owner == PUMPSWAP_PROGRAM_ID:
+        should_parse_pumpswap = event_type_filter is None or (
+            event_type_filter.should_include(EventType.ACCOUNT_PUMP_SWAP_GLOBAL_CONFIG)
+            or event_type_filter.should_include(EventType.ACCOUNT_PUMP_SWAP_POOL)
+        )
+        if should_parse_pumpswap:
             ev = _parse_pumpswap_account(account, metadata)
             if ev is not None:
-                return ev
-
-    if account.owner in (PUMPFUN_PROGRAM_ID, PUMP_FEES_PROGRAM_ID) and event_type_filter is not None:
-        if event_type_filter.should_include(
-            EventType.ACCOUNT_PUMP_FUN_GLOBAL
-        ) or event_type_filter.should_include(
-            EventType.ACCOUNT_PUMP_FUN_BONDING_CURVE
-        ) or event_type_filter.should_include(
-            EventType.ACCOUNT_PUMP_FUN_FEE_CONFIG
-        ) or event_type_filter.should_include(
-            EventType.ACCOUNT_PUMP_FUN_SHARING_CONFIG
-        ) or event_type_filter.should_include(
-            EventType.ACCOUNT_PUMP_FUN_GLOBAL_VOLUME_ACCUMULATOR
-        ) or event_type_filter.should_include(
-            EventType.ACCOUNT_PUMP_FUN_USER_VOLUME_ACCUMULATOR
-        ):
+                return _filter_account_event(ev, event_type_filter)
+        return None
+
+    if account.owner in (PUMPFUN_PROGRAM_ID, PUMP_FEES_PROGRAM_ID):
+        should_parse_pumpfun = event_type_filter is None or (
+            event_type_filter.should_include(EventType.ACCOUNT_PUMP_FUN_GLOBAL)
+            or event_type_filter.should_include(EventType.ACCOUNT_PUMP_FUN_BONDING_CURVE)
+            or event_type_filter.should_include(EventType.ACCOUNT_PUMP_FUN_FEE_CONFIG)
+            or event_type_filter.should_include(EventType.ACCOUNT_PUMP_FUN_SHARING_CONFIG)
+            or event_type_filter.should_include(EventType.ACCOUNT_PUMP_FUN_GLOBAL_VOLUME_ACCUMULATOR)
+            or event_type_filter.should_include(EventType.ACCOUNT_PUMP_FUN_USER_VOLUME_ACCUMULATOR)
+        )
+        if should_parse_pumpfun:
             ev = _parse_pumpfun_account(account, metadata)
             if ev is not None:
-                return ev
+                return _filter_account_event(ev, event_type_filter)
+        return None
 
     if acc_utils.is_nonce_account(data):
         if event_type_filter is not None:
@@ -213,9 +226,11 @@ def parse_account_unified(
         return _parse_nonce_fast(account, metadata)
 
     if event_type_filter is not None:
-        if not event_type_filter.should_include(EventType.TOKEN_ACCOUNT):
+        if not event_type_filter.should_include(
+            EventType.TOKEN_ACCOUNT
+        ) and not event_type_filter.should_include(EventType.TOKEN_INFO):
             return None
-    return parse_token_account(account, metadata)
+    return _filter_account_event(parse_token_account(account, metadata), event_type_filter)
 
 
 def _parse_pumpswap_account(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
@@ -706,6 +721,9 @@ def _parse_pumpswap_pool_fast(account: AccountData, metadata: EventMetadata) ->
 
 
 def parse_token_account(account: AccountData, metadata: EventMetadata) -> Optional[DexEvent]:
+    if not acc_utils.is_token_program_account(account.owner):
+        return None
+
     if len(account.data) <= 100:
         event = _parse_mint_fast(account, metadata)
         if event:

sol_parser/dex_parsers.py

@@ -39,12 +39,22 @@ from .event_types import (
     MeteoraDammV2CreatePositionEvent, MeteoraDammV2ClosePositionEvent,
     MeteoraDammV2AddLiquidityEvent, MeteoraDammV2RemoveLiquidityEvent,
     MeteoraDammV2InitializePoolEvent,
-    BonkTradeEvent, BonkPoolCreateEvent, BonkMigrateAmmEvent,
+    RaydiumLaunchlabTradeEvent, RaydiumLaunchlabPoolCreateEvent,
 )
 
 Z = "11111111111111111111111111111111"
 
 
+def normalize_pumpfun_ix_name(ix_name: str) -> str:
+    if ix_name == "buy_v2":
+        return "buy"
+    if ix_name == "sell_v2":
+        return "sell"
+    if ix_name == "buy_exact_quote_in_v2":
+        return "buy_exact_quote_in"
+    return ix_name
+
+
 def _u64le(b: bytes, o: int) -> int:
     return struct.unpack_from("<Q", b, o)[0]
 
@@ -218,6 +228,7 @@ def parse_trade_from_data(data: bytes, meta: dict, is_created_buy: bool) -> DexE
     ix_name = ""
     if o + 4 <= len(data):
         ix_name, o = _borsh_str(data, o)
+    ix_name = normalize_pumpfun_ix_name(ix_name)
     mm = _bool(data, o) if o < len(data) else False
     o += 1
     cb_bps = _u64le(data, o) if o + 8 <= len(data) else 0
@@ -277,12 +288,14 @@ def parse_trade_from_data(data: bytes, meta: dict, is_created_buy: bool) -> DexE
         creator_vault=Z,
     )
     
-    if ix_name in ("buy", "buy_v2"):
+    if ix_name == "buy":
         return DexEvent(type=EventType.PUMP_FUN_BUY, data=event_data)
-    if ix_name in ("sell", "sell_v2"):
+    if ix_name == "sell":
         return DexEvent(type=EventType.PUMP_FUN_SELL, data=event_data)
-    if ix_name in ("buy_exact_sol_in", "buy_exact_quote_in", "buy_exact_quote_in_v2"):
+    if ix_name == "buy_exact_sol_in":
         return DexEvent(type=EventType.PUMP_FUN_BUY_EXACT_SOL_IN, data=event_data)
+    if ix_name == "buy_exact_quote_in":
+        return DexEvent(type=EventType.PUMP_FUN_BUY, data=event_data)
     return DexEvent(type=EventType.PUMP_FUN_TRADE, data=event_data)
 
 
@@ -319,6 +332,10 @@ def parse_create_from_data(data: bytes, meta: dict) -> DexEvent:
     mm = _bool(data, o) if o < len(data) else False
     o += 1
     ice = _bool(data, o) if o < len(data) else False
+    o += 1
+    quote_mint = _pub(data, o) if o + 32 <= len(data) else Z
+    o += 32
+    virtual_quote_reserves = _u64le(data, o) if o + 8 <= len(data) else 0
     
     return DexEvent(
         type=EventType.PUMP_FUN_CREATE,
@@ -339,6 +356,8 @@ def parse_create_from_data(data: bytes, meta: dict) -> DexEvent:
             token_program=tp,
             is_mayhem_mode=mm,
             is_cashback_enabled=ice,
+            quote_mint=quote_mint,
+            virtual_quote_reserves=virtual_quote_reserves,
         ),
     )
 
@@ -1811,45 +1830,35 @@ def _parse_damm_remove_liquidity(data: bytes, meta: dict) -> Optional[DexEvent]:
     )
 
 
-# --- Bonk ---
+# --- RaydiumLaunchlab ---
 
-DISC_BONK_TRADE = _d(2, 3, 4, 5, 6, 7, 8, 9)
-DISC_BONK_POOL_CREATE = _d(1, 2, 3, 4, 5, 6, 7, 8)
-DISC_BONK_MIGRATE_AMM = _d(3, 4, 5, 6, 7, 8, 9, 10)
+DISC_RAYDIUM_LAUNCHLAB_TRADE = _d(189, 219, 127, 211, 78, 230, 97, 238)
+DISC_RAYDIUM_LAUNCHLAB_POOL_CREATE = _d(151, 215, 226, 9, 118, 161, 115, 174)
 
 
-def parse_bonk_from_discriminator(disc: int, data: bytes, meta: dict) -> Optional[DexEvent]:
-    if disc == DISC_BONK_TRADE:
-        return _parse_bonk_trade(data, meta)
-    if disc == DISC_BONK_POOL_CREATE:
-        return _parse_bonk_pool_create(data, meta)
-    if disc == DISC_BONK_MIGRATE_AMM:
-        return _parse_bonk_migrate_amm(data, meta)
+def parse_raydium_launchlab_from_discriminator(disc: int, data: bytes, meta: dict) -> Optional[DexEvent]:
+    if disc == DISC_RAYDIUM_LAUNCHLAB_TRADE:
+        return _parse_raydium_launchlab_trade(data, meta)
+    if disc == DISC_RAYDIUM_LAUNCHLAB_POOL_CREATE:
+        return _parse_raydium_launchlab_pool_create(data, meta)
     return None
 
 
-def _parse_bonk_trade(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 32 + 32 + 8 + 8 + 1 + 1:
+def _parse_raydium_launchlab_trade(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 139:
         return None
-    o = 0
-    pool = _pub(data, o)
-    o += 32
-    user = _pub(data, o)
-    o += 32
-    ai = _u64le(data, o)
-    o += 8
-    ao = _u64le(data, o)
-    o += 8
-    is_buy = _bool(data, o)
-    o += 1
-    ex_in = _bool(data, o)
+    pool = _pub(data, 0)
+    ai = _u64le(data, 88)
+    ao = _u64le(data, 96)
+    is_buy = _u8(data, 136) == 0
+    ex_in = _bool(data, 138)
     d = "Buy" if is_buy else "Sell"
     return DexEvent(
-        type=EventType.BONK_TRADE,
-        data=BonkTradeEvent(
+        type=EventType.RAYDIUM_LAUNCHLAB_TRADE,
+        data=RaydiumLaunchlabTradeEvent(
             metadata=_make_meta(meta),
             pool_state=pool,
-            user=user,
+            user=Z,
             amount_in=ai,
             amount_out=ao,
             is_buy=is_buy,
@@ -1859,52 +1868,36 @@ def _parse_bonk_trade(data: bytes, meta: dict) -> Optional[DexEvent]:
     )
 
 
-def _parse_bonk_pool_create(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 32 + 32 + 32 + 32 + 8 + 8:
+def _parse_raydium_launchlab_pool_create(data: bytes, meta: dict) -> Optional[DexEvent]:
+    if len(data) < 97:
+        return None
+    pool = _pub(data, 0)
+    creator = _pub(data, 32)
+    o = 96
+    decimals = _u8(data, o)
+    o += 1
+    try:
+        name, o = _borsh_str(data, o)
+        symbol, o = _borsh_str(data, o)
+        uri, o = _borsh_str(data, o)
+    except (struct.error, UnicodeDecodeError):
         return None
-    o = 0
-    pool = _pub(data, o)
-    o += 32 + 32 + 32
-    creator = _pub(data, o)
     return DexEvent(
-        type=EventType.BONK_POOL_CREATE,
-        data=BonkPoolCreateEvent(
+        type=EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE,
+        data=RaydiumLaunchlabPoolCreateEvent(
             metadata=_make_meta(meta),
-            base_mint_param={"symbol": "BONK", "name": "Bonk Pool", "uri": "https://bonk.com", "decimals": 5},
+            base_mint_param={"symbol": symbol, "name": name, "uri": uri, "decimals": decimals},
             pool_state=pool,
             creator=creator,
         ),
     )
 
 
-def _parse_bonk_migrate_amm(data: bytes, meta: dict) -> Optional[DexEvent]:
-    if len(data) < 32 + 32 + 32 + 8:
-        return None
-    o = 0
-    old_p = _pub(data, o)
-    o += 32
-    new_p = _pub(data, o)
-    o += 32
-    user = _pub(data, o)
-    o += 32
-    liq = _u64le(data, o)
-    return DexEvent(
-        type=EventType.BONK_MIGRATE_AMM,
-        data=BonkMigrateAmmEvent(
-            metadata=_make_meta(meta),
-            old_pool=old_p,
-            new_pool=new_p,
-            user=user,
-            liquidity_amount=liq,
-        ),
-    )
-
-
 # --- PumpSwap ---
 
 
 def parse_ps_buy_from_data(data: bytes, meta: dict) -> Optional[DexEvent]:
-    min_len = 14 * 8 + 7 * 32 + 1 + 5 * 8 + 4
+    min_len = 16 * 8 + 7 * 32 + 1 + 5 * 8 + 4
     if len(data) < min_len:
         return None
     o = 0
@@ -2488,9 +2481,7 @@ _LOG_DISCRIMINATOR_EVENT_TYPES = {
     _d(228, 50, 246, 85, 203, 66, 134, 37): EventType.METEORA_DAMM_V2_INITIALIZE_POOL,
     _d(156, 15, 119, 198, 29, 181, 221, 55): EventType.METEORA_DAMM_V2_CREATE_POSITION,
     _d(20, 145, 144, 68, 143, 142, 214, 178): EventType.METEORA_DAMM_V2_CLOSE_POSITION,
-    DISC_BONK_TRADE: EventType.BONK_TRADE,
-    DISC_BONK_POOL_CREATE: EventType.BONK_POOL_CREATE,
-    DISC_BONK_MIGRATE_AMM: EventType.BONK_MIGRATE_AMM,
+    DISC_RAYDIUM_LAUNCHLAB_POOL_CREATE: EventType.RAYDIUM_LAUNCHLAB_POOL_CREATE,
     DLMM_ADD_LIQ: EventType.METEORA_DLMM_ADD_LIQUIDITY,
     DLMM_REMOVE_LIQ: EventType.METEORA_DLMM_REMOVE_LIQUIDITY,
     DLMM_INIT_POOL: EventType.METEORA_DLMM_INITIALIZE_POOL,
@@ -2623,7 +2614,7 @@ def dispatch_program_data(
         _d(20, 145, 144, 68, 143, 142, 214, 178),
     ):
         return parse_meteora_damm_from_buf(buf, meta)
-    bonk = parse_bonk_from_discriminator(disc, data, meta)
-    if bonk:
-        return bonk
+    raydium_launchlab = parse_raydium_launchlab_from_discriminator(disc, data, meta)
+    if raydium_launchlab:
+        return raydium_launchlab
     return parse_dlmm_from_program_data(buf, meta)