@drift-labs/sdk-browser 2.104.0-beta.21

package/src/events/fetchLogs.ts

@@ -0,0 +1,169 @@
+import { Program } from '@coral-xyz/anchor';
+import {
+	Connection,
+	Finality,
+	PublicKey,
+	TransactionResponse,
+	TransactionSignature,
+	VersionedTransactionResponse,
+} from '@solana/web3.js';
+import { WrappedEvents } from './types';
+import { promiseTimeout } from '../util/promiseTimeout';
+import { parseLogs } from './parse';
+
+type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
+type FetchLogsResponse = {
+	earliestTx: string;
+	mostRecentTx: string;
+	earliestSlot: number;
+	mostRecentSlot: number;
+	transactionLogs: Log[];
+	mostRecentBlockTime: number | undefined;
+};
+
+function mapTransactionResponseToLog(
+	transaction: TransactionResponse | VersionedTransactionResponse
+): Log {
+	return {
+		txSig: transaction.transaction.signatures[0],
+		slot: transaction.slot,
+		logs: transaction.meta.logMessages,
+	};
+}
+
+export async function fetchLogs(
+	connection: Connection,
+	address: PublicKey,
+	finality: Finality,
+	beforeTx?: TransactionSignature,
+	untilTx?: TransactionSignature,
+	limit?: number,
+	batchSize = 25
+): Promise<FetchLogsResponse> {
+	const signatures = await connection.getSignaturesForAddress(
+		address,
+		{
+			before: beforeTx,
+			until: untilTx,
+			limit,
+		},
+		finality
+	);
+
+	const sortedSignatures = signatures.sort((a, b) =>
+		a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1
+	);
+
+	const filteredSignatures = sortedSignatures.filter(
+		(signature) => !signature.err
+	);
+
+	if (filteredSignatures.length === 0) {
+		return undefined;
+	}
+
+	const chunkedSignatures = chunk(filteredSignatures, batchSize);
+
+	const transactionLogs = (
+		await Promise.all(
+			chunkedSignatures.map(async (chunk) => {
+				return await fetchTransactionLogs(
+					connection,
+					chunk.map((confirmedSignature) => confirmedSignature.signature),
+					finality
+				);
+			})
+		)
+	).flat();
+
+	const earliest = filteredSignatures[0];
+	const mostRecent = filteredSignatures[filteredSignatures.length - 1];
+
+	return {
+		transactionLogs: transactionLogs,
+		earliestTx: earliest.signature,
+		mostRecentTx: mostRecent.signature,
+		earliestSlot: earliest.slot,
+		mostRecentSlot: mostRecent.slot,
+		mostRecentBlockTime: mostRecent.blockTime,
+	};
+}
+
+export async function fetchTransactionLogs(
+	connection: Connection,
+	signatures: TransactionSignature[],
+	finality: Finality
+): Promise<Log[]> {
+	const requests = new Array<{ methodName: string; args: any }>();
+	for (const signature of signatures) {
+		const args = [
+			signature,
+			{ commitment: finality, maxSupportedTransactionVersion: 0 },
+		];
+
+		requests.push({
+			methodName: 'getTransaction',
+			args,
+		});
+	}
+
+	const rpcResponses: any | null = await promiseTimeout(
+		// @ts-ignore
+		connection._rpcBatchRequest(requests),
+		10 * 1000 // 10 second timeout
+	);
+
+	if (rpcResponses === null) {
+		return Promise.reject('RPC request timed out fetching transactions');
+	}
+
+	const logs = new Array<Log>();
+	for (const rpcResponse of rpcResponses) {
+		if (rpcResponse.result) {
+			logs.push(mapTransactionResponseToLog(rpcResponse.result));
+		}
+	}
+
+	return logs;
+}
+
+function chunk<T>(array: readonly T[], size: number): T[][] {
+	return new Array(Math.ceil(array.length / size))
+		.fill(null)
+		.map((_, index) => index * size)
+		.map((begin) => array.slice(begin, begin + size));
+}
+
+export class LogParser {
+	private program: Program;
+
+	constructor(program: Program) {
+		this.program = program;
+	}
+
+	public parseEventsFromTransaction(
+		transaction: TransactionResponse
+	): WrappedEvents {
+		const transactionLogObject = mapTransactionResponseToLog(transaction);
+
+		return this.parseEventsFromLogs(transactionLogObject);
+	}
+
+	public parseEventsFromLogs(event: Log): WrappedEvents {
+		const records: WrappedEvents = [];
+
+		if (!event.logs) return records;
+
+		let runningEventIndex = 0;
+		for (const eventLog of parseLogs(this.program, event.logs)) {
+			eventLog.data.txSig = event.txSig;
+			eventLog.data.slot = event.slot;
+			eventLog.data.eventType = eventLog.name;
+			eventLog.data.txSigIndex = runningEventIndex;
+			// @ts-ignore
+			records.push(eventLog.data);
+			runningEventIndex++;
+		}
+		return records;
+	}
+}

