@velocity-exchange/sdk 0.0.1

package/lib/browser/dlob/DLOBNode.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="bn.js" />
+import { BN } from '../isomorphic/anchor';
+import { MarketTypeStr, Order } from '../types';
+import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
+export interface DLOBNode {
+    getPrice<T extends MarketTypeStr>(oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData, slot: number): BN;
+    isVammNode(): boolean;
+    order: Order | undefined;
+    isBaseFilled(): boolean;
+    haveFilled: boolean;
+    userAccount: string | undefined;
+    isSignedMsg: boolean | undefined;
+    baseAssetAmount: BN;
+}
+export declare abstract class OrderNode implements DLOBNode {
+    order: Order;
+    userAccount: string;
+    sortValue: BN;
+    haveFilled: boolean;
+    haveTrigger: boolean;
+    baseAssetAmount: BN;
+    isSignedMsg: boolean;
+    constructor(order: Order, userAccount: string, baseAssetAmount?: BN, isSignedMsg?: boolean);
+    abstract getSortValue(order: Order): BN;
+    getLabel(): string;
+    getPrice<T extends MarketTypeStr>(oraclePriceData: T extends 'spot' ? OraclePriceData : MMOraclePriceData, slot: number): BN;
+    isBaseFilled(): boolean;
+    isVammNode(): boolean;
+}
+export declare class TakingLimitOrderNode extends OrderNode {
+    next?: TakingLimitOrderNode;
+    previous?: TakingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class RestingLimitOrderNode extends OrderNode {
+    next?: RestingLimitOrderNode;
+    previous?: RestingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class FloatingLimitOrderNode extends OrderNode {
+    next?: FloatingLimitOrderNode;
+    previous?: FloatingLimitOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class MarketOrderNode extends OrderNode {
+    next?: MarketOrderNode;
+    previous?: MarketOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class TriggerOrderNode extends OrderNode {
+    next?: TriggerOrderNode;
+    previous?: TriggerOrderNode;
+    getSortValue(order: Order): BN;
+}
+export declare class SignedMsgOrderNode extends OrderNode {
+    next?: SignedMsgOrderNode;
+    previous?: SignedMsgOrderNode;
+    constructor(order: Order, userAccount: string, baseAssetAmount?: BN);
+    getSortValue(order: Order): BN;
+}
+export type DLOBNodeMap = {
+    restingLimit: RestingLimitOrderNode;
+    takingLimit: TakingLimitOrderNode;
+    floatingLimit: FloatingLimitOrderNode;
+    market: MarketOrderNode;
+    trigger: TriggerOrderNode;
+    signedMsg: SignedMsgOrderNode;
+};
+export type DLOBNodeType = 'signedMsg' | 'restingLimit' | 'takingLimit' | 'floatingLimit' | 'market' | ('trigger' & keyof DLOBNodeMap);
+export declare function createNode<T extends DLOBNodeType>(nodeType: T, order: Order, userAccount: string, baseAssetAmount?: BN): DLOBNodeMap[T];

package/lib/browser/dlob/DLOBNode.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNode = exports.SignedMsgOrderNode = exports.TriggerOrderNode = exports.MarketOrderNode = exports.FloatingLimitOrderNode = exports.RestingLimitOrderNode = exports.TakingLimitOrderNode = exports.OrderNode = void 0;
+const anchor_1 = require("../isomorphic/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const orders_1 = require("../math/orders");
+const types_1 = require("../types");
+const conversion_1 = require("../math/conversion");
+const NodeList_1 = require("./NodeList");
+class OrderNode {
+    constructor(order, userAccount, baseAssetAmount, isSignedMsg = false) {
+        this.haveFilled = false;
+        this.haveTrigger = false;
+        // Copy the order over to the node
+        this.order = { ...order };
+        this.userAccount = userAccount;
+        this.sortValue = this.getSortValue(order);
+        this.baseAssetAmount = baseAssetAmount !== null && baseAssetAmount !== void 0 ? baseAssetAmount : order.baseAssetAmount;
+        this.isSignedMsg = isSignedMsg;
+    }
+    getLabel() {
+        let msg = `Order ${(0, NodeList_1.getOrderSignature)(this.order.orderId, this.userAccount)}`;
+        msg += ` ${(0, types_1.isVariant)(this.order.direction, 'long') ? 'LONG' : 'SHORT'} `;
+        msg += `${(0, conversion_1.convertToNumber)(this.order.baseAssetAmount, numericConstants_1.AMM_RESERVE_PRECISION).toFixed(3)}`;
+        if (this.order.price.gt(numericConstants_1.ZERO)) {
+            msg += ` @ ${(0, conversion_1.convertToNumber)(this.order.price, numericConstants_1.PRICE_PRECISION).toFixed(3)}`;
+        }
+        if (this.order.triggerPrice.gt(numericConstants_1.ZERO)) {
+            msg += ` ${(0, types_1.isVariant)(this.order.triggerCondition, 'below') ? 'BELOW' : 'ABOVE'}`;
+            msg += ` ${(0, conversion_1.convertToNumber)(this.order.triggerPrice, numericConstants_1.PRICE_PRECISION).toFixed(3)}`;
+        }
+        return msg;
+    }
+    getPrice(oraclePriceData, slot) {
+        return (0, orders_1.getLimitPrice)(this.order, oraclePriceData, slot);
+    }
+    isBaseFilled() {
+        return this.order.baseAssetAmountFilled.eq(this.order.baseAssetAmount);
+    }
+    isVammNode() {
+        return false;
+    }
+}
+exports.OrderNode = OrderNode;
+class TakingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.slot;
+    }
+}
+exports.TakingLimitOrderNode = TakingLimitOrderNode;
+class RestingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.price;
+    }
+}
+exports.RestingLimitOrderNode = RestingLimitOrderNode;
+class FloatingLimitOrderNode extends OrderNode {
+    getSortValue(order) {
+        return new anchor_1.BN(order.oraclePriceOffset);
+    }
+}
+exports.FloatingLimitOrderNode = FloatingLimitOrderNode;
+class MarketOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.slot;
+    }
+}
+exports.MarketOrderNode = MarketOrderNode;
+class TriggerOrderNode extends OrderNode {
+    getSortValue(order) {
+        return order.triggerPrice;
+    }
+}
+exports.TriggerOrderNode = TriggerOrderNode;
+// We'll use the signedMsg uuid for the order id since it's not yet on-chain
+class SignedMsgOrderNode extends OrderNode {
+    constructor(order, userAccount, baseAssetAmount) {
+        super(order, userAccount, baseAssetAmount, true);
+    }
+    getSortValue(order) {
+        return order.slot;
+    }
+}
+exports.SignedMsgOrderNode = SignedMsgOrderNode;
+function createNode(nodeType, order, userAccount, baseAssetAmount) {
+    switch (nodeType) {
+        case 'floatingLimit':
+            return new FloatingLimitOrderNode(order, userAccount, baseAssetAmount);
+        case 'restingLimit':
+            return new RestingLimitOrderNode(order, userAccount, baseAssetAmount);
+        case 'takingLimit':
+            return new TakingLimitOrderNode(order, userAccount, baseAssetAmount);
+        case 'market':
+            return new MarketOrderNode(order, userAccount, baseAssetAmount);
+        case 'trigger':
+            return new TriggerOrderNode(order, userAccount, baseAssetAmount);
+        case 'signedMsg':
+            return new SignedMsgOrderNode(order, userAccount, baseAssetAmount);
+        default:
+            throw Error(`Unknown DLOBNode type ${nodeType}`);
+    }
+}
+exports.createNode = createNode;

