@oobe-protocol-labs/synapse-sap-sdk 0.13.0 → 0.14.0

package/dist/esm/parser/complete.js

@@ -1,173 +0,0 @@
-/**
- * @module parser/complete
- * @description Full SAP transaction parser: instructions + args + accounts + events.
- *
- * This is "Case 2 Complete": given a raw transaction response, produce a
- * single {@link ParsedSapTransaction} containing every decoded instruction,
- * all inner (CPI) calls, and all SAP events extracted from the logs.
- *
- * Designed for indexer pipelines where the decode step must be pure,
- * deterministic, and fully testable without an RPC connection.
- *
- * @category Parser
- * @since v0.5.0
- *
- * @example
- * ```ts
- * import { parseSapTransactionComplete } from "@synapse-sap/sdk/parser";
- * import { SAP_PROGRAM_ID, SAP_IDL } from "@synapse-sap/sdk";
- * import { Program } from "\@coral-xyz/anchor";
- *
- * const program = new Program(SAP_IDL, provider);
- * const tx = await connection.getTransaction(sig, {
- *   commitment: "confirmed",
- *   maxSupportedTransactionVersion: 0,
- * });
- *
- * const parsed = parseSapTransactionComplete(tx, program, SAP_PROGRAM_ID);
- * console.log(parsed.instructions.map(i => i.name));
- * console.log(parsed.events.map(e => e.name));
- * ```
- */
-import { EventParser } from "../events";
-import { parseSapInstructionsFromTransaction } from "./transaction";
-import { decodeInnerInstructions, extractAccountKeys, } from "./inner";
-// ================================================================
-//  Public API
-// ================================================================
-/**
- * Parse a complete SAP transaction into a unified result.
- *
- * Combines three stages:
- * 1. **Instruction decode** - top-level SAP instructions with args and accounts
- * 2. **Inner instruction decode** - CPI calls with full account reconstruction
- * 3. **Event extraction** - SAP events decoded from the transaction logs
- *
- * All three stages are safe: malformed data produces `null` fields
- * rather than exceptions. This makes the function suitable for
- * batch-processing in indexer workers where a single bad transaction
- * must not halt the pipeline.
- *
- * @param tx - The raw transaction response from `connection.getTransaction`.
- * @param program - An Anchor `Program` instance built from the SAP IDL.
- *   The coder and program ID are extracted automatically.
- * @param sapProgramId - The SAP program public key. Passed explicitly so
- *   callers can target devnet/localnet deployments independently.
- * @param options - Optional filters for instructions, events, and inner calls.
- * @param addressLookupTables - Resolved lookup table accounts for v0 transactions.
- * @returns A fully parsed transaction, or `null` if the input is `null`/`undefined`.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function parseSapTransactionComplete(tx, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-program, sapProgramId, options, addressLookupTables) {
-    if (!tx)
-        return null;
-    const opts = {
-        includeInner: options?.includeInner ?? false,
-        includeEvents: options?.includeEvents ?? true,
-        instructionFilter: options?.instructionFilter ?? [],
-        eventFilter: options?.eventFilter ?? [],
-    };
-    // Extract coder from the program
-    const coder = program.coder.instruction;
-    // 1. Top-level instructions
-    let instructions = parseSapInstructionsFromTransaction(tx, coder, sapProgramId, addressLookupTables);
-    if (opts.instructionFilter.length > 0) {
-        const filterSet = new Set(opts.instructionFilter);
-        instructions = instructions.filter((ix) => filterSet.has(ix.name));
-    }
-    // 2. Inner (CPI) instructions
-    let innerInstructions = [];
-    if (opts.includeInner && tx.meta?.innerInstructions) {
-        const accountKeys = extractAccountKeys(tx);
-        innerInstructions = decodeInnerInstructions(tx.meta.innerInstructions, accountKeys, coder, sapProgramId);
-    }
-    // 3. Events from logs
-    let events = [];
-    const logs = tx.meta?.logMessages ?? [];
-    if (opts.includeEvents && logs.length > 0) {
-        const eventParser = new EventParser(program);
-        events = eventParser.parseLogs(logs);
-        if (opts.eventFilter.length > 0) {
-            const filterSet = new Set(opts.eventFilter);
-            events = events.filter((e) => filterSet.has(e.name));
-        }
-    }
-    // 4. Metadata
-    const signature = extractSignature(tx);
-    const slot = tx.slot ?? null;
-    const blockTime = tx.blockTime ?? null;
-    const success = tx.meta?.err === null || tx.meta?.err === undefined;
-    return {
-        signature,
-        slot,
-        blockTime,
-        success,
-        instructions,
-        innerInstructions,
-        events,
-        logs,
-    };
-}
-/**
- * Parse multiple transactions in batch.
- *
- * Convenience wrapper for indexer pipelines that process pages of
- * transactions. Skips `null` entries and failed decodes silently.
- *
- * @param txs - Array of transaction responses (may contain `null` entries).
- * @param program - The Anchor SAP program instance.
- * @param sapProgramId - The SAP program public key.
- * @param options - Optional parse filters applied to every transaction.
- * @param addressLookupTables - Lookup tables for v0 transactions.
- * @returns An array of non-null parsed transactions.
- *
- * @category Parser
- * @since v0.5.0
- *
- * @example
- * ```ts
- * const signatures = await connection.getSignaturesForAddress(agentPda);
- * const txs = await Promise.all(
- *   signatures.map(s => connection.getTransaction(s.signature, { ... }))
- * );
- * const parsed = parseSapTransactionBatch(txs, program, SAP_PROGRAM_ID, {
- *   includeEvents: true,
- *   includeInner: true,
- * });
- * ```
- */
-export function parseSapTransactionBatch(txs, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-program, sapProgramId, options, addressLookupTables) {
-    const results = [];
-    for (const tx of txs) {
-        const parsed = parseSapTransactionComplete(tx, program, sapProgramId, options, addressLookupTables);
-        if (parsed)
-            results.push(parsed);
-    }
-    return results;
-}
-// ================================================================
-//  Internal
-// ================================================================
-/**
- * Extract the transaction signature from the response.
- * Different RPC clients expose it in different locations.
- *
- * @internal
- */
-function extractSignature(tx) {
-    // Some clients expose signatures on the transaction object
-    const txObj = tx.transaction;
-    if ("signatures" in txObj && Array.isArray(txObj.signatures) && txObj.signatures.length > 0) {
-        const first = txObj.signatures[0];
-        if (typeof first === "string")
-            return first;
-    }
-    return null;
-}
-//# sourceMappingURL=complete.js.map

