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

package/dist/esm/parser/client.js

@@ -0,0 +1,142 @@
+/**
+ * @module parser/client
+ * @description Object-oriented wrapper for transaction parsing.
+ *
+ * Binds the Anchor `Program` reference so callers do not need to
+ * pass it on every call. Designed as a lazy singleton accessible
+ * from {@link SapClient.parser}.
+ *
+ * @category Parser
+ * @since v0.5.0
+ *
+ * @example
+ * ```ts
+ * const client = SapClient.from(provider);
+ *
+ * // Parse a full transaction
+ * const parsed = client.parser.parseTransaction(txResponse);
+ *
+ * // Quick instruction names
+ * const names = client.parser.instructionNames(txResponse);
+ *
+ * // From pre-built instructions
+ * const decoded = client.parser.fromInstructions(ixList);
+ * ```
+ */
+import { parseSapInstructionsFromTransaction } from "./transaction";
+import { parseSapInstructionsFromList, containsSapInstruction } from "./instructions";
+import { parseSapTransactionComplete, parseSapTransactionBatch } from "./complete";
+import { decodeInnerInstructions, extractAccountKeys, } from "./inner";
+/**
+ * Stateful transaction parser bound to a specific Anchor `Program`.
+ *
+ * Stores the program reference, instruction coder, and program ID
+ * internally so that repeated parse calls require only the
+ * transaction data as input.
+ *
+ * @name TransactionParser
+ * @category Parser
+ * @since v0.5.0
+ */
+export class TransactionParser {
+    program;
+    coder;
+    programId;
+    /**
+     * Create a new TransactionParser.
+     *
+     * @param program - An Anchor `Program` built from the SAP IDL.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(program) {
+        this.program = program;
+        this.coder = program.coder.instruction;
+        this.programId = program.programId;
+    }
+    /**
+     * Full parse: instructions + inner calls + events.
+     *
+     * @param tx - Raw transaction response from `connection.getTransaction`.
+     * @param options - Optional filters for instructions, events, and inner calls.
+     * @param addressLookupTables - Resolved lookup tables for v0 transactions.
+     * @returns Complete parsed transaction, or `null` if the input is nullish.
+     *
+     * @since v0.5.0
+     */
+    parseTransaction(tx, options, addressLookupTables) {
+        return parseSapTransactionComplete(tx, this.program, this.programId, options, addressLookupTables);
+    }
+    /**
+     * Parse a batch of transactions.
+     *
+     * @param txs - Array of transaction responses (may contain `null` entries).
+     * @param options - Optional parse filters.
+     * @param addressLookupTables - Resolved lookup tables for v0 transactions.
+     * @returns Non-null parsed transactions.
+     *
+     * @since v0.5.0
+     */
+    parseBatch(txs, options, addressLookupTables) {
+        return parseSapTransactionBatch(txs, this.program, this.programId, options, addressLookupTables);
+    }
+    /**
+     * Decode top-level SAP instructions from a transaction response.
+     *
+     * @param tx - Raw transaction response.
+     * @param addressLookupTables - Resolved lookup tables for v0 transactions.
+     * @returns Decoded SAP instructions.
+     *
+     * @since v0.5.0
+     */
+    instructionsFromTransaction(tx, addressLookupTables) {
+        return parseSapInstructionsFromTransaction(tx, this.coder, this.programId, addressLookupTables);
+    }
+    /**
+     * Extract only the instruction names from a transaction response.
+     *
+     * @param tx - Raw transaction response.
+     * @param addressLookupTables - Resolved lookup tables for v0 transactions.
+     * @returns Instruction name strings.
+     *
+     * @since v0.5.0
+     */
+    instructionNames(tx, addressLookupTables) {
+        return this.instructionsFromTransaction(tx, addressLookupTables).map((ix) => ix.name);
+    }
+    /**
+     * Decode SAP instructions from a pre-built instruction array.
+     *
+     * @param instructions - The instruction list to decode.
+     * @returns Decoded SAP instructions.
+     *
+     * @since v0.5.0
+     */
+    fromInstructions(instructions) {
+        return parseSapInstructionsFromList(instructions, this.coder, this.programId);
+    }
+    /**
+     * Check if any instruction in the list targets the SAP program.
+     *
+     * @param instructions - The instruction array to inspect.
+     * @returns `true` if at least one instruction targets SAP.
+     *
+     * @since v0.5.0
+     */
+    isSapTransaction(instructions) {
+        return containsSapInstruction(instructions, this.programId);
+    }
+    /**
+     * Decode inner (CPI) instructions from transaction metadata.
+     *
+     * @param innerGroups - The `tx.meta.innerInstructions` array.
+     * @param tx - The transaction response (for account key resolution).
+     * @returns Decoded inner instructions.
+     *
+     * @since v0.5.0
+     */
+    decodeInner(innerGroups, tx) {
+        const accountKeys = extractAccountKeys(tx);
+        return decodeInnerInstructions(innerGroups, accountKeys, this.coder, this.programId);
+    }
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/parser/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAiBH,OAAO,EAAE,mCAAmC,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACtF,OAAO,EAAE,2BAA2B,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACnF,OAAO,EACL,uBAAuB,EACvB,kBAAkB,GAEnB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;GAUG;AACH,MAAM,OAAO,iBAAiB;IAUC;IATZ,KAAK,CAAsB;IAC3B,SAAS,CAAY;IAEtC;;;;OAIG;IACH,8DAA8D;IAC9D,YAA6B,OAAqB;QAArB,YAAO,GAAP,OAAO,CAAc;QAChD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,WAA6C,CAAC;QACzE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;IACrC,CAAC;IAED;;;;;;;;;OASG;IACH,gBAAgB,CACd,EAAyE,EACzE,OAA4B,EAC5B,mBAAiD;QAEjD,OAAO,2BAA2B,CAChC,EAAE,EACF,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,SAAS,EACd,OAAO,EACP,mBAAmB,CACpB,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,UAAU,CACR,GAA8E,EAC9E,OAA4B,EAC5B,mBAAiD;QAEjD,OAAO,wBAAwB,CAC7B,GAAG,EACH,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,SAAS,EACd,OAAO,EACP,mBAAmB,CACpB,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACH,2BAA2B,CACzB,EAAsD,EACtD,mBAAiD;QAEjD,OAAO,mCAAmC,CACxC,EAAE,EACF,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,SAAS,EACd,mBAAmB,CACpB,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACH,gBAAgB,CACd,EAAsD,EACtD,mBAAiD;QAEjD,OAAO,IAAI,CAAC,2BAA2B,CAAC,EAAE,EAAE,mBAAmB,CAAC,CAAC,GAAG,CAClE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAChB,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,gBAAgB,CACd,YAAsC;QAEtC,OAAO,4BAA4B,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;;OAOG;IACH,gBAAgB,CAAC,YAAsC;QACrD,OAAO,sBAAsB,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW,CACT,WAAoC,EACpC,EAAsD;QAEtD,MAAM,WAAW,GAAG,kBAAkB,CAAC,EAAE,CAAC,CAAC;QAC3C,OAAO,uBAAuB,CAC5B,WAAW,EACX,WAAW,EACX,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,SAAS,CACf,CAAC;IACJ,CAAC;CACF"}

package/dist/esm/parser/complete.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @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 { AddressLookupTableAccount, type PublicKey, type TransactionResponse, type VersionedTransactionResponse } from "@solana/web3.js";
+import type { Program } from "@coral-xyz/anchor";
+import type { ParsedSapTransaction, ParseFilterOptions } from "./types";
+/**
+ * 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 declare function parseSapTransactionComplete(tx: TransactionResponse | VersionedTransactionResponse | null | undefined, program: Program<any>, sapProgramId: PublicKey, options?: ParseFilterOptions, addressLookupTables?: AddressLookupTableAccount[]): ParsedSapTransaction | null;
+/**
+ * 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 declare function parseSapTransactionBatch(txs: (TransactionResponse | VersionedTransactionResponse | null | undefined)[], program: Program<any>, sapProgramId: PublicKey, options?: ParseFilterOptions, addressLookupTables?: AddressLookupTableAccount[]): ParsedSapTransaction[];
+//# sourceMappingURL=complete.d.ts.map

package/dist/esm/parser/complete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../../src/parser/complete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EACL,yBAAyB,EACzB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,4BAA4B,EAClC,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EAGnB,MAAM,SAAS,CAAC;AAcjB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,mBAAmB,GAAG,4BAA4B,GAAG,IAAI,GAAG,SAAS,EAEzE,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,EACrB,YAAY,EAAE,SAAS,EACvB,OAAO,CAAC,EAAE,kBAAkB,EAC5B,mBAAmB,CAAC,EAAE,yBAAyB,EAAE,GAChD,oBAAoB,GAAG,IAAI,CAoE7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,CAAC,mBAAmB,GAAG,4BAA4B,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EAE9E,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,EACrB,YAAY,EAAE,SAAS,EACvB,OAAO,CAAC,EAAE,kBAAkB,EAC5B,mBAAmB,CAAC,EAAE,yBAAyB,EAAE,GAChD,oBAAoB,EAAE,CAaxB"}

package/dist/esm/parser/complete.js

@@ -0,0 +1,173 @@
+/**
+ * @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

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

package/dist/esm/parser/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @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";
+ * ```
+ */
+export type { DecodedSapInstruction, DecodedInnerInstruction, ParsedSapTransaction, ParseFilterOptions, SapInstructionCoder, } from "./types";
+export { parseSapInstructionsFromTransaction, parseSapInstructionNamesFromTransaction, } from "./transaction";
+export { parseSapInstructionsFromList, parseSapInstructionNamesFromList, containsSapInstruction, } from "./instructions";
+export { parseSapTransactionComplete, parseSapTransactionBatch, } from "./complete";
+export { decodeInnerInstructions, filterSapInnerInstructions, extractAccountKeys, } from "./inner";
+export type { CompiledInner, InnerInstructionGroup } from "./inner";
+export { TransactionParser } from "./client";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,YAAY,EACV,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,mCAAmC,EACnC,uCAAuC,GACxC,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,4BAA4B,EAC5B,gCAAgC,EAChC,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAGpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}

