@drift-labs/sdk 2.0.14 → 2.0.16

package/tests/dlob/test.ts

@@ -4448,6 +4448,258 @@ describe('DLOB Spot Tests', () => {
 		expect(nodesToFillAfter[1].makerNode?.order?.orderId).to.equal(3);
 	});
 
+	it('Test market orders skipping maker with same authority', () => {
+		const vAsk = new BN(15);
+		const vBid = new BN(8);
+
+		const mockUserMap = new MockUserMap();
+		const user0 = Keypair.generate();
+		const userAuth0 = Keypair.generate();
+		const user1 = Keypair.generate();
+		const userAuth1 = Keypair.generate();
+
+		mockUserMap.addUserAccountAuthority(user0.publicKey, userAuth0.publicKey);
+		mockUserMap.addUserAccountAuthority(user1.publicKey, userAuth1.publicKey);
+
+		const dlob = new DLOB(
+			mockPerpMarkets,
+			mockSpotMarkets,
+			mockStateAccount,
+			mockUserMap,
+			false
+		);
+		const marketIndex = 0;
+
+		const slot = 12;
+		const oracle = {
+			price: vBid.add(vAsk).div(new BN(2)),
+			slot: new BN(slot),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+
+		// insert some limit sells below vAMM ask, above bid
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			1, // orderId
+			marketIndex,
+			new BN(14), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk
+		);
+		insertOrderToDLOB(
+			dlob,
+			user1.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			2, // orderId
+			marketIndex,
+			new BN(13), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk
+		);
+
+		// should have no crossing orders
+		const nodesToFillBefore = dlob.findNodesToFill(
+			marketIndex,
+			undefined,
+			undefined,
+			12, // auction over
+			Date.now(),
+			MarketType.PERP,
+			oracle
+		);
+		expect(nodesToFillBefore.length).to.equal(0);
+
+		// place two market buy orders to eat the best ask
+		insertOrderToDLOB(
+			dlob,
+			user1.publicKey,
+			OrderType.MARKET,
+			MarketType.PERP,
+			3, // orderId
+			marketIndex,
+			new BN(0), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk
+		);
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.MARKET,
+			MarketType.PERP,
+			4, // orderId
+			marketIndex,
+			new BN(0), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk
+		);
+
+		const nodesToFillAfter = dlob.findNodesToFill(
+			marketIndex,
+			undefined,
+			undefined,
+			slot, // auction over
+			Date.now(),
+			MarketType.PERP,
+			oracle
+		);
+
+		printBookState(dlob, marketIndex, vBid, vAsk, slot, oracle);
+
+		for (const n of nodesToFillAfter) {
+			console.log(
+				`cross found: taker orderId: ${n.node.order?.orderId.toString()}: BAA: ${n.node.order?.baseAssetAmountFilled.toString()}/${n.node.order?.baseAssetAmount.toString()}, maker orderId: ${n.makerNode?.order?.orderId.toString()}: BAA: ${n.makerNode?.order?.baseAssetAmountFilled.toString()}/${n.makerNode?.order?.baseAssetAmount.toString()}`
+			);
+		}
+		expect(nodesToFillAfter.length).to.equal(2);
+
+		// taker should fill completely with best maker
+		expect(nodesToFillAfter[0].node.order?.orderId).to.equal(3);
+		expect(nodesToFillAfter[0].makerNode?.order?.orderId).to.equal(1);
+
+		// taker should fill completely with second best maker
+		expect(nodesToFillAfter[1].node.order?.orderId).to.equal(4);
+		expect(nodesToFillAfter[1].makerNode?.order?.orderId).to.equal(2);
+	});
+
+	it('Test limit orders skipping maker with same authority', () => {
+		const vAsk = new BN(15);
+		const vBid = new BN(8);
+
+		const mockUserMap = new MockUserMap();
+		const user0 = Keypair.generate();
+		const userAuth0 = Keypair.generate();
+		const user1 = Keypair.generate();
+		const userAuth1 = Keypair.generate();
+
+		mockUserMap.addUserAccountAuthority(user0.publicKey, userAuth0.publicKey);
+		mockUserMap.addUserAccountAuthority(user1.publicKey, userAuth1.publicKey);
+
+		const dlob = new DLOB(
+			mockPerpMarkets,
+			mockSpotMarkets,
+			mockStateAccount,
+			mockUserMap,
+			false
+		);
+		const marketIndex = 0;
+
+		const slot = 12;
+		const oracle = {
+			price: vBid.add(vAsk).div(new BN(2)),
+			slot: new BN(slot),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+
+		// insert some limit sells below vAMM ask, above bid
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			1, // orderId
+			marketIndex,
+			new BN(14), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk
+		);
+		insertOrderToDLOB(
+			dlob,
+			user1.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			2, // orderId
+			marketIndex,
+			new BN(13), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.SHORT,
+			vBid,
+			vAsk
+		);
+
+		// should have no crossing orders
+		const nodesToFillBefore = dlob.findNodesToFill(
+			marketIndex,
+			undefined,
+			undefined,
+			12, // auction over
+			Date.now(),
+			MarketType.PERP,
+			oracle
+		);
+		expect(nodesToFillBefore.length).to.equal(0);
+
+		// place two market buy orders to eat the best ask
+		insertOrderToDLOB(
+			dlob,
+			user1.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			3, // orderId
+			marketIndex,
+			new BN(15), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk
+		);
+		insertOrderToDLOB(
+			dlob,
+			user0.publicKey,
+			OrderType.LIMIT,
+			MarketType.PERP,
+			4, // orderId
+			marketIndex,
+			new BN(14), // price
+			BASE_PRECISION, // quantity
+			PositionDirection.LONG,
+			vBid,
+			vAsk
+		);
+
+		const nodesToFillAfter = dlob.findNodesToFill(
+			marketIndex,
+			undefined,
+			undefined,
+			slot, // auction over
+			Date.now(),
+			MarketType.PERP,
+			oracle
+		);
+
+		printBookState(dlob, marketIndex, vBid, vAsk, slot, oracle);
+
+		for (const n of nodesToFillAfter) {
+			console.log(
+				`cross found: taker orderId: ${n.node.order?.orderId.toString()}: BAA: ${n.node.order?.baseAssetAmountFilled.toString()}/${n.node.order?.baseAssetAmount.toString()}, maker orderId: ${n.makerNode?.order?.orderId.toString()}: BAA: ${n.makerNode?.order?.baseAssetAmountFilled.toString()}/${n.makerNode?.order?.baseAssetAmount.toString()}`
+			);
+		}
+		expect(nodesToFillAfter.length).to.equal(2);
+
+		// taker should fill completely with best maker
+		expect(nodesToFillAfter[0].node.order?.orderId).to.equal(2);
+		expect(nodesToFillAfter[0].makerNode?.order?.orderId).to.equal(4);
+
+		// taker should fill completely with second best maker
+		expect(nodesToFillAfter[1].node.order?.orderId).to.equal(1);
+		expect(nodesToFillAfter[1].makerNode?.order?.orderId).to.equal(3);
+	});
+
 	it('Test trigger orders', () => {
 		const vAsk = new BN(15);
 		const vBid = new BN(8);

package/src/events/eventList.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventList = void 0;
-class Node {
-    constructor(event, next, prev) {
-        this.event = event;
-        this.next = next;
-        this.prev = prev;
-    }
-}
-class EventList {
-    constructor(eventType, maxSize, sortFn, orderDirection) {
-        this.eventType = eventType;
-        this.maxSize = maxSize;
-        this.sortFn = sortFn;
-        this.orderDirection = orderDirection;
-        this.size = 0;
-    }
-    insert(event) {
-        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 (currentNode.next !== undefined) {
-                newNode.next.prev = newNode;
-            }
-            currentNode.next = newNode;
-            newNode.prev = currentNode;
-        }
-        if (this.size > this.maxSize) {
-            this.detach();
-        }
-    }
-    detach() {
-        const node = this.tail;
-        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() {
-        return Array.from(this);
-    }
-    *[Symbol.iterator]() {
-        let node = this.head;
-        while (node) {
-            yield node.event;
-            node = node.next;
-        }
-    }
-}
-exports.EventList = EventList;