@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.0

package/src/events/eventSubscriber.ts

@@ -0,0 +1,194 @@
+import { Connection, TransactionSignature } from '@solana/web3.js';
+import { Program } from '@project-serum/anchor';
+import {
+	DefaultEventSubscriptionOptions,
+	EventSubscriptionOptions,
+	EventType,
+	WrappedEvents,
+	EventMap,
+	LogProvider,
+	EventSubscriberEvents,
+} from './types';
+import { TxEventCache } from './txEventCache';
+import { EventList } from './eventList';
+import { PollingLogProvider } from './pollingLogProvider';
+import { fetchLogs } from './fetchLogs';
+import { WebSocketLogProvider } from './webSocketLogProvider';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { getSortFn } from './sort';
+
+export class EventSubscriber {
+	private eventListMap: Map<EventType, EventList<EventType>>;
+	private txEventCache: TxEventCache;
+	private awaitTxPromises = new Map<string, Promise<void>>();
+	private awaitTxResolver = new Map<string, () => void>();
+	private logProvider: LogProvider;
+	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+
+	public constructor(
+		private connection: Connection,
+		private program: Program,
+		private options: EventSubscriptionOptions = DefaultEventSubscriptionOptions
+	) {
+		this.options = Object.assign({}, DefaultEventSubscriptionOptions, options);
+		this.txEventCache = new TxEventCache(this.options.maxTx);
+		this.eventListMap = new Map<EventType, EventList<EventType>>();
+		for (const eventType of this.options.eventTypes) {
+			this.eventListMap.set(
+				eventType,
+				new EventList(
+					eventType,
+					this.options.maxEventsPerType,
+					getSortFn(this.options.orderBy, this.options.orderDir, eventType),
+					this.options.orderDir
+				)
+			);
+		}
+		this.eventEmitter = new EventEmitter();
+		if (this.options.logProviderConfig.type === 'websocket') {
+			this.logProvider = new WebSocketLogProvider(
+				this.connection,
+				this.program.programId,
+				this.options.commitment
+			);
+		} else {
+			this.logProvider = new PollingLogProvider(
+				this.connection,
+				this.program.programId,
+				options.commitment,
+				this.options.logProviderConfig.frequency
+			);
+		}
+	}
+
+	public subscribe(): boolean {
+		if (this.logProvider.isSubscribed()) {
+			return true;
+		}
+
+		this.fetchPreviousTx().catch((e) => {
+			console.error('Error fetching previous txs in event subscriber');
+			console.error(e);
+		});
+
+		return this.logProvider.subscribe((txSig, slot, logs) => {
+			this.handleTxLogs(txSig, slot, logs);
+		});
+	}
+
+	private handleTxLogs(
+		txSig: TransactionSignature,
+		slot: number,
+		logs: string[]
+	): void {
+		if (this.txEventCache.has(txSig)) {
+			return;
+		}
+
+		const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+		for (const wrappedEvent of wrappedEvents) {
+			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+			this.eventEmitter.emit('newEvent', wrappedEvent);
+		}
+
+		if (this.awaitTxPromises.has(txSig)) {
+			this.awaitTxPromises.delete(txSig);
+			this.awaitTxResolver.get(txSig)();
+			this.awaitTxResolver.delete(txSig);
+		}
+
+		this.txEventCache.add(txSig, wrappedEvents);
+	}
+
+	private async fetchPreviousTx(): Promise<void> {
+		if (!this.options.untilTx) {
+			return;
+		}
+
+		let txFetched = 0;
+		let beforeTx: TransactionSignature = undefined;
+		const untilTx: TransactionSignature = this.options.untilTx;
+		while (txFetched < this.options.maxTx) {
+			const response = await fetchLogs(
+				this.connection,
+				this.program.programId,
+				this.options.commitment === 'finalized' ? 'finalized' : 'confirmed',
+				beforeTx,
+				untilTx
+			);
+
+			if (response === undefined) {
+				break;
+			}
+
+			txFetched += response.transactionLogs.length;
+			beforeTx = response.earliestTx;
+
+			for (const { txSig, slot, logs } of response.transactionLogs) {
+				this.handleTxLogs(txSig, slot, logs);
+			}
+		}
+	}
+
+	public async unsubscribe(): Promise<boolean> {
+		return await this.logProvider.unsubscribe();
+	}
+
+	private parseEventsFromLogs(
+		txSig: TransactionSignature,
+		slot: number,
+		logs: string[]
+	): WrappedEvents {
+		const records = [];
+		// @ts-ignore
+		this.program._events._eventParser.parseLogs(logs, (event) => {
+			const expectRecordType = this.eventListMap.has(event.name);
+			if (expectRecordType) {
+				event.data.txSig = txSig;
+				event.data.slot = slot;
+				event.data.eventType = event.name;
+				records.push(event.data);
+			}
+		});
+		return records;
+	}
+
+	public awaitTx(txSig: TransactionSignature): Promise<void> {
+		if (this.awaitTxPromises.has(txSig)) {
+			return this.awaitTxPromises.get(txSig);
+		}
+
+		if (this.txEventCache.has(txSig)) {
+			return Promise.resolve();
+		}
+
+		const promise = new Promise<void>((resolve) => {
+			this.awaitTxResolver.set(txSig, resolve);
+		});
+		this.awaitTxPromises.set(txSig, promise);
+		return promise;
+	}
+
+	public getEventList<Type extends keyof EventMap>(
+		eventType: Type
+	): EventList<Type> {
+		return this.eventListMap.get(eventType) as EventList<Type>;
+	}
+
+	/**
+	 * This requires the EventList be cast to an array, which requires reallocation of memory.
+	 * Would bias to using getEventList over getEvents
+	 *
+	 * @param eventType
+	 */
+	public getEventsArray<Type extends EventType>(
+		eventType: Type
+	): EventMap[Type][] {
+		return this.eventListMap.get(eventType).toArray() as EventMap[Type][];
+	}
+
+	public getEventsByTx(txSig: TransactionSignature): WrappedEvents | undefined {
+		return this.txEventCache.get(txSig);
+	}
+}

