@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/src/idl/pyth.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0",
+  "version": "0.1.0",
   "name": "pyth",
   "instructions": [
     {
@@ -41,6 +41,102 @@
           "type": "i64"
         }
       ]
+    },
+    {
+      "name": "setPriceInfo",
+      "accounts": [
+        {
+          "name": "price",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "price",
+          "type": "i64"
+        },
+        {
+          "name": "conf",
+          "type": "u64"
+        },
+        {
+          "name": "slot",
+          "type": "u64"
+        }
+      ]
+    },
+    {
+      "name": "setTwap",
+      "accounts": [
+        {
+          "name": "price",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "twap",
+          "type": "i64"
+        }
+      ]
+    }
+  ],
+  "types": [
+    {
+      "name": "PriceStatus",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Unknown"
+          },
+          {
+            "name": "Trading"
+          },
+          {
+            "name": "Halted"
+          },
+          {
+            "name": "Auction"
+          }
+        ]
+      }
+    },
+    {
+      "name": "CorpAction",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "NoCorpAct"
+          }
+        ]
+      }
+    },
+    {
+      "name": "PriceType",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Unknown"
+          },
+          {
+            "name": "Price"
+          },
+          {
+            "name": "TWAP"
+          },
+          {
+            "name": "Volatility"
+          }
+        ]
+      }
     }
-  ]
+  ],
+  "metadata": {
+    "address": "gSbePebfvPy7tRqimPoVecS2UsBvYv46ynrzWocc92s"
+  }
 }

package/src/index.ts

@@ -7,26 +7,34 @@ export * from './oracles/types';
 export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
 export * from './types';
-export * from './constants/markets';
+export * from './constants/perpMarkets';
 export * from './accounts/fetch';
-export * from './accounts/webSocketClearingHouseAccountSubscriber';
+export * from './accounts/webSocketDriftClientAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
-export * from './accounts/pollingClearingHouseAccountSubscriber';
-export * from './accounts/pollingOracleSubscriber';
+export * from './accounts/bulkUserStatsSubscription';
+export * from './accounts/pollingDriftClientAccountSubscriber';
+export * from './accounts/pollingOracleAccountSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
+export * from './accounts/pollingUserAccountSubscriber';
+export * from './accounts/pollingUserStatsAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
-export * from './admin';
-export * from './clearingHouseUser';
-export * from './clearingHouseUserConfig';
-export * from './clearingHouse';
+export * from './adminClient';
+export * from './user';
+export * from './userConfig';
+export * from './userStats';
+export * from './userStatsConfig';
+export * from './driftClient';
 export * from './factory/oracleClient';
 export * from './factory/bigNum';
 export * from './events/types';
 export * from './events/eventSubscriber';
+export * from './events/fetchLogs';
 export * from './math/auction';
+export * from './math/spotMarket';
 export * from './math/conversion';
+export * from './math/exchangeStatus';
 export * from './math/funding';
 export * from './math/market';
 export * from './math/position';
@@ -35,7 +43,8 @@ export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
-export * from './orders';
+export * from './math/margin';
+export * from './math/insurance';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';
@@ -43,11 +52,19 @@ export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './serum/serumSubscriber';
+export * from './serum/serumFulfillmentConfigMap';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
-export * from './math/bankBalance';
-export * from './constants/banks';
-export * from './clearingHouseConfig';
+export * from './util/promiseTimeout';
+export * from './math/spotBalance';
+export * from './constants/spotMarkets';
+export * from './driftClientConfig';
+export * from './dlob/DLOB';
+export * from './dlob/DLOBNode';
+export * from './dlob/NodeList';
+export * from './userMap/userMap';
+export * from './userMap/userStatsMap';
 
 export { BN, PublicKey, pyth };

package/src/math/amm.ts

