@velocity-exchange/sdk 0.0.1

package/src/events/parse.ts

@@ -0,0 +1,248 @@
+import { Program, Event } from '../isomorphic/anchor';
+import { CuUsageEvent } from './types';
+
+const driftProgramId = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
+const PROGRAM_LOG = 'Program log: ';
+const PROGRAM_INSTRUCTION = 'Program log: Instruction: ';
+const PROGRAM_DATA = 'Program data: ';
+const PROGRAM_LOG_START_INDEX = PROGRAM_LOG.length;
+const PROGRAM_DATA_START_INDEX = PROGRAM_DATA.length;
+const PROGRAM_INSTRUCTION_START_INDEX = PROGRAM_INSTRUCTION.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[] = [];
+	ixStack: 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();
+	}
+
+	ix(): string {
+		if (!this.ixStack.length) {
+			throw new Error('Expected the ix stack to have elements');
+		}
+		return this.ixStack[this.ixStack.length - 1];
+	}
+
+	pushIx(newIx: string) {
+		this.ixStack.push(newIx);
+	}
+
+	popIx() {
+		this.ixStack.pop();
+	}
+}
+
+export function parseLogsForCuUsage(
+	logs: string[],
+	programId = driftProgramId
+): Event<any, CuUsageEvent>[] {
+	const cuUsageEvents: Event<any, CuUsageEvent>[] = [];
+
+	const execution = new ExecutionContext();
+	for (const log of logs) {
+		if (log.startsWith('Log truncated')) {
+			break;
+		}
+
+		const [newProgram, newIx, didPopProgram, didPopIx] = handleLogForCuUsage(
+			execution,
+			log,
+			programId
+		);
+		if (newProgram) {
+			execution.push(newProgram);
+		}
+		if (newIx) {
+			execution.pushIx(newIx);
+		}
+		if (didPopProgram) {
+			execution.pop();
+		}
+		if (didPopIx !== null) {
+			cuUsageEvents.push({
+				name: 'CuUsage',
+				data: {
+					instruction: execution.ix(),
+					cuUsage: didPopIx!,
+				},
+			} as any);
+			execution.popIx();
+		}
+	}
+	return cuUsageEvents;
+}
+
+function handleLogForCuUsage(
+	execution: ExecutionContext,
+	log: string,
+	programId = driftProgramId
+): [string | null, string | null, boolean, number | null] {
+	if (execution.stack.length > 0 && execution.program() === programId) {
+		return handleProgramLogForCuUsage(log, programId);
+	} else {
+		return handleSystemLogForCuUsage(log, programId);
+	}
+}
+
+function handleProgramLogForCuUsage(
+	log: string,
+	programId = driftProgramId
+): [string | null, string | null, boolean, number | null] {
+	if (log.startsWith(PROGRAM_INSTRUCTION)) {
+		const ixStr = log.slice(PROGRAM_INSTRUCTION_START_INDEX);
+		return [null, ixStr, false, null];
+	} else {
+		return handleSystemLogForCuUsage(log, programId);
+	}
+}
+
+function handleSystemLogForCuUsage(
+	log: string,
+	programId = driftProgramId
+): [string | null, string | null, boolean, number | null] {
+	// 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, null, true, null];
+		// Recursive call.
+	} else if (logStart.startsWith(programStart)) {
+		return [programId, null, false, null];
+		// Consumed CU log.
+	} else if (log.startsWith(`Program ${programId} consumed `)) {
+		// Extract CU usage, e.g. 'Program ... consumed 29242 of 199700 compute units'
+		// We need to extract the consumed value (29242)
+		const matches = log.match(/consumed (\d+) of \d+ compute units/);
+		if (matches) {
+			return [null, null, false, Number(matches[1])];
+		}
+		return [null, null, false, null];
+	}
+	// CPI call.
+	else if (logStart.includes('invoke')) {
+		return ['cpi', null, false, null]; // Any string will do.
+	} else {
+		return [null, null, false, null];
+	}
+}

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,228 @@
+import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
+import {
+	DepositRecord,
+	FundingPaymentRecord,
+	FundingRateRecord,
+	LiquidationRecord,
+	NewUserRecord,
+	OrderActionRecord,
+	OrderRecord,
+	SettlePnlRecord,
+	InsuranceFundRecord,
+	SpotInterestRecord,
+	InsuranceFundStakeRecord,
+	CurveRecord,
+	SwapRecord,
+	SpotMarketVaultDepositRecord,
+	SignedMsgOrderRecord,
+	DeleteUserRecord,
+	InsuranceFundSwapRecord,
+	TransferProtocolIfSharesToRevenuePoolRecord,
+	LPMintRedeemRecord,
+	LPSettleRecord,
+	LPSwapRecord,
+	LPBorrowLendDepositRecord,
+} from '../types';
+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',
+		'InsuranceFundRecord',
+		'SpotInterestRecord',
+		'InsuranceFundStakeRecord',
+		'CurveRecord',
+		'SwapRecord',
+		'SpotMarketVaultDepositRecord',
+		'SignedMsgOrderRecord',
+		'DeleteUserRecord',
+		'InsuranceFundSwapRecord',
+		'TransferProtocolIfSharesToRevenuePoolRecord',
+		'LPMintRedeemRecord',
+		'LPSettleRecord',
+		'LPSwapRecord',
+	],
+	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>;
+	InsuranceFundRecord: Event<InsuranceFundRecord>;
+	SpotInterestRecord: Event<SpotInterestRecord>;
+	InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
+	CurveRecord: Event<CurveRecord>;
+	SwapRecord: Event<SwapRecord>;
+	SpotMarketVaultDepositRecord: Event<SpotMarketVaultDepositRecord>;
+	SignedMsgOrderRecord: Event<SignedMsgOrderRecord>;
+	DeleteUserRecord: Event<DeleteUserRecord>;
+	InsuranceFundSwapRecord: Event<InsuranceFundSwapRecord>;
+	TransferProtocolIfSharesToRevenuePoolRecord: Event<TransferProtocolIfSharesToRevenuePoolRecord>;
+	LPSettleRecord: Event<LPSettleRecord>;
+	LPMintRedeemRecord: Event<LPMintRedeemRecord>;
+	LPSwapRecord: Event<LPSwapRecord>;
+};
+
+export type EventType = keyof EventMap;
+
+export type VelocityEvent =
+	| Event<DepositRecord>
+	| Event<FundingPaymentRecord>
+	| Event<LiquidationRecord>
+	| Event<FundingRateRecord>
+	| Event<OrderRecord>
+	| Event<OrderActionRecord>
+	| Event<SettlePnlRecord>
+	| Event<NewUserRecord>
+	| Event<InsuranceFundRecord>
+	| Event<SpotInterestRecord>
+	| Event<InsuranceFundStakeRecord>
+	| Event<CurveRecord>
+	| Event<SwapRecord>
+	| Event<SpotMarketVaultDepositRecord>
+	| Event<SignedMsgOrderRecord>
+	| Event<DeleteUserRecord>
+	| Event<InsuranceFundSwapRecord>
+	| Event<TransferProtocolIfSharesToRevenuePoolRecord>
+	| Event<LPSettleRecord>
+	| Event<LPMintRedeemRecord>
+	| Event<LPSwapRecord>
+	| Event<LPBorrowLendDepositRecord>
+	| Event<CuUsage>;
+
+/** @deprecated Use `VelocityEvent` instead. `DriftEvent` will be removed in a future major. */
+export type DriftEvent = VelocityEvent;
+
+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;
+
+export type CuUsageEvent = {
+	name: 'CuUsage';
+	fields: [
+		{
+			name: 'instruction';
+			type: 'string';
+			index: false;
+		},
+		{
+			name: 'cuUsage';
+			type: 'u32';
+			index: false;
+		},
+	];
+};
+
+export type CuUsage = {
+	instruction: string;
+	cuUsage: number;
+};