package/src/events/fetchLogs.ts

@@ -0,0 +1,80 @@
+import {
+	Connection,
+	Finality,
+	PublicKey,
+	TransactionSignature,
+} from '@solana/web3.js';
+
+type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
+type FetchLogsResponse = {
+	earliestTx: string;
+	mostRecentTx: string;
+	transactionLogs: Log[];
+};
+
+export async function fetchLogs(
+	connection: Connection,
+	programId: PublicKey,
+	finality: Finality,
+	beforeTx?: TransactionSignature,
+	untilTx?: TransactionSignature
+): Promise<FetchLogsResponse | undefined> {
+	const signatures = await connection.getSignaturesForAddress(
+		programId,
+		{
+			before: beforeTx,
+			until: untilTx,
+		},
+		finality
+	);
+
+	const sortedSignatures = signatures.sort((a, b) =>
+		a.slot < b.slot ? -1 : 1
+	);
+
+	const filteredSignatures = sortedSignatures.filter(
+		(signature) => !signature.err
+	);
+
+	if (filteredSignatures.length === 0) {
+		return undefined;
+	}
+
+	const chunkedSignatures = chunk(filteredSignatures, 100);
+
+	const transactionLogs = (
+		await Promise.all(
+			chunkedSignatures.map(async (chunk) => {
+				const transactions = await connection.getTransactions(
+					chunk.map((confirmedSignature) => confirmedSignature.signature),
+					finality
+				);
+
+				return transactions.map((transaction) => {
+					return {
+						txSig: transaction.transaction.signatures[0],
+						slot: transaction.slot,
+						logs: transaction.meta.logMessages,
+					};
+				});
+			})
+		)
+	).flat();
+
+	const earliestTx = filteredSignatures[0].signature;
+	const mostRecentTx =
+		filteredSignatures[filteredSignatures.length - 1].signature;
+
+	return {
+		transactionLogs: transactionLogs,
+		earliestTx: earliestTx,
+		mostRecentTx: mostRecentTx,
+	};
+}
+
+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));
+}

