@liquid-af/sdk 0.9.1 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@liquid-af/sdk",
-	"version": "0.9.1",
+	"version": "0.10.1",
 	"description": "TypeScript SDK for the Liquid DeFi protocol on Solana",
 	"type": "module",
 	"publishConfig": {
@@ -79,16 +79,16 @@
 		"src"
 	],
 	"scripts": {
-		"build": "yarn copy-idl && tsc",
+		"build": "bun run copy-idl && tsc",
 		"copy-idl": "cp ../../target/idl/*.json src/idl/ && cp ../../target/types/*.ts src/idl/",
 		"clean": "rm -rf dist",
-		"prebuild": "yarn clean",
-		"prepack": "yarn build",
-		"prepublishOnly": "yarn test:build",
+		"prebuild": "bun run clean",
+		"prepack": "bun run build",
+		"prepublishOnly": "bun run test:build",
 		"test:build": "tsc --noEmit",
-		"version:patch": "yarn version --patch --no-git-tag-version",
-		"version:minor": "yarn version --minor --no-git-tag-version",
-		"version:major": "yarn version --major --no-git-tag-version",
+		"version:patch": "bun run version --patch --no-git-tag-version",
+		"version:minor": "bun run version --minor --no-git-tag-version",
+		"version:major": "bun run version --major --no-git-tag-version",
 		"docs": "typedoc",
 		"publish:test": "npm publish --dry-run",
 		"publish:prod": "npm publish"

package/src/events/index.ts

@@ -40,9 +40,5 @@ export type {
 	LiquidEventName,
 } from "./types.js";
 
-export {
-	parseTransactionEvents,
-	addEventListener,
-	waitForEvent,
-} from "./parser.js";
-export type { ParsedEvent } from "./parser.js";
+export { parseTransactionEvents, waitForEvent } from "./parser.js";
+export type { ParsedEvent, TransactionForEventParsing } from "./parser.js";

package/src/events/parser.ts

@@ -1,4 +1,5 @@
-import { BorshCoder, type Program } from "@coral-xyz/anchor";
+import { BorshCoder, type Idl, type Program, utils } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
 import type { LiquidEvents } from "../idl/liquid_events.js";
 import type { LiquidEventMap, LiquidEventName } from "./types.js";
 
@@ -8,59 +9,126 @@ export interface ParsedEvent<T = unknown> {
 	data: T;
 }
 
-const PROGRAM_DATA = "Program data: ";
-const PROGRAM_LOG = "Program log: ";
-const INVOKE_RE = /^Program ([1-9A-HJ-NP-Za-km-z]+) invoke \[(\d+)\]$/;
-const EXIT_RE = /^Program ([1-9A-HJ-NP-Za-km-z]+) (success|failed)/;
+/** Minimal transaction shape needed for event parsing. */
+export interface TransactionForEventParsing {
+	meta: {
+		innerInstructions?:
+			| Array<{
+					instructions: Array<{
+						programIdIndex: number;
+						data: string;
+					}>;
+			  }>
+			| null;
+	} | null;
+	transaction: {
+		message:
+			| { staticAccountKeys: PublicKey[] }
+			| { accountKeys: PublicKey[] };
+	};
+}
 
 /**
- * Parses events from transaction logs for the liquid-events program.
- * Unlike Anchor's built-in EventParser, this correctly identifies events
- * from programs invoked via CPI (not just top-level invocations).
- *
- * @param logs - Transaction log messages
- * @param program - The liquid-events program instance
- * @returns Array of parsed events
+ * Maps IDL instruction names (snake_case) to LiquidEventMap keys (camelCase).
+ * Anchor's BorshCoder.instruction.decode() returns camelCase names, so this
+ * maps those decoded names to our event type keys.
  */
-export const parseTransactionEvents = (
-	logs: string[],
-	program: Program<LiquidEvents>,
-): ParsedEvent[] => {
-	return parseCpiLogs(
-		logs,
-		program.programId.toString(),
-		new BorshCoder(program.idl),
-	);
+const INSTRUCTION_TO_EVENT: Record<string, LiquidEventName> = {
+	logTokenCreated: "tokenCreated",
+	logTrade: "tradeEvent",
+	logMigrationCompleted: "migrationCompleted",
+	logCurveCompleted: "curveCompleted",
+	logCurveBuyback: "curveBuybackExecuted",
+	logReferralWithdrawn: "referralRewardsWithdrawn",
+	logCurvePaused: "curveProtocolPaused",
+	logCurveUnpaused: "curveProtocolUnpaused",
+	logPoolCreated: "poolCreated",
+	logSwap: "swapEvent",
+	logLpChange: "lpChangeEvent",
+	logAmmBuyback: "ammBuybackExecuted",
+	logAmmPaused: "ammProtocolPaused",
+	logAmmUnpaused: "ammProtocolUnpaused",
+	logFeesDistributed: "feesDistributed",
+	logFeesClaimed: "feesClaimed",
+	logFeeConfigRevoked: "feeConfigRevoked",
+	logFeeConfigUpdated: "feeConfigUpdated",
+	logFeeConfigAuthorityOverridden: "feeConfigAuthorityOverridden",
+	logDealCreated: "dealCreated",
+	logDealUpdated: "dealUpdated",
+	logDealClosed: "dealClosed",
+	logDealRedeemed: "dealRedeemed",
+	logSnapshotTaken: "snapshotTaken",
+	logUserUpdated: "userUpdatedByAdmin",
+	logReferrerSet: "referrerSet",
+	logCashbackMode: "cashbackModeActivated",
+	logCashbackEarned: "cashbackEarned",
+	logCashbackSpent: "cashbackSpent",
 };
 
 /**
- * Registers an event listener on the liquid-events program.
- * Returns the listener ID (use program.removeEventListener to unsubscribe).
+ * Parses events from a transaction by inspecting inner instructions
+ * (CPI calls to the liquid-events program) instead of transaction logs.
+ *
+ * This approach is immune to log bleaching attacks since event data is
+ * encoded in the instruction data of CPI calls, not in transaction logs.
  *
+ * @param transaction - Full transaction response (from getTransaction)
  * @param program - The liquid-events program instance
- * @param eventName - Name of the event to listen for
- * @param callback - Handler called when event is received
- * @returns Listener ID for removal
+ * @returns Array of parsed events
  */
-export const addEventListener = <N extends LiquidEventName>(
+export const parseTransactionEvents = (
+	transaction: TransactionForEventParsing | null | undefined,
 	program: Program<LiquidEvents>,
-	eventName: N,
-	callback: (event: LiquidEventMap[N]) => void,
-): number => {
-	// Cast needed: Anchor's IdlEvents types differ structurally from our
-	// hand-written interfaces (e.g. enum variant wrapping), but the runtime
-	// data is identical.
-	return program.addEventListener(eventName, (data: unknown) => {
-		callback(data as LiquidEventMap[N]);
-	});
+): ParsedEvent[] => {
+	if (!transaction?.meta?.innerInstructions) return [];
+
+	const coder = new BorshCoder(program.idl as Idl);
+	const programId = program.programId;
+	const events: ParsedEvent[] = [];
+
+	// Get account keys from the transaction message
+	const message = transaction.transaction.message;
+	const accountKeys: PublicKey[] =
+		"staticAccountKeys" in message
+			? (message.staticAccountKeys as PublicKey[])
+			: (message as unknown as { accountKeys: PublicKey[] }).accountKeys;
+
+	for (const innerIxGroup of transaction.meta.innerInstructions) {
+		for (const innerIx of innerIxGroup.instructions) {
+			// Check if this inner instruction targets the events program
+			const ixProgramKey = accountKeys[innerIx.programIdIndex];
+			if (!ixProgramKey || !programId.equals(new PublicKey(ixProgramKey)))
+				continue;
+
+			// Decode the instruction data (base58-encoded in RPC responses)
+			const rawData = utils.bytes.bs58.decode(innerIx.data);
+			if (rawData.length < 8) continue;
+
+			// Use Anchor's instruction coder to decode
+			const decoded = coder.instruction.decode(Buffer.from(rawData));
+			if (!decoded) continue;
+
+			// Map instruction name to event name
+			const eventName = INSTRUCTION_TO_EVENT[decoded.name];
+			if (!eventName) continue;
+
+			// The instruction has a single "data" argument containing the event struct
+			events.push({
+				name: eventName,
+				data: (decoded.data as Record<string, unknown>).data,
+			});
+		}
+	}
+
+	return events;
 };
 
 /**
- * Subscribes to logs via WebSocket, fires a trigger, and polls until the
- * event arrives or the timeout is exceeded.
+ * Subscribes to logs to capture the transaction signature, fires a trigger,
+ * then fetches the full transaction to parse events from inner instructions.
  *
- * Uses CPI-aware log parsing so events emitted by programs that are only
- * invoked via CPI (e.g., the centralized events program) are correctly detected.
+ * Immune to log bleaching: event data is decoded from CPI instruction data,
+ * not from transaction logs.
  *
  * @param program - The liquid-events program instance
  * @param eventName - Name of the event to wait for
@@ -69,95 +137,68 @@ export const addEventListener = <N extends LiquidEventName>(
  * @returns Object containing the trigger result and the captured event data
  * @throws If the event is not received within the timeout period
  */
-export async function waitForEvent<N extends LiquidEventName, TResult = string>(
+export async function waitForEvent<
+	N extends LiquidEventName,
+	TResult = string,
+>(
 	program: Program<LiquidEvents>,
 	eventName: N,
 	trigger: () => Promise<TResult>,
 	timeoutMs = 5000,
 ): Promise<{ result: TResult; event: LiquidEventMap[N] }> {
-	let eventData: LiquidEventMap[N] | null = null;
-	const programId = program.programId.toString();
-	const coder = new BorshCoder(program.idl);
+	const connection = program.provider.connection;
+	let capturedSignature: string | null = null;
 
-	// Subscribe to logs mentioning this program (includes CPI invocations)
-	const subscriptionId = program.provider.connection.onLogs(
+	// Subscribe to logs to capture the transaction signature
+	// (invoke/exit logs are always present even without emit!)
+	const subscriptionId = connection.onLogs(
 		program.programId,
-		(logs) => {
-			if (logs.err) return;
-			const events = parseCpiLogs(logs.logs, programId, coder);
-			for (const event of events) {
-				if (event.name === eventName) {
-					eventData = event.data as LiquidEventMap[N];
-				}
-			}
+		(logInfo) => {
+			if (logInfo.err) return;
+			capturedSignature = logInfo.signature;
 		},
 	);
 
 	try {
 		const result = await trigger();
+
+		// If the trigger returned a string, use it as the signature directly
+		if (typeof result === "string") {
+			capturedSignature = result;
+		}
+
+		// Wait for the signature to be captured
 		const start = Date.now();
-		while (!eventData && Date.now() - start < timeoutMs) {
+		while (!capturedSignature && Date.now() - start < timeoutMs) {
 			await new Promise((r) => setTimeout(r, 200));
 		}
-		if (!eventData) {
+		if (!capturedSignature) {
 			throw new Error(
-				`Event '${eventName}' not received within ${timeoutMs}ms`,
+				`No transaction signature captured within ${timeoutMs}ms`,
 			);
 		}
-		return { result, event: eventData };
-	} finally {
-		await program.provider.connection.removeOnLogsListener(subscriptionId);
-	}
-}
 
-/**
- * Parses events from transaction logs, properly handling CPI contexts.
- *
- * Anchor's built-in EventParser pushes a generic "cpi" string onto its
- * execution stack for nested invocations, so it cannot identify events
- * emitted by a CPI-only program. This parser extracts the actual program
- * ID from each `invoke` log line, enabling correct attribution of events
- * to programs at any CPI depth.
- */
-function parseCpiLogs(
-	logs: string[],
-	programId: string,
-	coder: BorshCoder,
-): ParsedEvent[] {
-	const events: ParsedEvent[] = [];
-	const stack: string[] = [];
-
-	for (const log of logs) {
-		if (!log.startsWith("Program ")) continue;
-
-		const invokeMatch = INVOKE_RE.exec(log);
-		if (invokeMatch) {
-			stack.push(invokeMatch[1]);
-			continue;
+		// Fetch the full transaction to get inner instructions
+		const tx = await connection.getTransaction(capturedSignature, {
+			commitment: "confirmed",
+			maxSupportedTransactionVersion: 0,
+		});
+		if (!tx) {
+			throw new Error(`Transaction not found: ${capturedSignature}`);
 		}
 
-		const exitMatch = EXIT_RE.exec(log);
-		if (exitMatch) {
-			stack.pop();
-			continue;
+		// Parse events from inner instructions
+		const events = parseTransactionEvents(tx, program);
+		const event = events.find((e) => e.name === eventName);
+		if (!event) {
+			throw new Error(
+				`Event '${eventName}' not found in transaction ${capturedSignature}. ` +
+				`Found events: [${events.map((e) => e.name).join(", ")}]`,
+			);
 		}
 
-		// Only try to decode events when inside the target program's context
-		if (stack.length > 0 && stack[stack.length - 1] === programId) {
-			let logStr: string | null = null;
-			if (log.startsWith(PROGRAM_DATA)) {
-				logStr = log.slice(PROGRAM_DATA.length);
-			} else if (log.startsWith(PROGRAM_LOG)) {
-				logStr = log.slice(PROGRAM_LOG.length);
-			}
-			if (logStr) {
-				const event = coder.events.decode(logStr);
-				if (event) {
-					events.push({ name: event.name, data: event.data });
-				}
-			}
-		}
+		return { result, event: event.data as LiquidEventMap[N] };
+	} finally {
+		await connection.removeOnLogsListener(subscriptionId);
 	}
-
-	return events;
 }

package/src/idl/liquid.json

@@ -1097,6 +1097,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -2108,6 +2115,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -3027,6 +3041,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -4038,6 +4059,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -9244,6 +9272,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -10255,6 +10290,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -11174,6 +11216,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -12185,6 +12234,13 @@
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -13135,6 +13191,11 @@
       "code": 6045,
       "name": "BuybackVaultNotDrained",
       "msg": "Buyback vault must be drained before migration"
+    },
+    {
+      "code": 6046,
+      "name": "ExclusivityPeriod",
+      "msg": "This action cannot be performed during the exclusivity period"
     }
   ],
   "types": [
@@ -13342,12 +13403,16 @@
             "name": "basis_points",
             "type": "u16"
           },
+          {
+            "name": "vault_bump",
+            "type": "u8"
+          },
           {
             "name": "_padding",
             "type": {
               "array": [
                 "u8",
-                6
+                5
               ]
             }
           }

package/src/idl/liquid.ts

@@ -1103,6 +1103,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -2114,6 +2121,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -3033,6 +3047,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -4044,6 +4065,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -9250,6 +9278,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -10261,6 +10296,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -11180,6 +11222,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -12191,6 +12240,13 @@ export type Liquid = {
             "Liquid events program for centralized event emission."
           ],
           "address": "EventsQeXA43nLKR69DhHwNsJ6aM512AweMCgG3wG8zG"
+        },
+        {
+          "name": "instructions",
+          "docs": [
+            "Instructions sysvar for CPI caller detection."
+          ],
+          "address": "Sysvar1nstructions1111111111111111111111111"
         }
       ],
       "args": [
@@ -13141,6 +13197,11 @@ export type Liquid = {
       "code": 6045,
       "name": "buybackVaultNotDrained",
       "msg": "Buyback vault must be drained before migration"
+    },
+    {
+      "code": 6046,
+      "name": "exclusivityPeriod",
+      "msg": "This action cannot be performed during the exclusivity period"
     }
   ],
   "types": [
@@ -13348,12 +13409,16 @@ export type Liquid = {
             "name": "basisPoints",
             "type": "u16"
           },
+          {
+            "name": "vaultBump",
+            "type": "u8"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                6
+                5
               ]
             }
           }