package/src/events/parse.ts

@@ -0,0 +1,133 @@
+import { Program, Event } from '@coral-xyz/anchor';
+
+const driftProgramId = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
+const PROGRAM_LOG = 'Program log: ';
+const PROGRAM_DATA = 'Program data: ';
+const PROGRAM_LOG_START_INDEX = PROGRAM_LOG.length;
+const PROGRAM_DATA_START_INDEX = PROGRAM_DATA.length;
+
+export function parseLogs(
+	program: Program,
+	logs: string[],
+	programId = driftProgramId
+): Event[] {
+	const { events } = parseLogsWithRaw(program, logs, programId);
+	return events;
+}
+
+export function parseLogsWithRaw(
+	program: Program,
+	logs: string[],
+	programId = driftProgramId
+): { events: Event[]; rawLogs: string[] } {
+	const events = [];
+	const rawLogs = [];
+	const execution = new ExecutionContext();
+	for (const log of logs) {
+		if (log.startsWith('Log truncated')) {
+			break;
+		}
+
+		const [event, newProgram, didPop] = handleLog(
+			execution,
+			log,
+			program,
+			programId
+		);
+		if (event) {
+			events.push(event);
+			rawLogs.push(log);
+		}
+		if (newProgram) {
+			execution.push(newProgram);
+		}
+		if (didPop) {
+			execution.pop();
+		}
+	}
+	return { events, rawLogs };
+}
+
+function handleLog(
+	execution: ExecutionContext,
+	log: string,
+	program: Program,
+	programId = driftProgramId
+): [Event | null, string | null, boolean] {
+	// Executing program is drift program.
+	if (execution.stack.length > 0 && execution.program() === programId) {
+		return handleProgramLog(log, program, programId);
+	}
+	// Executing program is not drift program.
+	else {
+		return [null, ...handleSystemLog(log, programId)];
+	}
+}
+
+// Handles logs from *drift* program.
+function handleProgramLog(
+	log: string,
+	program: Program,
+	programId = driftProgramId
+): [Event | null, string | null, boolean] {
+	// This is a `msg!` log or a `sol_log_data` log.
+	if (log.startsWith(PROGRAM_LOG)) {
+		const logStr = log.slice(PROGRAM_LOG_START_INDEX);
+		const event = program.coder.events.decode(logStr);
+		return [event, null, false];
+	} else if (log.startsWith(PROGRAM_DATA)) {
+		const logStr = log.slice(PROGRAM_DATA_START_INDEX);
+		const event = program.coder.events.decode(logStr);
+		return [event, null, false];
+	} else {
+		return [null, ...handleSystemLog(log, programId)];
+	}
+}
+
+// Handles logs when the current program being executing is *not* drift.
+function handleSystemLog(
+	log: string,
+	programId = driftProgramId
+): [string | null, boolean] {
+	// System component.
+	const logStart = log.split(':')[0];
+	const programStart = `Program ${programId} invoke`;
+
+	// Did the program finish executing?
+	if (logStart.match(/^Program (.*) success/g) !== null) {
+		return [null, true];
+		// Recursive call.
+	} else if (logStart.startsWith(programStart)) {
+		return [programId, false];
+	}
+	// CPI call.
+	else if (logStart.includes('invoke')) {
+		return ['cpi', false]; // Any string will do.
+	} else {
+		return [null, false];
+	}
+}
+
+// Stack frame execution context, allowing one to track what program is
+// executing for a given log.
+class ExecutionContext {
+	stack: string[] = [];
+
+	program(): string {
+		if (!this.stack.length) {
+			throw new Error('Expected the stack to have elements');
+		}
+		return this.stack[this.stack.length - 1];
+	}
+
+	push(newProgram: string) {
+		this.stack.push(newProgram);
+	}
+
+	pop() {
+		if (!this.stack.length) {
+			throw new Error('Expected the stack to have elements');
+		}
+		this.stack.pop();
+	}
+}

