@drift-labs/sdk 0.1.8 → 0.1.12

package/src/math/funding.ts

@@ -1,23 +1,26 @@
 import { BN } from '@project-serum/anchor';
 import {
-	AMM_RESERVE_PRECISION, MARK_PRICE_PRECISION, QUOTE_PRECISION, ZERO
+	AMM_RESERVE_PRECISION,
+	MARK_PRICE_PRECISION,
+	QUOTE_PRECISION,
+	ZERO,
 } from '../constants/numericConstants';
 import { PythClient } from '../pythClient';
 import { Market } from '../types';
 import { calculateMarkPrice } from './market';
 
 /**
- * 
- * @param market 
- * @param pythClient 
- * @param periodAdjustment 
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
- export async function calculateAllEstimatedFundingRate(
+export async function calculateAllEstimatedFundingRate(
 	market: Market,
 	pythClient: PythClient,
-	periodAdjustment: BN = new BN(1),
-): Promise<[BN, BN, BN]> {
+	periodAdjustment: BN = new BN(1)
+): Promise<[BN, BN, BN, BN, BN]> {
 	// periodAdjustment
 	// 	1: hourly
 	//  24: daily
@@ -26,27 +29,24 @@ import { calculateMarkPrice } from './market';
 	const hoursInDay = new BN(24);
 
 	if (!market.initialized) {
-		return [new BN(0), new BN(0), new BN(0)];
+		return [ZERO, ZERO, ZERO, ZERO, ZERO];
 	}
 
 	const payFreq = new BN(market.amm.fundingPeriod);
 
-	const oraclePriceData = await pythClient.getPriceData(market.amm.oracle);
-	const oracleTwapWithMantissa = new BN(
-		oraclePriceData.twap.value * MARK_PRICE_PRECISION.toNumber()
-	);
-
+	// todo: sufficiently differs from blockchain timestamp?
 	const now = new BN((Date.now() / 1000).toFixed(0));
 	const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
 
+	// calculate real-time mark twap
 	const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
 	const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
 
 	const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
-	const markTwapTimeSinceLastUpdate = lastMarkPriceTwapTs.sub(
-		market.amm.lastFundingRateTs
+	const markTwapTimeSinceLastUpdate = BN.max(
+		secondsInHour,
+		secondsInHour.sub(timeSinceLastMarkChange)
 	);
-
 	const baseAssetPriceWithMantissa = calculateMarkPrice(market);
 
 	const markTwapWithMantissa = markTwapTimeSinceLastUpdate
@@ -54,6 +54,27 @@ import { calculateMarkPrice } from './market';
 		.add(timeSinceLastMarkChange.mul(baseAssetPriceWithMantissa))
 		.div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
 
+	// calculate real-time (predicted) oracle twap
+	// note: oracle twap depends on `when the chord is struck` (market is trade)
+	const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
+	const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
+
+	const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
+	const oracleTwapTimeSinceLastUpdate = BN.max(
+		secondsInHour,
+		secondsInHour.sub(timeSinceLastOracleTwapUpdate)
+	);
+	const oraclePriceData = await pythClient.getPriceData(market.amm.oracle);
+	const oraclePriceStableWithMantissa = new BN(
+		((oraclePriceData.price + oraclePriceData.previousPrice) / 2) *
+			MARK_PRICE_PRECISION.toNumber()
+	);
+
+	const oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
+		.mul(lastOracleTwapWithMantissa)
+		.add(timeSinceLastMarkChange.mul(oraclePriceStableWithMantissa))
+		.div(timeSinceLastOracleTwapUpdate.add(oracleTwapTimeSinceLastUpdate));
+
 	const twapSpread = markTwapWithMantissa.sub(oracleTwapWithMantissa);
 
 	const twapSpreadPct = twapSpread
@@ -61,7 +82,6 @@ import { calculateMarkPrice } from './market';
 		.mul(new BN(100))
 		.div(oracleTwapWithMantissa);
 
-
 	const lowerboundEst = twapSpreadPct
 		.mul(payFreq)
 		.mul(BN.min(secondsInHour, timeSinceLastUpdate))
@@ -72,54 +92,82 @@ import { calculateMarkPrice } from './market';
 
 	const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
 
-	
-	const interpRateQuote = twapSpreadPct.mul(periodAdjustment).div(hoursInDay)
-	.div(MARK_PRICE_PRECISION.div(QUOTE_PRECISION));
+	const interpRateQuote = twapSpreadPct
+		.mul(periodAdjustment)
+		.div(hoursInDay)
+		.div(MARK_PRICE_PRECISION.div(QUOTE_PRECISION));
 	let feePoolSize = calculateFundingPool(market);
-	if(interpRateQuote.lt(new BN(0))){
+	if (interpRateQuote.lt(new BN(0))) {
 		feePoolSize = feePoolSize.mul(new BN(-1));
 	}
 
 	let cappedAltEst: BN;
 	let largerSide: BN;
 	let smallerSide: BN;
-
-	if(market.baseAssetAmountLong.gt(market.baseAssetAmountShort)){
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
 		largerSide = market.baseAssetAmountLong.abs();
 		smallerSide = market.baseAssetAmountShort.abs();
-		if(twapSpread.gt(new BN(0))){
-			return [lowerboundEst, interpEst, interpEst];
+		if (twapSpread.gt(new BN(0))) {
+			return [
+				markTwapWithMantissa,
+				oracleTwapWithMantissa,
+				lowerboundEst,
+				interpEst,
+				interpEst,
+			];
 		}
-	} else if(market.baseAssetAmountLong.lt(market.baseAssetAmountShort)){
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
 		largerSide = market.baseAssetAmountShort.abs();
 		smallerSide = market.baseAssetAmountLong.abs();
-		if(twapSpread.lt(new BN(0))){
-			return [lowerboundEst, interpEst, interpEst];
+		if (twapSpread.lt(new BN(0))) {
+			return [
+				markTwapWithMantissa,
+				oracleTwapWithMantissa,
+				lowerboundEst,
+				interpEst,
+				interpEst,
+			];
 		}
-	} else{
-		return [lowerboundEst, interpEst, interpEst];
+	} else {
+		return [
+			markTwapWithMantissa,
+			oracleTwapWithMantissa,
+			lowerboundEst,
+			interpEst,
+			interpEst,
+		];
 	}
 
-	if(largerSide.gt(ZERO)){
+	if (largerSide.gt(ZERO)) {
 		cappedAltEst = smallerSide.mul(twapSpread).div(largerSide);
-		const feePoolTopOff = feePoolSize.mul(MARK_PRICE_PRECISION.div(QUOTE_PRECISION))
-		.mul(AMM_RESERVE_PRECISION).div(largerSide);
+
+		const feePoolTopOff = feePoolSize
+			.mul(MARK_PRICE_PRECISION.div(QUOTE_PRECISION))
+			.mul(AMM_RESERVE_PRECISION)
+			.div(largerSide);
+
 		cappedAltEst = cappedAltEst.add(feePoolTopOff);
-	
-		cappedAltEst = cappedAltEst.mul(MARK_PRICE_PRECISION)
-		.mul(new BN(100))
-		.div(oracleTwapWithMantissa)
-		.mul(periodAdjustment).div(hoursInDay);
-	
-		if(cappedAltEst.abs().gt(interpEst.abs())){
+
+		cappedAltEst = cappedAltEst
+			.mul(MARK_PRICE_PRECISION)
+			.mul(new BN(100))
+			.div(oracleTwapWithMantissa)
+			.mul(periodAdjustment)
+			.div(hoursInDay);
+		if (cappedAltEst.abs().gt(interpEst.abs())) {
 			cappedAltEst = interpEst;
 		}
-	} else{
+	} else {
 		cappedAltEst = interpEst;
 	}
 
-
-	return [lowerboundEst, cappedAltEst, interpEst];
+	return [
+		markTwapWithMantissa,
+		oracleTwapWithMantissa,
+		lowerboundEst,
+		cappedAltEst,
+		interpEst,
+	];
 }
 
 /**
@@ -136,8 +184,12 @@ export async function calculateEstimatedFundingRate(
 	periodAdjustment: BN = new BN(1),
 	estimationMethod: 'interpolated' | 'lowerbound' | 'capped'
 ): Promise<BN> {
-	const [lowerboundEst, cappedAltEst, interpEst] = 
-		await calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment);
+	const [_1, _2, lowerboundEst, cappedAltEst, interpEst] =
+		await calculateAllEstimatedFundingRate(
+			market,
+			pythClient,
+			periodAdjustment
+		);
 
 	if (estimationMethod == 'lowerbound') {
 		//assuming remaining funding period has no gap
@@ -149,31 +201,62 @@ export async function calculateEstimatedFundingRate(
 	}
 }
 
-
 /**
- * 
- * @param market 
- * @param pythClient 
- * @param periodAdjustment 
- * @param estimationMethod 
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
- export async function calculateLongShortFundingRate(
+export async function calculateLongShortFundingRate(
 	market: Market,
 	pythClient: PythClient,
-	periodAdjustment: BN = new BN(1),
+	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
-	const [_, cappedAltEst, interpEst] = 
-		await calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment);
+	const [_1, _2, _, cappedAltEst, interpEst] =
+		await calculateAllEstimatedFundingRate(
+			market,
+			pythClient,
+			periodAdjustment
+		);
 
-	if(market.baseAssetAmountLong.gt(market.baseAssetAmountShort)){
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
 		return [cappedAltEst, interpEst];
-	} else if(market.baseAssetAmountLong.lt(market.baseAssetAmountShort)){
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
 		return [interpEst, cappedAltEst];
-	} else{
+	} else {
 		return [interpEst, interpEst];
 	}
+}
 
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export async function calculateLongShortFundingRateAndLiveTwaps(
+	market: Market,
+	pythClient: PythClient,
+	periodAdjustment: BN = new BN(1)
+): Promise<[BN, BN, BN, BN]> {
+	const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] =
+		await calculateAllEstimatedFundingRate(
+			market,
+			pythClient,
+			periodAdjustment
+		);
+
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+		return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+		return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
+	} else {
+		return [markTwapLive, oracleTwapLive, interpEst, interpEst];
+	}
 }
 
 /**
@@ -182,8 +265,8 @@ export async function calculateEstimatedFundingRate(
  * @returns Estimated fee pool size
  */
 export function calculateFundingPool(market: Market): BN {
+	// todo
 	const totalFeeLB = market.amm.totalFee.div(new BN(2));
 	const feePool = market.amm.totalFeeMinusDistributions.sub(totalFeeLB);
-	// return new BN(QUOTE_PRECISION.mul(new BN(2400)));
 	return feePool;
 }

