@liquid-af/sdk 0.5.1 → 0.5.2

package/src/events/parser.ts

@@ -1,4 +1,6 @@
 import { BorshCoder, type Program } from "@coral-xyz/anchor";
+import type { LiquidEvents } from "../idl/liquid_events.js";
+import type { LiquidEventMap, LiquidEventName } from "./types.js";
 
 /** Parsed event with name and data */
 export interface ParsedEvent<T = unknown> {
@@ -12,17 +14,17 @@ 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)/;
 
 /**
- * Parses events from transaction logs for a given program.
+ * 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 Anchor program to parse events for
+ * @param program - The liquid-events program instance
  * @returns Array of parsed events
  */
 export const parseTransactionEvents = (
 	logs: string[],
-	program: Program,
+	program: Program<LiquidEvents>,
 ): ParsedEvent[] => {
 	return parseCpiLogs(
 		logs,
@@ -32,21 +34,24 @@ export const parseTransactionEvents = (
 };
 
 /**
- * Registers an event listener on a program.
+ * Registers an event listener on the liquid-events program.
  * Returns the listener ID (use program.removeEventListener to unsubscribe).
  *
- * @param program - The Anchor program
+ * @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
  */
-export const addEventListener = <T>(
-	program: Program,
-	eventName: string,
-	callback: (event: T) => void,
+export const addEventListener = <N extends LiquidEventName>(
+	program: Program<LiquidEvents>,
+	eventName: N,
+	callback: (event: LiquidEventMap[N]) => void,
 ): number => {
-	return program.addEventListener(eventName, (data: T) => {
-		callback(data);
+	// 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]);
 	});
 };
 
@@ -55,23 +60,22 @@ export const addEventListener = <T>(
  * event arrives or the timeout is exceeded.
  *
  * Uses CPI-aware log parsing so events emitted by programs that are only
- * invoked via CPI (e.g., a centralized events program) are correctly detected.
+ * invoked via CPI (e.g., the centralized events program) are correctly detected.
  *
- * @param program - The Anchor program whose events to listen for
+ * @param program - The liquid-events program instance
  * @param eventName - Name of the event to wait for
  * @param trigger - Async function to trigger the event (e.g., sendAndConfirm)
  * @param timeoutMs - Maximum wait time in milliseconds (default: 5000)
  * @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<TEvent, TResult = string>(
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	program: Program<any>,
-	eventName: string,
+export async function waitForEvent<N extends LiquidEventName, TResult = string>(
+	program: Program<LiquidEvents>,
+	eventName: N,
 	trigger: () => Promise<TResult>,
 	timeoutMs = 5000,
-): Promise<{ result: TResult; event: TEvent }> {
-	let eventData: TEvent | null = null;
+): Promise<{ result: TResult; event: LiquidEventMap[N] }> {
+	let eventData: LiquidEventMap[N] | null = null;
 	const programId = program.programId.toString();
 	const coder = new BorshCoder(program.idl);
 
@@ -83,7 +87,7 @@ export async function waitForEvent<TEvent, TResult = string>(
 			const events = parseCpiLogs(logs.logs, programId, coder);
 			for (const event of events) {
 				if (event.name === eventName) {
-					eventData = event.data as TEvent;
+					eventData = event.data as LiquidEventMap[N];
 				}
 			}
 		},

package/src/events/types.ts

@@ -224,6 +224,15 @@ export interface FeesDistributedEvent {
 	timestamp: BN;
 }
 
+/** Event emitted when a recipient claims accumulated fees */
+export interface FeesClaimedEvent {
+	feeConfig: PublicKey;
+	mint: PublicKey;
+	amount: BN;
+	recipient: PublicKey;
+	timestamp: BN;
+}
+
 /** Event emitted when a fee configuration is revoked */
 export interface FeeConfigRevokedEvent {
 	feeConfig: PublicKey;
@@ -308,3 +317,37 @@ export interface CashbackSpentEvent {
 	remainingBalance: BN;
 	timestamp: BN;
 }
+
+/** Maps camelCase event names (as Anchor uses in JS) to their typed data interfaces */
+export interface LiquidEventMap {
+	tokenCreated: TokenCreatedEvent;
+	tradeEvent: TradeEvent;
+	migrationCompleted: MigrationCompletedEvent;
+	curveCompleted: CurveCompletedEvent;
+	curveBuybackExecuted: BondingCurveBuybackExecutedEvent;
+	referralRewardsWithdrawn: ReferralRewardsWithdrawnEvent;
+	curveProtocolPaused: BondingCurveProtocolPausedEvent;
+	curveProtocolUnpaused: BondingCurveProtocolUnpausedEvent;
+	swapEvent: SwapEvent;
+	lpChangeEvent: LpChangeEvent;
+	poolCreated: PoolCreatedEvent;
+	ammBuybackExecuted: AmmBuybackExecutedEvent;
+	ammProtocolPaused: AmmProtocolPausedEvent;
+	ammProtocolUnpaused: AmmProtocolUnpausedEvent;
+	feesDistributed: FeesDistributedEvent;
+	feesClaimed: FeesClaimedEvent;
+	feeConfigRevoked: FeeConfigRevokedEvent;
+	dealCreated: DealCreatedEvent;
+	dealUpdated: DealUpdatedEvent;
+	dealClosed: DealClosedEvent;
+	dealRedeemed: DealRedeemedEvent;
+	snapshotTaken: SnapshotTakenEvent;
+	userUpdatedByAdmin: UserUpdatedByAdminEvent;
+	referrerSet: ReferrerSetEvent;
+	cashbackModeActivated: CashbackModeActivatedEvent;
+	cashbackEarned: CashbackEarnedEvent;
+	cashbackSpent: CashbackSpentEvent;
+}
+
+/** All valid event names (camelCase, as Anchor uses in JS) */
+export type LiquidEventName = keyof LiquidEventMap;