@velocity-exchange/sdk 0.1.0 → 0.2.0

package/src/dlob/DLOBNode.ts

@@ -10,9 +10,16 @@ import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
 import { convertToNumber } from '../math/conversion';
 import { getOrderSignature } from './NodeList';
 
+export type NodeOraclePriceData<T extends MarketTypeStr = MarketTypeStr> =
+	T extends 'spot' ? OraclePriceData : MMOraclePriceData;
+
 export interface DLOBNode {
 	getPrice<T extends MarketTypeStr>(
-		oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData,
+		oraclePriceData: NodeOraclePriceData<T>,
+		slot: number
+	): BN | undefined;
+	getPriceOrThrow<T extends MarketTypeStr>(
+		oraclePriceData: NodeOraclePriceData<T>,
 		slot: number
 	): BN;
 	isVammNode(): boolean;
@@ -77,12 +84,25 @@ export abstract class OrderNode implements DLOBNode {
 	}
 
 	getPrice<T extends MarketTypeStr>(
-		oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData,
+		oraclePriceData: NodeOraclePriceData<T>,
 		slot: number
-	): BN {
+	): BN | undefined {
 		return getLimitPrice<T>(this.order, oraclePriceData, slot);
 	}
 
+	getPriceOrThrow<T extends MarketTypeStr>(
+		oraclePriceData: NodeOraclePriceData<T>,
+		slot: number
+	): BN {
+		const price = this.getPrice<T>(oraclePriceData, slot);
+		if (price === undefined) {
+			throw new Error(
+				`OrderNode.getPrice: order ${this.order.orderId} has no limit price`
+			);
+		}
+		return price;
+	}
+
 	isBaseFilled(): boolean {
 		return this.order.baseAssetAmountFilled.eq(this.order.baseAssetAmount);
 	}

package/src/dlob/DLOBSubscriber.ts

@@ -52,7 +52,10 @@ export class DLOBSubscriber {
 				await this.updateDLOB();
 				this.eventEmitter.emit('update', this.dlob);
 			} catch (e) {
-				this.eventEmitter.emit('error', e);
+				this.eventEmitter.emit(
+					'error',
+					e instanceof Error ? e : new Error(String(e))
+				);
 			}
 		}, this.updateFrequency);
 	}
@@ -111,44 +114,52 @@ export class DLOBSubscriber {
 			}
 		}
 
