sol-parser-sdk 0.5.14 → 0.5.16

package/dist/simulation_route.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSimulationRoutes = analyzeSimulationRoutes;
+/** Explicit simulation evidence adapter. No RPC or transaction reserialization. */
+const bs58_1 = __importDefault(require("bs58"));
+const wire_transaction_js_1 = require("./wire_transaction.js");
+const transaction_route_js_1 = require("./transaction_route.js");
+function unsigned(value, bits) {
+    if (typeof value === "number" && !Number.isSafeInteger(value))
+        throw Error("Unsafe simulation integer");
+    if ((typeof value !== "number" && typeof value !== "string") ||
+        !/^[0-9]+$/.test(String(value)))
+        throw Error("Invalid simulation integer");
+    const n = BigInt(value);
+    if (n < 0n || n >= 1n << BigInt(bits))
+        throw Error("Simulation integer outside range");
+    return n;
+}
+/** Original wire plus simulateTransaction response. Parsed SPL transfers and ATA setup.
+ * Unsupported parsed CPI fail explicitly; raw/compiled CPI are preserved.
+ * V0 ALT requires the existing compiled route API and loadedAddresses.
+ */
+function analyzeSimulationRoutes(wire, response, graduatedPools = []) {
+    const tx = (0, wire_transaction_js_1.decodeWireTransaction)(wire).transaction;
+    if (tx.message.addressTableLookups.length)
+        throw Error("V0 ALT addresses unavailable; use compiled route input with loadedAddresses");
+    const root = response, value = root?.result?.value;
+    if (root?.error ||
+        !value ||
+        typeof value !== "object" ||
+        !("err" in value) ||
+        !("innerInstructions" in value))
+        throw Error("Simulation response missing execution metadata");
+    if (value.innerInstructions !== null &&
+        !Array.isArray(value.innerInstructions))
+        throw Error("Invalid simulation inner instructions");
+    const keys = tx.message.accountKeys;
+    const index = (key) => {
+        if (typeof key !== "string")
+            throw Error("Missing simulation account key");
+        const n = keys.indexOf(key);
+        if (n < 0)
+            throw Error("Simulation account absent from transaction");
+        return n;
+    };
+    const validIndex = (n) => {
+        if (typeof n !== "number" ||
+            !Number.isInteger(n) ||
+            n < 0 ||
+            n >= keys.length)
+            throw Error("Invalid simulation account index");
+        return n;
+    };
+    const seen = new Set();
+    const groups = (value.innerInstructions ?? []).map((group) => {
+        if (!group ||
+            typeof group !== "object" ||
+            !Number.isInteger(group.index) ||
+            group.index < 0 ||
+            group.index >= tx.message.instructions.length ||
+            seen.has(group.index) ||
+            !Array.isArray(group.instructions))
+            throw Error("Invalid simulation instruction group");
+        seen.add(group.index);
+        return {
+            index: group.index,
+            instructions: group.instructions.map((ix) => {
+                if (!ix || typeof ix !== "object")
+                    throw Error("Invalid simulation instruction");
+                if (ix.stackHeight !== undefined &&
+                    ix.stackHeight !== null &&
+                    (!Number.isInteger(ix.stackHeight) || ix.stackHeight < 2))
+                    throw Error("Invalid simulation stack height");
+                const stackHeight = ix.stackHeight ?? null;
+                if (ix.programIdIndex !== undefined) {
+                    if (ix.parsed !== undefined ||
+                        typeof ix.data !== "string" ||
+                        !Array.isArray(ix.accounts))
+                        throw Error("Invalid compiled simulation instruction");
+                    bs58_1.default.decode(ix.data);
+                    return {
+                        programIdIndex: validIndex(ix.programIdIndex),
+                        accounts: ix.accounts.map(validIndex),
+                        data: ix.data,
+                        stackHeight,
+                    };
+                }
+                const programIdIndex = index(ix.programId);
+                if (ix.parsed === undefined) {
+                    if (typeof ix.data !== "string" || !Array.isArray(ix.accounts))
+                        throw Error("Invalid raw simulation instruction");
+                    bs58_1.default.decode(ix.data);
+                    return {
+                        programIdIndex,
+                        accounts: ix.accounts.map(index),
+                        data: ix.data,
+                        stackHeight,
+                    };
+                }
+                if (!ix.parsed ||
+                    typeof ix.parsed !== "object" ||
+                    Array.isArray(ix.parsed) ||
+                    !ix.parsed.info ||
+                    typeof ix.parsed.info !== "object" ||
+                    Array.isArray(ix.parsed.info))
+                    throw Error("Unsupported parsed simulation instruction");
+                const setup = simulationAccountSetup(ix.programId, ix.parsed.type, ix.parsed.info);
+                if (setup)
+                    return {
+                        programIdIndex,
+                        accounts: setup.accounts.map(index),
+                        data: bs58_1.default.encode(setup.data),
+                        stackHeight,
+                    };
+                if (ix.programId !== transaction_route_js_1.TOKEN && ix.programId !== transaction_route_js_1.TOKEN_2022)
+                    throw Error("Unsupported parsed simulation program");
+                const { type, info } = ix.parsed;
+                if (!info ||
+                    !["transfer", "transferChecked", "transferCheckedWithFee"].includes(type))
+                    throw Error("Unsupported parsed simulation instruction");
+                const authority = info.authority ?? info.multisigAuthority, signers = info.signers ?? [];
+                if (!Array.isArray(signers))
+                    throw Error("Invalid simulation signers");
+                let accounts, data;
+                if (type === "transfer") {
+                    accounts = [info.source, info.destination, authority, ...signers];
+                    data = Buffer.alloc(9);
+                    data[0] = 3;
+                    data.writeBigUInt64LE(unsigned(info.amount, 64), 1);
+                }
+                else {
+                    const withFee = type === "transferCheckedWithFee";
+                    if (withFee && ix.programId !== transaction_route_js_1.TOKEN_2022)
+                        throw Error("Transfer fee requires Token-2022");
+                    if (!info.tokenAmount ||
+                        typeof info.tokenAmount !== "object" ||
+                        Array.isArray(info.tokenAmount))
+                        throw Error("Invalid simulation token amount");
+                    const amount = unsigned(info.tokenAmount?.amount, 64), decimals = Number(unsigned(info.tokenAmount?.decimals, 8));
+                    accounts = [
+                        info.source,
+                        info.mint,
+                        info.destination,
+                        authority,
+                        ...signers,
+                    ];
+                    data = Buffer.alloc(withFee ? 19 : 10);
+                    if (withFee) {
+                        data[0] = 26;
+                        data[1] = 1;
+                        data.writeBigUInt64LE(amount, 2);
+                        data[10] = decimals;
+                        data.writeBigUInt64LE(unsigned(info.feeAmount, 64), 11);
+                    }
+                    else {
+                        data[0] = 12;
+                        data.writeBigUInt64LE(amount, 1);
+                        data[9] = decimals;
+                    }
+                }
+                return {
+                    programIdIndex,
+                    accounts: accounts.map(index),
+                    data: bs58_1.default.encode(data),
+                    stackHeight,
+                };
+            }),
+        };
+    });
+    return (0, transaction_route_js_1.analyzeRpcTransactionRoutes)({ transaction: tx, meta: { ...value, innerInstructions: groups } }, graduatedPools);
+}
+/** Reconstruct only understood setup layouts; extension names are deliberately bounded. */
+function simulationAccountSetup(program, type, info) {
+    const pubkey = (key) => {
+        if (typeof key !== "string")
+            throw Error("Invalid simulation public key");
+        const bytes = Buffer.from(bs58_1.default.decode(key));
+        if (bytes.length !== 32)
+            throw Error("Invalid simulation public key");
+        return bytes;
+    };
+    if (program === transaction_route_js_1.ZERO && type === "createAccount") {
+        const data = Buffer.alloc(52);
+        data.writeBigUInt64LE(unsigned(info.lamports, 64), 4);
+        data.writeBigUInt64LE(unsigned(info.space, 64), 12);
+        pubkey(info.owner).copy(data, 20);
+        return { accounts: [info.source, info.newAccount], data };
+    }
+    if (program === transaction_route_js_1.ZERO && (type === "transfer" || type === "allocate")) {
+        const data = Buffer.alloc(12);
+        data.writeUInt32LE(type === "transfer" ? 2 : 8, 0);
+        data.writeBigUInt64LE(unsigned(type === "transfer" ? info.lamports : info.space, 64), 4);
+        return { accounts: type === "transfer" ? [info.source, info.destination] : [info.account], data };
+    }
+    if (program === transaction_route_js_1.ZERO && type === "assign") {
+        const data = Buffer.alloc(36);
+        data.writeUInt32LE(1, 0);
+        pubkey(info.owner).copy(data, 4);
+        return { accounts: [info.account], data };
+    }
+    if (program !== transaction_route_js_1.TOKEN && program !== transaction_route_js_1.TOKEN_2022)
+        return null;
+    if (typeof type === "string" && ["mintTo", "mintToChecked", "burn", "burnChecked"].includes(type)) {
+        const minting = type.startsWith("mintTo"), checked = type.endsWith("Checked");
+        const authority = minting ? (info.mintAuthority ?? info.multisigMintAuthority) : (info.authority ?? info.multisigAuthority);
+        const signers = info.signers === undefined ? [] : info.signers;
+        if (!Array.isArray(signers))
+            throw Error("Invalid simulation signers");
+        const amount = checked ? info.tokenAmount : info;
+        if (!amount || typeof amount !== "object" || Array.isArray(amount))
+            throw Error("Invalid simulation token amount");
+        const data = Buffer.alloc(checked ? 10 : 9);
+        data[0] = checked ? (minting ? 14 : 15) : (minting ? 7 : 8);
+        data.writeBigUInt64LE(unsigned(amount.amount, 64), 1);
+        if (checked)
+            data[9] = Number(unsigned(amount.decimals, 8));
+        return { accounts: [...(minting ? [info.mint, info.account] : [info.account, info.mint]), authority, ...signers], data };
+    }
+    if (type === "initializeImmutableOwner")
+        return { accounts: [info.account], data: Buffer.from([22]) };
+    if (type === "initializeAccount3")
+        return {
+            accounts: [info.account, info.mint],
+            data: Buffer.concat([Buffer.from([18]), pubkey(info.owner)]),
+        };
+    if (type === "getAccountDataSize") {
+        if (!Array.isArray(info.extensionTypes))
+            throw Error("Invalid simulation extension types");
+        const data = Buffer.alloc(1 + info.extensionTypes.length * 2);
+        data[0] = 21;
+        info.extensionTypes.forEach((extension, i) => {
+            if (extension !== "immutableOwner")
+                throw Error("Unsupported simulation extension type");
+            data.writeUInt16LE(7, 1 + 2 * i);
+        });
+        return { accounts: [info.mint], data };
+    }
+    return null;
+}

