sol-parser-sdk 0.5.9

package/dist/shredstream/entries_decode.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bincodeVecEntryCount = bincodeVecEntryCount;
+exports.decodeCompactU16 = decodeCompactU16;
+exports.parseTransaction = parseTransaction;
+exports.decodeEntriesBincodeFlat = decodeEntriesBincodeFlat;
+exports.decodeEntriesBincodeNested = decodeEntriesBincodeNested;
+exports.decodeShredstreamEntriesBincode = decodeShredstreamEntriesBincode;
+const wire_to_shred_tx_js_1 = require("./wire_to_shred_tx.js");
+const MAX_VEC_ENTRIES = 100_000;
+function readU64LE(buf, offset) {
+    const v = new DataView(buf.buffer, buf.byteOffset + offset, 8);
+    return v.getBigUint64(0, true);
+}
+/** 与 Go `BincodeVecEntryCount` 一致 */
+function bincodeVecEntryCount(entriesBytes) {
+    if (entriesBytes.length < 8) {
+        throw new Error("shredstream: entries payload too short for vec length");
+    }
+    const n = readU64LE(entriesBytes, 0);
+    if (n > BigInt(MAX_VEC_ENTRIES)) {
+        throw new Error(`shredstream: corrupt entry_count ${n} exceeds limit`);
+    }
+    return n;
+}
+/** compact-u16，与 Go `decodeCompactU16` 一致 */
+function decodeCompactU16(buf, pos) {
+    if (pos >= buf.length)
+        return null;
+    const b0 = buf[pos];
+    if (b0 < 0x80)
+        return { value: b0, bytes: 1 };
+    if (pos + 1 >= buf.length)
+        return null;
+    const b1 = buf[pos + 1];
+    if (b1 < 0x80) {
+        return { value: (b0 & 0x7f) | (b1 << 7), bytes: 2 };
+    }
+    if (pos + 2 >= buf.length)
+        return null;
+    const b2 = buf[pos + 2];
+    return { value: (b0 & 0x7f) | ((b1 & 0x7f) << 7) | (b2 << 14), bytes: 3 };
+}
+/** 返回 (txWireLength, signatures)；失败返回 null */
+function parseTransaction(buf, pos) {
+    const start = pos;
+    if (pos >= buf.length)
+        return null;
+    const sigCountEnc = decodeCompactU16(buf, pos);
+    if (!sigCountEnc)
+        return null;
+    let p = pos + sigCountEnc.bytes;
+    const sigCount = sigCountEnc.value;
+    const sigsEnd = p + sigCount * 64;
+    if (sigsEnd > buf.length)
+        return null;
+    const sigs = [];
+    for (let i = 0; i < sigCount; i++) {
+        sigs.push(buf.subarray(p, p + 64));
+        p += 64;
+    }
+    if (p >= buf.length)
+        return null;
+    const msgFirst = buf[p];
+    const isV0 = msgFirst >= 0x80;
+    if (isV0)
+        p += 1;
+    p += 3;
+    if (p > buf.length)
+        return null;
+    const acctEnc = decodeCompactU16(buf, p);
+    if (!acctEnc)
+        return null;
+    p += acctEnc.bytes;
+    p += acctEnc.value * 32;
+    if (p > buf.length)
+        return null;
+    p += 32;
+    if (p > buf.length)
+        return null;
+    const ixCountEnc = decodeCompactU16(buf, p);
+    if (!ixCountEnc)
+        return null;
+    p += ixCountEnc.bytes;
+    const ixCount = ixCountEnc.value;
+    for (let ix = 0; ix < ixCount; ix++) {
+        p += 1;
+        if (p > buf.length)
+            return null;
+        const acctLenEnc = decodeCompactU16(buf, p);
+        if (!acctLenEnc)
+            return null;
+        p += acctLenEnc.bytes;
+        p += acctLenEnc.value;
+        if (p > buf.length)
+            return null;
+        const dataLenEnc = decodeCompactU16(buf, p);
+        if (!dataLenEnc)
+            return null;
+        p += dataLenEnc.bytes;
+        p += dataLenEnc.value;
+        if (p > buf.length)
+            return null;
+    }
+    if (isV0) {
+        if (p >= buf.length)
+            return null;
+        const atlCountEnc = decodeCompactU16(buf, p);
+        if (!atlCountEnc)
+            return null;
+        p += atlCountEnc.bytes;
+        const atlCount = atlCountEnc.value;
+        for (let atl = 0; atl < atlCount; atl++) {
+            p += 32;
+            if (p > buf.length)
+                return null;
+            const wLenEnc = decodeCompactU16(buf, p);
+            if (!wLenEnc)
+                return null;
+            p += wLenEnc.bytes;
+            p += wLenEnc.value;
+            if (p > buf.length)
+                return null;
+            const rLenEnc = decodeCompactU16(buf, p);
+            if (!rLenEnc)
+                return null;
+            p += rLenEnc.bytes;
+            p += rLenEnc.value;
+            if (p > buf.length)
+                return null;
+        }
+    }
+    return { txLen: p - start, sigs };
+}
+class BatchDecoder {
+    buffer = new Uint8Array(0);
+    expectedEntryCount = 0;
+    entriesYielded = 0;
+    cursor = 0;
+    append(payload) {
+        const merged = new Uint8Array(this.buffer.length + payload.length);
+        merged.set(this.buffer);
+        merged.set(payload, this.buffer.length);
+        this.buffer = merged;
+    }
+    tryDecodeEntry() {
+        const pos = this.cursor;
+        const buf = this.buffer;
+        if (pos + 48 > buf.length)
+            return null;
+        let p = pos + 8 + 32;
+        const txCount = Number(readU64LE(buf, p));
+        p += 8;
+        const txs = [];
+        for (let i = 0; i < txCount; i++) {
+            const txStart = p;
+            const parsed = parseTransaction(buf, p);
+            if (!parsed) {
+                throw new Error(`shredstream: truncated transaction ${i} in entry`);
+            }
+            const { txLen, sigs } = parsed;
+            const raw = buf.subarray(txStart, txStart + txLen);
+            txs.push({
+                raw: Uint8Array.from(raw),
+                signatures: sigs.map((s) => Uint8Array.from(s)),
+            });
+            p = txStart + txLen;
+        }
+        this.cursor = p;
+        return txs;
+    }
+    /** 扁平列表，对齐 Go `DecodeEntriesBincode` */
+    pushFlat(payload) {
+        this.append(payload);
+        if (this.expectedEntryCount === 0 && this.entriesYielded === 0 && this.cursor === 0) {
+            if (this.buffer.length < 8) {
+                throw new Error("shredstream: entries payload too short for vec length");
+            }
+            const count = readU64LE(this.buffer, 0);
+            if (count > BigInt(MAX_VEC_ENTRIES)) {
+                throw new Error(`shredstream: corrupt entry_count ${count} exceeds limit`);
+            }
+            this.expectedEntryCount = Number(count);
+            this.cursor = 8;
+        }
+        const out = [];
+        while (this.entriesYielded < this.expectedEntryCount) {
+            const entryTxs = this.tryDecodeEntry();
+            if (entryTxs === null) {
+                throw new Error(`shredstream: incomplete entry at offset ${this.cursor}`);
+            }
+            out.push(...entryTxs);
+            this.entriesYielded++;
+        }
+        return out;
+    }
+    /** 按 Solana `Entry` 分层，供 ShredStream 客户端（Entry 内 tx_index） */
+    pushNested(payload) {
+        this.append(payload);
+        if (this.expectedEntryCount === 0 && this.entriesYielded === 0 && this.cursor === 0) {
+            if (this.buffer.length < 8) {
+                throw new Error("shredstream: entries payload too short for vec length");
+            }
+            const count = readU64LE(this.buffer, 0);
+            if (count > BigInt(MAX_VEC_ENTRIES)) {
+                throw new Error(`shredstream: corrupt entry_count ${count} exceeds limit`);
+            }
+            this.expectedEntryCount = Number(count);
+            this.cursor = 8;
+        }
+        const nested = [];
+        while (this.entriesYielded < this.expectedEntryCount) {
+            const entryTxs = this.tryDecodeEntry();
+            if (entryTxs === null) {
+                throw new Error(`shredstream: incomplete entry at offset ${this.cursor}`);
+            }
+            nested.push(entryTxs);
+            this.entriesYielded++;
+        }
+        return nested;
+    }
+}
+function decodeEntriesBincodeFlat(entriesBytes) {
+    if (entriesBytes.length === 0)
+        return [];
+    const dec = new BatchDecoder();
+    return dec.pushFlat(entriesBytes);
+}
+function decodeEntriesBincodeNested(entriesBytes) {
+    if (entriesBytes.length === 0)
+        return [];
+    const dec = new BatchDecoder();
+    return dec.pushNested(entriesBytes);
+}
+/**
+ * 解码 gRPC `entries` 字节并展开为与旧 WASM 相同的嵌套 `ShredWasmTx`（跳过无法反序列化的单笔交易）。
+ */
+function decodeShredstreamEntriesBincode(bytes) {
+    const nested = decodeEntriesBincodeNested(bytes);
+    const out = [];
+    for (const entryTxs of nested) {
+        const row = [];
+        for (const w of entryTxs) {
+            const tx = (0, wire_to_shred_tx_js_1.wireBytesToShredWasmTx)(w.raw);
+            if (tx)
+                row.push(tx);
+        }
+        out.push(row);
+    }
+    return out;
+}