@@ -1,7 +1,7 @@
 import { BN } from '@project-serum/anchor';
 import {
 	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
@@ -15,11 +15,11 @@ import {
 	AMM,
 	PositionDirection,
 	SwapDirection,
-	MarketAccount,
+	PerpMarketAccount,
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN } from '..';
+import { squareRootBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -33,18 +33,21 @@ export function calculatePegFromTargetPrice(
 	baseAssetReserve: BN,
 	quoteAssetReserve: BN
 ): BN {
-	return targetPrice
-		.mul(baseAssetReserve)
-		.div(quoteAssetReserve)
-		.add(PRICE_DIV_PEG.div(new BN(2)))
-		.div(PRICE_DIV_PEG);
+	return BN.max(
+		targetPrice
+			.mul(baseAssetReserve)
+			.div(quoteAssetReserve)
+			.add(PRICE_DIV_PEG.div(new BN(2)))
+			.div(PRICE_DIV_PEG),
+		ONE
+	);
 }
 
 export function calculateOptimalPegAndBudget(
 	amm: AMM,
 	oraclePriceData: OraclePriceData
 ): [BN, BN, BN, boolean] {
-	const markPriceBefore = calculatePrice(
+	const reservePriceBefore = calculatePrice(
 		amm.baseAssetReserve,
 		amm.quoteAssetReserve,
 		amm.pegMultiplier
@@ -67,15 +70,15 @@ export function calculateOptimalPegAndBudget(
 		let newTargetPrice: BN;
 		let newOptimalPeg: BN;
 		let newBudget: BN;
-		const targetPriceGap = markPriceBefore.sub(targetPrice);
+		const targetPriceGap = reservePriceBefore.sub(targetPrice);
 
 		if (targetPriceGap.abs().gt(maxPriceSpread)) {
 			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
 
 			if (targetPriceGap.lt(new BN(0))) {
-				newTargetPrice = markPriceBefore.add(markAdj);
+				newTargetPrice = reservePriceBefore.add(markAdj);
 			} else {
-				newTargetPrice = markPriceBefore.sub(markAdj);
+				newTargetPrice = reservePriceBefore.sub(markAdj);
 			}
 
 			newOptimalPeg = calculatePegFromTargetPrice(
@@ -114,7 +117,7 @@ export function calculateNewAmm(
 		newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
 		const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
 		newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-		const directionToClose = amm.netBaseAssetAmount.gt(ZERO)
+		const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
 			? PositionDirection.SHORT
 			: PositionDirection.LONG;
 
@@ -122,7 +125,7 @@ export function calculateNewAmm(
 			calculateAmmReservesAfterSwap(
 				newAmm,
 				'base',
-				amm.netBaseAssetAmount.abs(),
+				amm.baseAssetAmountWithAmm.abs(),
 				getSwapDirection('base', directionToClose)
 			);
 
@@ -154,7 +157,7 @@ export function calculateUpdatedAMM(
 	newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
 	newAmm.pegMultiplier = newPeg;
 
-	const directionToClose = amm.netBaseAssetAmount.gt(ZERO)
+	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
 
@@ -162,7 +165,7 @@ export function calculateUpdatedAMM(
 		calculateAmmReservesAfterSwap(
 			newAmm,
 			'base',
-			amm.netBaseAssetAmount.abs(),
+			amm.baseAssetAmountWithAmm.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
@@ -239,7 +242,7 @@ export function calculateBidAskPrice(
  * @param baseAssetReserves
  * @param quoteAssetReserves
  * @param pegMultiplier
- * @returns price : Precision MARK_PRICE_PRECISION
+ * @returns price : Precision PRICE_PRECISION
  */
 export function calculatePrice(
 	baseAssetReserves: BN,
@@ -251,7 +254,7 @@ export function calculatePrice(
 	}
 
 	return quoteAssetReserves
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(baseAssetReserves);
@@ -305,13 +308,62 @@ export function calculateAmmReservesAfterSwap(
 	return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 
+export function calculateMarketOpenBidAsk(
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): [BN, BN] {
+	// open orders
+	let openAsks;
+	if (maxBaseAssetReserve > baseAssetReserve) {
+		openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new BN(-1));
+	} else {
+		openAsks = ZERO;
+	}
+
+	let openBids;
+	if (minBaseAssetReserve < baseAssetReserve) {
+		openBids = baseAssetReserve.sub(minBaseAssetReserve);
+	} else {
+		openBids = ZERO;
+	}
+	return [openBids, openAsks];
+}
+
+export function calculateInventoryScale(
+	netBaseAssetAmount: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): number {
+	const maxScale = BID_ASK_SPREAD_PRECISION.mul(new BN(10));
+	// inventory skew
+	const [openBids, openAsks] = calculateMarketOpenBidAsk(
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+
+	const minSideLiquidity = BN.max(
+		new BN(1),
+		BN.min(openBids.abs(), openAsks.abs())
+	);
+	const inventoryScale =
+		BN.min(
+			maxScale,
+			netBaseAssetAmount.mul(maxScale).div(minSideLiquidity).abs()
+		).toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
+
+	return inventoryScale;
+}
+
 export function calculateEffectiveLeverage(
 	baseSpread: number,
 	quoteAssetReserve: BN,
 	terminalQuoteAssetReserve: BN,
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
-	markPrice: BN,
+	reservePrice: BN,
 	totalFeeMinusDistributions: BN
 ): number {
 	// inventory skew
@@ -321,8 +373,8 @@ export function calculateEffectiveLeverage(
 		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
 
 	const localBaseAssetValue = netBaseAssetAmount
-		.mul(markPrice)
-		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+		.mul(reservePrice)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
 
 	const effectiveLeverage =
 		localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
@@ -342,34 +394,59 @@ export function calculateMaxSpread(marginRatioInitial: number): number {
 
 export function calculateSpreadBN(
 	baseSpread: number,
-	lastOracleMarkSpreadPct: BN,
+	lastOracleReservePriceSpreadPct: BN,
 	lastOracleConfPct: BN,
 	maxSpread: number,
 	quoteAssetReserve: BN,
 	terminalQuoteAssetReserve: BN,
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
-	markPrice: BN,
-	totalFeeMinusDistributions: BN
+	reservePrice: BN,
+	totalFeeMinusDistributions: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
 ): [number, number] {
 	let longSpread = baseSpread / 2;
 	let shortSpread = baseSpread / 2;
 
-	if (lastOracleMarkSpreadPct.gt(ZERO)) {
+	if (lastOracleReservePriceSpreadPct.gt(ZERO)) {
 		shortSpread = Math.max(
 			shortSpread,
-			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+			lastOracleReservePriceSpreadPct.abs().toNumber() +
+				lastOracleConfPct.toNumber()
 		);
-	} else if (lastOracleMarkSpreadPct.lt(ZERO)) {
+	} else if (lastOracleReservePriceSpreadPct.lt(ZERO)) {
 		longSpread = Math.max(
 			longSpread,
-			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+			lastOracleReservePriceSpreadPct.abs().toNumber() +
+				lastOracleConfPct.toNumber()
 		);
 	}
 
-	const maxTargetSpread: number = maxSpread;
+	const maxTargetSpread: number = Math.max(
+		maxSpread,
+		lastOracleReservePriceSpreadPct.abs().toNumber()
+	);
 
-	const MAX_INVENTORY_SKEW = 5;
+	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = 10;
+
+	const inventoryScale = calculateInventoryScale(
+		netBaseAssetAmount,
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+	const inventorySpreadScale = Math.min(
+		MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
+		1 + inventoryScale
+	);
+
+	if (netBaseAssetAmount.gt(ZERO)) {
+		longSpread *= inventorySpreadScale;
+	} else if (netBaseAssetAmount.lt(ZERO)) {
+		shortSpread *= inventorySpreadScale;
+	}
 
 	const effectiveLeverage = calculateEffectiveLeverage(
 		baseSpread,
@@ -377,20 +454,23 @@ export function calculateSpreadBN(
 		terminalQuoteAssetReserve,
 		pegMultiplier,
 		netBaseAssetAmount,
-		markPrice,
+		reservePrice,
 		totalFeeMinusDistributions
 	);
 
 	if (totalFeeMinusDistributions.gt(ZERO)) {
-		const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+		const spreadScale = Math.min(
+			MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
+			1 + effectiveLeverage
+		);
 		if (netBaseAssetAmount.gt(ZERO)) {
 			longSpread *= spreadScale;
 		} else {
 			shortSpread *= spreadScale;
 		}
 	} else {
-		longSpread *= MAX_INVENTORY_SKEW;
-		shortSpread *= MAX_INVENTORY_SKEW;
+		longSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
+		shortSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
 	}
 
 	const totalSpread = longSpread + shortSpread;
@@ -416,23 +496,23 @@ export function calculateSpread(
 		return amm.baseSpread / 2;
 	}
 
-	const markPrice = calculatePrice(
+	const reservePrice = calculatePrice(
 		amm.baseAssetReserve,
 		amm.quoteAssetReserve,
 		amm.pegMultiplier
 	);
 
-	const targetPrice = oraclePriceData?.price || markPrice;
+	const targetPrice = oraclePriceData?.price || reservePrice;
 	const confInterval = oraclePriceData.confidence || ZERO;
 
-	const targetMarkSpreadPct = markPrice
+	const targetMarkSpreadPct = reservePrice
 		.sub(targetPrice)
 		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(markPrice);
+		.div(reservePrice);
 
 	const confIntervalPct = confInterval
 		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(markPrice);
+		.div(reservePrice);
 
 	const [longSpread, shortSpread] = calculateSpreadBN(
 		amm.baseSpread,
@@ -442,9 +522,12 @@ export function calculateSpread(
 		amm.quoteAssetReserve,
 		amm.terminalQuoteAssetReserve,
 		amm.pegMultiplier,
-		amm.netBaseAssetAmount,
-		markPrice,
-		amm.totalFeeMinusDistributions
+		amm.baseAssetAmountWithAmm,
+		reservePrice,
+		amm.totalFeeMinusDistributions,
+		amm.baseAssetReserve,
+		amm.minBaseAssetReserve,
+		amm.maxBaseAssetReserve
 	);
 
 	let spread: number;
@@ -543,10 +626,10 @@ export function getSwapDirection(
  * Helper function calculating terminal price of amm
  *
  * @param market
- * @returns cost : Precision MARK_PRICE_PRECISION
+ * @returns cost : Precision PRICE_PRECISION
  */
-export function calculateTerminalPrice(market: MarketAccount) {
-	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
+export function calculateTerminalPrice(market: PerpMarketAccount) {
+	const directionToClose = market.amm.baseAssetAmountWithAmm.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
 
@@ -554,12 +637,12 @@ export function calculateTerminalPrice(market: MarketAccount) {
 		calculateAmmReservesAfterSwap(
 			market.amm,
 			'base',
-			market.amm.netBaseAssetAmount.abs(),
+			market.amm.baseAssetAmountWithAmm.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
 	const terminalPrice = newQuoteAssetReserve
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(market.amm.pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(newBaseAssetReserve);
@@ -576,7 +659,7 @@ export function calculateMaxBaseAssetAmountToTrade(
 	const invariant = amm.sqrtK.mul(amm.sqrtK);
 
 	const newBaseAssetReserveSquared = invariant
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(amm.pegMultiplier)
 		.div(limit_price)
 		.div(PEG_PRECISION);
@@ -610,6 +693,10 @@ export function calculateQuoteAssetAmountSwapped(
 	pegMultiplier: BN,
 	swapDirection: SwapDirection
 ): BN {
+	if (isVariant(swapDirection, 'remove')) {
+		quoteAssetReserves = quoteAssetReserves.add(ONE);
+	}
+
 	let quoteAssetAmount = quoteAssetReserves
 		.mul(pegMultiplier)
 		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
@@ -620,3 +707,29 @@ export function calculateQuoteAssetAmountSwapped(
 
 	return quoteAssetAmount;
 }
+
+export function calculateMaxBaseAssetAmountFillable(
+	amm: AMM,
+	orderDirection: PositionDirection
+): BN {
+	const maxFillSize = amm.baseAssetReserve.div(
+		new BN(amm.maxFillReserveFraction)
+	);
+	let maxBaseAssetAmountOnSide: BN;
+	if (isVariant(orderDirection, 'long')) {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.baseAssetReserve.sub(amm.minBaseAssetReserve)
+		);
+	} else {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.maxBaseAssetReserve.sub(amm.baseAssetReserve)
+		);
+	}
+
+	return standardizeBaseAssetAmount(
+		BN.min(maxFillSize, maxBaseAssetAmountOnSide),
+		amm.orderStepSize
+	);
+}

package/src/math/conversion.ts

@@ -1,9 +1,9 @@
 import { BN } from '../';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+import { PRICE_PRECISION } from '../constants/numericConstants';
 
 export const convertToNumber = (
 	bigNumber: BN,
-	precision: BN = MARK_PRICE_PRECISION
+	precision: BN = PRICE_PRECISION
 ) => {
 	if (!bigNumber) return 0;
 	return (

package/src/math/exchangeStatus.ts

@@ -0,0 +1,31 @@
+import {
+	isOneOfVariant,
+	isVariant,
+	PerpMarketAccount,
+	SpotMarketAccount,
+	StateAccount,
+} from '../types';
+
+export function exchangePaused(state: StateAccount): boolean {
+	return isVariant(state.exchangeStatus, 'paused');
+}
+
+export function fillPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	return (
+		isOneOfVariant(state.exchangeStatus, ['paused', 'fillPaused']) ||
+		isOneOfVariant(market.status, ['paused', 'fillPaused'])
+	);
+}
+
+export function ammPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	return (
+		isOneOfVariant(state.exchangeStatus, ['paused', 'ammPaused']) ||
+		isOneOfVariant(market.status, ['paused', 'ammPaused'])
+	);
+}