package/src/events/pollingLogProvider.ts

@@ -0,0 +1,89 @@
+import { LogProvider, logProviderCallback } from './types';
+import {
+	Commitment,
+	Connection,
+	Finality,
+	PublicKey,
+	TransactionSignature,
+} from '@solana/web3.js';
+import { fetchLogs } from './fetchLogs';
+
+export class PollingLogProvider implements LogProvider {
+	private finality: Finality;
+	private intervalId: ReturnType<typeof setTimeout>;
+	private mostRecentSeenTx?: TransactionSignature;
+	private mutex: number;
+	private firstFetch = true;
+
+	public constructor(
+		private connection: Connection,
+		private address: PublicKey,
+		commitment: Commitment,
+		private frequency = 15 * 1000,
+		private batchSize?: number
+	) {
+		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+	}
+
+	public async subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): Promise<boolean> {
+		if (this.intervalId) {
+			return true;
+		}
+
+		this.intervalId = setInterval(async () => {
+			if (this.mutex === 1) {
+				return;
+			}
+			this.mutex = 1;
+
+			try {
+				const response = await fetchLogs(
+					this.connection,
+					this.address,
+					this.finality,
+					undefined,
+					this.mostRecentSeenTx,
+					// If skipping history, only fetch one log back, not the maximum amount available
+					skipHistory && this.firstFetch ? 1 : undefined,
+					this.batchSize
+				);
+
+				if (response === undefined) {
+					return;
+				}
+
+				this.firstFetch = false;
+
+				const { mostRecentTx, transactionLogs } = response;
+
+				for (const { txSig, slot, logs } of transactionLogs) {
+					callback(txSig, slot, logs, response.mostRecentBlockTime, undefined);
+				}
+
+				this.mostRecentSeenTx = mostRecentTx;
+			} catch (e) {
+				console.error('PollingLogProvider threw an Error');
+				console.error(e);
+			} finally {
+				this.mutex = 0;
+			}
+		}, this.frequency);
+
+		return true;
+	}
+
+	public isSubscribed(): boolean {
+		return this.intervalId !== undefined;
+	}
+
+	public async unsubscribe(): Promise<boolean> {
+		if (this.intervalId !== undefined) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+		return true;
+	}
+}

package/src/events/sort.ts

@@ -0,0 +1,39 @@
+import {
+	EventMap,
+	EventSubscriptionOrderBy,
+	EventSubscriptionOrderDirection,
+	EventType,
+	SortFn,
+} from './types';
+
+function clientSortAscFn(): 'less than' {
+	return 'less than';
+}
+
+function clientSortDescFn(): 'greater than' {
+	return 'greater than';
+}
+
+function blockchainSortFn(
+	currentEvent: EventMap[EventType],
+	newEvent: EventMap[EventType]
+): 'less than' | 'greater than' {
+	if (currentEvent.slot == newEvent.slot) {
+		return currentEvent.txSigIndex < newEvent.txSigIndex
+			? 'less than'
+			: 'greater than';
+	}
+
+	return currentEvent.slot < newEvent.slot ? 'less than' : 'greater than';
+}
+
+export function getSortFn(
+	orderBy: EventSubscriptionOrderBy,
+	orderDir: EventSubscriptionOrderDirection
+): SortFn {
+	if (orderBy === 'client') {
+		return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+	}
+
+	return blockchainSortFn;
+}

package/src/events/txEventCache.ts