package/dist/esm/parser/index.js

@@ -0,0 +1,43 @@
+/**
+ * @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

@@ -0,0 +1 @@
+{"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.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @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 type { DecodedInnerInstruction, SapInstructionCoder } from "./types";
+/**
+ * Shape of a single compiled inner instruction from `tx.meta.innerInstructions`.
+ * Mirrors the Solana RPC `CompiledInnerInstruction` format.
+ *
+ * @interface CompiledInner
+ * @category Parser
+ * @since v0.5.0
+ */
+export interface CompiledInner {
+    readonly programIdIndex: number;
+    readonly accounts: number[];
+    readonly data: string;
+}
+/**
+ * Top-level inner instruction group from the transaction metadata.
+ * Each group corresponds to one outer instruction by `index`.
+ *
+ * @interface InnerInstructionGroup
+ * @category Parser
+ * @since v0.5.0
+ */
+export interface InnerInstructionGroup {
+    readonly index: number;
+    readonly instructions: CompiledInner[];
+}
+/**
+ * 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 declare function decodeInnerInstructions(innerInstructionGroups: InnerInstructionGroup[], accountKeys: PublicKey[], coder: SapInstructionCoder, sapProgramId: PublicKey): DecodedInnerInstruction[];
+/**
+ * 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 declare function filterSapInnerInstructions(inner: DecodedInnerInstruction[]): DecodedInnerInstruction[];
+/**
+ * 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 declare function extractAccountKeys(tx: {
+    transaction: {
+        message: any;
+    };
+    meta?: {
+        loadedAddresses?: {
+            writable: PublicKey[];
+            readonly: PublicKey[];
+        } | null;
+    } | null;
+}): PublicKey[];
+//# sourceMappingURL=inner.d.ts.map

package/dist/esm/parser/inner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inner.d.ts","sourceRoot":"","sources":["../../../src/parser/inner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAM5E;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,aAAa,EAAE,CAAC;CACxC;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACrC,sBAAsB,EAAE,qBAAqB,EAAE,EAC/C,WAAW,EAAE,SAAS,EAAE,EACxB,KAAK,EAAE,mBAAmB,EAC1B,YAAY,EAAE,SAAS,GACtB,uBAAuB,EAAE,CAwC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,uBAAuB,EAAE,GAC/B,uBAAuB,EAAE,CAE3B;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE;IACF,WAAW,EAAE;QAEX,OAAO,EAAE,GAAG,CAAC;KACd,CAAC;IACF,IAAI,CAAC,EAAE;QACL,eAAe,CAAC,EAAE;YAChB,QAAQ,EAAE,SAAS,EAAE,CAAC;YACtB,QAAQ,EAAE,SAAS,EAAE,CAAC;SACvB,GAAG,IAAI,CAAC;KACV,GAAG,IAAI,CAAC;CACV,GACA,SAAS,EAAE,CAuBb"}