package/src/events/pollingLogProvider.ts

@@ -0,0 +1,79 @@
+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: NodeJS.Timer;
+	private mostRecentSeenTx?: TransactionSignature;
+	private mutex: number;
+
+	public constructor(
+		private connection: Connection,
+		private programId: PublicKey,
+		commitment: Commitment,
+		private frequency = 15 * 1000
+	) {
+		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+	}
+
+	public subscribe(callback: logProviderCallback): 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.programId,
+					this.finality,
+					undefined,
+					this.mostRecentSeenTx
+				);
+
+				if (response === undefined) {
+					return;
+				}
+
+				const { mostRecentTx, transactionLogs } = response;
+
+				for (const { txSig, slot, logs } of transactionLogs) {
+					callback(txSig, slot, logs);
+				}
+
+				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,65 @@
+import {
+	EventMap,
+	EventSubscriptionOrderBy,
+	EventSubscriptionOrderDirection,
+	EventType,
+	SortFn,
+	Event,
+} from './types';
+import { OrderRecord } from '../types';
+import { PublicKey, ZERO } from '../index';
+
+function clientSortAscFn(): 'less than' {
+	return 'less than';
+}
+
+function clientSortDescFn(): 'greater than' {
+	return 'greater than';
+}
+
+function defaultBlockchainSortFn(
+	currentEvent: EventMap[EventType],
+	newEvent: EventMap[EventType]
+): 'less than' | 'greater than' {
+	return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
+}
+
+function orderRecordSortFn(
+	currentEvent: Event<OrderRecord>,
+	newEvent: Event<OrderRecord>
+): 'less than' | 'greater than' {
+	const currentEventMarketIndex = !currentEvent.maker.equals(PublicKey.default)
+		? currentEvent.makerOrder.marketIndex
+		: currentEvent.takerOrder.marketIndex;
+	const newEventMarketIndex = !newEvent.maker.equals(PublicKey.default)
+		? newEvent.makerOrder.marketIndex
+		: newEvent.takerOrder.marketIndex;
+	if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
+		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+	}
+
+	if (currentEvent.fillRecordId.gt(ZERO) && newEvent.fillRecordId.gt(ZERO)) {
+		return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
+			? 'less than'
+			: 'greater than';
+	} else {
+		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+	}
+}
+
+export function getSortFn(
+	orderBy: EventSubscriptionOrderBy,
+	orderDir: EventSubscriptionOrderDirection,
+	eventType: EventType
+): SortFn {
+	if (orderBy === 'client') {
+		return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+	}
+
+	switch (eventType) {
+		case 'OrderRecord':
+			return orderRecordSortFn;
+		default:
+			return defaultBlockchainSortFn;
+	}
+}

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,98 @@
+import { Commitment, TransactionSignature } from '@solana/web3.js';
+import {
+	DepositRecord,
+	FundingPaymentRecord,
+	FundingRateRecord,
+	LiquidationRecord,
+	OrderRecord,
+} from '../index';
+
+export type EventSubscriptionOptions = {
+	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',
+		'FundingRateRecord',
+	],
+	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;
+};
+
+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>;
+};
+
+export type EventType = keyof EventMap;
+
+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[]
+) => void;
+
+export interface LogProvider {
+	isSubscribed(): boolean;
+	subscribe(callback: logProviderCallback): boolean;
+	unsubscribe(): Promise<boolean>;
+}
+
+export type WebSocketLogProviderConfig = {
+	type: 'websocket';
+};
+
+export type PollingLogProviderConfig = {
+	type: 'polling';
+	frequency: number;
+};
+
+export type LogProviderConfig =
+	| WebSocketLogProviderConfig
+	| PollingLogProviderConfig;

package/src/events/webSocketLogProvider.ts

