@drift-labs/sdk 0.1.7 → 0.1.11

package/src/idl/clearing_house.json

@@ -1724,6 +1724,34 @@
     }
   ],
   "types": [
+    {
+      "name": "InitializeUserOptionalAccounts",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "whitelistToken",
+            "type": "bool"
+          }
+        ]
+      }
+    },
+    {
+      "name": "ManagePositionOptionalAccounts",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "discountToken",
+            "type": "bool"
+          },
+          {
+            "name": "referrer",
+            "type": "bool"
+          }
+        ]
+      }
+    },
     {
       "name": "CurveRecord",
       "type": {
@@ -1938,34 +1966,6 @@
         ]
       }
     },
-    {
-      "name": "InitializeUserOptionalAccounts",
-      "type": {
-        "kind": "struct",
-        "fields": [
-          {
-            "name": "whitelistToken",
-            "type": "bool"
-          }
-        ]
-      }
-    },
-    {
-      "name": "ManagePositionOptionalAccounts",
-      "type": {
-        "kind": "struct",
-        "fields": [
-          {
-            "name": "discountToken",
-            "type": "bool"
-          },
-          {
-            "name": "referrer",
-            "type": "bool"
-          }
-        ]
-      }
-    },
     {
       "name": "LiquidationRecord",
       "type": {
@@ -2140,7 +2140,7 @@
             "type": "i64"
           },
           {
-            "name": "lastOracleMarkSpreadTwap",
+            "name": "lastOraclePriceTwap",
             "type": "i128"
           },
           {
@@ -2175,9 +2175,13 @@
             "name": "minimumTradeSize",
             "type": "u128"
           },
+          {
+            "name": "lastOraclePriceTwapTs",
+            "type": "i64"
+          },
           {
             "name": "padding0",
-            "type": "u128"
+            "type": "u64"
           },
           {
             "name": "padding1",

package/src/math/funding.ts

@@ -1,23 +1,26 @@
 import { BN } from '@project-serum/anchor';
 import {
-	AMM_RESERVE_PRECISION, MARK_PRICE_PRECISION, QUOTE_PRECISION
+	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,34 +29,43 @@ 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
 		.mul(lastMarkTwapWithMantissa)
 		.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 +73,6 @@ import { calculateMarkPrice } from './market';
 		.mul(new BN(100))
 		.div(oracleTwapWithMantissa);
 
-
 	const lowerboundEst = twapSpreadPct
 		.mul(payFreq)
 		.mul(BN.min(secondsInHour, timeSinceLastUpdate))
@@ -72,30 +83,59 @@ 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 feePoolSize = calculateFundingPool(market);
+	const interpRateQuote = twapSpreadPct
+		.mul(periodAdjustment)
+		.div(hoursInDay)
+		.div(MARK_PRICE_PRECISION.div(QUOTE_PRECISION));
+	let feePoolSize = calculateFundingPool(market);
+	if (interpRateQuote.lt(new BN(0))) {
+		feePoolSize = feePoolSize.mul(new BN(-1));
+	}
 
 	let cappedAltEst: BN;
-
-	if(market.baseAssetAmountLong.gt(market.baseAssetAmountShort)){
-		const largerSide = market.baseAssetAmountLong;
-		const smallerSide = market.baseAssetAmountShort;
-		cappedAltEst =feePoolSize.add(
-			smallerSide.mul(interpRateQuote).div(AMM_RESERVE_PRECISION))
-		.div(largerSide);
-	} else if(market.baseAssetAmountLong.lt(market.baseAssetAmountShort)){
-		const largerSide = market.baseAssetAmountShort;
-		const smallerSide = market.baseAssetAmountLong;
-		cappedAltEst = feePoolSize.add(
-			smallerSide.mul(interpRateQuote).div(AMM_RESERVE_PRECISION))
-		.div(largerSide);
+	let largerSide: BN;
+	let smallerSide: BN;
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+		largerSide = market.baseAssetAmountLong.abs();
+		smallerSide = market.baseAssetAmountShort.abs();
+		if(twapSpread.gt(new BN(0))) {
+			return [markTwapWithMantissa, oracleTwapWithMantissa, lowerboundEst, interpEst, interpEst];
+		}
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+		largerSide = market.baseAssetAmountShort.abs();
+		smallerSide = market.baseAssetAmountLong.abs();
+		if(twapSpread.lt(new BN(0))){
+			return [markTwapWithMantissa, oracleTwapWithMantissa, lowerboundEst, interpEst, interpEst];
+		}
 	} else{
+		return [markTwapWithMantissa, oracleTwapWithMantissa, lowerboundEst, interpEst, interpEst];
+	}
+
+	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);
+
+			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 = interpEst;
+		}
+	} else {
 		cappedAltEst = interpEst;
 	}
 