@@ -0,0 +1,74 @@
+import { WrappedEvent, EventType } from './types';
+
+class Node {
+	constructor(
+		public key: string,
+		public value: WrappedEvent<EventType>[],
+		public next?: Node,
+		public prev?: Node
+	) {}
+}
+
+// lru cache
+export class TxEventCache {
+	size = 0;
+	head?: Node;
+	tail?: Node;
+	cacheMap: { [key: string]: Node } = {};
+
+	constructor(public maxTx = 1024) {}
+
+	public add(key: string, events: WrappedEvent<EventType>[]): void {
+		const existingNode = this.cacheMap[key];
+		if (existingNode) {
+			this.detach(existingNode);
+			this.size--;
+		} else if (this.size === this.maxTx) {
+			delete this.cacheMap[this.tail.key];
+			this.detach(this.tail);
+			this.size--;
+		}
+
+		// Write to head of LinkedList
+		if (!this.head) {
+			this.head = this.tail = new Node(key, events);
+		} else {
+			const node = new Node(key, events, this.head);
+			this.head.prev = node;
+			this.head = node;
+		}
+
+		// update cacheMap with LinkedList key and Node reference
+		this.cacheMap[key] = this.head;
+		this.size++;
+	}
+
+	public has(key: string): boolean {
+		return this.cacheMap.hasOwnProperty(key);
+	}
+
+	public get(key: string): WrappedEvent<EventType>[] | undefined {
+		return this.cacheMap[key]?.value;
+	}
+
+	detach(node: Node): void {
+		if (node.prev !== undefined) {
+			node.prev.next = node.next;
+		} else {
+			this.head = node.next;
+		}
+
+		if (node.next !== undefined) {
+			node.next.prev = node.prev;
+		} else {
+			this.tail = node.prev;
+		}
+	}
+
+	public clear(): void {
+		this.head = undefined;
+		this.tail = undefined;
+		this.size = 0;
+		this.cacheMap = {};
+	}
+}

package/src/events/types.ts

