@drift-labs/sdk 0.1.6 → 0.1.10

package/src/constants/markets.ts

@@ -16,25 +16,32 @@ export const Markets: Market[] = [
 		devnetPythOracle: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
 		mainnetPythOracle: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
 	},
-	// {
-	// 	symbol: 'BTC-PERP',
-	// 	baseAssetSymbol: 'BTC',
-	// 	marketIndex: new BN(1),
-	// 	devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
-	// 	mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
-	// },
-	// {
-	// 	symbol: 'ETH-PERP',
-	// 	baseAssetSymbol: 'ETH',
-	// 	marketIndex: new BN(2),
-	// 	devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
-	// 	mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
-	// },
-	// {
-	// 	symbol: 'COPE-PERP',
-	// 	baseAssetSymbol: 'COPE',
-	// 	marketIndex: new BN(3),
-	// 	devnetPythOracle: 'BAXDJUXtz6P5ARhHH1aPwgv4WENzHwzyhmLYK4daFwiM',
-	// 	mainnetPythOracle: '9xYBiDWYsh2fHzpsz3aaCnNHCKWBNtfEDLtU6kS4aFD9',
-	// },
+	{
+		symbol: 'BTC-PERP',
+		baseAssetSymbol: 'BTC',
+		marketIndex: new BN(1),
+		devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
+		mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
+	},
+	{
+		symbol: 'ETH-PERP',
+		baseAssetSymbol: 'ETH',
+		marketIndex: new BN(2),
+		devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
+		mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
+	},
+	{
+		symbol: 'LUNA-PERP',
+		baseAssetSymbol: 'LUNA',
+		marketIndex: new BN(3),
+		devnetPythOracle: '8PugCXTAHLM9kfLSQWe2njE5pzAgUdpPk3Nx5zSm7BD3',
+		mainnetPythOracle: '5bmWuR1dgP4avtGYMNKLuxumZTVKGgoN2BCMXWDNL9nY',
+	},
+	{
+		symbol: 'AVAX-PERP',
+		baseAssetSymbol: 'AVAX',
+		marketIndex: new BN(4),
+		devnetPythOracle: 'FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz',
+		mainnetPythOracle: 'Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU',
+	},
 ];

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",
@@ -2757,6 +2761,11 @@
       "code": 337,
       "name": "InvalidFundingProfitability",
       "msg": "AMM funding out of bounds pnl"
+    },
+    {
+      "code": 338,
+      "name": "CastingFailure",
+      "msg": "Casting Failure"
     }
   ]
 }

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,
+} from '../constants/numericConstants';
 import { PythClient } from '../pythClient';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
 import { Market } from '../types';
 import { calculateMarkPrice } from './market';
 
 /**
- * 
- * @param market 
- * @param pythClient 
- * @param periodAdjustment 
- * @param estimationMethod 
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export async function calculateEstimatedFundingRate(
+export async function calculateAllEstimatedFundingRate(
 	market: Market,
 	pythClient: PythClient,
-	periodAdjustment: BN = new BN(1),
-	estimationMethod: 'interpolated' | 'lowerbound'
-): Promise<BN> {
+	periodAdjustment: BN = new BN(1)
+): Promise<[BN, BN, BN, BN, BN]> {
 	// periodAdjustment
 	// 	1: hourly
 	//  24: daily
@@ -26,34 +29,43 @@ export async function calculateEstimatedFundingRate(
 	const hoursInDay = new BN(24);
 
 	if (!market.initialized) {
-		return 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,16 +73,164 @@ export async function calculateEstimatedFundingRate(
 		.mul(new BN(100))
 		.div(oracleTwapWithMantissa);
 
-	if (estimationMethod == 'lowerbound') {
-		//assuming remaining funding period has no gap
-		return twapSpreadPct
-			.mul(payFreq)
-			.mul(BN.min(secondsInHour, timeSinceLastUpdate))
+	const lowerboundEst = twapSpreadPct
+		.mul(payFreq)
+		.mul(BN.min(secondsInHour, timeSinceLastUpdate))
+		.mul(periodAdjustment)
+		.div(secondsInHour)
+		.div(secondsInHour)
+		.div(hoursInDay);
+
+	const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+
+	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;
+	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(secondsInHour)
-			.div(secondsInHour)
 			.div(hoursInDay);
+		if (cappedAltEst.abs().gt(interpEst.abs())) {
+			cappedAltEst = interpEst;
+		}
 	} else {
-		return twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+		cappedAltEst = interpEst;
 	}
+
+
+	return [markTwapWithMantissa, oracleTwapWithMantissa, lowerboundEst, cappedAltEst, interpEst];
+}
+
+/**
+ *
+ * @param market
+ * @param pythClient
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+export async function calculateEstimatedFundingRate(
+	market: Market,
+	pythClient: PythClient,
+	periodAdjustment: BN = new BN(1),
+	estimationMethod: 'interpolated' | 'lowerbound' | 'capped'
+): Promise<BN> {
+	const [_1, _2, lowerboundEst, cappedAltEst, interpEst] =
+		await calculateAllEstimatedFundingRate(
+			market,
+			pythClient,
+			periodAdjustment
+		);
+
+	if (estimationMethod == 'lowerbound') {
+		//assuming remaining funding period has no gap
+		return lowerboundEst;
+	} else if (estimationMethod == 'capped') {
+		return cappedAltEst;
+	} else {
+		return interpEst;
+	}
+}
+
+/**
+ *
+ * @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];
+	}
+}
+
+/**
+ * 
+ * @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];
+	}
+
+}
+
+/**
+ *
+ * @param market
+ * @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

@@ -102,9 +102,9 @@ export function calculatePositionPNL(
 }
 
 /**
- * 
- * @param market 
- * @param marketPosition 
+ *
+ * @param market
+ * @param marketPosition
  * @returns // TODO-PRECISION
  */
 export function calculatePositionFundingPNL(

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);
@@ -129,8 +134,8 @@ export function calculateTradeAcquiredAmounts(
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.
- * @returns trade direction/size in order to push price to a targetPrice, 
- * 
+ * @returns trade direction/size in order to push price to a targetPrice,
+ *
  * [
  *   direction => direction of trade required, TODO-PRECISION
  *   tradeSize => size of trade required, TODO-PRECISION
@@ -236,6 +241,7 @@ export function calculateTargetPriceTrade(
 
 	const entryPrice = tradeSize
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.mul(MARK_PRICE_PRECISION)
 		.div(baseSize.abs());
 
 	assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');

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,7 +266,9 @@ export interface Trade {
 	afterPrice: number;
 	side: TradeSide;
 	size: number;
+	quoteSize: number;
 	ts: number;
+	fee: number;
 	marketIndex: number;
 	chainTs: number;
 }
@@ -299,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"]