@drift-labs/sdk 2.0.16 → 2.0.18

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/index.ts

@@ -63,6 +63,7 @@ export * from './constants/spotMarkets';
 export * from './driftClientConfig';
 export * from './dlob/DLOB';
 export * from './dlob/DLOBNode';
+export * from './dlob/DLOBOrders';
 export * from './dlob/NodeList';
 export * from './userMap/userMap';
 export * from './userMap/userStatsMap';

package/src/math/amm.ts

@@ -479,8 +479,34 @@ export function calculateSpreadBN(
 	oracleStd: BN,
 	longIntensity: BN,
 	shortIntensity: BN,
-	volume24H: BN
-): [number, number] {
+	volume24H: BN,
+	returnTerms = false
+) {
+	assert(Number.isInteger(baseSpread));
+	assert(Number.isInteger(maxSpread));
+
+	const spreadTerms = {
+		longVolSpread: 0,
+		shortVolSpread: 0,
+		longSpreadwPS: 0,
+		shortSpreadwPS: 0,
+		maxTargetSpread: 0,
+		inventorySpreadScale: 0,
+		longSpreadwInvScale: 0,
+		shortSpreadwInvScale: 0,
+		effectiveLeverage: 0,
+		effectiveLeverageCapped: 0,
+		longSpreadwEL: 0,
+		shortSpreadwEL: 0,
+		revenueRetreatAmount: 0,
+		halfRevenueRetreatAmount: 0,
+		longSpreadwRevRetreat: 0,
+		shortSpreadwRevRetreat: 0,
+		totalSpread: 0,
+		longSpread: 0,
+		shortSpread: 0,
+	};
+
 	const [longVolSpread, shortVolSpread] = calculateVolSpreadBN(
 		lastOracleConfPct,
 		reservePrice,
@@ -491,6 +517,9 @@ export function calculateSpreadBN(
 		volume24H
 	);
 
+	spreadTerms.longVolSpread = longVolSpread.toNumber();
+	spreadTerms.shortVolSpread = shortVolSpread.toNumber();
+
 	let longSpread = Math.max(baseSpread / 2, longVolSpread.toNumber());
 	let shortSpread = Math.max(baseSpread / 2, shortVolSpread.toNumber());
 
@@ -507,10 +536,11 @@ export function calculateSpreadBN(
 				longVolSpread.toNumber()
 		);
 	}
+	spreadTerms.longSpreadwPS = longSpread;
+	spreadTerms.shortSpreadwPS = shortSpread;
 
-	const maxTargetSpread: number = Math.max(
-		maxSpread,
-		lastOracleReservePriceSpreadPct.abs().toNumber()
+	const maxTargetSpread: number = Math.floor(
+		Math.max(maxSpread, lastOracleReservePriceSpreadPct.abs().toNumber())
 	);
 
 	const inventorySpreadScale = calculateInventoryScale(
@@ -527,6 +557,10 @@ export function calculateSpreadBN(
 	} else if (baseAssetAmountWithAmm.lt(ZERO)) {
 		shortSpread *= inventorySpreadScale;
 	}
+	spreadTerms.maxTargetSpread = maxTargetSpread;
+	spreadTerms.inventorySpreadScale = inventorySpreadScale;
+	spreadTerms.longSpreadwInvScale = longSpread;
+	spreadTerms.shortSpreadwInvScale = shortSpread;
 
 	const MAX_SPREAD_SCALE = 10;
 	if (totalFeeMinusDistributions.gt(ZERO)) {
@@ -539,53 +573,76 @@ export function calculateSpreadBN(
 			reservePrice,
 			totalFeeMinusDistributions
 		);
+		spreadTerms.effectiveLeverage = effectiveLeverage;
+
 		const spreadScale = Math.min(MAX_SPREAD_SCALE, 1 + effectiveLeverage);
+		spreadTerms.effectiveLeverageCapped = spreadScale;
+
 		if (baseAssetAmountWithAmm.gt(ZERO)) {
 			longSpread *= spreadScale;
+			shortSpread = Math.floor(longSpread);
 		} else {
 			shortSpread *= spreadScale;
+			shortSpread = Math.floor(shortSpread);
 		}
 	} else {
 		longSpread *= MAX_SPREAD_SCALE;
 		shortSpread *= MAX_SPREAD_SCALE;
 	}
 
+	spreadTerms.longSpreadwEL = longSpread;
+	spreadTerms.shortSpreadwEL = shortSpread;
+
 	if (
 		netRevenueSinceLastFunding.lt(
 			DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT
 		)
 	) {
-		const retreatAmount = Math.min(
+		const revenueRetreatAmount = Math.min(
 			maxTargetSpread / 10,
 			Math.floor(
 				(baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
 					DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.toNumber()
 			)
 		);
-		const halfRetreatAmount = Math.floor(retreatAmount / 2);
+		const halfRevenueRetreatAmount = Math.floor(revenueRetreatAmount / 2);
+
+		spreadTerms.revenueRetreatAmount = revenueRetreatAmount;
+		spreadTerms.halfRevenueRetreatAmount = halfRevenueRetreatAmount;
+
 		if (baseAssetAmountWithAmm.gt(ZERO)) {
-			longSpread += retreatAmount;
-			shortSpread += halfRetreatAmount;
+			longSpread += revenueRetreatAmount;
+			shortSpread += halfRevenueRetreatAmount;
 		} else if (baseAssetAmountWithAmm.lt(ZERO)) {
-			longSpread += halfRetreatAmount;
-			shortSpread += retreatAmount;
+			longSpread += halfRevenueRetreatAmount;
+			shortSpread += revenueRetreatAmount;
 		} else {
-			longSpread += halfRetreatAmount;
-			shortSpread += halfRetreatAmount;
+			longSpread += halfRevenueRetreatAmount;
+			shortSpread += halfRevenueRetreatAmount;
 		}
 	}
 
+	spreadTerms.longSpreadwRevRetreat = longSpread;
+	spreadTerms.shortSpreadwRevRetreat = shortSpread;
+
 	const totalSpread = longSpread + shortSpread;
 	if (totalSpread > maxTargetSpread) {
 		if (longSpread > shortSpread) {
 			longSpread = Math.ceil((longSpread * maxTargetSpread) / totalSpread);
-			shortSpread = maxTargetSpread - longSpread;
+			shortSpread = Math.floor(maxTargetSpread - longSpread);
 		} else {
 			shortSpread = Math.ceil((shortSpread * maxTargetSpread) / totalSpread);
-			longSpread = maxTargetSpread - shortSpread;
+			longSpread = Math.floor(maxTargetSpread - shortSpread);
 		}
 	}
 
+	spreadTerms.totalSpread = totalSpread;
+	spreadTerms.longSpread = longSpread;
+	spreadTerms.shortSpread = shortSpread;
+
+	if (returnTerms) {
+		return spreadTerms;
+	}
 	return [longSpread, shortSpread];
 }
 
@@ -617,7 +674,7 @@ export function calculateSpread(
 	const now = new BN(new Date().getTime() / 1000); //todo
 	const liveOracleStd = calculateLiveOracleStd(amm, oraclePriceData, now);
 
-	const [longSpread, shortSpread] = calculateSpreadBN(
+	const spreads = calculateSpreadBN(
 		amm.baseSpread,
 		targetMarkSpreadPct,
 		confIntervalPct,
@@ -638,6 +695,8 @@ export function calculateSpread(
 		amm.shortIntensityVolume,
 		amm.volume24H
 	);
+	const longSpread = spreads[0];
+	const shortSpread = spreads[1];
 
 	return [longSpread, shortSpread];
 }

package/src/math/oracles.ts

@@ -113,8 +113,7 @@ export function calculateLiveOracleTwap(
 
 	const newOracleTwap = amm.historicalOracleData.lastOraclePriceTwap
 		.mul(sinceStart)
-		.add(clampedOraclePrice)
-		.mul(sinceLastUpdate)
+		.add(clampedOraclePrice.mul(sinceLastUpdate))
 		.div(sinceStart.add(sinceLastUpdate));
 
 	return newOracleTwap;

package/tests/amm/test.ts

@@ -0,0 +1,178 @@
+import {
+    BN,
+    PEG_PRECISION, PRICE_PRECISION,
+	AMM_RESERVE_PRECISION,
+	QUOTE_PRECISION,
+	calculateSpreadBN,
+    ZERO,
+    calculateLiveOracleStd,
+    calculateLiveOracleTwap
+} from '../../src';
+import {
+	mockPerpMarkets,
+} from '../dlob/helpers';
+
+import { assert } from '../../src/assert/assert';
+
+class AMMSpreadTerms {
+    longVolSpread: number;
+    shortVolSpread: number;
+    longSpreadwPS: number;
+    shortSpreadwPS: number;
+    maxTargetSpread: number;
+    inventorySpreadScale: number;
+    longSpreadwInvScale: number;
+    shortSpreadwInvScale: number;
+    effectiveLeverage: number;
+    effectiveLeverageCapped: number;
+    longSpreadwEL: number;
+    shortSpreadwEL: number;
+    revenueRetreatAmount: number;
+    halfRevenueRetreatAmount: number;
+    longSpreadwRevRetreat: number;
+    shortSpreadwRevRetreat: number;
+    totalSpread: number;
+    longSpread: number;
+    shortSpread: number;
+}
+
+describe('AMM Tests', () => {
+	it('Various Spreads', () => {
+
+        const baseSpread: number = .025 * 1e6;
+        const lastOracleReservePriceSpreadPct: BN = ZERO;
+        const lastOracleConfPct: BN = ZERO;
+        const maxSpread: number = .03 * 1e6;
+        const quoteAssetReserve: BN = new BN(AMM_RESERVE_PRECISION.toNumber() * 100);
+        const terminalQuoteAssetReserve: BN = new BN(AMM_RESERVE_PRECISION.toNumber() * 100);
+        const pegMultiplier: BN = new BN(13.455 * PEG_PRECISION.toNumber());
+        const baseAssetAmountWithAmm: BN = ZERO;
+        const reservePrice: BN = new BN(13.455 * PRICE_PRECISION.toNumber());
+        const totalFeeMinusDistributions: BN = new BN(1);
+        const netRevenueSinceLastFunding: BN = new BN(QUOTE_PRECISION.toNumber() * 2);
+        const baseAssetReserve: BN = new BN(AMM_RESERVE_PRECISION.toNumber() * 100);
+        const minBaseAssetReserve: BN = new BN(AMM_RESERVE_PRECISION.toNumber() * 90);
+        const maxBaseAssetReserve: BN = new BN(AMM_RESERVE_PRECISION.toNumber() * 110);
+        const markStd: BN = new BN(.45 * PRICE_PRECISION.toNumber());
+        const oracleStd: BN = new BN(.55 * PRICE_PRECISION.toNumber());
+        const longIntensity: BN = new BN(QUOTE_PRECISION.toNumber() * 20);
+        const shortIntensity: BN =new BN(QUOTE_PRECISION.toNumber() * 2);
+        const volume24H: BN = new BN(QUOTE_PRECISION.toNumber() * 25);
+
+        const spreads = calculateSpreadBN(
+            baseSpread,
+            lastOracleReservePriceSpreadPct,
+            lastOracleConfPct,
+            maxSpread,
+            quoteAssetReserve,
+            terminalQuoteAssetReserve,
+            pegMultiplier,
+            baseAssetAmountWithAmm,
+            reservePrice,
+            totalFeeMinusDistributions,
+            netRevenueSinceLastFunding,
+            baseAssetReserve,
+            minBaseAssetReserve,
+            maxBaseAssetReserve,
+            markStd,
+            oracleStd,
+            longIntensity,
+            shortIntensity,
+            volume24H, 
+        );
+        const l1 = spreads[0];
+        const s1 = spreads[1];
+
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+        const terms1: AMMSpreadTerms = calculateSpreadBN(
+            baseSpread,
+            lastOracleReservePriceSpreadPct,
+            lastOracleConfPct,
+            maxSpread,
+            quoteAssetReserve,
+            terminalQuoteAssetReserve,
+            pegMultiplier,
+            baseAssetAmountWithAmm,
+            reservePrice,
+            totalFeeMinusDistributions,
+            netRevenueSinceLastFunding,
+            baseAssetReserve,
+            minBaseAssetReserve,
+            maxBaseAssetReserve,
+            markStd,
+            oracleStd,
+            longIntensity,
+            shortIntensity,
+            volume24H, 
+            true
+        );
+        console.log(terms1);
+
+        console.log('long/short spread:', l1, s1);
+        assert(l1==14864);
+        assert(s1==12500);
+        assert(l1==terms1.longSpread);
+        assert(s1==terms1.shortSpread);
+
+
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+        const terms2: AMMSpreadTerms = calculateSpreadBN(
+            300,
+            new BN(0),
+            new BN(484),
+            47500,
+            new BN(923807816209694),
+            new BN(925117623772584),
+            new BN(13731157),
+            new BN(-1314027016625),
+            new BN(13667686),
+            new BN(115876379475),
+            new BN(91316628),
+            new BN(928097825691666),
+            new BN(907979542352912),
+            new BN(945977491145601),
+            new BN(161188),
+            new BN(1459632439),
+            new BN(12358265776),
+            new BN(72230366233),
+            new BN(432067603632),
+            true
+        );
+
+        console.log(terms2);
+        assert(terms2.effectiveLeverageCapped>=1.0002);
+        assert(terms2.inventorySpreadScale==10);
+        assert(terms2.longSpread==798);
+        assert(terms2.shortSpread==46702);
+
+    });
+
+    it('live update functions', () => {
+
+        const mockAmm = mockPerpMarkets[0].amm;
+        const now = new BN(new Date().getTime() / 1000); //todo
+
+		const oraclePriceData = {
+			price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+			slot: new BN(68 + 1),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+        mockAmm.oracleStd = new BN(.18 * PRICE_PRECISION.toNumber());
+        mockAmm.fundingPeriod = new BN(3600);
+        mockAmm.historicalOracleData.lastOraclePriceTwap = oraclePriceData.price.mul(new BN(999)).div(new BN(1000));
+        mockAmm.historicalOracleData.lastOraclePriceTwapTs = now.sub(new BN(11));
+
+
+        const liveOracleTwap = calculateLiveOracleTwap(mockAmm, oraclePriceData, now);
+        console.log('liveOracleTwap:', liveOracleTwap.toNumber());
+        assert(liveOracleTwap.eq(new BN(13539488)));
+
+
+        const liveOracleStd = calculateLiveOracleStd(mockAmm, oraclePriceData, now);
+        console.log('liveOracleStd:', liveOracleStd.toNumber());
+        assert(liveOracleStd.eq(new BN(192962)));
+    });
+});