sol-parser-sdk 0.5.15 → 0.5.17

package/dist/wire_transaction.d.ts

@@ -0,0 +1,35 @@
+export interface WireInstruction {
+    programIdIndex: number;
+    accounts: number[];
+    data: string;
+}
+export interface WireMessage {
+    header: {
+        numRequiredSignatures: number;
+        numReadonlySignedAccounts: number;
+        numReadonlyUnsignedAccounts: number;
+    };
+    accountKeys: string[];
+    recentBlockhash: string;
+    instructions: WireInstruction[];
+    addressTableLookups: {
+        accountKey: string;
+        writableIndexes: number[];
+        readonlyIndexes: number[];
+    }[];
+    config?: {
+        priorityFee?: bigint;
+        computeUnitLimit?: number;
+        loadedAccountsDataSizeLimit?: number;
+        heapSize?: number;
+    };
+}
+export interface DecodedWireTransaction {
+    signatures: string[];
+    message: WireMessage;
+    version: "legacy" | 0 | 1;
+}
+export declare function decodeWireTransaction(data: Uint8Array, offset?: number, requireComplete?: boolean): {
+    transaction: DecodedWireTransaction;
+    length: number;
+};

package/dist/wire_transaction.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeWireTransaction = decodeWireTransaction;
+/** Native canonical Solana Legacy, V0 and V1 decoder; no Rust runtime. */
+const bs58_1 = __importDefault(require("bs58"));
+class Reader {
+    data;
+    pos;
+    constructor(data, offset) {
+        this.data = data;
+        this.pos = offset;
+    }
+    take(n) {
+        if (!Number.isSafeInteger(n) || n < 0 || this.pos + n > this.data.length)
+            throw new Error("Truncated transaction");
+        const value = this.data.slice(this.pos, this.pos + n);
+        this.pos += n;
+        return value;
+    }
+    uint(n = 1) {
+        const bytes = this.take(n);
+        let value = 0;
+        for (let i = n - 1; i >= 0; i--)
+            value = value * 256 + bytes[i];
+        return value;
+    }
+    u64() {
+        const b = this.take(8);
+        let value = 0n;
+        for (let i = 7; i >= 0; i--)
+            value = value * 256n + BigInt(b[i]);
+        return value;
+    }
+    short() {
+        let value = 0;
+        for (let i = 0; i < 3; i++) {
+            const b = this.uint();
+            if (i === 2 && b > 3)
+                throw new Error("Invalid short-u16");
+            value |= (b & 127) << (7 * i);
+            if (!(b & 128)) {
+                if (i && b === 0)
+                    throw new Error("Noncanonical short-u16");
+                return value;
+            }
+        }
+        throw new Error("Invalid short-u16");
+    }
+}
+function decodeWireTransaction(data, offset = 0, requireComplete = true) {
+    if (!Number.isInteger(offset) || offset < 0 || offset >= data.length)
+        throw new Error("Invalid wire offset");
+    const r = new Reader(data, offset);
+    let version = "legacy";
+    let signatures = [];
+    let header;
+    let keys;
+    let hash;
+    let instructions = [];
+    const lookups = [];
+    let config;
+    if (data[offset] === 129) {
+        r.take(1);
+        version = 1;
+        header = r.take(3);
+        const mask = r.uint(4);
+        hash = r.take(32);
+        if (mask & ~31 || ((mask & 3) !== 0 && (mask & 3) !== 3))
+            throw new Error("Invalid V1 config mask");
+        const count = r.uint(), keyCount = r.uint();
+        if (count > 64 || keyCount > 64 || header[0] > 12)
+            throw new Error("V1 transaction limit exceeded");
+        keys = Array.from({ length: keyCount }, () => r.take(32));
+        config = {};
+        if (mask & 3)
+            config.priorityFee = r.u64();
+        if (mask & 4)
+            config.computeUnitLimit = r.uint(4);
+        if (mask & 8)
+            config.loadedAccountsDataSizeLimit = r.uint(4);
+        if (mask & 16)
+            config.heapSize = r.uint(4);
+        if (config.heapSize !== undefined &&
+            (config.heapSize < 32768 ||
+                config.heapSize > 262144 ||
+                config.heapSize % 1024))
+            throw new Error("Invalid heap size");
+        const headers = Array.from({ length: count }, () => [r.uint(), r.uint(), r.uint(2)]);
+        instructions = headers.map(([programIdIndex, n, length]) => ({
+            programIdIndex,
+            accounts: Array.from(r.take(n)),
+            data: bs58_1.default.encode(r.take(length)),
+        }));
+        signatures = Array.from({ length: header[0] }, () => r.take(64));
+        if (r.pos - offset > 4096)
+            throw new Error("V1 transaction exceeds 4096 bytes");
+    }
+    else {
+        const sigCount = r.short();
+        if (sigCount > 127)
+            throw new Error("Too many signatures");
+        signatures = Array.from({ length: sigCount }, () => r.take(64));
+        const first = r.uint();
+        if (first & 128) {
+            if (first !== 128)
+                throw new Error("Unknown transaction version");
+            version = 0;
+            header = r.take(3);
+        }
+        else
+            header = Uint8Array.from([first, ...r.take(2)]);
+        const keyCount = r.short();
+        if (keyCount > 256)
+            throw new Error("Too many account keys");
+        keys = Array.from({ length: keyCount }, () => r.take(32));
+        hash = r.take(32);
+        const count = r.short();
+        for (let i = 0; i < count; i++) {
+            const programIdIndex = r.uint();
+            const accounts = Array.from(r.take(r.short()));
+            const payload = r.take(r.short());
+            instructions.push({
+                programIdIndex,
+                accounts,
+                data: bs58_1.default.encode(payload),
+            });
+        }
+        if (version === 0) {
+            const count = r.short();
+            for (let i = 0; i < count; i++) {
+                const key = r.take(32);
+                const writableIndexes = Array.from(r.take(r.short()));
+                const readonlyIndexes = Array.from(r.take(r.short()));
+                lookups.push({
+                    accountKey: bs58_1.default.encode(key),
+                    writableIndexes,
+                    readonlyIndexes,
+                });
+            }
+        }
+        if (signatures.length !== header[0])
+            throw new Error("Signature count does not match header");
+    }
+    if (header[0] > keys.length ||
+        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);
+    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))
+            throw new Error("Invalid instruction index");
+    if (requireComplete && r.pos !== data.length)
+        throw new Error("Trailing transaction bytes");
+    const message = {
+        header: {
+            numRequiredSignatures: header[0],
+            numReadonlySignedAccounts: header[1],
+            numReadonlyUnsignedAccounts: header[2],
+        },
+        accountKeys: keys.map((k) => bs58_1.default.encode(k)),
+        recentBlockhash: bs58_1.default.encode(hash),
+        instructions,
+        addressTableLookups: lookups,
+    };
+    if (config)
+        message.config = config;
+    return {
+        transaction: {
+            signatures: signatures.map((s) => bs58_1.default.encode(s)),
+            message,
+            version,
+        },
+        length: r.pos - offset,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol-parser-sdk",
-  "version": "0.5.15",
+  "version": "0.5.17",
   "description": "High-performance Solana DEX event parser for Node.js/TypeScript (Yellowstone gRPC, log parsing)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,7 +9,11 @@
     "README.md",
     "README_CN.md",
     "LICENSE",
-    ".env.example"
+    ".env.example",
+    "NATIVE_ALIGNMENT.md",
+    "NATIVE_MIGRATION.md",
+    "NATIVE_*_ALIGNMENT_*.md",
+    "NATIVE_*_EVIDENCE_*.json"
   ],
   "repository": {
     "type": "git",
@@ -23,7 +27,7 @@
     "node": ">=20.18.0"
   },
   "scripts": {
-    "build": "tsc && mkdir -p dist/shredstream && cp src/shredstream/shredstream.proto dist/shredstream/",
+    "build": "tsc && mkdir -p dist/shredstream && cp src/shredstream/shredstream.proto dist/shredstream/ && mkdir -p dist/grpc/protocol && cp src/grpc/protocol/*.proto src/grpc/protocol/NOTICE src/grpc/protocol/LICENSE dist/grpc/protocol/",
     "prepublishOnly": "npm run build",
     "check:dex-events": "tsx scripts/check-dex-event-parity.ts",
     "verify:discriminators": "tsx scripts/verify-program-log-discriminators.ts",
@@ -58,7 +62,6 @@
     "@grpc/grpc-js": "^1.12.4",
     "@grpc/proto-loader": "^0.7.13",
     "@solana/web3.js": "^1.95.4",
-    "@triton-one/yellowstone-grpc": "7.0.0",
     "bs58": "^6.0.0"
   }
 }