@drift-labs/sdk 2.8.0-beta.2 → 2.9.0-beta.0

package/lib/dlob/DLOB.d.ts

@@ -67,7 +67,7 @@ export declare class DLOB {
     getLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     getAsks(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     getBids(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
-    findCrossingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
+    findCrossingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     determineMakerAndTaker(askNode: DLOBNode, bidNode: DLOBNode): {
         takerNode: DLOBNode;
         makerNode: DLOBNode;

package/lib/dlob/DLOB.js

@@ -261,7 +261,7 @@ class DLOB {
     }
     findLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        const crossingNodes = this.findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
+        const crossingNodes = this.findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData, fallbackAsk, fallbackBid);
         for (const crossingNode of crossingNodes) {
             nodesToFill.push(crossingNode);
         }
@@ -584,7 +584,7 @@ class DLOB {
             return bestPrice.gt(currentPrice);
         });
     }
-    findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData) {
+    findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
         for (const askNode of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
             for (const bidNode of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
@@ -602,6 +602,22 @@ class DLOB {
                     continue;
                 }
                 const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
+                // extra guard against bad fills for limit orders where auction is incomplete
+                if (!(0, __1.isAuctionComplete)(takerNode.order, slot)) {
+                    let bidPrice;
+                    let askPrice;
+                    if ((0, __1.isVariant)(takerNode.order.direction, 'long')) {
+                        bidPrice = __1.BN.min(takerNode.getPrice(oraclePriceData, slot), fallbackAsk || __1.BN_MAX);
+                        askPrice = makerNode.getPrice(oraclePriceData, slot);
+                    }
+                    else {
+                        bidPrice = makerNode.getPrice(oraclePriceData, slot);
+                        askPrice = __1.BN.max(takerNode.getPrice(oraclePriceData, slot), fallbackBid || __1.ZERO);
+                    }
+                    if (bidPrice.lt(askPrice)) {
+                        continue;
+                    }
+                }
                 const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
                 const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
                 const baseFilled = __1.BN.min(bidBaseRemaining, askBaseRemaining);

package/lib/driftClient.d.ts

@@ -194,6 +194,8 @@ export declare class DriftClient {
     addSerumRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: SerumV3FulfillmentConfigAccount): void;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
+    forceCancelOrders(userAccountPublicKey: PublicKey, user: UserAccount): Promise<TransactionSignature>;
+    getForceCancelOrdersIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
     placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;

package/lib/driftClient.js

@@ -1484,6 +1484,26 @@ class DriftClient {
             remainingAccounts,
         });
     }
+    async forceCancelOrders(userAccountPublicKey, user) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getForceCancelOrdersIx(userAccountPublicKey, user)), [], this.opts);
+        return txSig;
+    }
+    async getForceCancelOrdersIx(userAccountPublicKey, userAccount) {
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [userAccount],
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+        });
+        return await this.program.instruction.forceCancelOrders({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     async placeAndTakePerpOrder(orderParams, makerInfo, referrerInfo) {
         const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo)), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.8.0-beta.2",
+    "version": "2.9.0-beta.0",
     "name": "drift",
     "instructions": [
         {
@@ -946,6 +946,32 @@
                 }
             ]
         },
