@drift-labs/sdk 2.0.15 → 2.0.17

package/src/dlob/dlobIdl.json

@@ -0,0 +1,245 @@
+{
+  "version": "2.0.0",
+  "name": "dlob",
+  "instructions": [],
+  "accounts": [],
+  "types": [
+    {
+      "name": "DLOBOrders",
+      "type": {
+        "vec": {
+          "defined": "DLOBOrder"
+        }
+      }
+    },
+    {
+      "name": "DLOBOrder",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "user",
+            "type": "publicKey"
+          },
+          {
+            "name": "order",
+            "type": {
+              "defined": "Order"
+            }
+          }
+        ]
+      }
+    },
+    {
+      "name": "Order",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "slot",
+            "type": "u64"
+          },
+          {
+            "name": "price",
+            "type": "u64"
+          },
+          {
+            "name": "baseAssetAmount",
+            "type": "u64"
+          },
+          {
+            "name": "baseAssetAmountFilled",
+            "type": "u64"
+          },
+          {
+            "name": "quoteAssetAmountFilled",
+            "type": "u64"
+          },
+          {
+            "name": "triggerPrice",
+            "type": "u64"
+          },
+          {
+            "name": "auctionStartPrice",
+            "type": "u64"
+          },
+          {
+            "name": "auctionEndPrice",
+            "type": "u64"
+          },
+          {
+            "name": "maxTs",
+            "type": "i64"
+          },
+          {
+            "name": "oraclePriceOffset",
+            "type": "i32"
+          },
+          {
+            "name": "orderId",
+            "type": "u32"
+          },
+          {
+            "name": "marketIndex",
+            "type": "u16"
+          },
+          {
+            "name": "status",
+            "type": {
+              "defined": "OrderStatus"
+            }
+          },
+          {
+            "name": "orderType",
+            "type": {
+              "defined": "OrderType"
+            }
+          },
+          {
+            "name": "marketType",
+            "type": {
+              "defined": "MarketType"
+            }
+          },
+          {
+            "name": "userOrderId",
+            "type": "u8"
+          },
+          {
+            "name": "existingPositionDirection",
+            "type": {
+              "defined": "PositionDirection"
+            }
+          },
+          {
+            "name": "direction",
+            "type": {
+              "defined": "PositionDirection"
+            }
+          },
+          {
+            "name": "reduceOnly",
+            "type": "bool"
+          },
+          {
+            "name": "postOnly",
+            "type": "bool"
+          },
+          {
+            "name": "immediateOrCancel",
+            "type": "bool"
+          },
+          {
+            "name": "triggerCondition",
+            "type": {
+              "defined": "OrderTriggerCondition"
+            }
+          },
+          {
+            "name": "auctionDuration",
+            "type": "u8"
+          },
+          {
+            "name": "padding",
+            "type": {
+              "array": [
+                "u8",
+                3
+              ]
+            }
+          }
+        ]
+      }
+    },
+    {
+      "name": "OrderStatus",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Init"
+          },
+          {
+            "name": "Open"
+          },
+          {
+            "name": "Filled"
+          },
+          {
+            "name": "Canceled"
+          }
+        ]
+      }
+    },
+    {
+      "name": "OrderType",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Market"
+          },
+          {
+            "name": "Limit"
+          },
+          {
+            "name": "TriggerMarket"
+          },
+          {
+            "name": "TriggerLimit"
+          }
+        ]
+      }
+    },
+    {
+      "name": "OrderTriggerCondition",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Above"
+          },
+          {
+            "name": "Below"
+          },
+          {
+            "name": "TriggeredAbove"
+          },
+          {
+            "name": "TriggeredBelow"
+          }
+        ]
+      }
+    },
+    {
+      "name": "MarketType",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Spot"
+          },
+          {
+            "name": "Perp"
+          }
+        ]
+      }
+    },
+    {
+      "name": "PositionDirection",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Long"
+          },
+          {
+            "name": "Short"
+          }
+        ]
+      }
+    }
+  ],
+  "events": [],
+  "errors": []
+}

package/src/idl/drift.json

@@ -8519,6 +8519,11 @@
       "code": 6221,
       "name": "SpotFulfillmentConfigDisabled",
       "msg": "Spot Fulfullment Config Disabled"
+    },
+    {
+      "code": 6222,
+      "name": "InvalidMaker",
+      "msg": "Invalid Maker"
     }
   ]
 }

package/src/math/amm.ts

