@drift-labs/sdk 2.41.0-beta.0 → 2.41.0-beta.1

package/src/dlob/orderBookLevels.ts

@@ -10,11 +10,13 @@ import {
 	OraclePriceData,
 	PerpMarketAccount,
 	PositionDirection,
+	QUOTE_PRECISION,
 	standardizePrice,
 	SwapDirection,
 	ZERO,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
+import { assert } from '../assert/assert';
 
 type liquiditySource = 'serum' | 'vamm' | 'dlob' | 'phoenix';
 
@@ -46,9 +48,16 @@ export type L3OrderBook = {
 	bids: L3Level[];
 };
 
+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),
+];
+
 /**
  * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
- * @param dlobNodes e.g. {@link DLOB#getMakerLimitAsks} or {@link DLOB#getMakerLimitBids}
+ * @param dlobNodes e.g. {@link DLOB#getRestingLimitAsks} or {@link DLOB#getRestingLimitBids}
  * @param oraclePriceData
  * @param slot
  */
@@ -139,12 +148,20 @@ export function getVammL2Generator({
 	oraclePriceData,
 	numOrders,
 	now,
+	topOfBookQuoteAmounts,
 }: {
 	marketAccount: PerpMarketAccount;
 	oraclePriceData: OraclePriceData;
 	numOrders: number;
 	now?: BN;
+	topOfBookQuoteAmounts?: BN[];
 }): L2OrderBookGenerator {
+	let numBaseOrders = numOrders;
+	if (topOfBookQuoteAmounts) {
+		numBaseOrders = numOrders - topOfBookQuoteAmounts.length;
+		assert(topOfBookQuoteAmounts.length < numOrders);
+	}
+
 	const updatedAmm = calculateUpdatedAMM(marketAccount.amm, oraclePriceData);
 
 	const [openBids, openAsks] = calculateMarketOpenBidAsk(
@@ -162,38 +179,78 @@ export function getVammL2Generator({
 	);
 
 	let numBids = 0;
-	const baseSize = openBids.div(new BN(numOrders));
+
+	let topOfBookBidSize = ZERO;
+	let bidSize = openBids.div(new BN(numBaseOrders));
 	const bidAmm = {
 		baseAssetReserve: bidReserves.baseAssetReserve,
 		quoteAssetReserve: bidReserves.quoteAssetReserve,
 		sqrtK: updatedAmm.sqrtK,
 		pegMultiplier: updatedAmm.pegMultiplier,
 	};
+
 	const getL2Bids = function* () {
-		while (numBids < numOrders && baseSize.gt(ZERO)) {
-			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
-				calculateAmmReservesAfterSwap(
-					bidAmm,
-					'base',
-					baseSize,
+		while (numBids < numOrders && bidSize.gt(ZERO)) {
+			let quoteSwapped = ZERO;
+			let baseSwapped = ZERO;
+			let [afterSwapQuoteReserves, afterSwapBaseReserves] = [ZERO, ZERO];
+
+			if (topOfBookQuoteAmounts && numBids < topOfBookQuoteAmounts?.length) {
+				const remainingBaseLiquidity = openBids.sub(topOfBookBidSize);
+				quoteSwapped = topOfBookQuoteAmounts[numBids];
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						bidAmm,
+						'quote',
+						quoteSwapped,
+						SwapDirection.REMOVE
+					);
+
+				baseSwapped = bidAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (remainingBaseLiquidity.lt(baseSwapped)) {
+					baseSwapped = remainingBaseLiquidity;
+					[afterSwapQuoteReserves, afterSwapBaseReserves] =
+						calculateAmmReservesAfterSwap(
+							bidAmm,
+							'base',
+							baseSwapped,
+							SwapDirection.ADD
+						);
+
+					quoteSwapped = calculateQuoteAssetAmountSwapped(
+						bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+						bidAmm.pegMultiplier,
+						SwapDirection.ADD
+					);
+				}
+				topOfBookBidSize = topOfBookBidSize.add(baseSwapped);
+				bidSize = openBids.sub(topOfBookBidSize).div(new BN(numBaseOrders));
+			} else {
+				baseSwapped = bidSize;
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						bidAmm,
+						'base',
+						baseSwapped,
+						SwapDirection.ADD
+					);
+
+				quoteSwapped = calculateQuoteAssetAmountSwapped(
+					bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+					bidAmm.pegMultiplier,
 					SwapDirection.ADD
 				);
+			}
 
-			const quoteSwapped = calculateQuoteAssetAmountSwapped(
-				bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
-				bidAmm.pegMultiplier,
-				SwapDirection.ADD
-			);
-
-			const price = quoteSwapped.mul(BASE_PRECISION).div(baseSize);
+			const price = quoteSwapped.mul(BASE_PRECISION).div(baseSwapped);
 
 			bidAmm.baseAssetReserve = afterSwapBaseReserves;
 			bidAmm.quoteAssetReserve = afterSwapQuoteReserves;
 
 			yield {
 				price,
-				size: baseSize,
-				sources: { vamm: baseSize },
+				size: baseSwapped,
+				sources: { vamm: baseSwapped },
 			};
 
 			numBids++;
@@ -201,38 +258,82 @@ export function getVammL2Generator({
 	};
 
 	let numAsks = 0;
-	const askSize = openAsks.abs().div(new BN(numOrders));
+	let topOfBookAskSize = ZERO;
+	let askSize = openAsks.abs().div(new BN(numBaseOrders));
 	const askAmm = {
 		baseAssetReserve: askReserves.baseAssetReserve,
 		quoteAssetReserve: askReserves.quoteAssetReserve,
 		sqrtK: updatedAmm.sqrtK,
 		pegMultiplier: updatedAmm.pegMultiplier,
 	};
+
 	const getL2Asks = function* () {
 		while (numAsks < numOrders && askSize.gt(ZERO)) {
-			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
-				calculateAmmReservesAfterSwap(
-					askAmm,
-					'base',
-					askSize,
+			let quoteSwapped: BN = ZERO;
+			let baseSwapped: BN = ZERO;
+			let [afterSwapQuoteReserves, afterSwapBaseReserves] = [ZERO, ZERO];
+
+			if (topOfBookQuoteAmounts && numAsks < topOfBookQuoteAmounts?.length) {
+				const remainingBaseLiquidity = openAsks
+					.mul(new BN(-1))
+					.sub(topOfBookAskSize);
+				quoteSwapped = topOfBookQuoteAmounts[numAsks];
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						askAmm,
+						'quote',
+						quoteSwapped,
+						SwapDirection.ADD
+					);
+
+				baseSwapped = askAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (remainingBaseLiquidity.lt(baseSwapped)) {
+					baseSwapped = remainingBaseLiquidity;
+					[afterSwapQuoteReserves, afterSwapBaseReserves] =
+						calculateAmmReservesAfterSwap(
+							bidAmm,
+							'base',
+							baseSwapped,
+							SwapDirection.REMOVE
+						);
+
+					quoteSwapped = calculateQuoteAssetAmountSwapped(
+						bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+						bidAmm.pegMultiplier,
+						SwapDirection.REMOVE
+					);
+				}
+				topOfBookAskSize = topOfBookAskSize.add(baseSwapped);
+				askSize = openAsks
+					.abs()
+					.sub(topOfBookAskSize)
+					.div(new BN(numBaseOrders));
+			} else {
+				baseSwapped = askSize;
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						askAmm,
+						'base',
+						askSize,
+						SwapDirection.REMOVE
+					);
+
+				quoteSwapped = calculateQuoteAssetAmountSwapped(
+					askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+					askAmm.pegMultiplier,
 					SwapDirection.REMOVE
 				);
+			}
 
-			const quoteSwapped = calculateQuoteAssetAmountSwapped(
-				askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
-				askAmm.pegMultiplier,
-				SwapDirection.REMOVE
-			);
-
-			const price = quoteSwapped.mul(BASE_PRECISION).div(askSize);
+			const price = quoteSwapped.mul(BASE_PRECISION).div(baseSwapped);
 
 			askAmm.baseAssetReserve = afterSwapBaseReserves;
 			askAmm.quoteAssetReserve = afterSwapQuoteReserves;
 
 			yield {
 				price,
-				size: askSize,
-				sources: { vamm: baseSize },
+				size: baseSwapped,
+				sources: { vamm: baseSwapped },
 			};
 
 			numAsks++;

package/src/driftClient.ts

@@ -278,7 +278,8 @@ export class DriftClient {
 				config.perpMarketIndexes ?? [],
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
-				noMarketsAndOraclesSpecified
+				noMarketsAndOraclesSpecified,
+				config.accountSubscription?.resubTimeoutMs
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
@@ -3424,6 +3425,7 @@ export class DriftClient {
 		reduceOnly,
 		txParams,
 		v6,
+		onlyDirectRoutes = false,
 	}: {
 		jupiterClient: JupiterClient;
 		outMarketIndex: number;
@@ -3436,6 +3438,7 @@ export class DriftClient {
 		route?: Route;
 		reduceOnly?: SwapReduceOnly;
 		txParams?: TxParams;
+		onlyDirectRoutes?: boolean;
 		v6?: {
 			quote?: QuoteResponse;
 		};
@@ -3455,6 +3458,7 @@ export class DriftClient {
 				swapMode,
 				quote: v6.quote,
 				reduceOnly,
+				onlyDirectRoutes,
 			});
 			ixs = res.ixs;
 			lookupTables = res.lookupTables;

package/src/driftClientConfig.ts

@@ -36,6 +36,7 @@ export type DriftClientConfig = {
 export type DriftClientSubscriptionConfig =
 	| {
 			type: 'websocket';
+			resubTimeoutMs?: number;
 	  }
 	| {
 			type: 'polling';

package/src/factory/bigNum.ts

@@ -618,6 +618,8 @@ export class BigNum {
 		if (!val.replace(BigNum.delim, '')) {
 			return BigNum.from(ZERO, precisionShift);
 		}
+		if (val.includes('e'))
+			val = (+val).toFixed(precisionShift?.toNumber() ?? 9); // prevent small numbers e.g. 3.1e-8, use assume max precision 9 as default
 
 		const sides = val.split(BigNum.delim);
 		const rightSide = sides[1];

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.39.0",
+  "version": "2.40.0",
   "name": "drift",
   "instructions": [
     {
@@ -2376,6 +2376,61 @@
         }
       ]
     },
+    {
+      "name": "transferProtocolIfShares",
+      "accounts": [
+        {
+          "name": "signer",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "transferConfig",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "spotMarket",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "insuranceFundStake",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userStats",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "insuranceFundVault",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "marketIndex",
+          "type": "u16"
+        },
+        {
+          "name": "shares",
+          "type": "u128"
+        }
+      ]
+    },
     {
       "name": "initialize",
       "accounts": [
@@ -4542,6 +4597,76 @@
           "type": "u64"
         }
       ]
+    },
+    {
+      "name": "initializeProtocolIfSharesTransferConfig",
+      "accounts": [
+        {
+          "name": "admin",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "protocolIfSharesTransferConfig",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "rent",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "systemProgram",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": []
+    },
+    {
+      "name": "updateProtocolIfSharesTransferConfig",
+      "accounts": [
+        {
+          "name": "admin",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "protocolIfSharesTransferConfig",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "whitelistedSigners",
+          "type": {
+            "option": {
+              "array": [
+                "publicKey",
+                4
+              ]
+            }
+          }
+        },
+        {
+          "name": "maxTransferPerEpoch",
+          "type": {
+            "option": "u128"
+          }
+        }
+      ]
     }
   ],
   "accounts": [
@@ -4732,6 +4857,44 @@
         ]
       }
     },
+    {
+      "name": "ProtocolIfSharesTransferConfig",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "whitelistedSigners",
+            "type": {
+              "array": [
+                "publicKey",
+                4
+              ]
+            }
+          },
+          {
+            "name": "maxTransferPerEpoch",
+            "type": "u128"
+          },
+          {
+            "name": "currentEpochTransfer",
+            "type": "u128"
+          },
+          {
+            "name": "nextEpochTs",
+            "type": "i64"
+          },
+          {
+            "name": "padding",
+            "type": {
+              "array": [
+                "u128",
+                8
+              ]
+            }
+          }
+        ]
+      }
+    },
     {
       "name": "PerpMarket",
       "type": {
@@ -5004,7 +5167,7 @@
           {
             "name": "name",
             "docs": [
-              "The encoded display name fo the market e.g. SOL"
+              "The encoded display name for the market e.g. SOL"
             ],
             "type": {
               "array": [
@@ -6314,6 +6477,24 @@
         ]
       }
     },
+    {
+      "name": "MarketIdentifier",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "marketType",
+            "type": {
+              "defined": "MarketType"
+            }
+          },
+          {
+            "name": "marketIndex",
+            "type": "u16"
+          }
+        ]
+      }
+    },
     {
       "name": "HistoricalOracleData",
       "type": {
@@ -8157,6 +8338,12 @@
           },
           {
             "name": "Unstake"
+          },
+          {
+            "name": "UnstakeTransfer"
+          },
+          {
+            "name": "StakeTransfer"
           }
         ]
       }
@@ -8198,6 +8385,34 @@
         ]
       }
     },
+    {
+      "name": "MarginCalculationMode",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Standard"
+          },
+          {
+            "name": "Liquidation",
+            "fields": [
+              {
+                "name": "margin_buffer",
+                "type": "u128"
+              },
+              {
+                "name": "market_to_track_margin_requirement",
+                "type": {
+                  "option": {
+                    "defined": "MarketIdentifier"
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
     {
       "name": "OracleSource",
       "type": {
@@ -10781,6 +10996,11 @@
       "code": 6254,
       "name": "UserReduceOnly",
       "msg": "UserReduceOnly"
+    },
+    {
+      "code": 6255,
+      "name": "InvalidMarginCalculation",
+      "msg": "InvalidMarginCalculation"
     }
   ]
 }

package/src/jupiter/jupiterClient.ts

@@ -275,16 +275,20 @@ export class JupiterClient {
 		inputMint,
 		outputMint,
 		amount,
+		maxAccounts = 50, // 50 is an estimated amount with buffer
 		slippageBps = 50,
 		swapMode = 'ExactIn',
 		onlyDirectRoutes = false,
+		excludeDexes = [],
 	}: {
 		inputMint: PublicKey;
 		outputMint: PublicKey;
 		amount: BN;
+		maxAccounts?: number;
 		slippageBps?: number;
 		swapMode?: SwapMode;
 		onlyDirectRoutes?: boolean;
+		excludeDexes?: string[];
 	}): Promise<QuoteResponse> {
 		const params = new URLSearchParams({
 			inputMint: inputMint.toString(),
@@ -293,6 +297,8 @@ export class JupiterClient {
 			slippageBps: slippageBps.toString(),
 			swapMode,
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
+			maxAccounts: maxAccounts.toString(),
+			excludeDexes: excludeDexes.join(','),
 		}).toString();
 		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
 		return quote;

package/src/math/amm.ts

@@ -471,12 +471,19 @@ export function calculateVolSpreadBN(
 		clampMax
 	);
 
+	// only consider confidence interval at full value when above 25 bps
+	let confComponent = lastOracleConfPct;
+
+	if (lastOracleConfPct.lte(PRICE_PRECISION.div(new BN(400)))) {
+		confComponent = lastOracleConfPct.div(new BN(10));
+	}
+
 	const longVolSpread = BN.max(
-		lastOracleConfPct,
+		confComponent,
 		volSpread.mul(longVolSpreadFactor).div(PERCENTAGE_PRECISION)
 	);
 	const shortVolSpread = BN.max(
-		lastOracleConfPct,
+		confComponent,
 		volSpread.mul(shortVolSpreadFactor).div(PERCENTAGE_PRECISION)
 	);
 

package/src/math/auction.ts

@@ -1,5 +1,5 @@
-import { isOneOfVariant, isVariant, Order } from '../types';
-import { BN, ZERO } from '../.';
+import { isOneOfVariant, isVariant, Order, PositionDirection } from '../types';
+import { BN, ONE, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
 	if (order.auctionDuration === 0) {
@@ -104,3 +104,37 @@ export function getAuctionPriceForOracleOffsetAuction(
 
 	return oraclePrice.add(priceOffset);
 }
+
+export function deriveOracleAuctionParams({
+	direction,
+	oraclePrice,
+	auctionStartPrice,
+	auctionEndPrice,
+	limitPrice,
+}: {
+	direction: PositionDirection;
+	oraclePrice: BN;
+	auctionStartPrice: BN;
+	auctionEndPrice: BN;
+	limitPrice: BN;
+}): { auctionStartPrice: BN; auctionEndPrice: BN; oraclePriceOffset: number } {
+	let oraclePriceOffset = limitPrice.sub(oraclePrice);
+	if (oraclePriceOffset.eq(ZERO)) {
+		oraclePriceOffset = isVariant(direction, 'long')
+			? auctionEndPrice.sub(oraclePrice).add(ONE)
+			: auctionEndPrice.sub(oraclePrice).sub(ONE);
+	}
+
+	let oraclePriceOffsetNum;
+	try {
+		oraclePriceOffsetNum = oraclePriceOffset.toNumber();
+	} catch (e) {
+		oraclePriceOffsetNum = 0;
+	}
+
+	return {
+		auctionStartPrice: auctionStartPrice.sub(oraclePrice),
+		auctionEndPrice: auctionEndPrice.sub(oraclePrice),
+		oraclePriceOffset: oraclePriceOffsetNum,
+	};
+}

package/src/math/market.ts

@@ -279,27 +279,22 @@ export function calculateAvailablePerpLiquidity(
 
 	asks = asks.abs();
 
-	const bidPrice = calculateBidPrice(market, oraclePriceData);
-	const askPrice = calculateAskPrice(market, oraclePriceData);
-
-	for (const bid of dlob.getMakerLimitBids(
+	for (const bid of dlob.getRestingLimitBids(
 		market.marketIndex,
 		slot,
 		MarketType.PERP,
-		oraclePriceData,
-		askPrice
+		oraclePriceData
 	)) {
 		bids = bids.add(
 			bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled)
 		);
 	}
 
-	for (const ask of dlob.getMakerLimitAsks(
+	for (const ask of dlob.getRestingLimitAsks(
 		market.marketIndex,
 		slot,
 		MarketType.PERP,
-		oraclePriceData,
-		bidPrice
+		oraclePriceData
 	)) {
 		asks = asks.add(
 			ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled)