@drift-labs/sdk 2.38.1-beta.1 → 2.38.1-beta.11

package/src/math/spotBalance.ts

@@ -22,6 +22,7 @@ import {
 import { OraclePriceData } from '../oracles/types';
 import { PERCENTAGE_PRECISION } from '../constants/numericConstants';
 import { divCeil } from './utils';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
 
 /**
  * Calculates the balance of a given token amount including any accumulated interest. This
@@ -102,25 +103,23 @@ export function getSignedTokenAmount(
  *
  * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
  * @param {number} spotDecimals - The number of decimals in the token.
- * @param {OraclePriceData} oraclePriceData - The oracle price data (typically a token/USD oracle).
- * @param {BN} oraclePriceTwap - The Time-Weighted Average Price of the oracle.
+ * @param {StrictOraclePrice} strictOraclePrice - Contains oracle price and 5min twap.
  * @return {BN} The calculated value of the given token amount, scaled by `PRICE_PRECISION`
  */
 export function getStrictTokenValue(
 	tokenAmount: BN,
 	spotDecimals: number,
-	oraclePriceData: OraclePriceData,
-	oraclePriceTwap: BN
+	strictOraclePrice: StrictOraclePrice
 ): BN {
 	if (tokenAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
-	let price = oraclePriceData.price;
-	if (tokenAmount.gt(ZERO)) {
-		price = BN.min(oraclePriceData.price, oraclePriceTwap);
+	let price;
+	if (tokenAmount.gte(ZERO)) {
+		price = strictOraclePrice.min();
 	} else {
-		price = BN.max(oraclePriceData.price, oraclePriceTwap);
+		price = strictOraclePrice.max();
 	}
 
 	const precisionDecrease = TEN.pow(new BN(spotDecimals));
@@ -139,7 +138,7 @@ export function getStrictTokenValue(
 export function getTokenValue(
 	tokenAmount: BN,
 	spotDecimals: number,
-	oraclePriceData: OraclePriceData
+	oraclePriceData: Pick<OraclePriceData, 'price'>
 ): BN {
 	if (tokenAmount.eq(ZERO)) {
 		return ZERO;
@@ -152,6 +151,7 @@ export function getTokenValue(
 
 export function calculateAssetWeight(
 	balanceAmount: BN,
+	oraclePrice: BN,
 	spotMarket: SpotMarketAccount,
 	marginCategory: MarginCategory
 ): BN {
@@ -174,7 +174,7 @@ export function calculateAssetWeight(
 			assetWeight = calculateSizeDiscountAssetWeight(
 				sizeInAmmReservePrecision,
 				new BN(spotMarket.imfFactor),
-				new BN(spotMarket.initialAssetWeight)
+				calculateScaledInitialAssetWeight(spotMarket, oraclePrice)
 			);
 			break;
 		case 'Maintenance':
@@ -185,13 +185,39 @@ export function calculateAssetWeight(
 			);
 			break;
 		default:
-			assetWeight = new BN(spotMarket.initialAssetWeight);
+			assetWeight = calculateScaledInitialAssetWeight(spotMarket, oraclePrice);
 			break;
 	}
 
 	return assetWeight;
 }
 
+export function calculateScaledInitialAssetWeight(
+	spotMarket: SpotMarketAccount,
+	oraclePrice: BN
+): BN {
+	if (spotMarket.scaleInitialAssetWeightStart.eq(ZERO)) {
+		return new BN(spotMarket.initialAssetWeight);
+	}
+
+	const deposits = getTokenAmount(
+		spotMarket.depositBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	const depositsValue = getTokenValue(deposits, spotMarket.decimals, {
+		price: oraclePrice,
+	});
+
+	if (depositsValue.lt(spotMarket.scaleInitialAssetWeightStart)) {
+		return new BN(spotMarket.initialAssetWeight);
+	} else {
+		return new BN(spotMarket.initialAssetWeight)
+			.mul(spotMarket.scaleInitialAssetWeightStart)
+			.div(depositsValue);
+	}
+}
+
 export function calculateLiabilityWeight(
 	size: BN,
 	spotMarket: SpotMarketAccount,
@@ -229,7 +255,7 @@ export function calculateLiabilityWeight(
 			);
 			break;
 		default:
-			liabilityWeight = spotMarket.initialLiabilityWeight;
+			liabilityWeight = new BN(spotMarket.initialLiabilityWeight);
 			break;
 	}
 

package/src/math/spotMarket.ts

@@ -21,12 +21,18 @@ export function castNumberToSpotPrecision(
 
 export function calculateSpotMarketMarginRatio(
 	market: SpotMarketAccount,
+	oraclePrice: BN,
 	marginCategory: MarginCategory,
 	size: BN,
 	balanceType: SpotBalanceType
 ): number {
 	if (isVariant(balanceType, 'deposit')) {
-		const assetWeight = calculateAssetWeight(size, market, marginCategory);
+		const assetWeight = calculateAssetWeight(
+			size,
+			oraclePrice,
+			market,
+			marginCategory
+		);
 		return MARGIN_PRECISION.sub(assetWeight).toNumber();
 	} else {
 		const liabilityWeight = calculateLiabilityWeight(

package/src/math/spotPosition.ts

@@ -1,22 +1,38 @@
-import { SpotMarketAccount, SpotPosition } from '../types';
-import { ZERO } from '../constants/numericConstants';
+import { MarginCategory, SpotMarketAccount, SpotPosition } from '../types';
+import {
+	SPOT_MARKET_WEIGHT_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import {
+	calculateAssetWeight,
+	calculateLiabilityWeight,
 	getSignedTokenAmount,
+	getStrictTokenValue,
 	getTokenAmount,
 	getTokenValue,
 } from './spotBalance';
-import { OraclePriceData } from '../oracles/types';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
 
 export function isSpotPositionAvailable(position: SpotPosition): boolean {
 	return position.scaledBalance.eq(ZERO) && position.openOrders === 0;
 }
 
+export type OrderFillSimulation = {
+	tokenAmount: BN;
+	ordersValue: BN;
+	tokenValue: BN;
+	weight: BN;
+	weightedTokenValue: BN;
+	freeCollateralContribution;
+};
+
 export function getWorstCaseTokenAmounts(
 	spotPosition: SpotPosition,
 	spotMarketAccount: SpotMarketAccount,
-	oraclePriceData: OraclePriceData
-): [BN, BN] {
+	strictOraclePrice: StrictOraclePrice,
+	marginCategory: MarginCategory
+): OrderFillSimulation {
 	const tokenAmount = getSignedTokenAmount(
 		getTokenAmount(
 			spotPosition.scaledBalance,
@@ -26,22 +42,121 @@ export function getWorstCaseTokenAmounts(
 		spotPosition.balanceType
 	);
 
-	const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
-	const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+	const tokenValue = getStrictTokenValue(
+		tokenAmount,
+		spotMarketAccount.decimals,
+		strictOraclePrice
+	);
 
-	if (tokenAmountAllBidsFill.abs().gt(tokenAmountAllAsksFill.abs())) {
-		const worstCaseQuoteTokenAmount = getTokenValue(
-			spotPosition.openBids.neg(),
-			spotMarketAccount.decimals,
-			oraclePriceData
+	if (spotPosition.openBids.eq(ZERO) && spotPosition.openAsks.eq(ZERO)) {
+		const { weight, weightedTokenValue } = calculateWeightedTokenValue(
+			tokenAmount,
+			tokenValue,
+			strictOraclePrice.current,
+			spotMarketAccount,
+			marginCategory
 		);
-		return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+		return {
+			tokenAmount,
+			ordersValue: ZERO,
+			tokenValue,
+			weight,
+			weightedTokenValue,
+			freeCollateralContribution: weightedTokenValue,
+		};
+	}
+
+	const bidsSimulation = simulateOrderFill(
+		tokenAmount,
+		tokenValue,
+		spotPosition.openBids,
+		strictOraclePrice,
+		spotMarketAccount,
+		marginCategory
+	);
+	const asksSimulation = simulateOrderFill(
+		tokenAmount,
+		tokenValue,
+		spotPosition.openAsks,
+		strictOraclePrice,
+		spotMarketAccount,
+		marginCategory
+	);
+
+	if (
+		asksSimulation.freeCollateralContribution.lt(
+			bidsSimulation.freeCollateralContribution
+		)
+	) {
+		return asksSimulation;
 	} else {
-		const worstCaseQuoteTokenAmount = getTokenValue(
-			spotPosition.openAsks.neg(),
-			spotMarketAccount.decimals,
-			oraclePriceData
+		return bidsSimulation;
+	}
+}
+
+export function calculateWeightedTokenValue(
+	tokenAmount: BN,
+	tokenValue: BN,
+	oraclePrice: BN,
+	spotMarket: SpotMarketAccount,
+	marginCategory: MarginCategory
+): { weight: BN; weightedTokenValue: BN } {
+	let weight: BN;
+	if (tokenValue.gte(ZERO)) {
+		weight = calculateAssetWeight(
+			tokenAmount,
+			oraclePrice,
+			spotMarket,
+			marginCategory
+		);
+	} else {
+		weight = calculateLiabilityWeight(
+			tokenAmount.abs(),
+			spotMarket,
+			marginCategory
 		);
-		return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
 	}
+
+	return {
+		weight: weight,
+		weightedTokenValue: tokenValue
+			.mul(weight)
+			.div(SPOT_MARKET_WEIGHT_PRECISION),
+	};
+}
+
+export function simulateOrderFill(
+	tokenAmount: BN,
+	tokenValue: BN,
+	openOrders: BN,
+	strictOraclePrice: StrictOraclePrice,
+	spotMarket: SpotMarketAccount,
+	marginCategory: MarginCategory
+): OrderFillSimulation {
+	const ordersValue = getTokenValue(openOrders.neg(), spotMarket.decimals, {
+		price: strictOraclePrice.max(),
+	});
+	const tokenAmountAfterFill = tokenAmount.add(openOrders);
+	const tokenValueAfterFill = tokenValue.add(ordersValue.neg());
+
+	const { weight, weightedTokenValue: weightedTokenValueAfterFill } =
+		calculateWeightedTokenValue(
+			tokenAmountAfterFill,
+			tokenValueAfterFill,
+			strictOraclePrice.current,
+			spotMarket,
+			marginCategory
+		);
+
+	const freeCollateralContribution =
+		weightedTokenValueAfterFill.add(ordersValue);
+
+	return {
+		tokenAmount: tokenAmountAfterFill,
+		ordersValue: ordersValue,
+		tokenValue: tokenValueAfterFill,
+		weight,
+		weightedTokenValue: weightedTokenValueAfterFill,
+		freeCollateralContribution,
+	};
 }

package/src/oracles/strictOraclePrice.ts

@@ -0,0 +1,19 @@
+import { BN } from '@coral-xyz/anchor';
+
+export class StrictOraclePrice {
+	current: BN;
+	twap?: BN;
+
+	constructor(current: BN, twap?: BN) {
+		this.current = current;
+		this.twap = twap;
+	}
+
+	public max(): BN {
+		return this.twap ? BN.max(this.twap, this.current) : this.current;
+	}
+
+	public min(): BN {
+		return this.twap ? BN.min(this.twap, this.current) : this.current;
+	}
+}

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -0,0 +1,75 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+
+export class PriorityFeeSubscriber {
+	connection: Connection;
+	frequencyMs: number;
+	addresses: PublicKey[];
+	slotsToCheck: number;
+
+	intervalId?: NodeJS.Timer;
+
+	latestPriorityFee = 0;
+	// avg of last {slotsToCheck} slots
+	avgPriorityFee = 0;
+	// max of last {slotsToCheck} slots
+	maxPriorityFee = 0;
+	lastSlotSeen = 0;
+
+	public constructor({
+		connection,
+		frequencyMs,
+		addresses,
+		slotsToCheck = 10,
+	}: {
+		connection: Connection;
+		frequencyMs: number;
+		addresses: PublicKey[];
+		slotsToCheck?: number;
+	}) {
+		this.connection = connection;
+		this.frequencyMs = frequencyMs;
+		this.addresses = addresses;
+		this.slotsToCheck = slotsToCheck;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
+	}
+
+	public async load(): Promise<void> {
+		// @ts-ignore
+		const rpcJSONResponse: any = await this.connection._rpcRequest(
+			'getRecentPrioritizationFees',
+			[this.addresses]
+		);
+
+		const descResults: { slot: number; prioritizationFee: number }[] =
+			rpcJSONResponse?.result
+				?.sort((a, b) => b.slot - a.slot)
+				?.slice(0, this.slotsToCheck) ?? [];
+
+		if (!descResults?.length) return;
+
+		const mostRecentResult = descResults[0];
+		this.latestPriorityFee = mostRecentResult.prioritizationFee;
+		this.lastSlotSeen = mostRecentResult.slot;
+		this.avgPriorityFee =
+			descResults.reduce((a, b) => {
+				return a + b.prioritizationFee;
+			}, 0) / descResults.length;
+		this.maxPriorityFee = Math.max(
+			...descResults.map((result) => result.prioritizationFee)
+		);
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}

package/src/tokenFaucet.ts

@@ -38,6 +38,7 @@ export class TokenFaucet {
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts || AnchorProvider.defaultOptions();
+		// @ts-ignore
 		const provider = new AnchorProvider(connection, wallet, this.opts);
 		this.provider = provider;
 		this.program = new Program(tokenFaucet as Idl, programId, provider);

package/src/types.ts

@@ -155,6 +155,9 @@ export class OrderActionExplanation {
 	static readonly ORDER_FILLED_WITH_SERUM = {
 		orderFillWithSerum: {},
 	};
+	static readonly ORDER_FILLED_WITH_PHOENIX = {
+		orderFillWithPhoenix: {},
+	};
 	static readonly REDUCE_ONLY_ORDER_INCREASED_POSITION = {
 		reduceOnlyOrderIncreasedPosition: {},
 	};
@@ -652,6 +655,7 @@ export type SpotMarketAccount = {
 	maintenanceLiabilityWeight: number;
 	liquidatorFee: number;
 	imfFactor: number;
+	scaleInitialAssetWeightStart: BN;
 
 	withdrawGuardThreshold: BN;
 	depositTokenTwap: BN;