@@ -0,0 +1,38 @@
+import { LogProvider, logProviderCallback } from './types';
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+
+export class WebSocketLogProvider implements LogProvider {
+	private subscriptionId: number;
+	public constructor(
+		private connection: Connection,
+		private programId: PublicKey,
+		private commitment: Commitment
+	) {}
+
+	public subscribe(callback: logProviderCallback): boolean {
+		if (this.subscriptionId) {
+			return true;
+		}
+
+		this.subscriptionId = this.connection.onLogs(
+			this.programId,
+			(logs, ctx) => {
+				callback(logs.signature, ctx.slot, logs.logs);
+			},
+			this.commitment
+		);
+		return true;
+	}
+
+	public isSubscribed(): boolean {
+		return this.subscriptionId !== undefined;
+	}
+
+	public async unsubscribe(): Promise<boolean> {
+		if (this.subscriptionId !== undefined) {
+			await this.connection.removeOnLogsListener(this.subscriptionId);
+			this.subscriptionId = undefined;
+		}
+		return true;
+	}
+}

package/src/examples/makeTradeExample.ts

@@ -7,13 +7,13 @@ import {
 	ClearingHouse,
 	ClearingHouseUser,
 	initialize,
-	Markets,
 	PositionDirection,
 	convertToNumber,
 	calculateTradeSlippage,
 	MARK_PRICE_PRECISION,
 	QUOTE_PRECISION,
 } from '..';
+import { Banks } from '../constants/banks';
 
 export const getTokenAddress = (
 	mintAddress: string,
@@ -63,15 +63,18 @@ const main = async () => {
 	const clearingHousePublicKey = new PublicKey(
 		sdkConfig.CLEARING_HOUSE_PROGRAM_ID
 	);
-	const clearingHouse = ClearingHouse.from(
+	const clearingHouse = new ClearingHouse({
 		connection,
-		provider.wallet,
-		clearingHousePublicKey
-	);
+		wallet: provider.wallet,
+		programID: clearingHousePublicKey,
+	});
 	await clearingHouse.subscribe();
 
 	// Set up Clearing House user client
-	const user = ClearingHouseUser.from(clearingHouse, wallet.publicKey);
+	const user = new ClearingHouseUser({
+		clearingHouse,
+		userAccountPublicKey: await clearingHouse.getUserAccountPublicKey(),
+	});
 
 	//// Check if clearing house account exists for the current wallet
 	const userAccountExists = await user.exists();
@@ -84,19 +87,21 @@ const main = async () => {
 			await getTokenAddress(
 				usdcTokenAddress.toString(),
 				wallet.publicKey.toString()
-			)
+			),
+			Banks['devnet'][0].bankIndex
 		);
 	}
 
 	await user.subscribe();
 
 	// Get current price
-	const solMarketInfo = Markets.find(
+	const solMarketInfo = sdkConfig.MARKETS.find(
 		(market) => market.baseAssetSymbol === 'SOL'
 	);
 
 	const currentMarketPrice = calculateMarkPrice(
-		clearingHouse.getMarket(solMarketInfo.marketIndex)
+		clearingHouse.getMarketAccount(solMarketInfo.marketIndex),
+		undefined
 	);
 
 	const formattedPrice = convertToNumber(
@@ -107,14 +112,18 @@ const main = async () => {
 	console.log(`Current Market Price is $${formattedPrice}`);
 
 	// Estimate the slippage for a $5000 LONG trade
-	const solMarketAccount = clearingHouse.getMarket(solMarketInfo.marketIndex);
+	const solMarketAccount = clearingHouse.getMarketAccount(
+		solMarketInfo.marketIndex
+	);
 
 	const longAmount = new BN(5000).mul(QUOTE_PRECISION);
 	const slippage = convertToNumber(
 		calculateTradeSlippage(
 			PositionDirection.LONG,
 			longAmount,
-			solMarketAccount
+			solMarketAccount,
+			'quote',
+			undefined
 		)[0],
 		MARK_PRICE_PRECISION
 	);