package/dist/shredstream/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Jito ShredStream 超低延迟订阅（与 Rust `sol-parser-sdk::shredstream` 对齐）。
+ *
+ * 限制（与 Rust `shredstream/mod.rs` 文档一致）：
+ * - 仅静态账户键；使用 ALT 的交易账户列表不完整
+ * - 无 inner instructions，无法 CPI 解析
+ * - 无 block_time
+ * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则用默认 pubkey best-effort）
+ * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
+ */
+export { type ShredStreamConfig, defaultShredStreamConfig, lowLatencyShredStreamConfig, highThroughputShredStreamConfig, } from "./config.js";
+export { ShredStreamClient, ShredEventQueue, type ShredStreamReceiveStats, } from "./client.js";
+export { dexEventsFromShredWasmTx, dexEventsFromShredWasmTxWithFullKeys, type ShredWasmTx, type ShredWasmCompiledIx, } from "./instruction_parse.js";
+export { fullAccountKeyStringsFromShredTx, loadAddressLookupTableAccounts } from "./alt_lookup.js";
+export type { SubscribeEntriesRequest, ShredstreamEntryMessage } from "./proto_types.js";
+export { bincodeVecEntryCount, decodeEntriesBincodeFlat, decodeEntriesBincodeNested, decodeShredstreamEntriesBincode, type DecodedWireTransaction, } from "./entries_decode.js";
+export { wireBytesToShredWasmTx } from "./wire_to_shred_tx.js";

