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

sol_parser/simulation_route.py

@@ -0,0 +1,233 @@
+"""Explicit simulateTransaction evidence adapter; no RPC or wire reserialization."""
+
+from __future__ import annotations
+import re
+import struct
+import base58
+from .wire_transaction import decode_wire_transaction
+from .transaction_route import analyze_rpc_transaction_routes, TOKEN, TOKEN_2022, ZERO
+
+
+def _unsigned(value, bits):
+    if type(value) not in (str, int) or not re.fullmatch(r"[0-9]+", str(value)):
+        raise ValueError("Invalid simulation integer")
+    n = int(value)
+    if not 0 <= n < 1 << bits:
+        raise ValueError("Simulation integer outside range")
+    return n
+
+
+def analyze_simulation_routes(wire, response, graduated_pools=()):
+    """Original wire plus simulateTransaction response. SPL transfers and ATA setup.
+
+    Unsupported parsed CPI fail explicitly. Raw/compiled CPI are preserved.
+    V0 with ALT requires the existing compiled route API and loadedAddresses.
+    """
+    tx, _ = decode_wire_transaction(wire)
+    if tx["message"]["addressTableLookups"]:
+        raise ValueError(
+            "V0 ALT addresses unavailable; use compiled route input with loadedAddresses"
+        )
+    if not isinstance(response, dict) or not isinstance(response.get("result"), dict):
+        raise ValueError("Simulation response missing execution metadata")
+    value = response["result"].get("value")
+    if (
+        response.get("error")
+        or not isinstance(value, dict)
+        or "err" not in value
+        or "innerInstructions" not in value
+    ):
+        raise ValueError("Simulation response missing execution metadata")
+    groups = value["innerInstructions"]
+    if groups is None:
+        groups = []
+    if not isinstance(groups, list):
+        raise ValueError("Invalid simulation inner instructions")
+    keys = tx["message"]["accountKeys"]
+
+    def index(key):
+        if not isinstance(key, str) or key not in keys:
+            raise ValueError("Simulation account absent from transaction")
+        return keys.index(key)
+
+    def valid_index(n):
+        if type(n) is not int or not 0 <= n < len(keys):
+            raise ValueError("Invalid simulation account index")
+        return n
+
+    def instruction(ix):
+        if not isinstance(ix, dict):
+            raise ValueError("Invalid simulation instruction")
+        height = ix.get("stackHeight")
+        if height is not None and (type(height) is not int or height < 2):
+            raise ValueError("Invalid simulation stack height")
+        if "programIdIndex" in ix:
+            if (
+                "parsed" in ix
+                or not isinstance(ix.get("data"), str)
+                or not isinstance(ix.get("accounts"), list)
+            ):
+                raise ValueError("Invalid compiled simulation instruction")
+            base58.b58decode(ix["data"])
+            return dict(
+                programIdIndex=valid_index(ix["programIdIndex"]),
+                accounts=[valid_index(i) for i in ix["accounts"]],
+                data=ix["data"],
+                stackHeight=height,
+            )
+        program = index(ix.get("programId"))
+        if "parsed" not in ix:
+            if not isinstance(ix.get("data"), str) or not isinstance(
+                ix.get("accounts"), list
+            ):
+                raise ValueError("Invalid raw simulation instruction")
+            base58.b58decode(ix["data"])
+            return dict(
+                programIdIndex=program,
+                accounts=[index(k) for k in ix["accounts"]],
+                data=ix["data"],
+                stackHeight=height,
+            )
+        parsed = ix["parsed"]
+        if not isinstance(parsed, dict) or not isinstance(parsed.get("info"), dict):
+            raise ValueError("Unsupported parsed simulation instruction")
+        setup = _account_setup(ix["programId"], parsed.get("type"), parsed["info"])
+        if setup is not None:
+            accounts, data = setup
+            return dict(
+                programIdIndex=program,
+                accounts=[index(k) for k in accounts],
+                data=base58.b58encode(data).decode(),
+                stackHeight=height,
+            )
+        if ix["programId"] not in (TOKEN, TOKEN_2022):
+            raise ValueError("Unsupported parsed simulation program")
+        kind, info = ix["parsed"].get("type"), ix["parsed"].get("info")
+        if not isinstance(info, dict) or kind not in (
+            "transfer",
+            "transferChecked",
+            "transferCheckedWithFee",
+        ):
+            raise ValueError("Unsupported parsed simulation instruction")
+        authority = info.get("authority", info.get("multisigAuthority"))
+        signers = info.get("signers", [])
+        if not isinstance(signers, list):
+            raise ValueError("Invalid simulation signers")
+        if kind == "transfer":
+            accounts = [
+                info.get("source"),
+                info.get("destination"),
+                authority,
+            ] + signers
+            data = struct.pack("<BQ", 3, _unsigned(info.get("amount"), 64))
+        else:
+            with_fee = kind == "transferCheckedWithFee"
+            if with_fee and ix["programId"] != TOKEN_2022:
+                raise ValueError("Transfer fee requires Token-2022")
+            amount = info.get("tokenAmount")
+            if not isinstance(amount, dict):
+                raise ValueError("Invalid simulation token amount")
+            n, decimals = _unsigned(amount.get("amount"), 64), _unsigned(
+                amount.get("decimals"), 8
+            )
+            accounts = [
+                info.get("source"),
+                info.get("mint"),
+                info.get("destination"),
+                authority,
+            ] + signers
+            data = (
+                struct.pack(
+                    "<BBQBQ", 26, 1, n, decimals, _unsigned(info.get("feeAmount"), 64)
+                )
+                if with_fee
+                else struct.pack("<BQB", 12, n, decimals)
+            )
+        return dict(
+            programIdIndex=program,
+            accounts=[index(k) for k in accounts],
+            data=base58.b58encode(data).decode(),
+            stackHeight=height,
+        )
+
+    converted, seen = [], set()
+    for group in groups:
+        if not isinstance(group, dict):
+            raise ValueError("Invalid simulation instruction group")
+        outer = group.get("index")
+        if (
+            type(outer) is not int
+            or not 0 <= outer < len(tx["message"]["instructions"])
+            or outer in seen
+            or not isinstance(group.get("instructions"), list)
+        ):
+            raise ValueError("Invalid simulation instruction group")
+        seen.add(outer)
+        converted.append(
+            dict(
+                index=outer,
+                instructions=[instruction(ix) for ix in group["instructions"]],
+            )
+        )
+    return analyze_rpc_transaction_routes(
+        dict(transaction=tx, meta={**value, "innerInstructions": converted}),
+        graduated_pools,
+    )
+
+
+def _account_setup(program, kind, info):
+    def pubkey(key):
+        if not isinstance(key, str):
+            raise ValueError("Invalid simulation public key")
+        data = base58.b58decode(key)
+        if len(data) != 32:
+            raise ValueError("Invalid simulation public key")
+        return data
+
+    if program == ZERO and kind == "createAccount":
+        return [info.get("source"), info.get("newAccount")], struct.pack(
+            "<IQQ",
+            0,
+            _unsigned(info.get("lamports"), 64),
+            _unsigned(info.get("space"), 64),
+        ) + pubkey(info.get("owner"))
+    if program == ZERO and kind in ("transfer", "allocate"):
+        return ([info.get("source"), info.get("destination")] if kind == "transfer" else [info.get("account")]), struct.pack("<IQ", 2 if kind == "transfer" else 8, _unsigned(info.get("lamports" if kind == "transfer" else "space"), 64))
+    if program == ZERO and kind == "assign":
+        return [info.get("account")], struct.pack("<I", 1) + pubkey(info.get("owner"))
+    if program not in (TOKEN, TOKEN_2022):
+        return None
+    if kind in ("mintTo", "mintToChecked", "burn", "burnChecked"):
+        minting = kind.startswith("mintTo")
+        checked = kind.endswith("Checked")
+        authority_key = "mintAuthority" if minting else "authority"
+        multisig_key = "multisigMintAuthority" if minting else "multisigAuthority"
+        authority = info.get(authority_key)
+        if authority is None:
+            authority = info.get(multisig_key)
+        signers = info.get("signers", [])
+        if not isinstance(signers, list):
+            raise ValueError("Invalid simulation signers")
+        amount = info.get("tokenAmount") if checked else info
+        if not isinstance(amount, dict):
+            raise ValueError("Invalid simulation token amount")
+        data = struct.pack("<BQ", (14 if minting else 15) if checked else (7 if minting else 8),
+                           _unsigned(amount.get("amount"), 64))
+        if checked:
+            data += bytes([_unsigned(amount.get("decimals"), 8)])
+        accounts = [info.get("mint"), info.get("account")] if minting else [info.get("account"), info.get("mint")]
+        return accounts + [authority] + signers, data
+    if kind == "initializeImmutableOwner":
+        return [info.get("account")], bytes([22])
+    if kind == "initializeAccount3":
+        return [info.get("account"), info.get("mint")], bytes([18]) + pubkey(
+            info.get("owner")
+        )
+    if kind == "getAccountDataSize":
+        extensions = info.get("extensionTypes")
+        if not isinstance(extensions, list):
+            raise ValueError("Invalid simulation extension types")
+        if any(ext != "immutableOwner" for ext in extensions):
+            raise ValueError("Unsupported simulation extension type")
+        return [info.get("mint")], bytes([21]) + struct.pack("<H", 7) * len(extensions)
+    return None