package/dist/esm/parser/complete.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"complete.js","sourceRoot":"","sources":["../../../src/parser/complete.ts"],"names":[],"mappings":"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"}

package/dist/esm/parser/index.js

@@ -1,43 +0,0 @@
-/**
- * @module parser
- * @description Transaction parsing utilities for SAP v2.
- *
- * Provides modular, composable functions for decoding on-chain SAP
- * transactions into typed instruction data, argument objects, account
- * lists, and protocol events.
- *
- * Three levels of parsing are available depending on your use case:
- *
- * | Function | Input | Output |
- * |----------|-------|--------|
- * | `parseSapInstructionsFromTransaction` | `TransactionResponse` (RPC) | Decoded instructions |
- * | `parseSapInstructionsFromList` | `TransactionInstruction[]` | Decoded instructions |
- * | `parseSapTransactionComplete` | `TransactionResponse` (RPC) | Instructions + events + inner calls |
- *
- * All functions are pure and stateless: they accept the Anchor coder
- * (or full Program) as a parameter, making them safe for server-side
- * indexer workers, edge functions (Node.js runtime), and test suites.
- *
- * @category Parser
- * @since v0.5.0
- *
- * @example
- * ```ts
- * import {
- *   parseSapTransactionComplete,
- *   parseSapInstructionsFromList,
- *   containsSapInstruction,
- * } from "@synapse-sap/sdk/parser";
- * ```
- */
-// ── Case 2A: from TransactionResponse ────────────────
-export { parseSapInstructionsFromTransaction, parseSapInstructionNamesFromTransaction, } from "./transaction";
-// ── Case 2B: from TransactionInstruction[] ───────────
-export { parseSapInstructionsFromList, parseSapInstructionNamesFromList, containsSapInstruction, } from "./instructions";
-// ── Case 2 Complete: instructions + events + inner ───
-export { parseSapTransactionComplete, parseSapTransactionBatch, } from "./complete";
-// ── Inner instruction utilities ──────────────────────
-export { decodeInnerInstructions, filterSapInnerInstructions, extractAccountKeys, } from "./inner";
-// ── OOP wrapper (for SapClient integration) ──────────
-export { TransactionParser } from "./client";
-//# sourceMappingURL=index.js.map