package/dist/shredstream/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireBytesToShredWasmTx = exports.decodeShredstreamEntriesBincode = exports.decodeEntriesBincodeNested = exports.decodeEntriesBincodeFlat = exports.bincodeVecEntryCount = exports.loadAddressLookupTableAccounts = exports.fullAccountKeyStringsFromShredTx = exports.dexEventsFromShredWasmTxWithFullKeys = exports.dexEventsFromShredWasmTx = exports.ShredEventQueue = exports.ShredStreamClient = exports.highThroughputShredStreamConfig = exports.lowLatencyShredStreamConfig = exports.defaultShredStreamConfig = void 0;
+/**
+ * Jito ShredStream 超低延迟订阅（与 Rust `sol-parser-sdk::shredstream` 对齐）。
+ *
+ * 限制（与 Rust `shredstream/mod.rs` 文档一致）：
+ * - 仅静态账户键；使用 ALT 的交易账户列表不完整
+ * - 无 inner instructions，无法 CPI 解析
+ * - 无 block_time
+ * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则用默认 pubkey best-effort）
+ * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
+ */
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "defaultShredStreamConfig", { enumerable: true, get: function () { return config_js_1.defaultShredStreamConfig; } });
+Object.defineProperty(exports, "lowLatencyShredStreamConfig", { enumerable: true, get: function () { return config_js_1.lowLatencyShredStreamConfig; } });
+Object.defineProperty(exports, "highThroughputShredStreamConfig", { enumerable: true, get: function () { return config_js_1.highThroughputShredStreamConfig; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "ShredStreamClient", { enumerable: true, get: function () { return client_js_1.ShredStreamClient; } });
+Object.defineProperty(exports, "ShredEventQueue", { enumerable: true, get: function () { return client_js_1.ShredEventQueue; } });
+var instruction_parse_js_1 = require("./instruction_parse.js");
+Object.defineProperty(exports, "dexEventsFromShredWasmTx", { enumerable: true, get: function () { return instruction_parse_js_1.dexEventsFromShredWasmTx; } });
+Object.defineProperty(exports, "dexEventsFromShredWasmTxWithFullKeys", { enumerable: true, get: function () { return instruction_parse_js_1.dexEventsFromShredWasmTxWithFullKeys; } });
+var alt_lookup_js_1 = require("./alt_lookup.js");
+Object.defineProperty(exports, "fullAccountKeyStringsFromShredTx", { enumerable: true, get: function () { return alt_lookup_js_1.fullAccountKeyStringsFromShredTx; } });
+Object.defineProperty(exports, "loadAddressLookupTableAccounts", { enumerable: true, get: function () { return alt_lookup_js_1.loadAddressLookupTableAccounts; } });
+var entries_decode_js_1 = require("./entries_decode.js");
+Object.defineProperty(exports, "bincodeVecEntryCount", { enumerable: true, get: function () { return entries_decode_js_1.bincodeVecEntryCount; } });
+Object.defineProperty(exports, "decodeEntriesBincodeFlat", { enumerable: true, get: function () { return entries_decode_js_1.decodeEntriesBincodeFlat; } });
+Object.defineProperty(exports, "decodeEntriesBincodeNested", { enumerable: true, get: function () { return entries_decode_js_1.decodeEntriesBincodeNested; } });
+Object.defineProperty(exports, "decodeShredstreamEntriesBincode", { enumerable: true, get: function () { return entries_decode_js_1.decodeShredstreamEntriesBincode; } });
+var wire_to_shred_tx_js_1 = require("./wire_to_shred_tx.js");
+Object.defineProperty(exports, "wireBytesToShredWasmTx", { enumerable: true, get: function () { return wire_to_shred_tx_js_1.wireBytesToShredWasmTx; } });

package/dist/shredstream/instruction_parse.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ShredStream：外层编译指令 → `parseInstructionUnified`（与 gRPC 指令解析同源）。
+ * `ShredWasmTx` 来自线格式交易经 `@solana/web3.js` 反序列化（见 `wire_to_shred_tx.ts`），非 WASM。
+ * 有 `ShredStreamConfig.connection` 时可展开 V0 ALT；无 RPC 时用静态账户表 + 默认 pubkey best-effort。
+ */
+import type { MessageHeader } from "@solana/web3.js";
+import { type DexEvent } from "../core/dex_event.js";
+import { type EventTypeFilter } from "../grpc/types.js";
+export type ShredWasmCompiledIx = {
+    programIdIndex: number;
+    accounts: Uint8Array;
+    data: Uint8Array;
+};
+export type ShredAddressTableLookup = {
+    accountKey: string;
+    writableIndexes: Uint8Array;
+    readonlyIndexes: Uint8Array;
+};
+export type ShredWasmTx = {
+    signature: string;
+    accounts: string[];
+    instructions?: ShredWasmCompiledIx[];
+    /** 缺省则按仅静态账户处理 */
+    messageVersion?: "legacy" | "v0";
+    header?: MessageHeader;
+    recentBlockhash?: Uint8Array;
+    addressTableLookups?: ShredAddressTableLookup[];
+};
+/**
+ * 使用已解析的完整账户表（静态+ALT）解析外层指令。
+ */
+export declare function dexEventsFromShredWasmTxWithFullKeys(tx: ShredWasmTx, fullAccountKeys: string[], slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];
+/** 仅静态账户表（无 RPC 时；V0+ALT 缺失账户以默认 pubkey 占位） */
+export declare function dexEventsFromShredWasmTx(tx: ShredWasmTx, slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];

package/dist/shredstream/instruction_parse.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dexEventsFromShredWasmTxWithFullKeys = dexEventsFromShredWasmTxWithFullKeys;
+exports.dexEventsFromShredWasmTx = dexEventsFromShredWasmTx;
+const dex_event_js_1 = require("../core/dex_event.js");
+const pumpfun_fee_enrich_js_1 = require("../core/pumpfun_fee_enrich.js");
+const types_js_1 = require("../grpc/types.js");
+const mod_js_1 = require("../instr/mod.js");
+const program_ids_js_1 = require("../instr/program_ids.js");
+function asU8(b) {
+    if (b instanceof Uint8Array)
+        return b;
+    return Uint8Array.from(b);
+}
+const UNKNOWN_PROGRAM_CANDIDATES = [
+    program_ids_js_1.PUMPFUN_PROGRAM_ID,
+    program_ids_js_1.PUMPSWAP_PROGRAM_ID,
+    program_ids_js_1.PUMP_FEES_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_LAUNCHLAB_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_CPMM_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_CLMM_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_AMM_V4_PROGRAM_ID,
+    program_ids_js_1.ORCA_WHIRLPOOL_PROGRAM_ID,
+    program_ids_js_1.METEORA_POOLS_PROGRAM_ID,
+    program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID,
+    program_ids_js_1.METEORA_DLMM_PROGRAM_ID,
+];
+const SHRED_DEFAULT_PUBKEY = (0, dex_event_js_1.defaultPubkey)();
+function shouldParseShredInstructions(eventTypeFilter) {
+    const includeOnly = eventTypeFilter?.include_only;
+    return !includeOnly || (0, types_js_1.eventTypeFilterAllowsInstructionParsing)(includeOnly);
+}
+function ixAccountStrings(fullAccountKeys, accBytes) {
+    const accountStrs = [];
+    for (let i = 0; i < accBytes.length; i++) {
+        const ai = accBytes[i];
+        accountStrs.push(ai < fullAccountKeys.length ? fullAccountKeys[ai] : SHRED_DEFAULT_PUBKEY);
+    }
+    return accountStrs;
+}
+/**
+ * 使用已解析的完整账户表（静态+ALT）解析外层指令。
+ */
+function dexEventsFromShredWasmTxWithFullKeys(tx, fullAccountKeys, slot, txIndex, grpcRecvUs, eventTypeFilter) {
+    const ixs = tx.instructions;
+    if (!ixs?.length || fullAccountKeys.length === 0)
+        return [];
+    if (!shouldParseShredInstructions(eventTypeFilter))
+        return [];
+    const out = [];
+    for (const rawIx of ixs) {
+        const pidIdx = rawIx.programIdIndex;
+        if (!Number.isFinite(pidIdx) || pidIdx < 0)
+            continue;
+        const accBytes = asU8(rawIx.accounts);
+        const data = asU8(rawIx.data);
+        const accountStrs = ixAccountStrings(fullAccountKeys, accBytes);
+        if (pidIdx >= fullAccountKeys.length) {
+            for (const programId of UNKNOWN_PROGRAM_CANDIDATES) {
+                const ev = (0, mod_js_1.parseInstructionUnified)(data, accountStrs, tx.signature, slot, txIndex, undefined, grpcRecvUs, eventTypeFilter, programId);
+                if (ev) {
+                    out.push(ev);
+                    break;
+                }
+            }
+            continue;
+        }
+        const programId = fullAccountKeys[pidIdx];
+        const ev = (0, mod_js_1.parseInstructionUnified)(data, accountStrs, tx.signature, slot, txIndex, undefined, grpcRecvUs, eventTypeFilter, programId);
+        if (ev)
+            out.push(ev);
+    }
+    (0, pumpfun_fee_enrich_js_1.enrichPumpfunSameTxPostMerge)(out);
+    return out;
+}
+/** 仅静态账户表（无 RPC 时；V0+ALT 缺失账户以默认 pubkey 占位） */
+function dexEventsFromShredWasmTx(tx, slot, txIndex, grpcRecvUs, eventTypeFilter) {
+    return dexEventsFromShredWasmTxWithFullKeys(tx, tx.accounts, slot, txIndex, grpcRecvUs, eventTypeFilter);
+}

package/dist/shredstream/proto_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ShredStream gRPC 消息形状（与 Rust `shredstream::proto` 中 prost 定义一致）。
+ * 实际线路仍由 `shredstream.proto` + `@grpc/proto-loader` 解析。
+ */
+export type SubscribeEntriesRequest = Record<string, never>;
+export interface ShredstreamEntryMessage {
+    slot: number | string | bigint;
+    entries: Uint8Array | Buffer;
+}

package/dist/shredstream/proto_types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shredstream/shredstream.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package shredstream;
+
+// 与 Rust `shredstream/proto/mod.rs` 内嵌定义一致；路径 /shredstream.ShredstreamProxy/SubscribeEntries
+service ShredstreamProxy {
+  rpc SubscribeEntries(SubscribeEntriesRequest) returns (stream Entry);
+}
+
+message SubscribeEntriesRequest {}
+
+message Entry {
+  uint64 slot = 1;
+  bytes entries = 2;
+}

package/dist/shredstream/wire_to_shred_tx.d.ts

@@ -0,0 +1,2 @@
+import type { ShredWasmTx } from "./instruction_parse.js";
+export declare function wireBytesToShredWasmTx(raw: Uint8Array): ShredWasmTx | null;

package/dist/shredstream/wire_to_shred_tx.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireBytesToShredWasmTx = wireBytesToShredWasmTx;
+/**
+ * 线格式交易字节 → `ShredWasmTx`（与原 wasm-pack 展开字段对齐，供 `parseInstructionUnified`）。
+ */
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+function wireBytesToShredWasmTx(raw) {
+    try {
+        const vt = web3_js_1.VersionedTransaction.deserialize(Buffer.from(raw));
+        const sig0 = vt.signatures[0];
+        if (!sig0)
+            return null;
+        const signature = bs58_1.default.encode(sig0);
+        const msg = vt.message;
+        if (msg instanceof web3_js_1.MessageV0) {
+            const lookups = msg.addressTableLookups.map((l) => ({
+                accountKey: l.accountKey.toBase58(),
+                writableIndexes: new Uint8Array(l.writableIndexes),
+                readonlyIndexes: new Uint8Array(l.readonlyIndexes),
+            }));
+            const instructions = msg.compiledInstructions.map((ix) => ({
+                programIdIndex: ix.programIdIndex,
+                accounts: new Uint8Array(ix.accountKeyIndexes),
+                data: new Uint8Array(ix.data),
+            }));
+            return {
+                signature,
+                accounts: msg.staticAccountKeys.map((k) => k.toBase58()),
+                instructions,
+                messageVersion: "v0",
+                header: msg.header,
+                recentBlockhash: Uint8Array.from(bs58_1.default.decode(msg.recentBlockhash)),
+                addressTableLookups: lookups,
+            };
+        }
+        const m = msg;
+        const instructions = m.compiledInstructions.map((ix) => ({
+            programIdIndex: ix.programIdIndex,
+            accounts: new Uint8Array(ix.accountKeyIndexes),
+            data: new Uint8Array(ix.data),
+        }));
+        return {
+            signature,
+            accounts: m.staticAccountKeys.map((k) => k.toBase58()),
+            instructions,
+            messageVersion: "legacy",
+            header: m.header,
+            recentBlockhash: Uint8Array.from(bs58_1.default.decode(m.recentBlockhash)),
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/util/binary.d.ts

@@ -0,0 +1,14 @@
+export declare function readU8(u8: Uint8Array, o: number): number | null;
+export declare function readU16LE(u8: Uint8Array, o: number): number | null;
+export declare function readU32LE(u8: Uint8Array, o: number): number | null;
+export declare function readI32LE(u8: Uint8Array, o: number): number | null;
+export declare function readU64LE(u8: Uint8Array, o: number): bigint | null;
+export declare function readI64LE(u8: Uint8Array, o: number): bigint | null;
+export declare function readU128LE(u8: Uint8Array, o: number): bigint | null;
+export declare function readBool(u8: Uint8Array, o: number): boolean | null;
+export declare function readPubkey(u8: Uint8Array, o: number): string | null;
+export declare function readBorshString(u8: Uint8Array, o: number): {
+    s: string;
+    next: number;
+} | null;
+export declare function readDiscriminatorU64(u8: Uint8Array): bigint | null;

package/dist/util/binary.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readU8 = readU8;
+exports.readU16LE = readU16LE;
+exports.readU32LE = readU32LE;
+exports.readI32LE = readI32LE;
+exports.readU64LE = readU64LE;
+exports.readI64LE = readI64LE;
+exports.readU128LE = readU128LE;
+exports.readBool = readBool;
+exports.readPubkey = readPubkey;
+exports.readBorshString = readBorshString;
+exports.readDiscriminatorU64 = readDiscriminatorU64;
+const web3_js_1 = require("@solana/web3.js");
+function readU8(u8, o) {
+    if (o >= u8.length)
+        return null;
+    return u8[o];
+}
+function readU16LE(u8, o) {
+    if (o + 2 > u8.length)
+        return null;
+    const v = new DataView(u8.buffer, u8.byteOffset + o, 2);
+    return v.getUint16(0, true);
+}
+function readU32LE(u8, o) {
+    if (o + 4 > u8.length)
+        return null;
+    const v = new DataView(u8.buffer, u8.byteOffset + o, 4);
+    return v.getUint32(0, true);
+}
+function readI32LE(u8, o) {
+    if (o + 4 > u8.length)
+        return null;
+    const v = new DataView(u8.buffer, u8.byteOffset + o, 4);
+    return v.getInt32(0, true);
+}
+function readU64LE(u8, o) {
+    if (o + 8 > u8.length)
+        return null;
+    const v = new DataView(u8.buffer, u8.byteOffset + o, 8);
+    return v.getBigUint64(0, true);
+}
+function readI64LE(u8, o) {
+    if (o + 8 > u8.length)
+        return null;
+    const v = new DataView(u8.buffer, u8.byteOffset + o, 8);
+    return v.getBigInt64(0, true);
+}
+function readU128LE(u8, o) {
+    const lo = readU64LE(u8, o);
+    const hi = readU64LE(u8, o + 8);
+    if (lo === null || hi === null)
+        return null;
+    return lo | (hi << 64n);
+}
+function readBool(u8, o) {
+    const b = readU8(u8, o);
+    if (b === null)
+        return null;
+    return b === 1;
+}
+function readPubkey(u8, o) {
+    if (o + 32 > u8.length)
+        return null;
+    return new web3_js_1.PublicKey(u8.subarray(o, o + 32)).toBase58();
+}
+function readBorshString(u8, o) {
+    const len = readU32LE(u8, o);
+    if (len === null || o + 4 + len > u8.length)
+        return null;
+    const bytes = u8.subarray(o + 4, o + 4 + len);
+    try {
+        return { s: new TextDecoder().decode(bytes), next: o + 4 + len };
+    }
+    catch {
+        return null;
+    }
+}
+function readDiscriminatorU64(u8) {
+    return readU64LE(u8, 0);
+}

package/dist/util/market.d.ts

@@ -0,0 +1,18 @@
+export type NumericAmount = bigint | number | string;
+export type NormalizedTradeSide = "Buy" | "Sell";
+/**
+ * Convert a Q64.64 sqrt price into quote-token units per one base token.
+ */
+export declare function sqrtPriceX64ToPrice(sqrtPriceX64: NumericAmount, baseDecimals: number, quoteDecimals: number): number;
+/**
+ * Compute quote-token price per one base token from raw vault balances.
+ */
+export declare function vaultPriceFromBalances(baseRaw: NumericAmount, quoteRaw: NumericAmount, baseDecimals: number, quoteDecimals: number): number | undefined;
+/**
+ * Positive watched-token delta means Buy; negative means Sell.
+ */
+export declare function normalizeBuySellFromTokenDelta(tokenDelta: NumericAmount): NormalizedTradeSide | undefined;
+/**
+ * If input is quote, the user buys base. If input is base, the user sells base.
+ */
+export declare function normalizeBuySellFromInputMint(inputMint: string, baseMint: string, quoteMint: string): NormalizedTradeSide | undefined;