sol_parser/stonkfun_registry.py

@@ -0,0 +1,139 @@
+"""Caller-owned, replay-safe provenance for successfully migrated StonkFun pools."""
+
+from __future__ import annotations
+from dataclasses import asdict, dataclass
+import base64
+import base58
+from .transaction_route import (
+    PROGRAMS,
+    ZERO,
+    stonkfun_mode_from_platform_config,
+    analyze_rpc_transaction_routes,
+)
+from .wire_transaction import decode_wire_transaction
+
+
+@dataclass(frozen=True)
+class StonkFunGraduatedPool:
+    curve_pool: str
+    pool: str
+    base_mint: str
+    quote_mint: str
+    platform_config: str
+    migration_signature: str
+    migration_slot: int
+
+    def mode(self):
+        return stonkfun_mode_from_platform_config(self.platform_config)
+
+    def validate(self):
+        if (
+            self.mode() is None
+            or self.curve_pool == self.pool
+            or self.base_mint == self.quote_mint
+        ):
+            raise ValueError("Invalid StonkFun registry identity")
+        for key in (self.curve_pool, self.pool, self.base_mint, self.quote_mint):
+            if key == ZERO or len(base58.b58decode(key)) != 32:
+                raise ValueError("Invalid StonkFun registry key")
+        if (
+            len(base58.b58decode(self.migration_signature)) != 64
+            or type(self.migration_slot) is not int
+            or not 0 <= self.migration_slot < 1 << 64
+        ):
+            raise ValueError("Invalid migration provenance")
+
+
+class StonkFunPoolRegistry:
+    def __init__(self, pools=()):
+        self._pools = {}
+        for entry in pools:
+            entry.validate()
+            if entry.pool in self._pools:
+                raise ValueError("Duplicate StonkFun registry entry")
+            self._pools[entry.pool] = entry
+
+    def get(self, pool):
+        return self._pools.get(pool)
+
+    def pools_for_base_mint(self, mint):
+        return [
+            self._pools[k]
+            for k in sorted(self._pools)
+            if self._pools[k].base_mint == mint
+        ]
+
+    def verified_cpmm_pools(self):
+        return sorted(self._pools)
+
+    def to_dict(self):
+        return {"pools": [asdict(self._pools[k]) for k in sorted(self._pools)]}
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(StonkFunGraduatedPool(**p) for p in data["pools"])
+
+    def observe_migrations(self, entries, succeeded):
+        if not succeeded:
+            return 0
+        pending = {}
+        for entry in entries:
+            entry.validate()
+            prior = pending.get(entry.pool) or self._pools.get(entry.pool)
+            if prior is not None and prior != entry:
+                raise ValueError("Conflicting migration provenance")
+            pending[entry.pool] = entry
+        count = sum(k not in self._pools for k in pending)
+        self._pools.update(pending)
+        return count
+
+    def observe_rpc_transaction(self, transaction):
+        tx = transaction.get("result", transaction)
+        if not isinstance(tx.get("meta"), dict):
+            raise ValueError("Transaction metadata missing")
+        if "err" not in tx["meta"]:
+            raise ValueError("Transaction execution status missing")
+        if tx["meta"]["err"] is not None:
+            return 0
+        analyze_rpc_transaction_routes(transaction)
+        body = tx["transaction"]
+        if isinstance(body, list):
+            if body[1] != "base64":
+                raise ValueError("Expected base64 encoding")
+            body, _ = decode_wire_transaction(base64.b64decode(body[0], validate=True))
+        message, loaded = body["message"], tx["meta"].get("loadedAddresses") or {}
+        keys = (
+            [k if isinstance(k, str) else k["pubkey"] for k in message["accountKeys"]]
+            + loaded.get("writable", [])
+            + loaded.get("readonly", [])
+        )
+        instructions = list(message["instructions"])
+        for group in tx["meta"].get("innerInstructions") or []:
+            instructions.extend(group["instructions"])
+        entries = []
+        for ix in instructions:
+            data = (
+                base58.b58decode(ix["data"])
+                if isinstance(ix["data"], str)
+                else bytes(ix["data"])
+            )
+            if (
+                keys[ix["programIdIndex"]] != PROGRAMS["LaunchLab"]
+                or data[:8] != bytes([136, 92, 200, 103, 28, 218, 144, 140])
+                or len(ix["accounts"]) < 28
+            ):
+                continue
+            a = [keys[k] if 0 <= k < len(keys) else ZERO for k in ix["accounts"]]
+            if (
+                a[4] != PROGRAMS["RaydiumCpmm"]
+                or stonkfun_mode_from_platform_config(a[3]) is None
+            ):
+                continue
+            if ZERO in (a[17], a[5], a[1], a[2]) or a[17] == a[5] or a[1] == a[2]:
+                continue
+            entries.append(
+                StonkFunGraduatedPool(
+                    a[17], a[5], a[1], a[2], a[3], body["signatures"][0], tx["slot"]
+                )
+            )
+        return self.observe_migrations(entries, True)