package/dist/esm/parser/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAWH,wDAAwD;AACxD,OAAO,EACL,mCAAmC,EACnC,uCAAuC,GACxC,MAAM,eAAe,CAAC;AAEvB,wDAAwD;AACxD,OAAO,EACL,4BAA4B,EAC5B,gCAAgC,EAChC,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAExB,wDAAwD;AACxD,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAEpB,wDAAwD;AACxD,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,wDAAwD;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}

package/dist/esm/parser/inner.js

@@ -1,180 +0,0 @@
-/**
- * @module parser/inner
- * @description Decode inner (CPI) instructions from transaction metadata.
- *
- * When a SAP instruction triggers cross-program invocations, the
- * resulting inner instructions appear in `tx.meta.innerInstructions`.
- * These are stored in a "compiled" format that references account
- * indices rather than full public keys.
- *
- * This module reconstructs the full account keys from the transaction
- * message's account list and decodes any inner calls that target the
- * SAP program.
- *
- * @category Parser
- * @since v0.5.0
- *
- * @example
- * ```ts
- * import { decodeInnerInstructions } from "@synapse-sap/sdk/parser";
- *
- * const inner = decodeInnerInstructions(
- *   tx.meta?.innerInstructions ?? [],
- *   accountKeys,
- *   program.coder.instruction,
- *   SAP_PROGRAM_ID,
- * );
- * for (const cpi of inner) {
- *   if (cpi.name) console.log("SAP CPI:", cpi.name);
- * }
- * ```
- */
-import { PublicKey } from "@solana/web3.js";
-import { utils } from "@coral-xyz/anchor";
-// ================================================================
-//  Public API
-// ================================================================
-/**
- * Decode inner (CPI) instructions from transaction metadata.
- *
- * Reconstructs full public keys from the compiled account indices
- * and attempts to decode each inner instruction that targets the
- * SAP program. Non-SAP inner instructions are included in the
- * result with `name: null` and `args: null`.
- *
- * @param innerInstructionGroups - The `tx.meta.innerInstructions` array.
- * @param accountKeys - Ordered list of all account public keys from the
- *   transaction message (`staticAccountKeys` for versioned, or
- *   `accountKeys` for legacy).
- * @param coder - An Anchor instruction coder built from the SAP IDL.
- * @param sapProgramId - The SAP program public key.
- * @returns An array of decoded inner instructions.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function decodeInnerInstructions(innerInstructionGroups, accountKeys, coder, sapProgramId) {
-    const results = [];
-    for (const group of innerInstructionGroups) {
-        for (let innerIdx = 0; innerIdx < group.instructions.length; innerIdx++) {
-            const compiled = group.instructions[innerIdx];
-            if (!compiled)
-                continue;
-            const programId = resolveAccountKey(accountKeys, compiled.programIdIndex);
-            const accounts = compiled.accounts.map((idx) => resolveAccountKey(accountKeys, idx));
-            let name = null;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let args = null;
-            if (programId.equals(sapProgramId)) {
-                const decoded = safeDecodeInstruction(coder, compiled.data);
-                if (decoded) {
-                    name = decoded.name;
-                    args = decoded.data;
-                }
-            }
-            results.push({
-                outerIndex: group.index,
-                innerIndex: innerIdx,
-                name,
-                args,
-                accounts,
-                programId,
-            });
-        }
-    }
-    return results;
-}
-/**
- * Filter decoded inner instructions to only those targeting the SAP program.
- *
- * @param inner - The full inner instruction list from {@link decodeInnerInstructions}.
- * @returns Only inner instructions where `name` is not `null`.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function filterSapInnerInstructions(inner) {
-    return inner.filter((i) => i.name !== null);
-}
-// ================================================================
-//  Helpers: extract account keys from various tx formats
-// ================================================================
-/**
- * Extract the full ordered list of account keys from a transaction
- * response, handling both legacy and versioned formats.
- *
- * For versioned transactions that include loaded addresses (from
- * address lookup tables), these are appended after the static keys
- * in the order: static, writable loaded, readonly loaded.
- *
- * @param tx - The raw transaction response from RPC.
- * @returns An ordered array of all account public keys.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function extractAccountKeys(tx) {
-    const message = tx.transaction.message;
-    // Versioned messages expose `staticAccountKeys`
-    if ("staticAccountKeys" in message && Array.isArray(message.staticAccountKeys)) {
-        const staticKeys = message.staticAccountKeys.map(toPubkey);
-        const loaded = tx.meta?.loadedAddresses;
-        if (loaded) {
-            return [
-                ...staticKeys,
-                ...loaded.writable.map(toPubkey),
-                ...loaded.readonly.map(toPubkey),
-            ];
-        }
-        return staticKeys;
-    }
-    // Legacy messages expose `accountKeys`
-    if ("accountKeys" in message && Array.isArray(message.accountKeys)) {
-        return message.accountKeys.map(toPubkey);
-    }
-    return [];
-}
-// ================================================================
-//  Internal
-// ================================================================
-/**
- * Safely resolve an account index to a public key, returning
- * `PublicKey.default` for out-of-bounds indices instead of throwing.
- *
- * @internal
- */
-function resolveAccountKey(keys, index) {
-    const key = keys[index];
-    return key ?? PublicKey.default;
-}
-/**
- * Coerce a value to PublicKey. Handles both string base58 and
- * PublicKey instances returned by different RPC client versions.
- *
- * @internal
- */
-function toPubkey(value) {
-    if (typeof value === "string")
-        return new PublicKey(value);
-    return value;
-}
-/**
- * @internal
- */
-function safeDecodeInstruction(coder, data) {
-    try {
-        // Inner instruction data from RPC is base58-encoded
-        const buffer = Buffer.from(utils.bytes.bs58.decode(data));
-        return coder.decode(buffer);
-    }
-    catch {
-        // Fallback: try base64 encoding (some RPC responses use base64)
-        try {
-            return coder.decode(Buffer.from(data, "base64"));
-        }
-        catch {
-            return null;
-        }
-    }
-}
-//# sourceMappingURL=inner.js.map