package/src/math/position.ts

@@ -1,7 +1,9 @@
 import { Market, PositionDirection, UserPosition } from '../types';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
+	MARK_PRICE_PRECISION,
 	PEG_PRECISION,
+	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
 import BN from 'bn.js';
@@ -131,3 +133,20 @@ export function calculatePositionFundingPNL(
 
 	return perPositionFundingRate;
 }
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+export function calculateEntryPrice(userPosition: UserPosition): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	return userPosition.quoteAssetAmount
+		.mul(MARK_PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}

package/src/math/trade.ts

@@ -28,7 +28,8 @@ export type PriceImpactUnit =
 	| 'quoteAssetAmount'
 	| 'quoteAssetAmountPeg'
 	| 'acquiredBaseAssetAmount'
-	| 'acquiredQuoteAssetAmount';
+	| 'acquiredQuoteAssetAmount'
+	| 'all';
 
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
@@ -49,7 +50,7 @@ export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
 	market: Market,
-	inputAssetType: AssetType = 'quote',
+	inputAssetType: AssetType = 'quote'
 ): [BN, BN, BN, BN] {
 	const oldPrice = calculateMarkPrice(market);
 	if (amount.eq(ZERO)) {
@@ -107,7 +108,7 @@ export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
 	market: Market,
-	inputAssetType: AssetType = 'quote',
+	inputAssetType: AssetType = 'quote'
 ): [BN, BN] {
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO];

package/src/types.ts

@@ -221,6 +221,8 @@ export type AMM = {
 	lastFundingRateTs: BN;
 	lastMarkPriceTwap: BN;
 	lastMarkPriceTwapTs: BN;
+	lastOraclePriceTwap: BN;
+	lastOraclePriceTwapTs: BN;
 	oracle: PublicKey;
 	oracleSource: OracleSource;
 	fundingPeriod: BN;
@@ -242,6 +244,9 @@ export type UserPosition = {
 	lastCumulativeFundingRate: BN;
 	marketIndex: BN;
 	quoteAssetAmount: BN;
+	unrealizedPnl?: BN;
+	unrealizedFundingPnl?: BN;
+	baseAssetValue?: BN;
 };
 
 export type UserPositionsAccount = {
@@ -257,53 +262,16 @@ export type UserAccount = {
 	totalFeePaid: BN;
 };
 
-// # UI ↔ History Server Data Types
-export interface Trade {
-	price: number;
-	beforePrice: number;
-	afterPrice: number;
-	side: TradeSide;
-	size: number;
-	ts: number;
-	fee: number;
-	marketIndex: number;
-	chainTs: number;
-}
-
-export type Liquidation = {
-	ts: number;
-	chainTs: number;
-	recordId: number;
+export type UserSnapshotRecord = {
+	ts: BN;
 	userAuthority: PublicKey;
 	user: PublicKey;
-	partial: boolean;
-	baseAssetValue: number;
-	baseAssetValueClosed: number;
-	liquidationFee: number;
-	feeToLiquidator: number;
-	feeToInsuranceFund: number;
-	liquidator: PublicKey;
-	totalCollateral: number;
-	collateral: number;
-	unrealizedPnl: number;
-	marginRatio: number;
-};
-
-export type Candle = {
-	open: number;
-	close: number;
-	high: number;
-	low: number;
-	volume: number;
-	start: number;
-	end: number;
+	userPositions: UserPosition[];
+	userTotalRealizedPnl: BN;
+	userTotalUnrealizedPnl: BN;
+	userTotalUnrealizedFundingPnl: BN;
+	userCollateral: BN;
 };
-export interface FundingPayment {
-	userPublicKey: string;
-	ts: number;
-	marketIndex: number;
-	amount: string;
-}
 
 // # Misc Types
 export interface IWallet {

package/tsconfig.json

@@ -6,7 +6,8 @@
       "declaration": true,
       "outDir": "./lib",
       "resolveJsonModule": true,
-      "skipLibCheck": true
+      "skipLibCheck": true,
+      "declarationMap": true
     },
     "include": ["src"],
     "exclude": ["node_modules"]