@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/dlob/orderBookLevels.ts

@@ -1,601 +0,0 @@
-import { BN } from '../isomorphic/anchor';
-import {
-	BASE_PRECISION,
-	QUOTE_PRECISION,
-	ZERO,
-	PRICE_PRECISION,
-	AMM_TO_QUOTE_PRECISION_RATIO,
-} from '../constants/numericConstants';
-import {
-	calculateAmmReservesAfterSwap,
-	calculateMarketOpenBidAsk,
-	calculateQuoteAssetAmountSwapped,
-	calculateSpreadReserves,
-	calculateUpdatedAMM,
-} from '../math/amm';
-import { DLOBNode } from './DLOBNode';
-import { isOperationPaused } from '../math/exchangeStatus';
-import {
-	isVariant,
-	PerpMarketAccount,
-	PerpOperation,
-	PositionDirection,
-	SwapDirection,
-} from '../types';
-import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
-import { PublicKey } from '@solana/web3.js';
-import { standardizeBaseAssetAmount, standardizePrice } from '../math/orders';
-
-type liquiditySource = 'vamm' | 'dlob' | 'indicative';
-
-export type L2Level = {
-	price: BN;
-	size: BN;
-	sources: { [key in liquiditySource]?: BN };
-};
-
-export type L2OrderBook = {
-	asks: L2Level[];
-	bids: L2Level[];
-	slot?: number;
-};
-
-export interface L2OrderBookGenerator {
-	getL2Asks(): Generator<L2Level>;
-	getL2Bids(): Generator<L2Level>;
-}
-
-export type L3Level = {
-	price: BN;
-	size: BN;
-	maker: PublicKey;
-	orderId: number;
-};
-
-export type L3OrderBook = {
-	asks: L3Level[];
-	bids: L3Level[];
-	slot?: number;
-};
-
-export const DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = [
-	new BN(500).mul(QUOTE_PRECISION),
-	new BN(1000).mul(QUOTE_PRECISION),
-	new BN(2000).mul(QUOTE_PRECISION),
-	new BN(5000).mul(QUOTE_PRECISION),
-];
-
-export const MAJORS_TOP_OF_BOOK_QUOTE_AMOUNTS = [
-	new BN(5000).mul(QUOTE_PRECISION),
-	new BN(10000).mul(QUOTE_PRECISION),
-	new BN(20000).mul(QUOTE_PRECISION),
-	new BN(50000).mul(QUOTE_PRECISION),
-];
-
-const INDICATIVE_QUOTES_PUBKEY = 'inDNdu3ML4vG5LNExqcwuCQtLcCU8KfK5YM2qYV3JJz';
-
-/**
- * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
- * @param dlobNodes e.g. {@link DLOB#getRestingLimitAsks} or {@link DLOB#getRestingLimitBids}
- * @param oraclePriceData
- * @param slot
- */
-export function* getL2GeneratorFromDLOBNodes(
-	dlobNodes: Generator<DLOBNode>,
-	oraclePriceData: OraclePriceData,
-	slot: number
-): Generator<L2Level> {
-	for (const dlobNode of dlobNodes) {
-		if (!dlobNode.order) {
-			continue;
-		}
-		const size = dlobNode.baseAssetAmount.sub(
-			dlobNode.order.baseAssetAmountFilled
-		) as BN;
-
-		if (size.lte(ZERO)) {
-			continue;
-		}
-
-		yield {
-			size,
-			price: dlobNode.getPriceOrThrow(oraclePriceData, slot),
-			sources:
-				dlobNode.userAccount == INDICATIVE_QUOTES_PUBKEY
-					? { indicative: size }
-					: {
-							dlob: size,
-					  },
-		};
-	}
-}
-
-export function* mergeL2LevelGenerators(
-	l2LevelGenerators: Generator<L2Level>[],
-	compare: (a: L2Level, b: L2Level) => boolean
-): Generator<L2Level> {
-	type GeneratorState = {
-		generator: Generator<L2Level>;
-		next: IteratorResult<L2Level>;
-	};
-
-	const generators: GeneratorState[] = l2LevelGenerators.map((generator) => {
-		return {
-			generator,
-			next: generator.next(),
-		};
-	});
-
-	let next: GeneratorState | undefined;
-	do {
-		next = generators.reduce<GeneratorState | undefined>((best, next) => {
-			if (next.next.done) {
-				return best;
-			}
-
-			if (!best) {
-				return next;
-			}
-
-			if (compare(next.next.value, best.next.value)) {
-				return next;
-			} else {
-				return best;
-			}
-		}, undefined);
-
-		if (next) {
-			yield next.next.value;
-			next.next = next.generator.next();
-		}
-	} while (next !== undefined);
-}
-
-export function createL2Levels(
-	generator: Generator<L2Level>,
-	depth: number
-): L2Level[] {
-	const levels = [];
-	for (const level of generator) {
-		const price = level.price;
-		const size = level.size;
-		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) as [
-				liquiditySource,
-				BN,
-			][]) {
-				const existingSize = currentLevel.sources[source];
-				if (existingSize) {
-					currentLevel.sources[source] = existingSize.add(size);
-				} else {
-					currentLevel.sources[source] = size;
-				}
-			}
-		} else if (levels.length === depth) {
-			break;
-		} else {
-			levels.push(level);
-		}
-	}
-	return levels;
-}
-
-export function getVammL2Generator({
-	marketAccount,
-	mmOraclePriceData,
-	numOrders,
-	now = new BN(Math.floor(Date.now() / 1000)),
-	topOfBookQuoteAmounts = [],
-	latestSlot,
-}: {
-	marketAccount: PerpMarketAccount;
-	mmOraclePriceData: MMOraclePriceData;
-	numOrders: number;
-	now?: BN;
-	topOfBookQuoteAmounts?: BN[];
-	latestSlot?: BN;
-}): L2OrderBookGenerator {
-	const updatedAmm = calculateUpdatedAMM(marketAccount.amm, mmOraclePriceData);
-	const paused = isOperationPaused(
-		marketAccount.pausedOperations,
-		PerpOperation.AMM_FILL
-	);
-	let [openBids, openAsks] = paused
-		? [ZERO, ZERO]
-		: calculateMarketOpenBidAsk(
-				updatedAmm.baseAssetReserve,
-				updatedAmm.minBaseAssetReserve,
-				updatedAmm.maxBaseAssetReserve,
-				marketAccount.orderStepSize
-		  );
-
-	if (openBids.lt(marketAccount.marketStats.minOrderSize.muln(2)))
-		openBids = ZERO;
-	if (openAsks.abs().lt(marketAccount.marketStats.minOrderSize.muln(2)))
-		openAsks = ZERO;
-
-	const [bidReserves, askReserves] = calculateSpreadReserves(
-		updatedAmm,
-		marketAccount.marketStats,
-		mmOraclePriceData,
-		now,
-		latestSlot
-	);
-
-	const numBaseOrders = Math.max(1, numOrders - topOfBookQuoteAmounts.length);
-	const commonOpts = {
-		numOrders,
-		numBaseOrders,
-		mmOraclePriceData,
-		orderTickSize: marketAccount.orderTickSize,
-		orderStepSize: marketAccount.orderStepSize,
-		pegMultiplier: updatedAmm.pegMultiplier,
-		sqrtK: updatedAmm.sqrtK,
-		topOfBookQuoteAmounts,
-	};
-
-	const makeL2Gen = ({
-		openLiquidity,
-		startReserves,
-		swapDir,
-		positionDir,
-	}: {
-		openLiquidity: BN;
-		startReserves: { baseAssetReserve: BN; quoteAssetReserve: BN };
-		swapDir: SwapDirection;
-		positionDir: PositionDirection;
-	}) => {
-		return function* () {
-			let count = 0;
-			let topSize = ZERO;
-			let size = openLiquidity.abs().divn(commonOpts.numBaseOrders);
-			const amm = {
-				...startReserves,
-				sqrtK: commonOpts.sqrtK,
-				pegMultiplier: commonOpts.pegMultiplier,
-			};
-
-			while (count < commonOpts.numOrders && size.gt(ZERO)) {
-				let baseSwap = size;
-				if (count < commonOpts.topOfBookQuoteAmounts.length) {
-					const raw = commonOpts.topOfBookQuoteAmounts[count]
-						.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-						.mul(PRICE_PRECISION)
-						.div(commonOpts.mmOraclePriceData.price);
-					baseSwap = standardizeBaseAssetAmount(raw, commonOpts.orderStepSize);
-					const remaining = openLiquidity.abs().sub(topSize);
-					if (remaining.lt(baseSwap)) baseSwap = remaining;
-				}
-				if (baseSwap.isZero()) return;
-
-				const [newQuoteRes, newBaseRes] = calculateAmmReservesAfterSwap(
-					amm,
-					'base',
-					baseSwap,
-					swapDir
-				);
-				const quoteSwapped = calculateQuoteAssetAmountSwapped(
-					amm.quoteAssetReserve.sub(newQuoteRes).abs(),
-					amm.pegMultiplier,
-					swapDir
-				);
-				const price = standardizePrice(
-					quoteSwapped.mul(BASE_PRECISION).div(baseSwap),
-					commonOpts.orderTickSize,
-					positionDir
-				);
-
-				amm.baseAssetReserve = newBaseRes;
-				amm.quoteAssetReserve = newQuoteRes;
-
-				if (count < commonOpts.topOfBookQuoteAmounts.length) {
-					topSize = topSize.add(baseSwap);
-					size = openLiquidity
-						.abs()
-						.sub(topSize)
-						.divn(commonOpts.numBaseOrders);
-				}
-
-				yield { price, size: baseSwap, sources: { vamm: baseSwap } };
-				count++;
-			}
-		};
-	};
-
-	return {
-		getL2Bids: makeL2Gen({
-			openLiquidity: openBids,
-			startReserves: bidReserves,
-			swapDir: SwapDirection.ADD,
-			positionDir: PositionDirection.LONG,
-		}),
-		getL2Asks: makeL2Gen({
-			openLiquidity: openAsks,
-			startReserves: askReserves,
-			swapDir: SwapDirection.REMOVE,
-			positionDir: PositionDirection.SHORT,
-		}),
-	};
-}
-
-export function groupL2(
-	l2: L2OrderBook,
-	grouping: BN,
-	depth: number
-): L2OrderBook {
-	return {
-		bids: groupL2Levels(l2.bids, grouping, PositionDirection.LONG, depth),
-		asks: groupL2Levels(l2.asks, grouping, PositionDirection.SHORT, depth),
-		slot: l2.slot,
-	};
-}
-
-function cloneL2Level(level: L2Level): L2Level {
-	if (!level) return level;
-
-	return {
-		price: level.price,
-		size: level.size,
-		sources: { ...level.sources },
-	};
-}
-
-function groupL2Levels(
-	levels: L2Level[],
-	grouping: BN,
-	direction: PositionDirection,
-	depth: number
-): L2Level[] {
-	const groupedLevels: L2Level[] = [];
-	for (const level of levels) {
-		const price = standardizePrice(level.price, grouping, direction);
-		const size = level.size;
-		if (
-			groupedLevels.length > 0 &&
-			groupedLevels[groupedLevels.length - 1].price.eq(price)
-		) {
-			// Clones things so we don't mutate the original
-			const currentLevel = cloneL2Level(
-				groupedLevels[groupedLevels.length - 1]
-			);
-
-			currentLevel.size = currentLevel.size.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;
-				}
-			}
-
-			groupedLevels[groupedLevels.length - 1] = currentLevel;
-		} else {
-			const groupedLevel = {
-				price: price,
-				size,
-				sources: level.sources,
-			};
-			groupedLevels.push(groupedLevel);
-		}
-
-		if (groupedLevels.length === depth) {
-			break;
-		}
-	}
-	return groupedLevels;
-}
-
-/**
- * Method to merge bids or asks by price
- */
-const mergeByPrice = (bidsOrAsks: L2Level[]) => {
-	const merged = new Map<string, L2Level>();
-	for (const level of bidsOrAsks) {
-		const key = level.price.toString();
-		const existing = merged.get(key);
-		if (existing) {
-			existing.size = existing.size.add(level.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;
-				}
-			}
-		} else {
-			merged.set(key, cloneL2Level(level));
-		}
-	}
-	return Array.from(merged.values());
-};
-
-/**
- * The purpose of this function is uncross the L2 orderbook by modifying the bid/ask price at the top of the book
- * This will make the liquidity look worse but more intuitive (users familiar with clob get confused w temporarily
- * crossing book)
- *
- * Things to note about how it works:
- * - it will not uncross the user's liquidity
- * - it does the uncrossing by "shifting" the crossing liquidity to the nearest uncrossed levels. Thus the output liquidity maintains the same total size.
- *
- * @param bids
- * @param asks
- * @param oraclePrice
- * @param oracleTwap5Min
- * @param markTwap5Min
- * @param grouping
- * @param userBids
- * @param userAsks
- */
-export function uncrossL2(
-	bids: L2Level[],
-	asks: L2Level[],
-	oraclePrice: BN,
-	oracleTwap5Min: BN,
-	markTwap5Min: BN,
-	grouping: BN,
-	userBids: Set<string>,
-	userAsks: Set<string>
-): { bids: L2Level[]; asks: L2Level[] } {
-	// If there are no bids or asks, there is nothing to center
-	if (bids.length === 0 || asks.length === 0) {
-		return { bids, asks };
-	}
-
-	// If the top of the book is already centered, there is nothing to do
-	if (bids[0].price.lt(asks[0].price)) {
-		return { bids, asks };
-	}
-
-	const newBids: L2Level[] = [];
-	const newAsks: L2Level[] = [];
-
-	const updateLevels = (newPrice: BN, oldLevel: L2Level, levels: L2Level[]) => {
-		if (levels.length > 0 && levels[levels.length - 1].price.eq(newPrice)) {
-			levels[levels.length - 1].size = levels[levels.length - 1].size.add(
-				oldLevel.size
-			);
-			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]: existingSize.add(size),
-					};
-				} else {
-					levels[levels.length - 1].sources[source] = size;
-				}
-			}
-		} else {
-			levels.push({
-				price: newPrice,
-				size: oldLevel.size,
-				sources: oldLevel.sources,
-			});
-		}
-	};
-
-	// This is the best estimate of the premium in the market vs oracle to filter crossing around
-	const referencePrice = oraclePrice.add(markTwap5Min.sub(oracleTwap5Min));
-
-	let bidIndex = 0;
-	let askIndex = 0;
-	let maxBid: BN | undefined;
-	let minAsk: BN | undefined;
-
-	const getPriceAndSetBound = (newPrice: BN, direction: PositionDirection) => {
-		if (isVariant(direction, 'long')) {
-			maxBid = maxBid ? BN.min(maxBid, newPrice) : newPrice;
-			return maxBid;
-		} else {
-			minAsk = minAsk ? BN.max(minAsk, newPrice) : newPrice;
-			return minAsk;
-		}
-	};
-
-	while (bidIndex < bids.length || askIndex < asks.length) {
-		const nextBid = cloneL2Level(bids[bidIndex]);
-		const nextAsk = cloneL2Level(asks[askIndex]);
-
-		if (!nextBid) {
-			newAsks.push(nextAsk);
-			askIndex++;
-			continue;
-		}
-
-		if (!nextAsk) {
-			newBids.push(nextBid);
-			bidIndex++;
-			continue;
-		}
-
-		if (userBids.has(nextBid.price.toString())) {
-			newBids.push(nextBid);
-			bidIndex++;
-			continue;
-		}
-
-		if (userAsks.has(nextAsk.price.toString())) {
-			newAsks.push(nextAsk);
-			askIndex++;
-			continue;
-		}
-
-		if (nextBid.price.gte(nextAsk.price)) {
-			if (
-				nextBid.price.gt(referencePrice) &&
-				nextAsk.price.gt(referencePrice)
-			) {
-				let newBidPrice = nextAsk.price.sub(grouping);
-				newBidPrice = getPriceAndSetBound(newBidPrice, PositionDirection.LONG);
-				updateLevels(newBidPrice, nextBid, newBids);
-				bidIndex++;
-			} else if (
-				nextAsk.price.lt(referencePrice) &&
-				nextBid.price.lt(referencePrice)
-			) {
-				let newAskPrice = nextBid.price.add(grouping);
-				newAskPrice = getPriceAndSetBound(newAskPrice, PositionDirection.SHORT);
-				updateLevels(newAskPrice, nextAsk, newAsks);
-				askIndex++;
-			} else {
-				let newBidPrice = referencePrice.sub(grouping);
-				let newAskPrice = referencePrice.add(grouping);
-
-				newBidPrice = getPriceAndSetBound(newBidPrice, PositionDirection.LONG);
-				newAskPrice = getPriceAndSetBound(newAskPrice, PositionDirection.SHORT);
-
-				updateLevels(newBidPrice, nextBid, newBids);
-				updateLevels(newAskPrice, nextAsk, newAsks);
-				bidIndex++;
-				askIndex++;
-			}
-		} else {
-			if (minAsk && nextAsk.price.lte(minAsk)) {
-				const newAskPrice = getPriceAndSetBound(
-					nextAsk.price,
-					PositionDirection.SHORT
-				);
-				updateLevels(newAskPrice, nextAsk, newAsks);
-			} else {
-				newAsks.push(nextAsk);
-			}
-			askIndex++;
-
-			if (maxBid && nextBid.price.gte(maxBid)) {
-				const newBidPrice = getPriceAndSetBound(
-					nextBid.price,
-					PositionDirection.LONG
-				);
-				updateLevels(newBidPrice, nextBid, newBids);
-			} else {
-				newBids.push(nextBid);
-			}
-			bidIndex++;
-		}
-	}
-
-	newBids.sort((a, b) => b.price.cmp(a.price));
-	newAsks.sort((a, b) => a.price.cmp(b.price));
-
-	const finalNewBids = mergeByPrice(newBids);
-	const finalNewAsks = mergeByPrice(newAsks);
-
-	return {
-		bids: finalNewBids,
-		asks: finalNewAsks,
-	};
-}

