@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.27

package/src/index.ts

@@ -7,7 +7,7 @@ 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/bulkAccountLoader';
@@ -32,6 +32,7 @@ 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/funding';
 export * from './math/market';
@@ -50,11 +51,17 @@ export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './serum/serumSubscriber';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
-export * from './math/bankBalance';
-export * from './constants/banks';
+export * from './math/spotBalance';
+export * from './constants/spotMarkets';
 export * from './clearingHouseConfig';
+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

@@ -15,7 +15,7 @@ import {
 	AMM,
 	PositionDirection,
 	SwapDirection,
-	MarketAccount,
+	PerpMarketAccount,
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
@@ -418,7 +418,10 @@ export function calculateSpreadBN(
 		);
 	}
 
-	const maxTargetSpread: number = maxSpread;
+	const maxTargetSpread: number = Math.max(
+		maxSpread,
+		lastOracleMarkSpreadPct.abs().toNumber()
+	);
 
 	const MAX_INVENTORY_SKEW = 5;
 
@@ -613,7 +616,7 @@ export function getSwapDirection(
  * @param market
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
-export function calculateTerminalPrice(market: MarketAccount) {
+export function calculateTerminalPrice(market: PerpMarketAccount) {
 	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;

package/src/math/funding.ts

@@ -5,7 +5,7 @@ import {
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { MarketAccount } from '../types';
+import { PerpMarketAccount, isVariant } from '../types';
 import { calculateMarkPrice } from './market';
 import { OraclePriceData } from '../oracles/types';
 
@@ -17,7 +17,7 @@ import { OraclePriceData } from '../oracles/types';
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateAllEstimatedFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
@@ -29,7 +29,7 @@ export async function calculateAllEstimatedFundingRate(
 	const hoursInDay = new BN(24);
 	const ONE = new BN(1);
 
-	if (!market.initialized) {
+	if (isVariant(market.status, 'uninitialized')) {
 		return [ZERO, ZERO, ZERO, ZERO, ZERO];
 	}
 
@@ -208,7 +208,7 @@ export async function calculateAllEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateEstimatedFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'
@@ -238,7 +238,7 @@ export async function calculateEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
@@ -266,7 +266,7 @@ export async function calculateLongShortFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
@@ -291,7 +291,7 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
  * @param market
  * @returns Estimated fee pool size
  */
-export function calculateFundingPool(market: MarketAccount): BN {
+export function calculateFundingPool(market: PerpMarketAccount): BN {
 	// todo
 	const totalFeeLB = market.amm.totalExchangeFee.div(new BN(2));
 	const feePool = BN.max(

package/src/math/margin.ts

@@ -1,7 +1,7 @@
 import { squareRootBN } from './utils';
 import {
-	BANK_WEIGHT_PRECISION,
-	BANK_IMF_PRECISION,
+	SPOT_MARKET_WEIGHT_PRECISION,
+	SPOT_MARKET_IMF_PRECISION,
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -9,7 +9,8 @@ import {
 } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, UserPosition } from '..';
+import { PerpMarketAccount, PerpPosition } from '..';
+import { assert } from '../assert/assert';
 
 export function calculateSizePremiumLiabilityWeight(
 	size: BN, // AMM_RESERVE_PRECISION
@@ -22,14 +23,22 @@ export function calculateSizePremiumLiabilityWeight(
 	}
 
 	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+
+	const denom0 = BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor));
+	assert(denom0.gt(ZERO));
 	const liabilityWeightNumerator = liabilityWeight.sub(
-		liabilityWeight.div(BN.max(new BN(1), BANK_IMF_PRECISION.div(imfFactor)))
+		liabilityWeight.div(
+			BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor))
+		)
 	);
 
+	const denom = new BN(100_000).mul(SPOT_MARKET_IMF_PRECISION).div(precision);
+	assert(denom.gt(ZERO));
+
 	const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(
 		sizeSqrt // 1e5
 			.mul(imfFactor)
-			.div(new BN(100_000).mul(BANK_IMF_PRECISION).div(precision)) // 1e5
+			.div(denom) // 1e5
 	);
 
 	const maxLiabilityWeight = BN.max(
@@ -49,17 +58,19 @@ export function calculateSizeDiscountAssetWeight(
 	}
 
 	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
-	const imfNumerator = BANK_IMF_PRECISION.add(
-		BANK_IMF_PRECISION.div(new BN(10))
+	const imfNumerator = SPOT_MARKET_IMF_PRECISION.add(
+		SPOT_MARKET_IMF_PRECISION.div(new BN(10))
 	);
 
-	const sizeDiscountAssetWeight = imfNumerator.mul(BANK_WEIGHT_PRECISION).div(
-		BANK_IMF_PRECISION.add(
-			sizeSqrt // 1e5
-				.mul(imfFactor)
-				.div(new BN(100_000)) // 1e5
-		)
-	);
+	const sizeDiscountAssetWeight = imfNumerator
+		.mul(SPOT_MARKET_WEIGHT_PRECISION)
+		.div(
+			SPOT_MARKET_IMF_PRECISION.add(
+				sizeSqrt // 1e5
+					.mul(imfFactor)
+					.div(new BN(100_000)) // 1e5
+			)
+		);
 
 	const minAssetWeight = BN.min(assetWeight, sizeDiscountAssetWeight);
 
@@ -67,8 +78,8 @@ export function calculateSizeDiscountAssetWeight(
 }
 
 export function calculateOraclePriceForPerpMargin(
-	marketPosition: UserPosition,
-	market: MarketAccount,
+	perpPosition: PerpPosition,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const oraclePriceOffset = BN.min(
@@ -83,7 +94,7 @@ export function calculateOraclePriceForPerpMargin(
 	);
 
 	let marginPrice: BN;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
+	if (perpPosition.baseAssetAmount.gt(ZERO)) {
 		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
 	} else {
 		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
@@ -93,21 +104,21 @@ export function calculateOraclePriceForPerpMargin(
 }
 
 export function calculateBaseAssetValueWithOracle(
-	market: MarketAccount,
-	marketPosition: UserPosition,
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
-	return marketPosition.baseAssetAmount
+	return perpPosition.baseAssetAmount
 		.abs()
 		.mul(oraclePriceData.price)
 		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
 }
 
 export function calculateWorstCaseBaseAssetAmount(
-	marketPosition: UserPosition
+	perpPosition: PerpPosition
 ): BN {
-	const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
-	const allAsks = marketPosition.baseAssetAmount.add(marketPosition.openAsks);
+	const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+	const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
 
 	if (allBids.abs().gt(allAsks.abs())) {
 		return allBids;

package/src/math/market.ts

@@ -1,10 +1,10 @@
 import { BN } from '@project-serum/anchor';
 import {
-	MarketAccount,
+	PerpMarketAccount,
 	PositionDirection,
 	MarginCategory,
-	BankAccount,
-	BankBalanceType,
+	SpotMarketAccount,
+	SpotBalanceType,
 } from '../types';
 import {
 	calculateAmmReservesAfterSwap,
@@ -18,8 +18,13 @@ import {
 	calculateSizePremiumLiabilityWeight,
 } from './margin';
 import { OraclePriceData } from '../oracles/types';
-import { MARGIN_PRECISION } from '../constants/numericConstants';
-import { getTokenAmount } from './bankBalance';
+import {
+	BASE_PRECISION,
+	MARGIN_PRECISION,
+	PRICE_TO_QUOTE_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
+import { getTokenAmount } from './spotBalance';
 
 /**
  * Calculates market mark price
@@ -28,7 +33,7 @@ import { getTokenAmount } from './bankBalance';
  * @return markPrice : Precision MARK_PRICE_PRECISION
  */
 export function calculateMarkPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const newAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
@@ -46,7 +51,7 @@ export function calculateMarkPrice(
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
 export function calculateBidPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -63,10 +68,10 @@ export function calculateBidPrice(
  * Calculates market ask price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision MARK_PRICE_PRECISION
  */
 export function calculateAskPrice(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
@@ -82,8 +87,8 @@ export function calculateAskPrice(
 export function calculateNewMarketAfterTrade(
 	baseAssetAmount: BN,
 	direction: PositionDirection,
-	market: MarketAccount
-): MarketAccount {
+	market: PerpMarketAccount
+): PerpMarketAccount {
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
@@ -102,7 +107,7 @@ export function calculateNewMarketAfterTrade(
 }
 
 export function calculateMarkOracleSpread(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const markPrice = calculateMarkPrice(market, oraclePriceData);
@@ -117,7 +122,7 @@ export function calculateOracleSpread(
 }
 
 export function calculateMarketMarginRatio(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	size: BN,
 	marginCategory: MarginCategory
 ): number {
@@ -140,18 +145,34 @@ export function calculateMarketMarginRatio(
 }
 
 export function calculateUnrealizedAssetWeight(
-	market: MarketAccount,
+	market: PerpMarketAccount,
+	quoteSpotMarket: SpotMarketAccount,
 	unrealizedPnl: BN,
-	marginCategory: MarginCategory
+	marginCategory: MarginCategory,
+	oraclePriceData: OraclePriceData
 ): BN {
 	let assetWeight: BN;
-
 	switch (marginCategory) {
 		case 'Initial':
+			assetWeight = new BN(market.unrealizedInitialAssetWeight);
+
+			if (market.unrealizedMaxImbalance.gt(ZERO)) {
+				const netUnsettledPnl = calculateNetUserImbalance(
+					market,
+					quoteSpotMarket,
+					oraclePriceData
+				);
+				if (netUnsettledPnl.gt(market.unrealizedMaxImbalance)) {
+					assetWeight = assetWeight
+						.mul(market.unrealizedMaxImbalance)
+						.div(netUnsettledPnl);
+				}
+			}
+
 			assetWeight = calculateSizeDiscountAssetWeight(
 				unrealizedPnl,
 				market.unrealizedImfFactor,
-				new BN(market.unrealizedInitialAssetWeight)
+				assetWeight
 			);
 			break;
 		case 'Maintenance':
@@ -163,8 +184,39 @@ export function calculateUnrealizedAssetWeight(
 }
 
 export function calculateMarketAvailablePNL(
-	market: MarketAccount,
-	bank: BankAccount
+	perpMarket: PerpMarketAccount,
+	spotMarket: SpotMarketAccount
 ): BN {
-	return getTokenAmount(market.pnlPool.balance, bank, BankBalanceType.DEPOSIT);
+	return getTokenAmount(
+		perpMarket.pnlPool.balance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+}
+
+export function calculateNetUserImbalance(
+	market: PerpMarketAccount,
+	bank: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const netUserPositionValue = market.amm.netBaseAssetAmount
+		.mul(oraclePriceData.price)
+		.div(BASE_PRECISION)
+		.div(PRICE_TO_QUOTE_PRECISION);
+
+	const netUserCostBasis = market.amm.quoteAssetAmountLong
+		.add(market.amm.quoteAssetAmountShort)
+		.sub(market.amm.cumulativeSocialLoss);
+
+	const userEntitledPnl = netUserPositionValue.add(netUserCostBasis);
+
+	const pnlPool = getTokenAmount(
+		market.pnlPool.balance,
+		bank,
+		SpotBalanceType.DEPOSIT
+	);
+
+	const imbalance = userEntitledPnl.sub(pnlPool);
+
+	return imbalance;
 }

package/src/math/oracles.ts

@@ -2,11 +2,28 @@ import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import {
 	BID_ASK_SPREAD_PRECISION,
+	MARGIN_PRECISION,
 	MARK_PRICE_PRECISION,
 	ONE,
 	ZERO,
 } from '../constants/numericConstants';
-import { BN } from '../index';
+import { BN, PerpMarketAccount } from '../index';
+import { assert } from '../assert/assert';
+
+export function oraclePriceBands(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const maxPercentDiff =
+		market.marginRatioInitial - market.marginRatioMaintenance;
+	const offset = oraclePriceData.price
+		.mul(new BN(maxPercentDiff))
+		.div(MARGIN_PRECISION);
+
+	assert(offset.gt(ZERO));
+
+	return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
+}
 
 export function isOracleValid(
 	amm: AMM,

package/src/math/orders.ts

@@ -2,7 +2,7 @@ import { ClearingHouseUser } from '../clearingHouseUser';
 import {
 	isOneOfVariant,
 	isVariant,
-	MarketAccount,
+	PerpMarketAccount,
 	Order,
 	PositionDirection,
 } from '../types';
@@ -131,9 +131,9 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
-	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
-	slot: number
+	slot: number,
+	perpMarket?: PerpMarketAccount
 ): BN {
 	let limitPrice;
 	if (!order.oraclePriceOffset.eq(ZERO)) {
@@ -143,14 +143,26 @@ export function getLimitPrice(
 			limitPrice = getAuctionPrice(order, slot);
 		} else if (!order.price.eq(ZERO)) {
 			limitPrice = order.price;
-		} else if (isVariant(order.direction, 'long')) {
-			const askPrice = calculateAskPrice(market, oraclePriceData);
-			const delta = askPrice.div(new BN(market.amm.maxSlippageRatio));
-			limitPrice = askPrice.add(delta);
 		} else {
-			const bidPrice = calculateBidPrice(market, oraclePriceData);
-			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
-			limitPrice = bidPrice.sub(delta);
+			if (perpMarket) {
+				if (isVariant(order.direction, 'long')) {
+					const askPrice = calculateAskPrice(perpMarket, oraclePriceData);
+					const delta = askPrice.div(new BN(perpMarket.amm.maxSlippageRatio));
+					limitPrice = askPrice.add(delta);
+				} else {
+					const bidPrice = calculateBidPrice(perpMarket, oraclePriceData);
+					const delta = bidPrice.div(new BN(perpMarket.amm.maxSlippageRatio));
+					limitPrice = bidPrice.sub(delta);
+				}
+			} else {
+				// check oracle validity?
+				const oraclePrice1Pct = oraclePriceData.price.div(new BN(100));
+				if (isVariant(order.direction, 'long')) {
+					limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
+				} else {
+					limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
+				}
+			}
 		}
 	} else {
 		limitPrice = order.price;
@@ -161,10 +173,9 @@ export function getLimitPrice(
 
 export function isFillableByVAMM(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
-	slot: number,
-	maxAuctionDuration: number
+	slot: number
 ): boolean {
 	return (
 		(isAuctionComplete(order, slot) &&
@@ -174,13 +185,13 @@ export function isFillableByVAMM(
 				oraclePriceData,
 				slot
 			).eq(ZERO)) ||
-		isOrderExpired(order, slot, maxAuctionDuration)
+		isOrderExpired(order, slot)
 	);
 }
 
 export function calculateBaseAssetAmountForAmmToFulfill(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	slot: number
 ): BN {
@@ -191,7 +202,7 @@ export function calculateBaseAssetAmountForAmmToFulfill(
 		return ZERO;
 	}
 
-	const limitPrice = getLimitPrice(order, market, oraclePriceData, slot);
+	const limitPrice = getLimitPrice(order, oraclePriceData, slot, market);
 	const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
 		order,
 		market,
@@ -209,7 +220,7 @@ export function calculateBaseAssetAmountForAmmToFulfill(
 
 export function calculateBaseAssetAmountToFillUpToLimitPrice(
 	order: Order,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	limitPrice: BN,
 	oraclePriceData: OraclePriceData
 ): BN {
@@ -246,17 +257,14 @@ function isSameDirection(
 	);
 }
 
-export function isOrderExpired(
-	order: Order,
-	slot: number,
-	maxAuctionDuration: number
-): boolean {
+export function isOrderExpired(order: Order, slot: number): boolean {
 	if (
-		!isVariant(order.orderType, 'market') ||
-		!isVariant(order.status, 'open')
+		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) ||
+		!isVariant(order.status, 'open') ||
+		order.timeInForce === 0
 	) {
 		return false;
 	}
 
-	return new BN(slot).sub(order.slot).gt(new BN(maxAuctionDuration));
+	return new BN(slot).sub(order.slot).gt(new BN(order.timeInForce));
 }