@drift-labs/sdk 2.0.14 → 2.0.16

package/README.md

@@ -1,7 +1,7 @@
 <div align="center">
   <img height="120x" src="https://uploads-ssl.webflow.com/611580035ad59b20437eb024/616f97a42f5637c4517d0193_Logo%20(1)%20(1).png" />
 
-  <h1 style="margin-top:20px;">Drift Protocol v1</h1>
+  <h1 style="margin-top:20px;">Drift Protocol v2</h1>
 
   <p>
     <a href="https://www.npmjs.com/package/@drift-labs/sdk"><img alt="SDK npm package" src="https://img.shields.io/npm/v/@drift-labs/sdk" /></a>
@@ -11,13 +11,13 @@
   </p>
 </div>
 
-# Drift Protocol v1
+# Drift Protocol v2
 
 This repository provides open source access to Drift's Typescript SDK, Solana Programs, and more.
 
 # SDK Guide
 
-The technical documentation for the SDK can be found [here](https://drift-labs.github.io/protocol-v1/sdk/), and you can visit Drift's general purpose documentation [here](https://docs.drift.trade/drift-sdk-documentation).
+The technical documentation for the SDK can be found [here](https://drift-labs.github.io/protocol-v2/sdk/), and you can visit Drift's general purpose documentation [here](https://docs.drift.trade/sdk-documentation).
 
 ## Installation
 

package/lib/accounts/pollingDriftClientAccountSubscriber.js

@@ -201,9 +201,6 @@ class PollingDriftClientAccountSubscriber {
         return false;
     }
     async unsubscribe() {
-        if (!this.isSubscribed) {
-            return;
-        }
         for (const [_, accountToPoll] of this.accountsToPoll) {
             this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
         }

package/lib/accounts/pollingUserStatsAccountSubscriber.js

@@ -83,9 +83,6 @@ class PollingUserStatsAccountSubscriber {
         return success;
     }
     async unsubscribe() {
-        if (!this.isSubscribed) {
-            return;
-        }
         for (const [_, accountToPoll] of this.accountsToPoll) {
             this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
         }

package/lib/adminClient.d.ts

@@ -27,6 +27,8 @@ export declare class AdminClient extends DriftClient {
     updatePerpMarketMaxSpread(perpMarketIndex: number, maxSpread: number): Promise<TransactionSignature>;
     updatePerpFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateSpotFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
+    updateInitialPctToLiquidate(initialPctToLiquidate: number): Promise<TransactionSignature>;
+    updateLiquidationDuration(liquidationDuration: number): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
     updateStateSettlementDuration(settlementDuration: number): Promise<TransactionSignature>;
     updateWithdrawGuardThreshold(spotMarketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -324,6 +324,22 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updateInitialPctToLiquidate(initialPctToLiquidate) {
+        return await this.program.rpc.updateInitialPctToLiquidate(initialPctToLiquidate, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
+    async updateLiquidationDuration(liquidationDuration) {
+        return await this.program.rpc.updateLiquidationDuration(liquidationDuration, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
     async updateOracleGuardRails(oracleGuardRails) {
         return await this.program.rpc.updateOracleGuardRails(oracleGuardRails, {
             accounts: {

package/lib/constants/numericConstants.d.ts

@@ -50,7 +50,10 @@ export declare const PRICE_TO_QUOTE_PRECISION: BN;
 export declare const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO: BN;
 export declare const MARGIN_PRECISION: BN;
 export declare const BID_ASK_SPREAD_PRECISION: BN;
+export declare const LIQUIDATION_PCT_PRECISION: BN;
 export declare const ONE_YEAR: BN;
 export declare const QUOTE_SPOT_MARKET_INDEX = 0;
 export declare const LAMPORTS_PRECISION: BN;
 export declare const LAMPORTS_EXP: BN;
+export declare const OPEN_ORDER_MARGIN_REQUIREMENT: BN;
+export declare const DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT: BN;

package/lib/constants/numericConstants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BID_ASK_SPREAD_PRECISION = exports.MARGIN_PRECISION = exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.PRICE_TO_QUOTE_PRECISION = exports.PRICE_DIV_PEG = exports.AMM_TO_QUOTE_PRECISION_RATIO = exports.BASE_PRECISION_EXP = exports.BASE_PRECISION = exports.AMM_RESERVE_PRECISION = exports.PEG_PRECISION = exports.FUNDING_RATE_BUFFER_PRECISION = exports.FUNDING_RATE_PRECISION = exports.PRICE_PRECISION = exports.QUOTE_PRECISION = exports.LIQUIDATION_FEE_PRECISION = exports.SPOT_MARKET_IMF_PRECISION = exports.SPOT_MARKET_IMF_PRECISION_EXP = exports.SPOT_MARKET_BALANCE_PRECISION = exports.SPOT_MARKET_BALANCE_PRECISION_EXP = exports.SPOT_MARKET_WEIGHT_PRECISION = exports.SPOT_MARKET_UTILIZATION_PRECISION = exports.SPOT_MARKET_UTILIZATION_PRECISION_EXP = exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION = exports.SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP = exports.SPOT_MARKET_RATE_PRECISION = exports.SPOT_MARKET_RATE_PRECISION_EXP = exports.AMM_RESERVE_PRECISION_EXP = exports.PEG_PRECISION_EXP = exports.FUNDING_RATE_PRECISION_EXP = exports.PRICE_PRECISION_EXP = exports.FUNDING_RATE_BUFFER_PRECISION_EXP = exports.QUOTE_PRECISION_EXP = exports.CONCENTRATION_PRECISION = exports.PERCENTAGE_PRECISION = exports.PERCENTAGE_PRECISION_EXP = exports.MAX_LEVERAGE = exports.TEN_MILLION = exports.BN_MAX = exports.TEN_THOUSAND = exports.TEN = exports.NINE = exports.EIGHT = exports.SEVEN = exports.SIX = exports.FIVE = exports.FOUR = exports.THREE = exports.TWO = exports.ONE = exports.ZERO = void 0;
-exports.LAMPORTS_EXP = exports.LAMPORTS_PRECISION = exports.QUOTE_SPOT_MARKET_INDEX = exports.ONE_YEAR = void 0;
+exports.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT = exports.OPEN_ORDER_MARGIN_REQUIREMENT = exports.LAMPORTS_EXP = exports.LAMPORTS_PRECISION = exports.QUOTE_SPOT_MARKET_INDEX = exports.ONE_YEAR = exports.LIQUIDATION_PCT_PRECISION = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const __1 = require("../");
 exports.ZERO = new __1.BN(0);
@@ -54,7 +54,10 @@ exports.PRICE_TO_QUOTE_PRECISION = exports.PRICE_PRECISION.div(exports.QUOTE_PRE
 exports.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO = exports.AMM_RESERVE_PRECISION.mul(exports.PEG_PRECISION).div(exports.QUOTE_PRECISION); // 10^9
 exports.MARGIN_PRECISION = exports.TEN_THOUSAND;
 exports.BID_ASK_SPREAD_PRECISION = new __1.BN(1000000); // 10^6
+exports.LIQUIDATION_PCT_PRECISION = exports.TEN_THOUSAND;
 exports.ONE_YEAR = new __1.BN(31536000);
 exports.QUOTE_SPOT_MARKET_INDEX = 0;
 exports.LAMPORTS_PRECISION = new __1.BN(web3_js_1.LAMPORTS_PER_SOL);
 exports.LAMPORTS_EXP = new __1.BN(Math.log10(web3_js_1.LAMPORTS_PER_SOL));
+exports.OPEN_ORDER_MARGIN_REQUIREMENT = exports.QUOTE_PRECISION.div(new __1.BN(100));
+exports.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT = new __1.BN(-25).mul(exports.QUOTE_PRECISION);

package/lib/dlob/DLOB.d.ts

@@ -29,7 +29,6 @@ export declare type NodeToFill = {
 export declare type NodeToTrigger = {
     node: TriggerOrderNode;
 };
-declare type Side = 'ask' | 'bid' | 'both' | 'nocross';
 export declare class DLOB {
     openOrders: Map<MarketTypeStr, Set<string>>;
     orderLists: Map<MarketTypeStr, Map<number, MarketNodeLists>>;
@@ -59,7 +58,7 @@ export declare class DLOB {
     findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
     findLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     findMarketNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
-    findMarketNodesCrossingLimitNodes(slot: number, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGenerator: Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
+    findMarketNodesCrossingLimitNodes(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
     findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, fallbackPrice: BN, doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean): NodeToFill[];
     findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType): NodeToFill[];
     findJitAuctionNodesToFill(marketIndex: number, slot: number, marketType: MarketType): NodeToFill[];
@@ -70,14 +69,10 @@ 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(askNode: DLOBNode, bidNode: DLOBNode, oraclePriceData: OraclePriceData, slot: number): {
-        crossingNodes: NodeToFill[];
-        exhaustedSide: Side;
-    };
+    findCrossingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): NodeToFill[];
     determineMakerAndTaker(askNode: DLOBNode, bidNode: DLOBNode): {
         takerNode: DLOBNode;
         makerNode: DLOBNode;
-        makerSide: Side;
     };
     getBestAsk(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
     getBestBid(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;

package/lib/dlob/DLOB.js

@@ -189,36 +189,12 @@ class DLOB {
     }
     findLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
-        let askGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
-        let bidGenerator = this.getLimitBids(marketIndex, slot, marketType, oraclePriceData);
-        let nextAsk = askGenerator.next();
-        let nextBid = bidGenerator.next();
-        // First try to find orders that cross
-        while (!nextAsk.done && !nextBid.done) {
-            const { crossingNodes, exhaustedSide } = this.findCrossingLimitOrders(nextAsk.value, nextBid.value, oraclePriceData, slot);
-            if (exhaustedSide === 'bid') {
-                nextBid = bidGenerator.next();
-            }
-            else if (exhaustedSide === 'ask') {
-                nextAsk = askGenerator.next();
-            }
-            else if (exhaustedSide === 'both') {
-                nextBid = bidGenerator.next();
-                nextAsk = askGenerator.next();
-            }
-            else if (exhaustedSide === 'nocross') {
-                break;
-            }
-            else {
-                console.error(`invalid exhaustedSide: ${exhaustedSide}`);
-                break;
-            }
-            for (const crossingNode of crossingNodes) {
-                nodesToFill.push(crossingNode);
-            }
+        const crossingNodes = this.findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
+        for (const crossingNode of crossingNodes) {
+            nodesToFill.push(crossingNode);
         }
         if (fallbackBid && !isAmmPaused) {
-            askGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
+            const askGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
             const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, fallbackBid, (askPrice, fallbackPrice) => {
                 return askPrice.lte(fallbackPrice);
             });
@@ -227,7 +203,7 @@ class DLOB {
             }
         }
         if (fallbackAsk && !isAmmPaused) {
-            bidGenerator = this.getLimitBids(marketIndex, slot, marketType, oraclePriceData);
+            const bidGenerator = this.getLimitBids(marketIndex, slot, marketType, oraclePriceData);
             const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, fallbackAsk, (bidPrice, fallbackPrice) => {
                 return bidPrice.gte(fallbackPrice);
             });
@@ -240,8 +216,7 @@ class DLOB {
     findMarketNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
         let marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
-        let limitOrderGenerator = this.getLimitBids(marketIndex, slot, marketType, oraclePriceData);
-        const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(slot, oraclePriceData, marketOrderGenerator, limitOrderGenerator, (takerPrice, makerPrice) => {
+        const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getLimitBids.bind(this), (takerPrice, makerPrice) => {
             return takerPrice === undefined || takerPrice.lte(makerPrice);
         });
         for (const marketAskCrossingBid of marketAsksCrossingBids) {
@@ -257,8 +232,7 @@ class DLOB {
             }
         }
         marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
-        limitOrderGenerator = this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData);
-        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(slot, oraclePriceData, marketOrderGenerator, limitOrderGenerator, (takerPrice, fallbackPrice) => {
+        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getLimitAsks.bind(this), (takerPrice, fallbackPrice) => {
             return takerPrice === undefined || takerPrice.gte(fallbackPrice);
         });
         for (const marketBidToFill of marketBidsToFill) {
@@ -275,57 +249,46 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findMarketNodesCrossingLimitNodes(slot, oraclePriceData, takerNodeGenerator, makerNodeGenerator, doesCross) {
+    findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, takerNodeGenerator, makerNodeGeneratorFn, doesCross) {
         const nodesToFill = new Array();
-        let nextTakerNode = takerNodeGenerator.next();
-        let nextMakerNode = makerNodeGenerator.next();
-        while (!nextTakerNode.done && !nextMakerNode.done) {
-            const takerNode = nextTakerNode.value;
-            const makerNode = nextMakerNode.value;
-            const bidUserAuthority = this.userMap.getUserAuthority(makerNode.userAccount.toString());
-            const askUserAuthority = this.userMap.getUserAuthority(takerNode.userAccount.toString());
-            // Can't match orders from the same authority
-            const sameAuthority = bidUserAuthority.equals(askUserAuthority);
-            if (sameAuthority) {
-                if (Math.random() < 0.5) {
-                    nextTakerNode = takerNodeGenerator.next();
+        for (const takerNode of takerNodeGenerator) {
+            const makerNodeGenerator = makerNodeGeneratorFn(marketIndex, slot, marketType, oraclePriceData);
+            for (const makerNode of makerNodeGenerator) {
+                const bidUserAuthority = this.userMap.getUserAuthority(makerNode.userAccount.toString());
+                const askUserAuthority = this.userMap.getUserAuthority(takerNode.userAccount.toString());
+                // Can't match orders from the same authority
+                const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+                if (sameAuthority) {
+                    continue;
                 }
-                else {
-                    nextMakerNode = makerNodeGenerator.next();
+                const makerPrice = makerNode.getPrice(oraclePriceData, slot);
+                const takerPrice = takerNode.getPrice(oraclePriceData, slot);
+                const ordersCross = doesCross(takerPrice, makerPrice);
+                if (!ordersCross) {
+                    // market orders aren't sorted by price, they are sorted by time, so we need to traverse
+                    // through all of em
+                    break;
+                }
+                nodesToFill.push({
+                    node: takerNode,
+                    makerNode: makerNode,
+                });
+                const makerOrder = makerNode.order;
+                const takerOrder = takerNode.order;
+                const makerBaseRemaining = makerOrder.baseAssetAmount.sub(makerOrder.baseAssetAmountFilled);
+                const takerBaseRemaining = takerOrder.baseAssetAmount.sub(takerOrder.baseAssetAmountFilled);
+                const baseFilled = __1.BN.min(makerBaseRemaining, takerBaseRemaining);
+                const newMakerOrder = { ...makerOrder };
+                newMakerOrder.baseAssetAmountFilled =
+                    makerOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newMakerOrder).update(newMakerOrder, makerNode.userAccount);
+                const newTakerOrder = { ...takerOrder };
+                newTakerOrder.baseAssetAmountFilled =
+                    takerOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newTakerOrder).update(newTakerOrder, takerNode.userAccount);
+                if (newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)) {
+                    break;
                 }
-                continue;
-            }
-            const makerPrice = makerNode.getPrice(oraclePriceData, slot);
-            const takerPrice = takerNode.getPrice(oraclePriceData, slot);
-            const ordersCross = doesCross(takerPrice, makerPrice);
-            if (!ordersCross) {
-                // market orders aren't sorted by price, they are sorted by time, so we need to traverse
-                // through all of em
-                nextTakerNode = takerNodeGenerator.next();
-                continue;
-            }
-            nodesToFill.push({
-                node: takerNode,
-                makerNode: makerNode,
-            });
-            const makerOrder = makerNode.order;
-            const takerOrder = takerNode.order;
-            const makerBaseRemaining = makerOrder.baseAssetAmount.sub(makerOrder.baseAssetAmountFilled);
-            const takerBaseRemaining = takerOrder.baseAssetAmount.sub(takerOrder.baseAssetAmountFilled);
-            const baseFilled = __1.BN.min(makerBaseRemaining, takerBaseRemaining);
-            const newMakerOrder = { ...makerOrder };
-            newMakerOrder.baseAssetAmountFilled =
-                makerOrder.baseAssetAmountFilled.add(baseFilled);
-            this.getListForOrder(newMakerOrder).update(newMakerOrder, makerNode.userAccount);
-            if (newMakerOrder.baseAssetAmountFilled.eq(makerOrder.baseAssetAmount)) {
-                nextMakerNode = makerNodeGenerator.next();
-            }
-            const newTakerOrder = { ...takerOrder };
-            newTakerOrder.baseAssetAmountFilled =
-                takerOrder.baseAssetAmountFilled.add(baseFilled);
-            this.getListForOrder(newTakerOrder).update(newTakerOrder, takerNode.userAccount);
-            if (newTakerOrder.baseAssetAmountFilled.eq(takerOrder.baseAssetAmount)) {
-                nextTakerNode = takerNodeGenerator.next();
             }
         }
         return nodesToFill;
@@ -548,117 +511,72 @@ class DLOB {
             return bestPrice.gt(currentPrice);
         });
     }
-    findCrossingLimitOrders(askNode, bidNode, oraclePriceData, slot) {
-        const bidPrice = bidNode.getPrice(oraclePriceData, slot);
-        const askPrice = askNode.getPrice(oraclePriceData, slot);
-        // orders don't cross - we're done walkin gup the book
-        if (bidPrice.lt(askPrice)) {
-            return {
-                crossingNodes: [],
-                exhaustedSide: 'nocross',
-            };
-        }
-        const bidOrder = bidNode.order;
-        const askOrder = askNode.order;
-        const bidUserAuthority = this.userMap.getUserAuthority(bidNode.userAccount.toString());
-        const askUserAuthority = this.userMap.getUserAuthority(askNode.userAccount.toString());
-        // Can't match orders from the same authority
-        const sameAuthority = bidUserAuthority.equals(askUserAuthority);
-        if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
-            // don't have a principle way to pick which one to exhaust,
-            // exhaust each one 50% of the time so we can try each one against other orders
-            const exhaustedSide = Math.random() < 0.5 ? 'bid' : 'ask';
-            return {
-                crossingNodes: [],
-                exhaustedSide,
-            };
-        }
-        const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
-        const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
-        const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
-        let exhaustedSide;
-        if (bidBaseRemaining.eq(askBaseRemaining)) {
-            exhaustedSide = 'both';
-        }
-        else if (bidBaseRemaining.gt(askBaseRemaining)) {
-            exhaustedSide = 'ask';
-        }
-        else {
-            exhaustedSide = 'bid';
-        }
-        // update the orders on DLOB as if they were fill - so we don't try to match them on the next iteration
-        // NOTE: if something goes wrong during the actual fill (transaction fails, i.e. due to orders already being filled)
-        // then we risk having a mismatch between this local DLOB and the actual DLOB state on the blockchain. This isn't
-        // a problem in the current implementation because we construct a new DLOB from the blockchain state every time, rather
-        // than updating the existing DLOB based on events.
-        if (exhaustedSide === 'ask') {
-            // bid partially filled
-            const newBidOrder = { ...bidOrder };
-            newBidOrder.baseAssetAmountFilled =
-                bidOrder.baseAssetAmountFilled.add(askBaseRemaining);
-            this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
-            // ask completely filled
-            const newAskOrder = { ...askOrder };
-            newAskOrder.baseAssetAmountFilled = askOrder.baseAssetAmount;
-            this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
-        }
-        else if (exhaustedSide === 'bid') {
-            // ask partially filled
-            const newAskOrder = { ...askOrder };
-            newAskOrder.baseAssetAmountFilled =
-                askOrder.baseAssetAmountFilled.add(bidBaseRemaining);
-            this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
-            // bid completely filled
-            const newBidOrder = { ...bidOrder };
-            newBidOrder.baseAssetAmountFilled = bidOrder.baseAssetAmount;
-            this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
-        }
-        else {
-            // both completely filled
-            const newBidOrder = { ...bidOrder };
-            newBidOrder.baseAssetAmountFilled = bidOrder.baseAssetAmount;
-            this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
-            const newAskOrder = { ...askOrder };
-            newAskOrder.baseAssetAmountFilled = askOrder.baseAssetAmount;
-            this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
-        }
-        return {
-            crossingNodes: [
-                {
+    findCrossingLimitOrders(marketIndex, slot, marketType, oraclePriceData) {
+        const nodesToFill = new Array();
+        for (const askNode of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
+            for (const bidNode of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
+                const bidPrice = bidNode.getPrice(oraclePriceData, slot);
+                const askPrice = askNode.getPrice(oraclePriceData, slot);
+                // orders don't cross - we're done walking the book
+                if (bidPrice.lt(askPrice)) {
+                    return nodesToFill;
+                }
+                const bidOrder = bidNode.order;
+                const askOrder = askNode.order;
+                const bidUserAuthority = this.userMap.getUserAuthority(bidNode.userAccount.toString());
+                const askUserAuthority = this.userMap.getUserAuthority(askNode.userAccount.toString());
+                // Can't match orders from the same authority
+                const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+                if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
+                    continue;
+                }
+                const { takerNode, makerNode } = this.determineMakerAndTaker(askNode, bidNode);
+                const bidBaseRemaining = bidOrder.baseAssetAmount.sub(bidOrder.baseAssetAmountFilled);
+                const askBaseRemaining = askOrder.baseAssetAmount.sub(askOrder.baseAssetAmountFilled);
+                const baseFilled = __1.BN.min(bidBaseRemaining, askBaseRemaining);
+                const newBidOrder = { ...bidOrder };
+                newBidOrder.baseAssetAmountFilled =
+                    bidOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newBidOrder).update(newBidOrder, bidNode.userAccount);
+                // ask completely filled
+                const newAskOrder = { ...askOrder };
+                newAskOrder.baseAssetAmountFilled =
+                    askOrder.baseAssetAmountFilled.add(baseFilled);
+                this.getListForOrder(newAskOrder).update(newAskOrder, askNode.userAccount);
+                nodesToFill.push({
                     node: takerNode,
                     makerNode: makerNode,
-                },
-            ],
-            exhaustedSide,
-        };
+                });
+                if (newAskOrder.baseAssetAmount.eq(newAskOrder.baseAssetAmountFilled)) {
+                    break;
+                }
+            }
+        }
+        return nodesToFill;
     }
     determineMakerAndTaker(askNode, bidNode) {
         if (bidNode.order.postOnly) {
             return {
                 takerNode: askNode,
                 makerNode: bidNode,
-                makerSide: 'bid',
             };
         }
         else if (askNode.order.postOnly) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
-                makerSide: 'ask',
             };
         }
         else if (askNode.order.slot.lt(bidNode.order.slot)) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
-                makerSide: 'ask',
             };
         }
         else {
             return {
                 takerNode: askNode,
                 makerNode: bidNode,
-                makerSide: 'bid',
             };
         }
     }

package/lib/idl/drift.json

@@ -1432,7 +1432,7 @@
                 },
                 {
                     "name": "spotMarket",
-                    "isMut": false,
+                    "isMut": true,
                     "isSigner": false
                 },
                 {
@@ -3233,6 +3233,48 @@
                 }
             ]
         },
+        {
+            "name": "updateInitialPctToLiquidate",
+            "accounts": [
+                {
+                    "name": "admin",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "state",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "initialPctToLiquidate",
+                    "type": "u16"
+                }
+            ]
+        },
+        {
+            "name": "updateLiquidationDuration",
+            "accounts": [
+                {
+                    "name": "admin",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "state",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "liquidationDuration",
+                    "type": "u8"
+                }
+            ]
+        },
         {
             "name": "updateOracleGuardRails",
             "accounts": [
@@ -4320,12 +4362,20 @@
                             "defined": "ExchangeStatus"
                         }
                     },
+                    {
+                        "name": "liquidationDuration",
+                        "type": "u8"
+                    },
+                    {
+                        "name": "initialPctToLiquidate",
+                        "type": "u16"
+                    },
                     {
                         "name": "padding",
                         "type": {
                             "array": [
                                 "u8",
-                                17
+                                14
                             ]
                         }
                     }
@@ -4420,8 +4470,8 @@
                         "type": "u64"
                     },
                     {
-                        "name": "liquidationStartTs",
-                        "type": "i64"
+                        "name": "liquidationStartSlot",
+                        "type": "u64"
                     },
                     {
                         "name": "nextOrderId",
@@ -5596,11 +5646,11 @@
                         "type": "u64"
                     },
                     {
-                        "name": "lastNetBaseAssetAmountPerLp",
+                        "name": "lastBaseAssetAmountPerLp",
                         "type": "i64"
                     },
                     {
-                        "name": "lastNetQuoteAssetAmountPerLp",
+                        "name": "lastQuoteAssetAmountPerLp",
                         "type": "i64"
                     },
                     {
@@ -6016,6 +6066,9 @@
                     },
                     {
                         "name": "OrderFillWithSerum"
+                    },
+                    {
+                        "name": "NoBorrowLiquidity"
                     }
                 ]
             }
@@ -8454,11 +8507,16 @@
         },
         {
             "code": 6219,
+            "name": "UnableToGetLimitPrice",
+            "msg": "Unable To Get Limit Price"
+        },
+        {
+            "code": 6220,
             "name": "InvalidLiquidation",
             "msg": "Invalid Liquidation"
         },
         {
-            "code": 6220,
+            "code": 6221,
             "name": "SpotFulfillmentConfigDisabled",
             "msg": "Spot Fulfullment Config Disabled"
         }

package/lib/math/amm.d.ts

@@ -34,15 +34,16 @@ export declare type AssetType = 'quote' | 'base';
  */
 export declare function calculateAmmReservesAfterSwap(amm: Pick<AMM, 'pegMultiplier' | 'quoteAssetReserve' | 'sqrtK' | 'baseAssetReserve'>, inputAssetType: AssetType, swapAmount: BN, swapDirection: SwapDirection): [BN, BN];
 export declare function calculateMarketOpenBidAsk(baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): [BN, BN];
-export declare function calculateInventoryScale(netBaseAssetAmount: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): number;
+export declare function calculateInventoryScale(baseAssetAmountWithAmm: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN, directionalSpread: number, maxSpread: number): number;
 export declare function calculateEffectiveLeverage(baseSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, reservePrice: BN, totalFeeMinusDistributions: BN): number;
 export declare function calculateMaxSpread(marginRatioInitial: number): number;
-export declare function calculateSpreadBN(baseSpread: number, lastOracleReservePriceSpreadPct: BN, lastOracleConfPct: BN, maxSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, reservePrice: BN, totalFeeMinusDistributions: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): [number, number];
-export declare function calculateSpread(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): number;
-export declare function calculateSpreadReserves(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): {
-    baseAssetReserve: BN;
-    quoteAssetReserve: BN;
-};
+export declare function calculateVolSpreadBN(lastOracleConfPct: BN, reservePrice: BN, markStd: BN, oracleStd: BN, longIntensity: BN, shortIntensity: BN, volume24H: BN): [BN, BN];
+export declare function calculateSpreadBN(baseSpread: number, lastOracleReservePriceSpreadPct: BN, lastOracleConfPct: BN, maxSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, baseAssetAmountWithAmm: BN, reservePrice: BN, totalFeeMinusDistributions: BN, netRevenueSinceLastFunding: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN, markStd: BN, oracleStd: BN, longIntensity: BN, shortIntensity: BN, volume24H: BN): [number, number];
+export declare function calculateSpread(amm: AMM, oraclePriceData: OraclePriceData): [number, number];
+export declare function calculateSpreadReserves(amm: AMM, oraclePriceData: OraclePriceData): {
+    baseAssetReserve: any;
+    quoteAssetReserve: any;
+}[];
 /**
  * Helper function calculating constant product curve output. Agnostic to whether input asset is quote or base
  *