sol-parser-sdk 0.5.17 → 0.5.18

package/dist/shredstream/client.js

@@ -43,7 +43,7 @@ const protoLoader = __importStar(require("@grpc/proto-loader"));
 const node_path_1 = require("node:path");
 const unified_parser_js_1 = require("../core/unified_parser.js");
 const instruction_parse_js_1 = require("./instruction_parse.js");
-const alt_lookup_js_1 = require("./alt_lookup.js");
+const alt_cache_js_1 = require("./alt_cache.js");
 const config_js_1 = require("./config.js");
 const entries_decode_js_1 = require("./entries_decode.js");
 const PROTO_PATH = (0, node_path_1.join)(__dirname, "shredstream.proto");
@@ -79,8 +79,18 @@ function grpcCredentialsForEndpoint(endpoint) {
     }
     return grpc.credentials.createInsecure();
 }
-function sleepMs(ms) {
-    return new Promise((r) => setTimeout(r, ms));
+function sleepMs(ms, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const finish = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", finish);
+            resolve();
+        };
+        const timer = setTimeout(finish, ms);
+        signal.addEventListener("abort", finish, { once: true });
+    });
 }
 function shredDebugEnabled() {
     const v = process.env.SHREDSTREAM_DEBUG;
@@ -127,18 +137,22 @@ class ShredStreamClient {
     endpoint;
     config;
     ServiceClient;
+    lifecycleTail = Promise.resolve();
     loopAbort = null;
     loopPromise = null;
     activeCall = null;
+    altCache;
     receiveStats = {
         entryMessagesReceived: 0,
         entryDecodeFailures: 0,
         transactionsDecoded: 0,
         dexEventsQueued: 0,
+        altCacheMissTransactions: 0,
     };
     constructor(endpoint, config) {
         this.endpoint = endpoint;
         this.config = config;
+        this.altCache = new alt_cache_js_1.AddressLookupTableCache(config.connection, config.address_lookup_tables, config.alt_refresh_interval_ms);
         const root = loadProtoDefinition();
         const shred = root.shredstream;
         this.ServiceClient = shred.ShredstreamProxy;
@@ -167,6 +181,12 @@ class ShredStreamClient {
     getReceiveStats() {
         return { ...this.receiveStats };
     }
+    /** Prewarm required ALTs before subscribe(); this explicit call may perform RPC. */
+    async preloadAddressLookupTables(addresses) {
+        await this.altCache.preload(addresses);
+    }
+    /** Background refresh failures; cache misses are reported separately in receive stats. */
+    getAltRefreshFailures() { return this.altCache.refreshFailures; }
     /**
      * 与 Rust `new_with_config` 中 `ShredstreamProxyClient::connect_with_config(endpoint, &config)` 一致：
      * `connection_timeout_ms` / `request_timeout_ms` / `max_decoding_message_size` 见 `shredstream/proto/mod.rs`。
@@ -195,19 +215,27 @@ class ShredStreamClient {
      * 重连循环使用订阅时刻的配置快照（与 Rust 在 `tokio::spawn` 前 `config.clone()` 一致）。
      */
     async subscribe(eventTypeFilter) {
-        await this.stop();
-        this.receiveStats = {
-            entryMessagesReceived: 0,
-            entryDecodeFailures: 0,
-            transactionsDecoded: 0,
-            dexEventsQueued: 0,
-        };
-        const queue = new ShredEventQueue();
-        const ac = new AbortController();
-        this.loopAbort = ac;
-        const configSnapshot = { ...this.config };
-        this.loopPromise = this.runReconnectLoop(queue, ac.signal, configSnapshot, eventTypeFilter);
-        return queue;
+        return this.serializeLifecycle(async () => {
+            await this.stopUnlocked();
+            this.receiveStats = {
+                entryMessagesReceived: 0,
+                entryDecodeFailures: 0,
+                transactionsDecoded: 0,
+                dexEventsQueued: 0,
+                altCacheMissTransactions: 0,
+            };
+            const queue = new ShredEventQueue();
+            const ac = new AbortController();
+            this.loopAbort = ac;
+            const configSnapshot = { ...this.config };
+            this.altCache.start();
+            this.loopPromise = this.runReconnectLoop(queue, ac.signal, configSnapshot, eventTypeFilter)
+                .finally(() => {
+                if (this.loopAbort === ac)
+                    this.altCache.stop();
+            });
+            return queue;
+        });
     }
     /** 与 Rust `subscribe_with_filter` 对齐：在解析热路径按事件类型预过滤。 */
     async subscribeWithFilter(eventTypeFilter) {
@@ -215,6 +243,15 @@ class ShredStreamClient {
     }
     /** 停止订阅并中止当前流 */
     async stop() {
+        await this.serializeLifecycle(() => this.stopUnlocked());
+    }
+    serializeLifecycle(operation) {
+        const result = this.lifecycleTail.then(operation);
+        this.lifecycleTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async stopUnlocked() {
+        this.altCache.stop();
         this.loopAbort?.abort();
         this.loopAbort = null;
         this.activeCall?.cancel();
@@ -244,7 +281,7 @@ class ShredStreamClient {
                     break;
                 const msg = e instanceof Error ? e.message : String(e);
                 console.error(`ShredStream error: ${msg} - retry in ${delay}ms`);
-                await sleepMs(delay);
+                await sleepMs(delay, signal);
                 if (signal.aborted)
                     break;
                 delay = Math.min(delay * 2, 60_000);
@@ -268,23 +305,31 @@ class ShredStreamClient {
                 if (settled)
                     return;
                 settled = true;
+                signal.removeEventListener("abort", abort);
+                if (this.activeCall === call)
+                    this.activeCall = null;
+                client.close();
                 fn();
             };
+            const abort = () => {
+                call.cancel();
+                finish(resolve);
+            };
             const call = client.subscribeEntries({}, new grpc.Metadata());
             this.activeCall = call;
+            signal.addEventListener("abort", abort, { once: true });
             console.info("ShredStream connected, receiving entries...");
             call.on("data", (entry) => {
-                if (signal.aborted)
+                if (signal.aborted || settled)
                     return;
                 try {
-                    void this.processEntryMessage(entry, queue, eventTypeFilter);
+                    this.processEntryMessage(entry, queue, eventTypeFilter);
                 }
                 catch (err) {
                     console.error("processEntryMessage:", err);
                 }
             });
             call.on("error", (err) => {
-                client.close();
                 if (signal.aborted || err.code === grpc.status.CANCELLED) {
                     finish(() => resolve());
                     return;
@@ -293,12 +338,11 @@ class ShredStreamClient {
                 finish(() => reject(err));
             });
             call.on("end", () => {
-                client.close();
                 finish(() => resolve());
             });
         });
     }
-    async processEntryMessage(entry, queue, eventTypeFilter) {
+    processEntryMessage(entry, queue, eventTypeFilter) {
         this.receiveStats.entryMessagesReceived += 1;
         const recvUs = (0, unified_parser_js_1.nowUs)();
         const slotNum = toSlotNumber(entry.slot);
@@ -314,20 +358,9 @@ class ShredStreamClient {
             console.warn(`[shredstream] bincode 解码失败 slot=${slotNum} bytes=${bytes.length}: ${msg}`);
             return;
         }
-        const conn = this.config.connection;
-        if (conn) {
-            try {
-                await this.processEntryMessageWithAlt(decoded, slotNum, recvUs, queue, bytes.length, conn, eventTypeFilter);
-            }
-            catch (e) {
-                console.warn(`[shredstream] ALT/RPC 解析失败 slot=${slotNum}:`, e);
-                this.processEntryMessageSync(decoded, slotNum, recvUs, queue, bytes.length, eventTypeFilter);
-            }
-            return;
-        }
         this.processEntryMessageSync(decoded, slotNum, recvUs, queue, bytes.length, eventTypeFilter);
     }
-    /** 无 RPC：仅用静态账户表 */
+    /** Synchronous parsing: static keys or complete prewarmed ALT snapshots only. */
     processEntryMessageSync(decoded, slotNum, recvUs, queue, entriesBytesLen, eventTypeFilter) {
         let txTotal = 0;
         let evTotal = 0;
@@ -341,44 +374,15 @@ class ShredStreamClient {
                 const txIndex = globalTxIndex++;
                 if (!tx?.signature)
                     continue;
-                const events = (0, instruction_parse_js_1.dexEventsFromShredWasmTx)(tx, slotNum, txIndex, recvUs, eventTypeFilter);
-                evTotal += events.length;
-                for (const ev of events) {
-                    setGrpcRecvUsMut(ev, recvUs);
-                    queue.push(ev);
-                }
-            }
-        }
-        this.receiveStats.transactionsDecoded += txTotal;
-        this.receiveStats.dexEventsQueued += evTotal;
-        if (shredDebugEnabled()) {
-            console.info(`[shredstream] slot=${slotNum} entries_bytes=${entriesBytesLen} solana_entries=${decoded.length} txs=${txTotal} dex_events=${evTotal} (static_accounts_only)`);
-        }
-    }
-    /** 拉取 ALT 后完整账户表解析 */
-    async processEntryMessageWithAlt(decoded, slotNum, recvUs, queue, entriesBytesLen, conn, eventTypeFilter) {
-        const altKeys = new Set();
-        for (const outer of decoded) {
-            for (const tx of outer) {
-                for (const l of tx.addressTableLookups ?? []) {
-                    altKeys.add(l.accountKey);
-                }
-            }
-        }
-        const altMap = await (0, alt_lookup_js_1.loadAddressLookupTableAccounts)(conn, [...altKeys]);
-        let txTotal = 0;
-        let evTotal = 0;
-        let globalTxIndex = 0;
-        for (const outer of decoded) {
-            const txs = outer;
-            txTotal += txs.length;
-            for (let i = 0; i < txs.length; i++) {
-                const tx = txs[i];
-                const txIndex = globalTxIndex++;
-                if (!tx?.signature)
+                const useCache = this.config.connection || this.config.address_lookup_tables;
+                const fullKeys = useCache ? this.altCache.resolve(tx) : tx.accounts;
+                if (!fullKeys) {
+                    this.receiveStats.altCacheMissTransactions++;
                     continue;
-                const fullKeys = (0, alt_lookup_js_1.fullAccountKeyStringsFromShredTx)(tx, altMap);
-                const events = (0, instruction_parse_js_1.dexEventsFromShredWasmTxWithFullKeys)(tx, fullKeys, slotNum, txIndex, recvUs, eventTypeFilter);
+                }
+                const events = useCache
+                    ? (0, instruction_parse_js_1.dexEventsFromShredWasmTxWithFullKeys)(tx, fullKeys, slotNum, txIndex, recvUs, eventTypeFilter)
+                    : (0, instruction_parse_js_1.dexEventsFromShredWasmTx)(tx, slotNum, txIndex, recvUs, eventTypeFilter);
                 evTotal += events.length;
                 for (const ev of events) {
                     setGrpcRecvUsMut(ev, recvUs);
@@ -389,7 +393,7 @@ class ShredStreamClient {
         this.receiveStats.transactionsDecoded += txTotal;
         this.receiveStats.dexEventsQueued += evTotal;
         if (shredDebugEnabled()) {
-            console.info(`[shredstream] slot=${slotNum} entries_bytes=${entriesBytesLen} solana_entries=${decoded.length} txs=${txTotal} dex_events=${evTotal} alt_tables=${altKeys.size}`);
+            console.info(`[shredstream] slot=${slotNum} entries_bytes=${entriesBytesLen} solana_entries=${decoded.length} txs=${txTotal} dex_events=${evTotal} (static_accounts_only)`);
         }
     }
 }

package/dist/shredstream/config.d.ts

@@ -1,4 +1,4 @@
-import type { Connection } from "@solana/web3.js";
+import type { AddressLookupTableAccount, Connection } from "@solana/web3.js";
 /**
  * 与 Rust `sol-parser-sdk/src/shredstream/config.rs` 字段一一对应。
  *
@@ -7,7 +7,7 @@ import type { Connection } from "@solana/web3.js";
  * （`request_timeout_ms` 保留与 Rust `config.rs` 一致，流式路径不填 deadline）。
  * `reconnect_delay_ms` / `max_reconnect_attempts` 由 `client.rs` 重连循环使用。
  *
- * **TS 扩展**：`connection` 用于拉取链上 ALT，补全 V0 交易账户表以解析外层指令（主网 Pump 等必需）。
+ * **TS 扩展**：ALT 使用预热快照和独立刷新任务；解析热路径不发送 RPC。
  */
 export interface ShredStreamConfig {
     /** 连接超时（毫秒）→ tonic `Endpoint::connect_timeout` / gRPC `waitForReady` */
@@ -20,8 +20,12 @@ export interface ShredStreamConfig {
     reconnect_delay_ms: number;
     /** 最大重连次数（0 表示无限重连） */
     max_reconnect_attempts: number;
-    /** 可选：主网 RPC，用于解析 V0 地址查找表（ALT） */
+    /** 可选：只供显式预热及后台 ALT 刷新使用，解析热路径不发送 RPC。 */
     connection?: Connection;
+    /** 可选：订阅前已加载的 ALT 快照；未命中时跳过整笔 V0 交易并累计计数。 */
+    address_lookup_tables?: readonly AddressLookupTableAccount[];
+    /** 独立 ALT 刷新间隔（毫秒），默认 1000；最多一个刷新请求在途。 */
+    alt_refresh_interval_ms?: number;
 }
 export declare function defaultShredStreamConfig(): ShredStreamConfig;
 /** 低延迟：更短超时与重连间隔 */

package/dist/shredstream/index.d.ts

@@ -2,10 +2,10 @@
  * Jito ShredStream 超低延迟订阅（与 Rust `sol-parser-sdk::shredstream` 对齐）。
  *
  * 限制（与 Rust `shredstream/mod.rs` 文档一致）：
- * - 仅静态账户键；使用 ALT 的交易账户列表不完整
+ * - ALT 仅使用预热缓存；启用缓存后 miss 会跳过该交易并记录 altCacheMissTransactions，不回放
  * - 无 inner instructions，无法 CPI 解析
  * - 无 block_time
- * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则用默认 pubkey best-effort）
+ * - 无交易日志（program logs）；客户端使用外层指令解析。未配置 ALT 缓存时保留静态账户 best-effort 行为。
  * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
  */
 export { type ShredStreamConfig, defaultShredStreamConfig, lowLatencyShredStreamConfig, highThroughputShredStreamConfig, } from "./config.js";
@@ -15,3 +15,4 @@ export { fullAccountKeyStringsFromShredTx, loadAddressLookupTableAccounts } from
 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";
+export { AddressLookupTableCache } from "./alt_cache.js";

package/dist/shredstream/index.js

@@ -1,14 +1,14 @@
 "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;
+exports.AddressLookupTableCache = 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 的交易账户列表不完整
+ * - ALT 仅使用预热缓存；启用缓存后 miss 会跳过该交易并记录 altCacheMissTransactions，不回放
  * - 无 inner instructions，无法 CPI 解析
  * - 无 block_time
- * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则用默认 pubkey best-effort）
+ * - 无交易日志（program logs）；客户端使用外层指令解析。未配置 ALT 缓存时保留静态账户 best-effort 行为。
  * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
  */
 var config_js_1 = require("./config.js");
@@ -31,3 +31,5 @@ Object.defineProperty(exports, "decodeEntriesBincodeNested", { enumerable: true,
 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; } });
+var alt_cache_js_1 = require("./alt_cache.js");
+Object.defineProperty(exports, "AddressLookupTableCache", { enumerable: true, get: function () { return alt_cache_js_1.AddressLookupTableCache; } });

package/dist/shredstream/instruction_parse.d.ts

@@ -1,7 +1,7 @@
 /**
  * ShredStream：外层编译指令 → `parseInstructionUnified`（与 gRPC 指令解析同源）。
  * `ShredWasmTx` 来自线格式交易经 `@solana/web3.js` 反序列化（见 `wire_to_shred_tx.ts`），非 WASM。
- * 有 `ShredStreamConfig.connection` 时可展开 V0 ALT；无 RPC 时用静态账户表 + 默认 pubkey best-effort。
+ * 客户端通过预热 ALT 缓存展开 V0 账户；connection 只供独立刷新使用。
  */
 import type { MessageHeader } from "@solana/web3.js";
 import { type DexEvent } from "../core/dex_event.js";

package/dist/shredstream/instruction_parse.js

@@ -22,6 +22,7 @@ const UNKNOWN_PROGRAM_CANDIDATES = [
     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_DBC_PROGRAM_ID,
     program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID,
     program_ids_js_1.METEORA_DLMM_PROGRAM_ID,
 ];

package/dist/simulation_route.d.ts

@@ -1,6 +1,6 @@
 import { type TransactionRoute } from "./transaction_route.js";
 /** 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.
+ * V0 requires caller-resolved addresses in result.value.loadedAddresses.
  */
 export declare function analyzeSimulationRoutes(wire: Uint8Array, response: unknown, graduatedPools?: readonly string[]): TransactionRoute;

package/dist/simulation_route.js

@@ -21,12 +21,10 @@ function unsigned(value, bits) {
 }
 /** 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.
+ * V0 requires caller-resolved addresses in result.value.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 ||
@@ -37,7 +35,22 @@ function analyzeSimulationRoutes(wire, response, graduatedPools = []) {
     if (value.innerInstructions !== null &&
         !Array.isArray(value.innerInstructions))
         throw Error("Invalid simulation inner instructions");
-    const keys = tx.message.accountKeys;
+    const lookups = tx.message.addressTableLookups;
+    const loaded = value.loadedAddresses ?? { writable: [], readonly: [] };
+    if (lookups.length && value.loadedAddresses == null)
+        throw Error("V0 ALT addresses unavailable; provide loadedAddresses");
+    if (!loaded || typeof loaded !== "object" || Array.isArray(loaded))
+        throw Error("Invalid simulation loaded addresses");
+    for (const side of ["writable", "readonly"]) {
+        const expected = lookups.reduce((n, lookup) => n + lookup[side === "writable" ? "writableIndexes" : "readonlyIndexes"].length, 0);
+        if (!Array.isArray(loaded[side]) || loaded[side].length !== expected)
+            throw Error("Simulation loaded address count does not match wire lookups");
+        for (const key of loaded[side]) {
+            if (typeof key !== "string" || bs58_1.default.decode(key).length !== 32)
+                throw Error("Invalid simulation loaded public key");
+        }
+    }
+    const keys = [...tx.message.accountKeys, ...loaded.writable, ...loaded.readonly];
     const index = (key) => {
         if (typeof key !== "string")
             throw Error("Missing simulation account key");

package/dist/transaction_route.js

@@ -47,10 +47,14 @@ const LAB = new Map([
     [hex([95, 200, 71, 34, 8, 9, 11, 166]), [false, false]],
 ]);
 const PUMP = new Map([
+    [hex([184, 23, 238, 97, 103, 197, 211, 61]), [true, false]],
+    [hex([194, 171, 28, 70, 104, 77, 91, 47]), [true, true]],
+    [hex([93, 246, 130, 60, 231, 233, 64, 178]), [false, true]],
     [hex([198, 46, 21, 82, 180, 217, 232, 112]), [true, true]],
     [hex([102, 6, 61, 18, 1, 218, 235, 234]), [true, false]],
     [hex([51, 230, 133, 164, 1, 127, 131, 173]), [false, true]],
 ]);
+const CURVE_V3 = new Map([[hex([7, 5, 29, 196, 245, 23, 101, 80]), [true, false]], [hex([225, 247, 80, 30, 213, 179, 132, 136]), [true, true]], [hex([28, 146, 222, 119, 38, 196, 105, 213]), [false, true]]]);
 const CURVE_V2 = new Map([
     [hex([194, 171, 28, 70, 104, 77, 91, 47]), [true, true]],
     [hex([184, 23, 238, 97, 103, 197, 211, 61]), [true, false]],
@@ -132,7 +136,7 @@ function swap(ix, mints, graduated) {
         (protocol === "LaunchLab" ? LAB : PUMP).has(disc)) {
         const [buy, input] = (protocol === "LaunchLab" ? LAB : PUMP).get(disc);
         exact = input;
-        if (n < (protocol === "LaunchLab" ? 18 : 21))
+        if (n < (protocol === "LaunchLab" ? 18 : (["b817ee6167c5d33d", "c2ab1c46684d5b2f", "5df6823ce7e940b2"].includes(disc) ? 17 : 21)))
             return null;
         source = a(buy ? 6 : 5);
         dest = a(buy ? 5 : 6);
@@ -148,6 +152,21 @@ function swap(ix, mints, graduated) {
             pair = buy ? [a(4), a(3)] : [a(3), a(4)];
         }
     }
+    else if (protocol === 'PumpFun' && CURVE_V3.has(disc) && n === 17 && d.length >= 24) {
+        const [buy, input] = CURVE_V3.get(disc);
+        exact = input;
+        pool = a(5);
+        user = a(8);
+        source = a(buy ? 10 : 9);
+        dest = a(buy ? 9 : 10);
+        pair = buy ? [a(2), a(1)] : [a(1), a(2)];
+        if (a(2) === exports.WSOL) {
+            if (buy)
+                source = user;
+            else
+                dest = user;
+        }
+    }
     else if (protocol === 'PumpFun' && CURVE_V2.has(disc) && n >= 16) {
         const [buy, input] = CURVE_V2.get(disc);
         exact = input;

package/dist/wire_transaction.js

@@ -145,25 +145,24 @@ function decodeWireTransaction(data, offset = 0, requireComplete = true) {
             throw new Error("Signature count does not match header");
     }
     if (header[0] > keys.length ||
-        header[1] > header[0] ||
+        header[1] >= header[0] ||
         header[2] > keys.length - header[0])
         throw new Error("Invalid message header");
     if (version === 1) {
-        if (header[1] >= header[0])
-            throw new Error("V1 requires a writable fee payer");
         if (new Set(keys.map((k) => bs58_1.default.encode(k))).size !== keys.length)
             throw new Error("Duplicate V1 accounts");
-        for (const ix of instructions)
-            if (ix.programIdIndex === 0 ||
-                ix.programIdIndex >= keys.length ||
-                ix.accounts.some((i) => i >= keys.length))
-                throw new Error("Invalid V1 instruction index");
     }
-    const accountCount = keys.length + lookups.reduce((n, l) => n + l.writableIndexes.length + l.readonlyIndexes.length, 0);
+    let accountCount = keys.length;
+    for (const lookup of lookups) {
+        const count = lookup.writableIndexes.length + lookup.readonlyIndexes.length;
+        if (!count)
+            throw new Error("Empty address table lookup");
+        accountCount += count;
+    }
     if (accountCount > 256)
         throw new Error("Too many resolved account keys");
     for (const ix of instructions)
-        if (ix.programIdIndex >= keys.length || ix.accounts.some(i => i >= accountCount))
+        if (ix.programIdIndex === 0 || ix.programIdIndex >= keys.length || ix.accounts.some(i => i >= accountCount))
             throw new Error("Invalid instruction index");
     if (requireComplete && r.pos !== data.length)
         throw new Error("Trailing transaction bytes");