package/dist/esm/parser/inner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inner.js","sourceRoot":"","sources":["../../../src/parser/inner.ts"],"names":[],"mappings":"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"}

package/dist/esm/parser/instructions.js

@@ -1,109 +0,0 @@
-/**
- * @module parser/instructions
- * @description Decode SAP instruction names from a pre-built `TransactionInstruction[]`.
- *
- * This is "Case 2B": you already have the decompiled instruction list
- * (for example, from a UI that constructs instructions before sending)
- * and want to identify which ones target the SAP program.
- *
- * @category Parser
- * @since v0.5.0
- *
- * @example
- * ```ts
- * import { parseSapInstructionsFromList } from "@synapse-sap/sdk/parser";
- * import { SAP_PROGRAM_ID } from "@synapse-sap/sdk";
- *
- * const decoded = parseSapInstructionsFromList(
- *   instructions,
- *   program.coder.instruction,
- *   SAP_PROGRAM_ID,
- * );
- * for (const ix of decoded) {
- *   console.log(ix.name, ix.args);
- * }
- * ```
- */
-// ================================================================
-//  Public API
-// ================================================================
-/**
- * Decode an array of `TransactionInstruction` and return only the
- * SAP instructions with their decoded names and arguments.
- *
- * Non-SAP instructions (system, token, other programs) are silently
- * skipped. Instructions whose data cannot be decoded against the IDL
- * are still included with `name: "unknown"` and `args: null` so that
- * consumers can detect IDL mismatches or unsupported instruction
- * variants.
- *
- * @param instructions - The instruction array to inspect.
- * @param coder - An Anchor instruction coder built from the SAP IDL.
- * @param sapProgramId - The SAP program public key to filter by.
- * @returns An array of decoded SAP instructions.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function parseSapInstructionsFromList(instructions, coder, sapProgramId) {
-    const results = [];
-    for (const ix of instructions) {
-        if (!ix.programId.equals(sapProgramId))
-            continue;
-        const decoded = safeDecodeInstruction(coder, ix.data);
-        results.push({
-            name: decoded?.name ?? "unknown",
-            args: decoded?.data ?? null,
-            accounts: ix.keys.map((k) => k.pubkey),
-            raw: ix,
-        });
-    }
-    return results;
-}
-/**
- * Return only the instruction names for SAP instructions in the list.
- *
- * Convenience wrapper over {@link parseSapInstructionsFromList} for
- * callers that only need the string names.
- *
- * @param instructions - The instruction array to inspect.
- * @param coder - An Anchor instruction coder for the SAP IDL.
- * @param sapProgramId - The SAP program public key.
- * @returns An array of instruction name strings.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function parseSapInstructionNamesFromList(instructions, coder, sapProgramId) {
-    return parseSapInstructionsFromList(instructions, coder, sapProgramId).map((ix) => ix.name);
-}
-/**
- * Check whether any instruction in the list targets the SAP program.
- *
- * Useful as a fast pre-filter before committing to a full decode pass.
- *
- * @param instructions - The instruction array to inspect.
- * @param sapProgramId - The SAP program public key.
- * @returns `true` if at least one instruction targets the SAP program.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function containsSapInstruction(instructions, sapProgramId) {
-    return instructions.some((ix) => ix.programId.equals(sapProgramId));
-}
-// ================================================================
-//  Internal
-// ================================================================
-/**
- * @internal
- */
-function safeDecodeInstruction(coder, data) {
-    try {
-        return coder.decode(Buffer.from(data));
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=instructions.js.map

package/dist/esm/parser/instructions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../../src/parser/instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAKH,mEAAmE;AACnE,cAAc;AACd,mEAAmE;AAEnE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,4BAA4B,CAC1C,YAAsC,EACtC,KAA0B,EAC1B,YAAuB;IAEvB,MAAM,OAAO,GAA4B,EAAE,CAAC;IAE5C,KAAK,MAAM,EAAE,IAAI,YAAY,EAAE,CAAC;QAC9B,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC;YAAE,SAAS;QAEjD,MAAM,OAAO,GAAG,qBAAqB,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QACtD,OAAO,CAAC,IAAI,CAAC;YACX,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,SAAS;YAChC,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,IAAI;YAC3B,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;YACtC,GAAG,EAAE,EAAE;SACR,CAAC,CAAC;IACL,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gCAAgC,CAC9C,YAAsC,EACtC,KAA0B,EAC1B,YAAuB;IAEvB,OAAO,4BAA4B,CAAC,YAAY,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,GAAG,CACxE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAChB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,YAAsC,EACtC,YAAuB;IAEvB,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;AACtE,CAAC;AAED,mEAAmE;AACnE,YAAY;AACZ,mEAAmE;AAEnE;;GAEG;AACH,SAAS,qBAAqB,CAC5B,KAA0B,EAC1B,IAAyB;IAGzB,IAAI,CAAC;QACH,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/esm/parser/transaction.js

@@ -1,149 +0,0 @@
-/**
- * @module parser/transaction
- * @description Decode SAP instruction names from a raw `TransactionResponse`.
- *
- * This is "Case 2A": you have a transaction response object obtained
- * from `connection.getTransaction(signature, ...)` and need to extract
- * the SAP instruction names, arguments, and account keys.
- *
- * The function handles both legacy and versioned (v0) transactions
- * by decompiling the message into `TransactionInstruction[]` and then
- * filtering for instructions whose `programId` matches the SAP program.
- *
- * @category Parser
- * @since v0.5.0
- *
- * @example
- * ```ts
- * import { parseSapInstructionsFromTransaction } from "@synapse-sap/sdk/parser";
- * import { SAP_PROGRAM_ID } from "@synapse-sap/sdk";
- *
- * const tx = await connection.getTransaction(sig, {
- *   commitment: "confirmed",
- *   maxSupportedTransactionVersion: 0,
- * });
- * if (!tx) throw new Error("Transaction not found");
- *
- * const decoded = parseSapInstructionsFromTransaction(
- *   tx,
- *   program.coder.instruction,
- *   SAP_PROGRAM_ID,
- * );
- * for (const ix of decoded) {
- *   console.log(ix.name, ix.args);
- * }
- * ```
- */
-import { TransactionMessage, } from "@solana/web3.js";
-// ================================================================
-//  Public API
-// ================================================================
-/**
- * Extract and decode SAP instructions from a transaction response.
- *
- * Supports both legacy (`TransactionResponse`) and versioned
- * (`VersionedTransactionResponse`) formats. For versioned
- * transactions that use address lookup tables, pass the resolved
- * lookup table accounts so that `TransactionMessage.decompile`
- * can reconstruct the full account list.
- *
- * @param tx - The transaction response from `connection.getTransaction`.
- * @param coder - An Anchor instruction coder built from the SAP IDL.
- * @param sapProgramId - The SAP program public key to filter by.
- * @param addressLookupTables - Resolved lookup table accounts for v0 transactions.
- *   Required when the transaction uses address lookup tables; omit for legacy txs.
- * @returns An array of decoded SAP instructions found in the transaction.
- *
- * @throws {Error} When the transaction message cannot be decompiled.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function parseSapInstructionsFromTransaction(tx, coder, sapProgramId, addressLookupTables) {
-    const instructions = decompileTransaction(tx, addressLookupTables);
-    return decodeSapInstructions(instructions, coder, sapProgramId);
-}
-/**
- * Extract only the SAP instruction names from a transaction response.
- *
- * Lighter-weight alternative to {@link parseSapInstructionsFromTransaction}
- * when you only need the instruction names without decoded arguments.
- *
- * @param tx - The transaction response.
- * @param coder - An Anchor instruction coder built from the SAP IDL.
- * @param sapProgramId - The SAP program public key.
- * @param addressLookupTables - Resolved lookup table accounts for v0 transactions.
- * @returns An array of instruction name strings.
- *
- * @category Parser
- * @since v0.5.0
- */
-export function parseSapInstructionNamesFromTransaction(tx, coder, sapProgramId, addressLookupTables) {
-    return parseSapInstructionsFromTransaction(tx, coder, sapProgramId, addressLookupTables).map((ix) => ix.name);
-}
-// ================================================================
-//  Internal helpers
-// ================================================================
-/**
- * Decompile a transaction response into an array of `TransactionInstruction`.
- *
- * Handles both legacy messages (which already contain full account keys)
- * and versioned v0 messages (which require address lookup table resolution).
- *
- * @internal
- */
-function decompileTransaction(tx, addressLookupTables) {
-    const message = tx.transaction.message;
-    // Versioned transactions expose `version` on the response object.
-    // Legacy transactions have either `version = "legacy"` or no field at all.
-    const isVersioned = "version" in tx && tx.version !== undefined && tx.version !== "legacy";
-    if (isVersioned) {
-        // VersionedMessage requires decompile with optional lookup tables
-        const decompiledMessage = TransactionMessage.decompile(message, addressLookupTables?.length
-            ? { addressLookupTableAccounts: addressLookupTables }
-            : undefined);
-        return decompiledMessage.instructions;
-    }
-    // Legacy message: decompile directly
-    const decompiledMessage = TransactionMessage.decompile(message);
-    return decompiledMessage.instructions;
-}
-/**
- * Decode a list of raw `TransactionInstruction` into typed SAP results.
- *
- * Filters for instructions whose `programId` matches the SAP program,
- * then runs each through the Anchor instruction coder.
- *
- * @internal
- */
-function decodeSapInstructions(instructions, coder, sapProgramId) {
-    const results = [];
-    for (const ix of instructions) {
-        if (!ix.programId.equals(sapProgramId))
-            continue;
-        const decoded = safeDecodeInstruction(coder, ix.data);
-        results.push({
-            name: decoded?.name ?? "unknown",
-            args: decoded?.data ?? null,
-            accounts: ix.keys.map((k) => k.pubkey),
-            raw: ix,
-        });
-    }
-    return results;
-}
-/**
- * Attempt to decode instruction data, returning `null` on failure
- * instead of throwing. This prevents a single malformed instruction
- * from breaking the entire parse pipeline.
- *
- * @internal
- */
-function safeDecodeInstruction(coder, data) {
-    try {
-        return coder.decode(Buffer.from(data));
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=transaction.js.map