package/lib/browser/dlob/DLOBSubscriber.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { DLOB } from './DLOB';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { DLOBSource, DLOBSubscriberEvents, DLOBSubscriptionConfig, SlotSource } from './types';
+import { VelocityClient } from '../velocityClient';
+import { MarketType } from '../types';
+import { L2OrderBook, L2OrderBookGenerator, L3OrderBook } from './orderBookLevels';
+import { BN } from '../isomorphic/anchor';
+export declare class DLOBSubscriber {
+    driftClient: VelocityClient;
+    dlobSource: DLOBSource;
+    slotSource: SlotSource;
+    updateFrequency: number;
+    intervalId?: ReturnType<typeof setTimeout>;
+    dlob: DLOB;
+    eventEmitter: StrictEventEmitter<EventEmitter, DLOBSubscriberEvents>;
+    constructor(config: DLOBSubscriptionConfig);
+    subscribe(): Promise<void>;
+    updateDLOB(): Promise<void>;
+    getDLOB(): DLOB;
+    /**
+     * Get the L2 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     * @param depth Number of orders to include in the order book. Defaults to 10.
+     * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}
+     * @param latestSlot Latest slot observed via slot subscriber or similar for accuarate vamm quotes (if including the vAMM).
+     */
+    getL2({ marketName, marketIndex, marketType, depth, includeVamm, numVammOrders, fallbackL2Generators, latestSlot, }: {
+        marketName?: string;
+        marketIndex?: number;
+        marketType?: MarketType;
+        depth?: number;
+        includeVamm?: boolean;
+        numVammOrders?: number;
+        fallbackL2Generators?: L2OrderBookGenerator[];
+        latestSlot?: BN;
+    }): L2OrderBook;
+    /**
+     * Get the L3 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     */
+    getL3({ marketName, marketIndex, marketType, }: {
+        marketName?: string;
+        marketIndex?: number;
+        marketType?: MarketType;
+    }): L3OrderBook;
+    unsubscribe(): Promise<void>;
+}