-	return [lowerboundEst, cappedAltEst, interpEst];
+
+	return [markTwapWithMantissa, oracleTwapWithMantissa, lowerboundEst, cappedAltEst, interpEst];
 }
 
 /**
@@ -112,8 +152,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
@@ -125,6 +169,33 @@ export async function calculateEstimatedFundingRate(
 	}
 }
 
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export async function calculateLongShortFundingRate(
+	market: Market,
+	pythClient: PythClient,
+	periodAdjustment: BN = new BN(1)
+): Promise<[BN, BN]> {
+	const [_1, _2, _, cappedAltEst, interpEst] = await calculateAllEstimatedFundingRate(
+		market,
+		pythClient,
+		periodAdjustment
+	);
+
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+		return [cappedAltEst, interpEst];
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+		return [interpEst, cappedAltEst];
+	} else {
+		return [interpEst, interpEst];
+	}
+}
 
 /**
  * 
@@ -134,20 +205,20 @@ export async function calculateEstimatedFundingRate(
  * @param estimationMethod 
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
- export async function calculateLongShortFundingRate(
+ export async function calculateLongShortFundingRateAndLiveTwaps(
 	market: Market,
 	pythClient: PythClient,
 	periodAdjustment: BN = new BN(1),
-): Promise<[BN, BN]> {
-	const [_, cappedAltEst, interpEst] = 
+): Promise<[BN, BN, BN, BN]> {
+	const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = 
 		await calculateAllEstimatedFundingRate(market, pythClient, periodAdjustment);
 
-	if(market.baseAssetAmountLong.gt(market.baseAssetAmountShort)){
-		return [cappedAltEst, interpEst];
-	} else if(market.baseAssetAmountLong.lt(market.baseAssetAmountShort)){
-		return [interpEst, cappedAltEst];
+	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 [interpEst, interpEst];
+		return [markTwapLive, oracleTwapLive, interpEst, interpEst];
 	}
 
 }
@@ -158,6 +229,7 @@ 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 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

@@ -12,6 +12,7 @@ import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
 	getSwapDirection,
+	AssetType,
 } from './amm';
 import { squareRootBN } from './utils';
 
@@ -27,7 +28,8 @@ export type PriceImpactUnit =
 	| 'quoteAssetAmount'
 	| 'quoteAssetAmountPeg'
 	| 'acquiredBaseAssetAmount'
-	| 'acquiredQuoteAssetAmount';
+	| 'acquiredQuoteAssetAmount'
+	| 'all';
 
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
@@ -47,7 +49,8 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market
+	market: Market,
+	inputAssetType: AssetType = 'quote'
 ): [BN, BN, BN, BN] {
 	const oldPrice = calculateMarkPrice(market);
 	if (amount.eq(ZERO)) {
@@ -56,7 +59,8 @@ export function calculateTradeSlippage(
 	const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(
 		direction,
 		amount,
-		market
+		market,
+		inputAssetType
 	);
 
 	const entryPrice = calculatePrice(
@@ -103,7 +107,8 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market
+	market: Market,
+	inputAssetType: AssetType = 'quote'
 ): [BN, BN] {
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO];
@@ -112,9 +117,9 @@ export function calculateTradeAcquiredAmounts(
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
-			'quote',
+			inputAssetType,
 			amount,
-			getSwapDirection('quote', direction)
+			getSwapDirection(inputAssetType, direction)
 		);
 
 	const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);

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;
@@ -264,6 +266,7 @@ export interface Trade {
 	afterPrice: number;
 	side: TradeSide;
 	size: number;
+	quoteSize: number;
 	ts: number;
 	fee: number;
 	marketIndex: number;
@@ -300,9 +303,14 @@ export type Candle = {
 };
 export interface FundingPayment {
 	userPublicKey: string;
-	ts: number;
+	serverTs: number;
 	marketIndex: number;
 	amount: string;
+	blockchainTs: number;
+	baseAssetAmount: string;
+	userLastCumulativeFunding: string;
+	userLastFundingRateTs: string;
+	rate: number;
 }
 
 // # Misc Types

package/tsconfig.json

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