package/dist/stonkfun_registry.d.ts

@@ -0,0 +1,30 @@
+export interface StonkFunGraduatedPool {
+    curve_pool: string;
+    pool: string;
+    base_mint: string;
+    quote_mint: string;
+    platform_config: string;
+    migration_signature: string;
+    migration_slot: bigint;
+}
+export declare class StonkFunPoolRegistry {
+    private pools;
+    constructor(entries?: Iterable<StonkFunGraduatedPool>);
+    get(pool: string): Readonly<StonkFunGraduatedPool> | undefined;
+    verifiedCpmmPools(): string[];
+    poolsForBaseMint(mint: string): Readonly<StonkFunGraduatedPool>[];
+    toJSON(): {
+        pools: {
+            migration_slot: string;
+            curve_pool: string;
+            pool: string;
+            base_mint: string;
+            quote_mint: string;
+            platform_config: string;
+            migration_signature: string;
+        }[];
+    };
+    static fromJSON(data: ReturnType<StonkFunPoolRegistry["toJSON"]>): StonkFunPoolRegistry;
+    observeMigrations(entries: Iterable<StonkFunGraduatedPool>, succeeded: boolean): number;
+    observeRpcTransaction(transaction: unknown): number;
+}

package/dist/stonkfun_registry.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StonkFunPoolRegistry = void 0;
+/** Caller-owned migration provenance; transactions never mutate a global registry. */
+const bs58_1 = __importDefault(require("bs58"));
+const wire_transaction_js_1 = require("./wire_transaction.js");
+const transaction_route_js_1 = require("./transaction_route.js");
+function validate(p) {
+    if (!(0, transaction_route_js_1.stonkfunModeFromPlatformConfig)(p.platform_config) ||
+        p.curve_pool === p.pool ||
+        p.base_mint === p.quote_mint)
+        throw new Error("Invalid StonkFun registry identity");
+    for (const key of [p.curve_pool, p.pool, p.base_mint, p.quote_mint])
+        if (key === transaction_route_js_1.ZERO || bs58_1.default.decode(key).length !== 32)
+            throw new Error("Invalid registry key");
+    if (bs58_1.default.decode(p.migration_signature).length !== 64 ||
+        typeof p.migration_slot !== "bigint" ||
+        p.migration_slot < 0n ||
+        p.migration_slot >= 1n << 64n)
+        throw new Error("Invalid migration provenance");
+}
+const equal = (a, b) => Object.keys(a).every((k) => a[k] ===
+    b[k]);
+class StonkFunPoolRegistry {
+    pools = new Map();
+    constructor(entries = []) {
+        for (const p of entries) {
+            validate(p);
+            if (this.pools.has(p.pool))
+                throw new Error("Duplicate registry entry");
+            this.pools.set(p.pool, Object.freeze({ ...p }));
+        }
+    }
+    get(pool) {
+        return this.pools.get(pool);
+    }
+    verifiedCpmmPools() {
+        return [...this.pools.keys()].sort();
+    }
+    poolsForBaseMint(mint) {
+        return this.verifiedCpmmPools()
+            .map((k) => this.pools.get(k))
+            .filter((p) => p.base_mint === mint);
+    }
+    toJSON() {
+        return {
+            pools: this.verifiedCpmmPools().map((k) => ({
+                ...this.pools.get(k),
+                migration_slot: this.pools.get(k).migration_slot.toString(),
+            })),
+        };
+    }
+    static fromJSON(data) {
+        return new StonkFunPoolRegistry(data.pools.map((p) => ({
+            ...p,
+            migration_slot: BigInt(p.migration_slot),
+        })));
+    }
+    observeMigrations(entries, succeeded) {
+        if (!succeeded)
+            return 0;
+        const pending = new Map();
+        for (const p of entries) {
+            validate(p);
+            const prior = pending.get(p.pool) ?? this.pools.get(p.pool);
+            if (prior && !equal(prior, p))
+                throw new Error("Conflicting migration provenance");
+            pending.set(p.pool, p);
+        }
+        let count = 0;
+        for (const [k, p] of pending) {
+            if (!this.pools.has(k))
+                count++;
+            this.pools.set(k, Object.freeze({ ...p }));
+        }
+        return count;
+    }
+    observeRpcTransaction(transaction) {
+        const root = transaction, tx = root.result ?? root;
+        if (!tx.meta || typeof tx.meta !== "object")
+            throw new Error("Transaction metadata missing");
+        if (!("err" in tx.meta))
+            throw new Error("Transaction execution status missing");
+        if (tx.meta.err !== null)
+            return 0;
+        // Use the same compiled index/group validation as route analysis.
+        (0, transaction_route_js_1.analyzeRpcTransactionRoutes)(transaction);
+        let body = tx.transaction;
+        if (Array.isArray(body)) {
+            if (body.length !== 2 || body[1] !== "base64")
+                throw new Error("Expected base64 encoding");
+            body = (0, wire_transaction_js_1.decodeWireTransaction)(Buffer.from(body[0], "base64")).transaction;
+        }
+        const loaded = tx.meta.loadedAddresses ?? {}, keys = [
+            ...body.message.accountKeys.map((k) => typeof k === "string" ? k : k.pubkey),
+            ...(loaded.writable ?? []),
+            ...(loaded.readonly ?? []),
+        ];
+        const instructions = [...body.message.instructions];
+        for (const group of tx.meta.innerInstructions ?? [])
+            instructions.push(...group.instructions);
+        const entries = [];
+        for (const ix of instructions) {
+            if (ix.programIdIndex === undefined)
+                throw new Error("Expected compiled instructions");
+            const d = typeof ix.data === "string" ? bs58_1.default.decode(ix.data) : ix.data;
+            if (keys[ix.programIdIndex] !== transaction_route_js_1.ROUTE_PROGRAMS.LaunchLab ||
+                Buffer.from(d).subarray(0, 8).toString("hex") !== "885cc8671cda908c" ||
+                ix.accounts.length < 28)
+                continue;
+            const a = Array.from(ix.accounts, (k) => keys[k] ?? transaction_route_js_1.ZERO);
+            if (a[4] !== transaction_route_js_1.ROUTE_PROGRAMS.RaydiumCpmm ||
+                !(0, transaction_route_js_1.stonkfunModeFromPlatformConfig)(a[3]))
+                continue;
+            if ([a[17], a[5], a[1], a[2]].includes(transaction_route_js_1.ZERO) ||
+                a[17] === a[5] ||
+                a[1] === a[2])
+                continue;
+            if (typeof tx.slot === "number" && !Number.isSafeInteger(tx.slot))
+                throw new Error("Unsafe slot integer");
+            entries.push({
+                curve_pool: a[17],
+                pool: a[5],
+                base_mint: a[1],
+                quote_mint: a[2],
+                platform_config: a[3],
+                migration_signature: body.signatures[0],
+                migration_slot: BigInt(tx.slot),
+            });
+        }
+        return this.observeMigrations(entries, true);
+    }
+}
+exports.StonkFunPoolRegistry = StonkFunPoolRegistry;