package/lib/browser/dlob/DLOBSubscriber.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLOBSubscriber = void 0;
+const DLOB_1 = require("./DLOB");
+const events_1 = require("events");
+const types_1 = require("../types");
+const orderBookLevels_1 = require("./orderBookLevels");
+class DLOBSubscriber {
+    constructor(config) {
+        this.driftClient = config.driftClient;
+        this.dlobSource = config.dlobSource;
+        this.slotSource = config.slotSource;
+        this.updateFrequency = config.updateFrequency;
+        this.dlob = new DLOB_1.DLOB();
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        await this.updateDLOB();
+        this.intervalId = setInterval(async () => {
+            try {
+                await this.updateDLOB();
+                this.eventEmitter.emit('update', this.dlob);
+            }
+            catch (e) {
+                this.eventEmitter.emit('error', e);
+            }
+        }, this.updateFrequency);
+    }
+    async updateDLOB() {
+        this.dlob = await this.dlobSource.getDLOB(this.slotSource.getSlot());
+    }
+    getDLOB() {
+        return this.dlob;
+    }
+    /**
+     * Get the L2 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     * @param depth Number of orders to include in the order book. Defaults to 10.
+     * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+     * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}
+     * @param latestSlot Latest slot observed via slot subscriber or similar for accuarate vamm quotes (if including the vAMM).
+     */
+    getL2({ marketName, marketIndex, marketType, depth = 10, includeVamm = false, numVammOrders, fallbackL2Generators = [], latestSlot, }) {
+        if (marketName) {
+            const derivedMarketInfo = this.driftClient.getMarketIndexAndType(marketName);
+            if (!derivedMarketInfo) {
+                throw new Error(`Market ${marketName} not found`);
+            }
+            marketIndex = derivedMarketInfo.marketIndex;
+            marketType = derivedMarketInfo.marketType;
+        }
+        else {
+            if (marketIndex === undefined || marketType === undefined) {
+                throw new Error('Either marketName or marketIndex and marketType must be provided');
+            }
+        }
+        let oraclePriceData;
+        const isPerp = (0, types_1.isVariant)(marketType, 'perp');
+        if (isPerp) {
+            const perpMarketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+            oraclePriceData = this.driftClient.getOracleDataForPerpMarket(perpMarketAccount.marketIndex);
+        }
+        else {
+            oraclePriceData =
+                this.driftClient.getOracleDataForSpotMarket(marketIndex);
+        }
+        if (isPerp && includeVamm) {
+            if (fallbackL2Generators.length > 0) {
+                throw new Error('includeVamm can only be used if fallbackL2Generators is empty');
+            }
+            fallbackL2Generators = [
+                (0, orderBookLevels_1.getVammL2Generator)({
+                    marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
+                    mmOraclePriceData: this.driftClient.getMMOracleDataForPerpMarket(marketIndex),
+                    numOrders: numVammOrders !== null && numVammOrders !== void 0 ? numVammOrders : depth,
+                    topOfBookQuoteAmounts: marketIndex < 3
+                        ? orderBookLevels_1.MAJORS_TOP_OF_BOOK_QUOTE_AMOUNTS
+                        : orderBookLevels_1.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
+                    latestSlot,
+                }),
+            ];
+        }
+        return this.dlob.getL2({
+            marketIndex,
+            marketType,
+            depth,
+            oraclePriceData,
+            slot: this.slotSource.getSlot(),
+            fallbackL2Generators: fallbackL2Generators,
+        });
+    }
+    /**
+     * Get the L3 order book for a given market.
+     *
+     * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+     * @param marketIndex
+     * @param marketType
+     */
+    getL3({ marketName, marketIndex, marketType, }) {
+        if (marketName) {
+            const derivedMarketInfo = this.driftClient.getMarketIndexAndType(marketName);
+            if (!derivedMarketInfo) {
+                throw new Error(`Market ${marketName} not found`);
+            }
+            marketIndex = derivedMarketInfo.marketIndex;
+            marketType = derivedMarketInfo.marketType;
+        }
+        else {
+            if (marketIndex === undefined || marketType === undefined) {
+                throw new Error('Either marketName or marketIndex and marketType must be provided');
+            }
+        }
+        let oraclePriceData;
+        const isPerp = (0, types_1.isVariant)(marketType, 'perp');
+        if (isPerp) {
+            oraclePriceData =
+                this.driftClient.getOracleDataForPerpMarket(marketIndex);
+        }
+        else {
+            oraclePriceData =
+                this.driftClient.getOracleDataForSpotMarket(marketIndex);
+        }
+        return this.dlob.getL3({
+            marketIndex,
+            marketType,
+            oraclePriceData,
+            slot: this.slotSource.getSlot(),
+        });
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.DLOBSubscriber = DLOBSubscriber;

package/lib/browser/dlob/NodeList.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="bn.js" />
+import { MarketTypeStr, Order } from '../types';
+import { DLOBNode, DLOBNodeMap } from './DLOBNode';
+import { BN } from '../isomorphic/anchor';
+export type SortDirection = 'asc' | 'desc';
+export declare function getOrderSignature(orderId: number, userAccount: string): string;
+export interface DLOBNodeGenerator {
+    getGenerator(): Generator<DLOBNode>;
+}
+export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLOBNodeGenerator {
+    private nodeType;
+    private sortDirection;
+    head?: DLOBNodeMap[NodeType];
+    length: number;
+    nodeMap: Map<string, DLOBNodeMap[NodeType]>;
+    constructor(nodeType: NodeType, sortDirection: SortDirection);
+    clear(): void;
+    insert(order: Order, marketType: MarketTypeStr, userAccount: string, baseAssetAmount?: BN): void;
+    prependNode(currentNode: DLOBNodeMap[NodeType], newNode: DLOBNodeMap[NodeType]): boolean;
+    update(order: Order, userAccount: string): void;
+    remove(order: Order, userAccount: string): void;
+    getGenerator(): Generator<DLOBNode>;
+    has(order: Order, userAccount: string): boolean;
+    get(orderSignature: string): DLOBNodeMap[NodeType] | undefined;
+    print(): void;
+    printTop(): void;
+}

package/lib/browser/dlob/NodeList.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeList = exports.getOrderSignature = void 0;
+const types_1 = require("../types");
+const DLOBNode_1 = require("./DLOBNode");
+function getOrderSignature(orderId, userAccount) {
+    return `${userAccount.toString()}-${orderId.toString()}`;
+}
+exports.getOrderSignature = getOrderSignature;
+class NodeList {
+    constructor(nodeType, sortDirection) {
+        this.nodeType = nodeType;
+        this.sortDirection = sortDirection;
+        this.length = 0;
+        this.nodeMap = new Map();
+    }
+    clear() {
+        this.head = undefined;
+        this.length = 0;
+        this.nodeMap.clear();
+    }
+    insert(order, marketType, userAccount, baseAssetAmount) {
+        if (!(0, types_1.isVariant)(order.status, 'open')) {
+            return;
+        }
+        const newNode = (0, DLOBNode_1.createNode)(this.nodeType, order, userAccount, baseAssetAmount);
+        const orderSignature = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderSignature)) {
+            return;
+        }
+        this.nodeMap.set(orderSignature, newNode);
+        this.length += 1;
+        if (this.head === undefined) {
+            this.head = newNode;
+            return;
+        }
+        if (this.prependNode(this.head, newNode)) {
+            this.head.previous = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+            return;
+        }
+        let currentNode = this.head;
+        while (currentNode.next !== undefined &&
+            !this.prependNode(currentNode.next, newNode)) {
+            currentNode = currentNode.next;
+        }
+        newNode.next = currentNode.next;
+        if (currentNode.next !== undefined) {
+            newNode.next.previous = newNode;
+        }
+        currentNode.next = newNode;
+        newNode.previous = currentNode;
+    }
+    prependNode(currentNode, newNode) {
+        const currentOrder = currentNode.order;
+        const newOrder = newNode.order;
+        const currentOrderSortPrice = currentNode.sortValue;
+        const newOrderSortPrice = newNode.sortValue;
+        if (newOrderSortPrice.eq(currentOrderSortPrice)) {
+            return newOrder.slot.lt(currentOrder.slot);
+        }
+        if (this.sortDirection === 'asc') {
+            return newOrderSortPrice.lt(currentOrderSortPrice);
+        }
+        else {
+            return newOrderSortPrice.gt(currentOrderSortPrice);
+        }
+    }
+    update(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            Object.assign(node.order, order);
+            node.haveFilled = false;
+        }
+    }
+    remove(order, userAccount) {
+        const orderId = getOrderSignature(order.orderId, userAccount);
+        if (this.nodeMap.has(orderId)) {
+            const node = this.nodeMap.get(orderId);
+            if (node.next) {
+                node.next.previous = node.previous;
+            }
+            if (node.previous) {
+                node.previous.next = node.next;
+            }
+            if (this.head && node.order.orderId === this.head.order.orderId) {
+                this.head = node.next;
+            }
+            node.previous = undefined;
+            node.next = undefined;
+            this.nodeMap.delete(orderId);
+            this.length--;
+        }
+    }
+    *getGenerator() {
+        let node = this.head;
+        while (node !== undefined) {
+            yield node;
+            node = node.next;
+        }
+    }
+    has(order, userAccount) {
+        return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+    }
+    get(orderSignature) {
+        return this.nodeMap.get(orderSignature);
+    }
+    print() {
+        let currentNode = this.head;
+        while (currentNode !== undefined) {
+            console.log(currentNode.getLabel());
+            currentNode = currentNode.next;
+        }
+    }
+    printTop() {
+        if (this.head) {
+            console.log(this.sortDirection.toUpperCase(), this.head.getLabel());
+        }
+        else {
+            console.log('---');
+        }
+    }
+}
+exports.NodeList = NodeList;