@@ -12,6 +12,7 @@ import {
 	PRICE_DIV_PEG,
 	PERCENTAGE_PRECISION,
 	BASE_PRECISION,
+	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
 } from '../constants/numericConstants';
 import {
 	AMM,
@@ -190,11 +191,15 @@ export function calculateUpdatedAMMSpreadReserves(
 	oraclePriceData: OraclePriceData
 ): { baseAssetReserve: BN; quoteAssetReserve: BN; sqrtK: BN; newPeg: BN } {
 	const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
-	const dirReserves = calculateSpreadReserves(
+	const [shortReserves, longReserves] = calculateSpreadReserves(
 		newAmm,
-		direction,
 		oraclePriceData
 	);
+
+	const dirReserves = isVariant(direction, 'long')
+		? longReserves
+		: shortReserves;
+
 	const result = {
 		baseAssetReserve: dirReserves.baseAssetReserve,
 		quoteAssetReserve: dirReserves.quoteAssetReserve,
@@ -217,14 +222,8 @@ export function calculateBidAskPrice(
 		newAmm = amm;
 	}
 
-	const askReserves = calculateSpreadReserves(
+	const [bidReserves, askReserves] = calculateSpreadReserves(
 		newAmm,
-		PositionDirection.LONG,
-		oraclePriceData
-	);
-	const bidReserves = calculateSpreadReserves(
-		newAmm,
-		PositionDirection.SHORT,
 		oraclePriceData
 	);
 
@@ -431,11 +430,12 @@ export function calculateVolSpreadBN(
 	const marketAvgStdPct = markStd
 		.add(oracleStd)
 		.mul(PERCENTAGE_PRECISION)
-		.div(reservePrice.mul(new BN(2)));
+		.div(reservePrice)
+		.div(new BN(2));
 	const volSpread = BN.max(lastOracleConfPct, marketAvgStdPct.div(new BN(2)));
 
+	const clampMin = PERCENTAGE_PRECISION.div(new BN(100));
 	const clampMax = PERCENTAGE_PRECISION.mul(new BN(16)).div(new BN(10));
-	const clampMin = PERCENTAGE_PRECISION.div(new BN(10));
 
 	const longVolSpreadFactor = clampBN(
 		longIntensity.mul(PERCENTAGE_PRECISION).div(BN.max(ONE, volume24H)),
@@ -471,6 +471,7 @@ export function calculateSpreadBN(
 	baseAssetAmountWithAmm: BN,
 	reservePrice: BN,
 	totalFeeMinusDistributions: BN,
+	netRevenueSinceLastFunding: BN,
 	baseAssetReserve: BN,
 	minBaseAssetReserve: BN,
 	maxBaseAssetReserve: BN,
@@ -527,18 +528,17 @@ export function calculateSpreadBN(
 		shortSpread *= inventorySpreadScale;
 	}
 
-	const effectiveLeverage = calculateEffectiveLeverage(
-		baseSpread,
-		quoteAssetReserve,
-		terminalQuoteAssetReserve,
-		pegMultiplier,
-		baseAssetAmountWithAmm,
-		reservePrice,
-		totalFeeMinusDistributions
-	);
-
 	const MAX_SPREAD_SCALE = 10;
 	if (totalFeeMinusDistributions.gt(ZERO)) {
+		const effectiveLeverage = calculateEffectiveLeverage(
+			baseSpread,
+			quoteAssetReserve,
+			terminalQuoteAssetReserve,
+			pegMultiplier,
+			baseAssetAmountWithAmm,
+			reservePrice,
+			totalFeeMinusDistributions
+		);
 		const spreadScale = Math.min(MAX_SPREAD_SCALE, 1 + effectiveLeverage);
 		if (baseAssetAmountWithAmm.gt(ZERO)) {
 			longSpread *= spreadScale;
@@ -550,13 +550,38 @@ export function calculateSpreadBN(
 		shortSpread *= MAX_SPREAD_SCALE;
 	}
 
+	if (
+		netRevenueSinceLastFunding.lt(
+			DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT
+		)
+	) {
+		const retreatAmount = Math.min(
+			maxTargetSpread / 10,
+			Math.floor(
+				(baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
+					DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.toNumber()
+			)
+		);
+		const halfRetreatAmount = Math.floor(retreatAmount / 2);
+		if (baseAssetAmountWithAmm.gt(ZERO)) {
+			longSpread += retreatAmount;
+			shortSpread += halfRetreatAmount;
+		} else if (baseAssetAmountWithAmm.lt(ZERO)) {
+			longSpread += halfRetreatAmount;
+			shortSpread += retreatAmount;
+		} else {
+			longSpread += halfRetreatAmount;
+			shortSpread += halfRetreatAmount;
+		}
+	}
+
 	const totalSpread = longSpread + shortSpread;
 	if (totalSpread > maxTargetSpread) {
 		if (longSpread > shortSpread) {
-			longSpread = Math.min(longSpread, maxTargetSpread);
+			longSpread = Math.ceil((longSpread * maxTargetSpread) / totalSpread);
 			shortSpread = maxTargetSpread - longSpread;
 		} else {
-			shortSpread = Math.min(shortSpread, maxTargetSpread);
+			shortSpread = Math.ceil((shortSpread * maxTargetSpread) / totalSpread);
 			longSpread = maxTargetSpread - shortSpread;
 		}
 	}
@@ -566,11 +591,10 @@ export function calculateSpreadBN(
 
 export function calculateSpread(
 	amm: AMM,
-	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
-): number {
+): [number, number] {
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-		return amm.baseSpread / 2;
+		return [amm.baseSpread / 2, amm.baseSpread / 2];
 	}
 
 	const reservePrice = calculatePrice(
@@ -604,6 +628,7 @@ export function calculateSpread(
 		amm.baseAssetAmountWithAmm,
 		reservePrice,
 		amm.totalFeeMinusDistributions,
+		amm.netRevenueSinceLastFunding,
 		amm.baseAssetReserve,
 		amm.minBaseAssetReserve,
 		amm.maxBaseAssetReserve,
@@ -614,50 +639,59 @@ export function calculateSpread(
 		amm.volume24H
 	);
 
-	let spread: number;
-
-	if (isVariant(direction, 'long')) {
-		spread = longSpread;
-	} else {
-		spread = shortSpread;
-	}
-
-	return spread;
+	return [longSpread, shortSpread];
 }
 
 export function calculateSpreadReserves(
 	amm: AMM,
-	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
-): {
-	baseAssetReserve: BN;
-	quoteAssetReserve: BN;
-} {
-	const spread = calculateSpread(amm, direction, oraclePriceData);
+) {
+	function calculateSpreadReserve(
+		spread: number,
+		direction: PositionDirection,
+		amm: AMM
+	): {
+		baseAssetReserve;
+		quoteAssetReserve;
+	} {
+		if (spread === 0) {
+			return {
+				baseAssetReserve: amm.baseAssetReserve,
+				quoteAssetReserve: amm.quoteAssetReserve,
+			};
+		}
+
+		const quoteAssetReserveDelta = amm.quoteAssetReserve.div(
+			BID_ASK_SPREAD_PRECISION.div(new BN(spread / 2))
+		);
+
+		let quoteAssetReserve;
+		if (isVariant(direction, 'long')) {
+			quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
+		} else {
+			quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta);
+		}
 
-	if (spread === 0) {
+		const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
 		return {
-			baseAssetReserve: amm.baseAssetReserve,
-			quoteAssetReserve: amm.quoteAssetReserve,
+			baseAssetReserve,
+			quoteAssetReserve,
 		};
 	}
 
-	const quoteAsserReserveDelta = amm.quoteAssetReserve.div(
-		BID_ASK_SPREAD_PRECISION.div(new BN(spread / 2))
+	const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData);
+	const askReserves = calculateSpreadReserve(
+		longSpread,
+		PositionDirection.LONG,
+		amm
+	);
+	const bidReserves = calculateSpreadReserve(
+		shortSpread,
+		PositionDirection.SHORT,
+		amm
 	);
 
-	let quoteAssetReserve;
-	if (isVariant(direction, 'long')) {
-		quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
-	} else {
-		quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
-	}
-
-	const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
-	return {
-		baseAssetReserve,
-		quoteAssetReserve,
-	};
+	return [bidReserves, askReserves];
 }
 
 /**
@@ -749,12 +783,14 @@ export function calculateMaxBaseAssetAmountToTrade(
 		.div(PEG_PRECISION);
 
 	const newBaseAssetReserve = squareRootBN(newBaseAssetReserveSquared);
-
-	const baseAssetReserveBefore = calculateSpreadReserves(
+	const [shortSpreadReserves, longSpreadReserves] = calculateSpreadReserves(
 		amm,
-		direction,
 		oraclePriceData
-	).baseAssetReserve;
+	);
+
+	const baseAssetReserveBefore: BN = isVariant(direction, 'long')
+		? longSpreadReserves.baseAssetReserve
+		: shortSpreadReserves.baseAssetReserve;
 
 	if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
 		return [

package/src/math/utils.ts

@@ -4,7 +4,7 @@ export function clampBN(x: BN, min: BN, max: BN): BN {
 	return BN.max(min, BN.min(x, max));
 }
 
-export const squareRootBN = (n, closeness = new BN(1)) => {
+export const squareRootBN = (n, closeness = new BN(1)): BN => {
 	// Assuming the sqrt of n as n only
 	let x = n;