package/dist/transaction_route.d.ts

@@ -0,0 +1,84 @@
+export declare const ZERO = "11111111111111111111111111111111";
+export declare const TOKEN = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+export declare const TOKEN_2022 = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+export declare const WSOL = "So11111111111111111111111111111111111111112";
+export declare const STONKFUN_STANDARD_PLATFORM_CONFIG = "4E876qZTE9FJMrBzgVtBrSrzz2TLivB5Y5QXPjB4gZL7";
+export declare const STONKFUN_REWARD_PLATFORM_CONFIG = "6BwHHDg3u1854jC8PDLXvR4spTcLNaoBxLJNGC4nTESt";
+export type StonkFunMode = "Standard" | "Reward";
+export declare function stonkfunModeFromPlatformConfig(key: string): StonkFunMode | null;
+export declare const ROUTE_PROGRAMS: {
+    readonly PumpFun: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
+    readonly RaydiumClmm: "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK";
+    readonly RaydiumCpmm: "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C";
+    readonly RaydiumAmmV4: "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8";
+    readonly LaunchLab: "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj";
+    readonly OrcaWhirlpool: "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc";
+    readonly MeteoraDammV2: "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG";
+    readonly MeteoraDlmm: "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo";
+    readonly PumpSwap: "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA";
+};
+export type SwapProtocol = keyof typeof ROUTE_PROGRAMS;
+export interface InstructionPosition {
+    outer_index: number;
+    inner_index: number | null;
+    stack_height: number | null;
+}
+export interface RouteSwapLeg {
+    position: InstructionPosition;
+    program: string;
+    protocol: SwapProtocol;
+    pool: string;
+    trader: string;
+    input_account: string;
+    output_account: string;
+    input_mint: string | null;
+    output_mint: string | null;
+    amount_specified_is_input: boolean;
+    specified_amount: bigint;
+    other_amount_threshold: bigint;
+    actual_input_amount: bigint | null;
+    actual_output_amount: bigint | null;
+    stonkfun_mode: StonkFunMode | null;
+    stonkfun_graduated: boolean;
+}
+export interface RouteTokenTransfer {
+    position: InstructionPosition;
+    program: string;
+    source: string;
+    destination: string;
+    mint: string | null;
+    amount: bigint;
+    withheld_fee: bigint | null;
+}
+export interface RouteUnknownInvocation {
+    position: InstructionPosition;
+    program: string;
+    has_token_transfers: boolean;
+    has_known_swap_descendants: boolean;
+}
+export type NativeTokenAction = "SyncNative" | {
+    Fund: {
+        source: string;
+        lamports: bigint;
+    };
+} | {
+    Close: {
+        destination: string;
+        authority: string;
+    };
+};
+export interface RouteNativeTokenAction {
+    position: InstructionPosition;
+    account: string;
+    action: NativeTokenAction;
+}
+export interface TransactionRoute {
+    signature: string;
+    succeeded: boolean;
+    legs: RouteSwapLeg[];
+    transfers: RouteTokenTransfer[];
+    native_token_actions: RouteNativeTokenAction[];
+    unknown_invocations: RouteUnknownInvocation[];
+}
+/** JSON-encoded or base64-encoded RPC response; amounts are exact bigint. */
+export declare function analyzeRpcTransactionRoutes(transaction: unknown, graduatedStonkfunPools?: Iterable<string>): TransactionRoute;