package/lib/browser/dlob/orderBookLevels.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="bn.js" />
+import { BN } from '../isomorphic/anchor';
+import { DLOBNode } from './DLOBNode';
+import { PerpMarketAccount } from '../types';
+import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
+import { PublicKey } from '@solana/web3.js';
+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 declare const DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS: BN[];
+export declare const MAJORS_TOP_OF_BOOK_QUOTE_AMOUNTS: BN[];
+/**
+ * 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 declare function getL2GeneratorFromDLOBNodes(dlobNodes: Generator<DLOBNode>, oraclePriceData: OraclePriceData, slot: number): Generator<L2Level>;
+export declare function mergeL2LevelGenerators(l2LevelGenerators: Generator<L2Level>[], compare: (a: L2Level, b: L2Level) => boolean): Generator<L2Level>;
+export declare function createL2Levels(generator: Generator<L2Level>, depth: number): L2Level[];
+export declare function getVammL2Generator({ marketAccount, mmOraclePriceData, numOrders, now, topOfBookQuoteAmounts, latestSlot, }: {
+    marketAccount: PerpMarketAccount;
+    mmOraclePriceData: MMOraclePriceData;
+    numOrders: number;
+    now?: BN;
+    topOfBookQuoteAmounts?: BN[];
+    latestSlot?: BN;
+}): L2OrderBookGenerator;
+export declare function groupL2(l2: L2OrderBook, grouping: BN, depth: number): L2OrderBook;
+/**
+ * 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 declare function uncrossL2(bids: L2Level[], asks: L2Level[], oraclePrice: BN, oracleTwap5Min: BN, markTwap5Min: BN, grouping: BN, userBids: Set<string>, userAsks: Set<string>): {
+    bids: L2Level[];
+    asks: L2Level[];
+};
+export {};