+        {
+            "name": "forceCancelOrders",
+            "accounts": [
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "filler",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "user",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": []
+        },
         {
             "name": "settlePnl",
             "accounts": [

package/lib/tx/retryTxSender.js

@@ -22,10 +22,10 @@ class RetryTxSender {
         if (opts === undefined) {
             opts = this.provider.opts;
         }
-        if (!preSigned) {
-            await this.prepareTx(tx, additionalSigners, opts);
-        }
-        const rawTransaction = tx.serialize();
+        const signedTx = preSigned
+            ? tx
+            : await this.prepareTx(tx, additionalSigners, opts);
+        const rawTransaction = signedTx.serialize();
         const startTime = this.getTimestamp();
         let txid;
         try {
@@ -77,13 +77,13 @@ class RetryTxSender {
     async prepareTx(tx, additionalSigners, opts) {
         tx.feePayer = this.provider.wallet.publicKey;
         tx.recentBlockhash = (await this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
-        await this.provider.wallet.signTransaction(tx);
+        const signedTx = await this.provider.wallet.signTransaction(tx);
         additionalSigners
             .filter((s) => s !== undefined)
             .forEach((kp) => {
-            tx.partialSign(kp);
+            signedTx.partialSign(kp);
         });
-        return tx;
+        return signedTx;
     }
     async confirmTransaction(signature, commitment) {
         let decodedSignature;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.8.0-beta.2",
+	"version": "2.9.0-beta.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/dlob/DLOB.ts

@@ -26,6 +26,8 @@ import {
 	UserMap,
 	OrderRecord,
 	OrderActionRecord,
+	ZERO,
+	BN_MAX,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
@@ -440,7 +442,9 @@ export class DLOB {
 			marketIndex,
 			slot,
 			marketType,
-			oraclePriceData
+			oraclePriceData,
+			fallbackAsk,
+			fallbackBid
 		);
 
 		for (const crossingNode of crossingNodes) {
@@ -1009,7 +1013,9 @@ export class DLOB {
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
-		oraclePriceData: OraclePriceData
+		oraclePriceData: OraclePriceData,
+		fallbackAsk: BN | undefined,
+		fallbackBid: BN | undefined
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -1047,6 +1053,29 @@ export class DLOB {
 					bidNode
 				);
 
+				// extra guard against bad fills for limit orders where auction is incomplete
+				if (!isAuctionComplete(takerNode.order, slot)) {
+					let bidPrice: BN;
+					let askPrice: BN;
+					if (isVariant(takerNode.order.direction, 'long')) {
+						bidPrice = BN.min(
+							takerNode.getPrice(oraclePriceData, slot),
+							fallbackAsk || BN_MAX
+						);
+						askPrice = makerNode.getPrice(oraclePriceData, slot);
+					} else {
+						bidPrice = makerNode.getPrice(oraclePriceData, slot);
+						askPrice = BN.max(
+							takerNode.getPrice(oraclePriceData, slot),
+							fallbackBid || ZERO
+						);
+					}
+
+					if (bidPrice.lt(askPrice)) {
+						continue;
+					}
+				}
+
 				const bidBaseRemaining = bidOrder.baseAssetAmount.sub(
 					bidOrder.baseAssetAmountFilled
 				);

package/src/driftClient.ts

@@ -2470,6 +2470,40 @@ export class DriftClient {
 		});
 	}
 
+	public async forceCancelOrders(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getForceCancelOrdersIx(userAccountPublicKey, user)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getForceCancelOrdersIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount
+	): Promise<TransactionInstruction> {
+		const fillerPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [userAccount],
+			writableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
+		});
+
+		return await this.program.instruction.forceCancelOrders({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				filler: fillerPublicKey,
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts,
+		});
+	}
+
 	public async placeAndTakePerpOrder(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo,

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.8.0-beta.2",
+  "version": "2.9.0-beta.0",
   "name": "drift",
   "instructions": [
     {
@@ -946,6 +946,32 @@
         }
       ]
     },
+    {
+      "name": "forceCancelOrders",
+      "accounts": [
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "filler",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": []
+    },
     {
       "name": "settlePnl",
       "accounts": [

package/src/tx/retryTxSender.ts

@@ -52,11 +52,11 @@ export class RetryTxSender implements TxSender {
 			opts = this.provider.opts;
 		}
 
-		if (!preSigned) {
-			await this.prepareTx(tx, additionalSigners, opts);
-		}
+		const signedTx = preSigned
+			? tx
+			: await this.prepareTx(tx, additionalSigners, opts);
 
-		const rawTransaction = tx.serialize();
+		const rawTransaction = signedTx.serialize();
 		const startTime = this.getTimestamp();
 
 		let txid: TransactionSignature;
@@ -123,14 +123,14 @@ export class RetryTxSender implements TxSender {
 			)
 		).blockhash;
 
-		await this.provider.wallet.signTransaction(tx);
+		const signedTx = await this.provider.wallet.signTransaction(tx);
 		additionalSigners
 			.filter((s): s is Signer => s !== undefined)
 			.forEach((kp) => {
-				tx.partialSign(kp);
+				signedTx.partialSign(kp);
 			});
 
-		return tx;
+		return signedTx;
 	}
 
 	async confirmTransaction(

package/tests/dlob/test.ts

@@ -369,14 +369,16 @@ describe('DLOB Tests', () => {
 		expect(b).to.equal(3);
 
 		dlob.clear();
-		let thrown = false;
-		try {
-			const bids1 = dlob.getBids(marketIndex, vBid, 0, MarketType.PERP, oracle);
-			bids1.next();
-		} catch (e) {
-			thrown = true;
-		}
-		expect(thrown, 'should throw after clearing').to.equal(true);
+
+		const bids1 = dlob.getBids(
+			marketIndex,
+			undefined,
+			0,
+			MarketType.PERP,
+			oracle
+		);
+		bids1.next();
+		expect(bids1.next().done, 'bid generator should be done').to.equal(true);
 	});
 
 	it('DLOB orders', () => {