-		let oraclePriceData;
 		const isPerp = isVariant(marketType, 'perp');
 		if (isPerp) {
 			const perpMarketAccount =
-				this.velocityClient.getPerpMarketAccount(marketIndex);
-			oraclePriceData = this.velocityClient.getOracleDataForPerpMarket(
+				this.velocityClient.getPerpMarketAccountOrThrow(marketIndex);
+			const oraclePriceData = this.velocityClient.getMMOracleDataForPerpMarket(
 				perpMarketAccount.marketIndex
 			);
-		} else {
-			oraclePriceData =
-				this.velocityClient.getOracleDataForSpotMarket(marketIndex);
-		}
 
-		if (isPerp && includeVamm) {
-			if (fallbackL2Generators.length > 0) {
-				throw new Error(
-					'includeVamm can only be used if fallbackL2Generators is empty'
-				);
+			if (includeVamm) {
+				if (fallbackL2Generators.length > 0) {
+					throw new Error(
+						'includeVamm can only be used if fallbackL2Generators is empty'
+					);
+				}
+
+				fallbackL2Generators = [
+					getVammL2Generator({
+						marketAccount: perpMarketAccount,
+						mmOraclePriceData:
+							this.velocityClient.getMMOracleDataForPerpMarket(marketIndex),
+						numOrders: numVammOrders ?? depth,
+						topOfBookQuoteAmounts:
+							marketIndex < 3
+								? MAJORS_TOP_OF_BOOK_QUOTE_AMOUNTS
+								: DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
+						latestSlot,
+					}),
+				];
 			}
 
-			fallbackL2Generators = [
-				getVammL2Generator({
-					marketAccount: this.velocityClient.getPerpMarketAccount(marketIndex),
-					mmOraclePriceData:
-						this.velocityClient.getMMOracleDataForPerpMarket(marketIndex),
-					numOrders: numVammOrders ?? depth,
-					topOfBookQuoteAmounts:
-						marketIndex < 3
-							? MAJORS_TOP_OF_BOOK_QUOTE_AMOUNTS
-							: DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
-					latestSlot,
-				}),
-			];
+			return this.dlob.getL2({
+				marketIndex,
+				marketType: MarketType.PERP,
+				depth,
+				oraclePriceData,
+				slot: this.slotSource.getSlot(),
+				fallbackL2Generators: fallbackL2Generators,
+			});
 		}
 
+		const oraclePriceData =
+			this.velocityClient.getOracleDataForSpotMarket(marketIndex);
+
 		return this.dlob.getL2({
 			marketIndex,
-			marketType,
+			marketType: MarketType.SPOT,
 			depth,
 			oraclePriceData,
 			slot: this.slotSource.getSlot(),
@@ -188,19 +199,25 @@ export class DLOBSubscriber {
 			}
 		}
 
-		let oraclePriceData;
 		const isPerp = isVariant(marketType, 'perp');
 		if (isPerp) {
-			oraclePriceData =
-				this.velocityClient.getOracleDataForPerpMarket(marketIndex);
-		} else {
-			oraclePriceData =
-				this.velocityClient.getOracleDataForSpotMarket(marketIndex);
+			const oraclePriceData =
+				this.velocityClient.getMMOracleDataForPerpMarket(marketIndex);
+
+			return this.dlob.getL3({
+				marketIndex,
+				marketType: MarketType.PERP,
+				oraclePriceData,
+				slot: this.slotSource.getSlot(),
+			});
 		}
 
+		const oraclePriceData =
+			this.velocityClient.getOracleDataForSpotMarket(marketIndex);
+
 		return this.dlob.getL3({
 			marketIndex,
-			marketType,
+			marketType: MarketType.SPOT,
 			oraclePriceData,
 			slot: this.slotSource.getSlot(),
 		});

package/src/dlob/NodeList.ts

@@ -78,9 +78,10 @@ export class NodeList<NodeType extends keyof DLOBNodeMap>
 			currentNode = currentNode.next;
 		}
 
-		newNode.next = currentNode.next;
-		if (currentNode.next !== undefined) {
-			newNode.next.previous = newNode;
+		const nextNode = currentNode.next;
+		newNode.next = nextNode;
+		if (nextNode !== undefined) {
+			nextNode.previous = newNode;
 		}
 		currentNode.next = newNode;
 		newNode.previous = currentNode;
@@ -109,8 +110,8 @@ export class NodeList<NodeType extends keyof DLOBNodeMap>
 
 	public update(order: Order, userAccount: string): void {
 		const orderId = getOrderSignature(order.orderId, userAccount);
-		if (this.nodeMap.has(orderId)) {
-			const node = this.nodeMap.get(orderId);
+		const node = this.nodeMap.get(orderId);
+		if (node !== undefined) {
 			Object.assign(node.order, order);
 			node.haveFilled = false;
 		}
@@ -118,8 +119,8 @@ export class NodeList<NodeType extends keyof DLOBNodeMap>
 
 	public remove(order: Order, userAccount: string): void {
 		const orderId = getOrderSignature(order.orderId, userAccount);
-		if (this.nodeMap.has(orderId)) {
-			const node = this.nodeMap.get(orderId);
+		const node = this.nodeMap.get(orderId);
+		if (node !== undefined) {
 			if (node.next) {
 				node.next.previous = node.previous;
 			}

package/src/dlob/orderBookLevels.ts

@@ -86,6 +86,9 @@ export function* getL2GeneratorFromDLOBNodes(
 	slot: number
 ): Generator<L2Level> {
 	for (const dlobNode of dlobNodes) {
+		if (!dlobNode.order) {
+			continue;
+		}
 		const size = dlobNode.baseAssetAmount.sub(
 			dlobNode.order.baseAssetAmountFilled
 		) as BN;
@@ -96,7 +99,7 @@ export function* getL2GeneratorFromDLOBNodes(
 
 		yield {
 			size,
-			price: dlobNode.getPrice(oraclePriceData, slot),
+			price: dlobNode.getPriceOrThrow(oraclePriceData, slot),
 			sources:
 				dlobNode.userAccount == INDICATIVE_QUOTES_PUBKEY
 					? { indicative: size }
@@ -111,16 +114,21 @@ export function* mergeL2LevelGenerators(
 	l2LevelGenerators: Generator<L2Level>[],
 	compare: (a: L2Level, b: L2Level) => boolean
 ): Generator<L2Level> {
-	const generators = l2LevelGenerators.map((generator) => {
+	type GeneratorState = {
+		generator: Generator<L2Level>;
+		next: IteratorResult<L2Level>;
+	};
+
+	const generators: GeneratorState[] = l2LevelGenerators.map((generator) => {
 		return {
 			generator,
 			next: generator.next(),
 		};
 	});
 
-	let next;
+	let next: GeneratorState | undefined;
 	do {
-		next = generators.reduce((best, next) => {
+		next = generators.reduce<GeneratorState | undefined>((best, next) => {
 			if (next.next.done) {
 				return best;
 			}
@@ -154,9 +162,13 @@ export function createL2Levels(
 		if (levels.length > 0 && levels[levels.length - 1].price.eq(price)) {
 			const currentLevel = levels[levels.length - 1];
 			currentLevel.size = currentLevel.size.add(size);
-			for (const [source, size] of Object.entries(level.sources)) {
-				if (currentLevel.sources[source]) {
-					currentLevel.sources[source] = currentLevel.sources[source].add(size);
+			for (const [source, size] of Object.entries(level.sources) as [
+				liquiditySource,
+				BN,
+			][]) {
+				const existingSize = currentLevel.sources[source];
+				if (existingSize) {
+					currentLevel.sources[source] = existingSize.add(size);
 				} else {
 					currentLevel.sources[source] = size;
 				}
@@ -185,11 +197,7 @@ export function getVammL2Generator({
 	topOfBookQuoteAmounts?: BN[];
 	latestSlot?: BN;
 }): L2OrderBookGenerator {
-	const updatedAmm = calculateUpdatedAMM(
-		marketAccount.amm,
-		marketAccount.totalExchangeFee,
-		mmOraclePriceData
-	);
+	const updatedAmm = calculateUpdatedAMM(marketAccount.amm, mmOraclePriceData);
 	const paused = isOperationPaused(
 		marketAccount.pausedOperations,
 		PerpOperation.AMM_FILL
@@ -354,9 +362,13 @@ function groupL2Levels(
 			);
 
 			currentLevel.size = currentLevel.size.add(size);
-			for (const [source, size] of Object.entries(level.sources)) {
-				if (currentLevel.sources[source]) {
-					currentLevel.sources[source] = currentLevel.sources[source].add(size);
+			for (const [source, size] of Object.entries(level.sources) as [
+				liquiditySource,
+				BN,
+			][]) {
+				const existingSize = currentLevel.sources[source];
+				if (existingSize) {
+					currentLevel.sources[source] = existingSize.add(size);
 				} else {
 					currentLevel.sources[source] = size;
 				}
@@ -386,12 +398,16 @@ const mergeByPrice = (bidsOrAsks: L2Level[]) => {
 	const merged = new Map<string, L2Level>();
 	for (const level of bidsOrAsks) {
 		const key = level.price.toString();
-		if (merged.has(key)) {
-			const existing = merged.get(key);
+		const existing = merged.get(key);
+		if (existing) {
 			existing.size = existing.size.add(level.size);
-			for (const [source, size] of Object.entries(level.sources)) {
-				if (existing.sources[source]) {
-					existing.sources[source] = existing.sources[source].add(size);
+			for (const [source, size] of Object.entries(level.sources) as [
+				liquiditySource,
+				BN,
+			][]) {
+				const existingSize = existing.sources[source];
+				if (existingSize) {
+					existing.sources[source] = existingSize.add(size);
 				} else {
 					existing.sources[source] = size;
 				}
@@ -449,11 +465,15 @@ export function uncrossL2(
 			levels[levels.length - 1].size = levels[levels.length - 1].size.add(
 				oldLevel.size
 			);
-			for (const [source, size] of Object.entries(oldLevel.sources)) {
-				if (levels[levels.length - 1].sources[source]) {
+			for (const [source, size] of Object.entries(oldLevel.sources) as [
+				liquiditySource,
+				BN,
+			][]) {
+				const existingSize = levels[levels.length - 1].sources[source];
+				if (existingSize) {
 					levels[levels.length - 1].sources = {
 						...levels[levels.length - 1].sources,
-						[source]: levels[levels.length - 1].sources[source].add(size),
+						[source]: existingSize.add(size),
 					};
 				} else {
 					levels[levels.length - 1].sources[source] = size;
@@ -473,8 +493,8 @@ export function uncrossL2(
 
 	let bidIndex = 0;
 	let askIndex = 0;
-	let maxBid: BN;
-	let minAsk: BN;
+	let maxBid: BN | undefined;
+	let minAsk: BN | undefined;
 
 	const getPriceAndSetBound = (newPrice: BN, direction: PositionDirection) => {
 		if (isVariant(direction, 'long')) {

package/src/events/eventList.ts

@@ -51,7 +51,7 @@ export class EventList<Type extends EventType> {
 			}
 
 			newNode.next = currentNode.next;
-			if (currentNode.next !== undefined) {
+			if (newNode.next !== undefined) {
 				newNode.next.prev = newNode;
 			} else {
 				this.tail = newNode;
@@ -68,6 +68,9 @@ export class EventList<Type extends EventType> {
 
 	detach(): void {
 		const node = this.tail;
+		if (node === undefined) {
+			return;
+		}
 		if (node.prev !== undefined) {
 			node.prev.next = node.next;
 		} else {

package/src/events/eventSubscriber.ts

@@ -21,6 +21,7 @@ import {
 	LogProviderType,
 	StreamingLogProviderConfig,
 	PollingLogProviderConfig,
+	LogProviderConfig,
 } from './types';
 import { TxEventCache } from './txEventCache';
 import { EventList } from './eventList';
@@ -39,12 +40,21 @@ export class EventSubscriber {
 	private txEventCache: TxEventCache;
 	private awaitTxPromises = new Map<string, Promise<void>>();
 	private awaitTxResolver = new Map<string, () => void>();
-	private logProvider: LogProvider;
+	private _logProvider?: LogProvider;
 	private _currentProviderType: LogProviderType;
 	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
-	private lastSeenSlot: number;
+	private lastSeenSlot: number | undefined;
 	private lastSeenBlockTime: number | undefined;
-	public lastSeenTxSig: string;
+	public lastSeenTxSig: string | undefined;
+
+	private get logProvider(): LogProvider {
+		if (!this._logProvider) {
+			throw new Error(
+				'EventSubscriber: logProvider accessed before initializeLogProvider()'
+			);
+		}
+		return this._logProvider;
+	}
 
 	public constructor(
 		private connection: Connection,
@@ -57,26 +67,38 @@ export class EventSubscriber {
 		this.eventListMap = new Map<EventType, EventList<EventType>>();
 		this.eventEmitter = new EventEmitter();
 
-		this._currentProviderType = this.options.logProviderConfig.type;
+		this._currentProviderType = this.getLogProviderConfig().type;
 		this.initializeLogProvider();
 	}
 
+	private getLogProviderConfig(): LogProviderConfig {
+		if (this.options.logProviderConfig === undefined) {
+			throw new Error('EventSubscriber: logProviderConfig is not set');
+		}
+		return this.options.logProviderConfig;
+	}
+
+	private getEventTypes(): EventType[] {
+		if (this.options.eventTypes === undefined) {
+			throw new Error('EventSubscriber: eventTypes is not set');
+		}
+		return this.options.eventTypes;
+	}
+
 	get currentProviderType() {
 		return this._currentProviderType;
 	}
 
 	private initializeLogProvider(subscribe = false) {
-		const logProviderConfig = this.options.logProviderConfig;
+		const logProviderConfig = this.getLogProviderConfig();
 
 		if (this._currentProviderType === 'websocket') {
-			this.logProvider = new WebSocketLogProvider(
+			this._logProvider = new WebSocketLogProvider(
 				// @ts-ignore
 				this.connection,
 				this.address,
-				this.options.commitment,
-				(
-					this.options.logProviderConfig as WebSocketLogProviderConfig
-				).resubTimeoutMs
+				this.options.commitment ?? 'confirmed',
+				(logProviderConfig as WebSocketLogProviderConfig).resubTimeoutMs
 			);
 		} else if (this._currentProviderType === 'polling') {
 			const frequency =
@@ -88,18 +110,18 @@ export class EventSubscriber {
 					? (logProviderConfig as PollingLogProviderConfig).batchSize
 					: (logProviderConfig as StreamingLogProviderConfig).fallbackBatchSize;
 
-			this.logProvider = new PollingLogProvider(
+			this._logProvider = new PollingLogProvider(
 				// @ts-ignore
 				this.connection,
 				this.address,
-				this.options.commitment,
+				this.options.commitment ?? 'confirmed',
 				frequency,
 				batchSize
 			);
 		} else if (this._currentProviderType === 'events-server') {
-			this.logProvider = new EventsServerLogProvider(
+			this._logProvider = new EventsServerLogProvider(
 				(logProviderConfig as EventsServerLogProviderConfig).url,
-				this.options.eventTypes,
+				this.getEventTypes(),
 				this.options.address ? this.options.address.toString() : undefined
 			);
 		} else {
@@ -126,14 +148,26 @@ export class EventSubscriber {
 	}
 
 	private populateInitialEventListMap() {
-		for (const eventType of this.options.eventTypes) {
+		const maxEventsPerType = this.options.maxEventsPerType;
+		const orderBy = this.options.orderBy;
+		const orderDir = this.options.orderDir;
+		if (
+			maxEventsPerType === undefined ||
+			orderBy === undefined ||
+			orderDir === undefined
+		) {
+			throw new Error(
+				'EventSubscriber: maxEventsPerType, orderBy and orderDir must be set'
+			);
+		}
+		for (const eventType of this.getEventTypes()) {
 			this.eventListMap.set(
 				eventType,
 				new EventList(
 					eventType,
-					this.options.maxEventsPerType,
-					getSortFn(this.options.orderBy, this.options.orderDir),
-					this.options.orderDir
+					maxEventsPerType,
+					getSortFn(orderBy, orderDir),
+					orderDir
 				)
 			);
 		}
@@ -175,30 +209,33 @@ export class EventSubscriber {
 			this.populateInitialEventListMap();
 
 			if (
-				this.options.logProviderConfig.type === 'websocket' ||
-				this.options.logProviderConfig.type === 'events-server'
+				this.getLogProviderConfig().type === 'websocket' ||
+				this.getLogProviderConfig().type === 'events-server'
 			) {
-				const logProviderConfig = this.options
-					.logProviderConfig as StreamingLogProviderConfig;
-
-				if (this.logProvider.eventEmitter) {
-					this.logProvider.eventEmitter.on(
-						'reconnect',
-						async (reconnectAttempts) => {
-							if (reconnectAttempts > logProviderConfig.maxReconnectAttempts) {
-								console.log(
-									`EventSubscriber: Reconnect attempts ${reconnectAttempts}/${logProviderConfig.maxReconnectAttempts}, reconnecting...`
-								);
-								this.logProvider.eventEmitter.removeAllListeners('reconnect');
-								await this.unsubscribe();
-								this.updateFallbackProviderType(
-									reconnectAttempts,
-									logProviderConfig.maxReconnectAttempts
-								);
-								this.initializeLogProvider(true);
-							}
+				const logProviderConfig =
+					this.getLogProviderConfig() as StreamingLogProviderConfig;
+				// `maxReconnectAttempts` is optional; when unset the original
+				// `reconnectAttempts > undefined` comparison was always false, so
+				// fall back to Infinity to preserve that never-trigger behavior.
+				const maxReconnectAttempts =
+					logProviderConfig.maxReconnectAttempts ?? Infinity;
+
+				const eventEmitter = this.logProvider.eventEmitter;
+				if (eventEmitter) {
+					eventEmitter.on('reconnect', async (reconnectAttempts) => {
+						if (reconnectAttempts > maxReconnectAttempts) {
+							console.log(
+								`EventSubscriber: Reconnect attempts ${reconnectAttempts}/${maxReconnectAttempts}, reconnecting...`
+							);
+							eventEmitter.removeAllListeners('reconnect');
+							await this.unsubscribe();
+							this.updateFallbackProviderType(
+								reconnectAttempts,
+								maxReconnectAttempts
+							);
+							this.initializeLogProvider(true);
 						}
-					);
+					});
 				}
 			}
 			this.logProvider.subscribe(
@@ -243,7 +280,13 @@ export class EventSubscriber {
 		);
 
 		for (const wrappedEvent of wrappedEvents) {
-			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+			const eventList = this.eventListMap.get(wrappedEvent.eventType);
+			if (eventList === undefined) {
+				throw new Error(
+					`EventSubscriber: no EventList for eventType ${wrappedEvent.eventType}`
+				);
+			}
+			eventList.insert(wrappedEvent);
 		}
 
 		// dont emit event till we've added all the events to the eventListMap
@@ -253,7 +296,10 @@ export class EventSubscriber {
 
 		if (this.awaitTxPromises.has(txSig)) {
 			this.awaitTxPromises.delete(txSig);
-			this.awaitTxResolver.get(txSig)();
+			const resolver = this.awaitTxResolver.get(txSig);
+			if (resolver !== undefined) {
+				resolver();
+			}
 			this.awaitTxResolver.delete(txSig);
 		}
 
@@ -264,7 +310,8 @@ export class EventSubscriber {
 
 		if (
 			this.lastSeenBlockTime === undefined ||
-			mostRecentBlockTime > this.lastSeenBlockTime
+			(mostRecentBlockTime !== undefined &&
+				mostRecentBlockTime > this.lastSeenBlockTime)
 		) {
 			this.lastSeenBlockTime = mostRecentBlockTime;
 		}
@@ -278,9 +325,13 @@ export class EventSubscriber {
 		}
 
 		let txFetched = 0;
-		let beforeTx: TransactionSignature = undefined;
-		const untilTx: TransactionSignature = this.options.untilTx;
-		while (txFetched < this.options.maxTx) {
+		let beforeTx: TransactionSignature | undefined = undefined;
+		const untilTx: TransactionSignature | undefined = this.options.untilTx;
+		const maxTx = this.options.maxTx;
+		if (maxTx === undefined) {
+			throw new Error('EventSubscriber: maxTx is not set');
+		}
+		while (txFetched < maxTx) {
 			const response = await fetchLogs(
 				// @ts-ignore
 				this.connection,
@@ -343,8 +394,9 @@ export class EventSubscriber {
 	}
 
 	public awaitTx(txSig: TransactionSignature): Promise<void> {
-		if (this.awaitTxPromises.has(txSig)) {
-			return this.awaitTxPromises.get(txSig);
+		const existingPromise = this.awaitTxPromises.get(txSig);
+		if (existingPromise !== undefined) {
+			return existingPromise;
 		}
 
 		if (this.txEventCache.has(txSig)) {
@@ -373,7 +425,13 @@ export class EventSubscriber {
 	public getEventsArray<Type extends EventType>(
 		eventType: Type
 	): EventMap[Type][] {
-		return this.eventListMap.get(eventType).toArray() as EventMap[Type][];
+		const eventList = this.eventListMap.get(eventType);
+		if (eventList === undefined) {
+			throw new Error(
+				`EventSubscriber: no EventList for eventType ${eventType}`
+			);
+		}
+		return eventList.toArray() as EventMap[Type][];
 	}
 
 	public getEventsByTx(txSig: TransactionSignature): WrappedEvents | undefined {