package/src/dlob/types.ts

@@ -1,22 +0,0 @@
-import { DLOB } from './DLOB';
-import { VelocityClient } from '../velocityClient';
-
-export type DLOBSubscriptionConfig = {
-	velocityClient?: VelocityClient;
-	dlobSource: DLOBSource;
-	slotSource: SlotSource;
-	updateFrequency: number;
-};
-
-export interface DLOBSubscriberEvents {
-	update: (dlob: DLOB) => void;
-	error: (e: Error) => void;
-}
-
-export interface DLOBSource {
-	getDLOB(slot: number): Promise<DLOB>;
-}
-
-export interface SlotSource {
-	getSlot(): number;
-}

package/src/events/eventList.ts

@@ -1,100 +0,0 @@
-import {
-	EventType,
-	EventMap,
-	EventSubscriptionOrderDirection,
-	SortFn,
-} from './types';
-
-class Node<Type extends EventType, Event extends EventMap[Type]> {
-	constructor(
-		public event: Event,
-		public next?: Node<Type, Event>,
-		public prev?: Node<Type, Event>
-	) {}
-}
-
-export class EventList<Type extends EventType> {
-	size = 0;
-	head?: Node<Type, EventMap[Type]>;
-	tail?: Node<Type, EventMap[Type]>;
-
-	public constructor(
-		public eventType: Type,
-		public maxSize: number,
-		private sortFn: SortFn,
-		private orderDirection: EventSubscriptionOrderDirection
-	) {}
-
-	public insert(event: EventMap[Type]): void {
-		this.size++;
-		const newNode = new Node(event);
-		if (this.head === undefined) {
-			this.head = this.tail = newNode;
-			return;
-		}
-
-		if (
-			this.sortFn(this.head.event, newNode.event) ===
-			(this.orderDirection === 'asc' ? 'less than' : 'greater than')
-		) {
-			this.head.prev = newNode;
-			newNode.next = this.head;
-			this.head = newNode;
-		} else {
-			let currentNode = this.head;
-			while (
-				currentNode.next !== undefined &&
-				this.sortFn(currentNode.next.event, newNode.event) !==
-					(this.orderDirection === 'asc' ? 'less than' : 'greater than')
-			) {
-				currentNode = currentNode.next;
-			}
-
-			newNode.next = currentNode.next;
-			if (newNode.next !== undefined) {
-				newNode.next.prev = newNode;
-			} else {
-				this.tail = newNode;
-			}
-
-			currentNode.next = newNode;
-			newNode.prev = currentNode;
-		}
-
-		if (this.size > this.maxSize) {
-			this.detach();
-		}
-	}
-
-	detach(): void {
-		const node = this.tail;
-		if (node === undefined) {
-			return;
-		}
-		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;
-		}
-
-		this.size--;
-	}
-
-	toArray(): EventMap[Type][] {
-		return Array.from(this);
-	}
-
-	*[Symbol.iterator]() {
-		let node = this.head;
-		while (node) {
-			yield node.event;
-			node = node.next;
-		}
-	}
-}