@@ -0,0 +1,185 @@
+import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
+import {
+	DepositRecord,
+	FundingPaymentRecord,
+	FundingRateRecord,
+	LiquidationRecord,
+	NewUserRecord,
+	OrderActionRecord,
+	OrderRecord,
+	SettlePnlRecord,
+	LPRecord,
+	InsuranceFundRecord,
+	SpotInterestRecord,
+	InsuranceFundStakeRecord,
+	CurveRecord,
+	SwapRecord,
+	SpotMarketVaultDepositRecord,
+	SwiftOrderRecord,
+	DeleteUserRecord,
+} from '../index';
+import { EventEmitter } from 'events';
+
+export type EventSubscriptionOptions = {
+	address?: PublicKey;
+	eventTypes?: EventType[];
+	maxEventsPerType?: number;
+	orderBy?: EventSubscriptionOrderBy;
+	orderDir?: EventSubscriptionOrderDirection;
+	commitment?: Commitment;
+	maxTx?: number;
+	logProviderConfig?: LogProviderConfig;
+	// when the subscription starts, client might want to backtrack and fetch old tx's
+	// this specifies how far to backtrack
+	untilTx?: TransactionSignature;
+};
+
+export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
+	eventTypes: [
+		'DepositRecord',
+		'FundingPaymentRecord',
+		'LiquidationRecord',
+		'OrderRecord',
+		'OrderActionRecord',
+		'FundingRateRecord',
+		'NewUserRecord',
+		'SettlePnlRecord',
+		'LPRecord',
+		'InsuranceFundRecord',
+		'SpotInterestRecord',
+		'InsuranceFundStakeRecord',
+		'CurveRecord',
+		'SwapRecord',
+		'SpotMarketVaultDepositRecord',
+		'SwiftOrderRecord',
+		'DeleteUserRecord',
+	],
+	maxEventsPerType: 4096,
+	orderBy: 'blockchain',
+	orderDir: 'asc',
+	commitment: 'confirmed',
+	maxTx: 4096,
+	logProviderConfig: {
+		type: 'websocket',
+	},
+};
+
+// Whether we sort events based on order blockchain produced events or client receives events
+export type EventSubscriptionOrderBy = 'blockchain' | 'client';
+export type EventSubscriptionOrderDirection = 'asc' | 'desc';
+
+export type Event<T> = T & {
+	txSig: TransactionSignature;
+	slot: number;
+	txSigIndex: number; // Unique index for each event inside a tx
+};
+
+export type WrappedEvent<Type extends EventType> = EventMap[Type] & {
+	eventType: Type;
+};
+
+export type WrappedEvents = WrappedEvent<EventType>[];
+
+export type EventMap = {
+	DepositRecord: Event<DepositRecord>;
+	FundingPaymentRecord: Event<FundingPaymentRecord>;
+	LiquidationRecord: Event<LiquidationRecord>;
+	FundingRateRecord: Event<FundingRateRecord>;
+	OrderRecord: Event<OrderRecord>;
+	OrderActionRecord: Event<OrderActionRecord>;
+	SettlePnlRecord: Event<SettlePnlRecord>;
+	NewUserRecord: Event<NewUserRecord>;
+	LPRecord: Event<LPRecord>;
+	InsuranceFundRecord: Event<InsuranceFundRecord>;
+	SpotInterestRecord: Event<SpotInterestRecord>;
+	InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
+	CurveRecord: Event<CurveRecord>;
+	SwapRecord: Event<SwapRecord>;
+	SpotMarketVaultDepositRecord: Event<SpotMarketVaultDepositRecord>;
+	SwiftOrderRecord: Event<SwiftOrderRecord>;
+	DeleteUserRecord: Event<DeleteUserRecord>;
+};
+
+export type EventType = keyof EventMap;
+
+export type DriftEvent =
+	| Event<DepositRecord>
+	| Event<FundingPaymentRecord>
+	| Event<LiquidationRecord>
+	| Event<FundingRateRecord>
+	| Event<OrderRecord>
+	| Event<OrderActionRecord>
+	| Event<SettlePnlRecord>
+	| Event<NewUserRecord>
+	| Event<LPRecord>
+	| Event<InsuranceFundRecord>
+	| Event<SpotInterestRecord>
+	| Event<InsuranceFundStakeRecord>
+	| Event<CurveRecord>
+	| Event<SwapRecord>
+	| Event<SpotMarketVaultDepositRecord>
+	| Event<SwiftOrderRecord>
+	| Event<DeleteUserRecord>;
+
+export interface EventSubscriberEvents {
+	newEvent: (event: WrappedEvent<EventType>) => void;
+}
+
+export type SortFn = (
+	currentRecord: EventMap[EventType],
+	newRecord: EventMap[EventType]
+) => 'less than' | 'greater than';
+
+export type logProviderCallback = (
+	txSig: TransactionSignature,
+	slot: number,
+	logs: string[],
+	mostRecentBlockTime: number | undefined,
+	txSigIndex: number | undefined
+) => void;
+
+export interface LogProvider {
+	isSubscribed(): boolean;
+	subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): Promise<boolean>;
+	unsubscribe(external?: boolean): Promise<boolean>;
+	eventEmitter?: EventEmitter;
+}
+
+export type LogProviderType = 'websocket' | 'polling' | 'events-server';
+
+export type StreamingLogProviderConfig = {
+	/// Max number of times to try reconnecting before failing over to fallback provider
+	maxReconnectAttempts?: number;
+	/// used for PollingLogProviderConfig on fallback
+	fallbackFrequency?: number;
+	/// used for PollingLogProviderConfig on fallback
+	fallbackBatchSize?: number;
+};
+
+export type WebSocketLogProviderConfig = StreamingLogProviderConfig & {
+	type: 'websocket';
+	/// Max time to wait before resubscribing
+	resubTimeoutMs?: number;
+};
+
+export type PollingLogProviderConfig = {
+	type: 'polling';
+	/// frequency to poll for new events
+	frequency: number;
+	/// max number of events to fetch per poll
+	batchSize?: number;
+};
+
+export type EventsServerLogProviderConfig = StreamingLogProviderConfig & {
+	type: 'events-server';
+	/// url of the events server
+	url: string;
+};
+
+export type LogProviderConfig =
+	| WebSocketLogProviderConfig
+	| PollingLogProviderConfig
+	| EventsServerLogProviderConfig;