@drift-labs/sdk 0.1.12 → 0.1.16

package/src/constants/numericConstants.ts

@@ -19,3 +19,5 @@ export const AMM_TO_QUOTE_PRECISION_RATIO =
 	AMM_RESERVE_PRECISION.div(QUOTE_PRECISION); // 10^7
 export const PRICE_TO_QUOTE_PRECISION =
 	MARK_PRICE_PRECISION.div(QUOTE_PRECISION);
+export const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO =
+	AMM_RESERVE_PRECISION.mul(PEG_PRECISION).div(QUOTE_PRECISION); // 10^10

package/src/examples/makeTradeExample.ts

@@ -1,4 +1,5 @@
-import { BN, Provider, Wallet } from '@project-serum/anchor';
+import { BN, Provider } from '@project-serum/anchor';
+import { Wallet } from '..';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {

package/src/idl/clearing_house.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0",
+  "version": "1.0.0",
   "name": "clearing_house",
   "instructions": [
     {
@@ -156,11 +156,11 @@
           "type": "u64"
         },
         {
-          "name": "ammBaseAssetAmount",
+          "name": "ammBaseAssetReserve",
           "type": "u128"
         },
         {
-          "name": "ammQuoteAssetAmount",
+          "name": "ammQuoteAssetReserve",
           "type": "u128"
         },
         {
@@ -759,7 +759,59 @@
         },
         {
           "name": "authority",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "rent",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "systemProgram",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "userNonce",
+          "type": "u8"
+        },
+        {
+          "name": "optionalAccounts",
+          "type": {
+            "defined": "InitializeUserOptionalAccounts"
+          }
+        }
+      ]
+    },
+    {
+      "name": "initializeUserWithExplicitPayer",
+      "accounts": [
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "state",
           "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "userPositions",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "payer",
+          "isMut": true,
           "isSigner": true
         },
         {
@@ -2573,197 +2625,197 @@
   ],
   "errors": [
     {
-      "code": 300,
+      "code": 6000,
       "name": "InvalidCollateralAccountAuthority",
       "msg": "Clearing house not collateral account owner"
     },
     {
-      "code": 301,
+      "code": 6001,
       "name": "InvalidInsuranceAccountAuthority",
       "msg": "Clearing house not insurance account owner"
     },
     {
-      "code": 302,
+      "code": 6002,
       "name": "InsufficientDeposit",
       "msg": "Insufficient deposit"
     },
     {
-      "code": 303,
+      "code": 6003,
       "name": "InsufficientCollateral",
       "msg": "Insufficient collateral"
     },
     {
-      "code": 304,
+      "code": 6004,
       "name": "SufficientCollateral",
       "msg": "Sufficient collateral"
     },
     {
-      "code": 305,
+      "code": 6005,
       "name": "MaxNumberOfPositions",
       "msg": "Max number of positions taken"
     },
     {
-      "code": 306,
+      "code": 6006,
       "name": "AdminControlsPricesDisabled",
       "msg": "Admin Controls Prices Disabled"
     },
     {
-      "code": 307,
+      "code": 6007,
       "name": "MarketIndexNotInitialized",
       "msg": "Market Index Not Initialized"
     },
     {
-      "code": 308,
+      "code": 6008,
       "name": "MarketIndexAlreadyInitialized",
       "msg": "Market Index Already Initialized"
     },
     {
-      "code": 309,
+      "code": 6009,
       "name": "UserAccountAndUserPositionsAccountMismatch",
       "msg": "User Account And User Positions Account Mismatch"
     },
     {
-      "code": 310,
+      "code": 6010,
       "name": "UserHasNoPositionInMarket",
       "msg": "User Has No Position In Market"
     },
     {
-      "code": 311,
+      "code": 6011,
       "name": "InvalidInitialPeg",
       "msg": "Invalid Initial Peg"
     },
     {
-      "code": 312,
+      "code": 6012,
       "name": "InvalidRepegRedundant",
       "msg": "AMM repeg already configured with amt given"
     },
     {
-      "code": 313,
+      "code": 6013,
       "name": "InvalidRepegDirection",
       "msg": "AMM repeg incorrect repeg direction"
     },
     {
-      "code": 314,
+      "code": 6014,
       "name": "InvalidRepegProfitability",
       "msg": "AMM repeg out of bounds pnl"
     },
     {
-      "code": 315,
+      "code": 6015,
       "name": "SlippageOutsideLimit",
       "msg": "Slippage Outside Limit Price"
     },
     {
-      "code": 316,
+      "code": 6016,
       "name": "TradeSizeTooSmall",
       "msg": "Trade Size Too Small"
     },
     {
-      "code": 317,
+      "code": 6017,
       "name": "InvalidUpdateK",
       "msg": "Price change too large when updating K"
     },
     {
-      "code": 318,
+      "code": 6018,
       "name": "AdminWithdrawTooLarge",
       "msg": "Admin tried to withdraw amount larger than fees collected"
     },
     {
-      "code": 319,
+      "code": 6019,
       "name": "MathError",
       "msg": "Math Error"
     },
     {
-      "code": 320,
+      "code": 6020,
       "name": "BnConversionError",
       "msg": "Conversion to u128/u64 failed with an overflow or underflow"
     },
     {
-      "code": 321,
+      "code": 6021,
       "name": "ClockUnavailable",
       "msg": "Clock unavailable"
     },
     {
-      "code": 322,
+      "code": 6022,
       "name": "UnableToLoadOracle",
       "msg": "Unable To Load Oracles"
     },
     {
-      "code": 323,
+      "code": 6023,
       "name": "OracleMarkSpreadLimit",
       "msg": "Oracle/Mark Spread Too Large"
     },
     {
-      "code": 324,
+      "code": 6024,
       "name": "HistoryAlreadyInitialized",
       "msg": "Clearing House history already initialized"
     },
     {
-      "code": 325,
+      "code": 6025,
       "name": "ExchangePaused",
       "msg": "Exchange is paused"
     },
     {
-      "code": 326,
+      "code": 6026,
       "name": "InvalidWhitelistToken",
       "msg": "Invalid whitelist token"
     },
     {
-      "code": 327,
+      "code": 6027,
       "name": "WhitelistTokenNotFound",
       "msg": "Whitelist token not found"
     },
     {
-      "code": 328,
+      "code": 6028,
       "name": "InvalidDiscountToken",
       "msg": "Invalid discount token"
     },
     {
-      "code": 329,
+      "code": 6029,
       "name": "DiscountTokenNotFound",
       "msg": "Discount token not found"
     },
     {
-      "code": 330,
+      "code": 6030,
       "name": "InvalidReferrer",
       "msg": "Invalid referrer"
     },
     {
-      "code": 331,
+      "code": 6031,
       "name": "ReferrerNotFound",
       "msg": "Referrer not found"
     },
     {
-      "code": 332,
+      "code": 6032,
       "name": "InvalidOracle",
       "msg": "InvalidOracle"
     },
     {
-      "code": 333,
+      "code": 6033,
       "name": "OracleNotFound",
       "msg": "OracleNotFound"
     },
     {
-      "code": 334,
+      "code": 6034,
       "name": "LiquidationsBlockedByOracle",
       "msg": "Liquidations Blocked By Oracle"
     },
     {
-      "code": 335,
+      "code": 6035,
       "name": "UserMaxDeposit",
       "msg": "Can not deposit more than max deposit"
     },
     {
-      "code": 336,
+      "code": 6036,
       "name": "CantDeleteUserWithCollateral",
       "msg": "Can not delete user that still has collateral"
     },
     {
-      "code": 337,
+      "code": 6037,
       "name": "InvalidFundingProfitability",
       "msg": "AMM funding out of bounds pnl"
     },
     {
-      "code": 338,
+      "code": 6038,
       "name": "CastingFailure",
       "msg": "Casting Failure"
     }

package/src/index.ts

@@ -4,7 +4,6 @@ export * from './mockUSDCFaucet';
 export * from './pythClient';
 export * from './types';
 export * from './constants/markets';
-export * from './accounts/defaultHistoryAccountSubscriber';
 export * from './accounts/defaultClearingHouseAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses';
@@ -13,13 +12,17 @@ export * from './clearingHouseUser';
 export * from './clearingHouse';
 export * from './math/conversion';
 export * from './math/funding';
+export * from './math/insuranceFund';
 export * from './math/market';
 export * from './math/position';
 export * from './math/amm';
 export * from './math/trade';
+export * from './wallet';
 export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './util/computeUnits';
+export * from './util/tps';
 
 export { BN };

package/src/math/amm.ts

@@ -1,12 +1,14 @@
 import { BN } from '@project-serum/anchor';
 import {
+	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
 	MARK_PRICE_PRECISION,
-	ONE,
 	PEG_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { AMM, PositionDirection, SwapDirection } from '../types';
+import { calculateBaseAssetValue } from './position';
+import { AMM, PositionDirection, SwapDirection, Market } from '../types';
 import { assert } from '../assert/assert';
+import { calculatePositionPNL, calculateMarkPrice, convertToNumber } from '..';
 
 /**
  * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
@@ -55,17 +57,9 @@ export function calculateAmmReservesAfterSwap(
 	let newBaseAssetReserve;
 
 	if (inputAssetType === 'quote') {
-		const swapAmountIntermediate = swapAmount.mul(MARK_PRICE_PRECISION);
-		swapAmount = swapAmountIntermediate.div(amm.pegMultiplier);
-
-		// Because ints round down by default, we need to add 1 back when removing from
-		// AMM to avoid giving users extra pnl when they short
-		const roundUp =
-			swapDirection === SwapDirection.REMOVE &&
-			!swapAmountIntermediate.mod(amm.pegMultiplier).eq(ZERO);
-		if (roundUp) {
-			swapAmount = swapAmount.add(ONE);
-		}
+		swapAmount = swapAmount
+			.mul(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+			.div(amm.pegMultiplier);
 
 		[newQuoteAssetReserve, newBaseAssetReserve] = calculateSwapOutput(
 			amm.quoteAssetReserve,
@@ -136,3 +130,116 @@ export function getSwapDirection(
 
 	return SwapDirection.ADD;
 }
+
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateAdjustKCost(
+	market: Market,
+	marketIndex: BN,
+	numerator: BN,
+	denomenator: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+
+	const marketNewK = Object.assign({}, market);
+	marketNewK.amm = Object.assign({}, market.amm);
+
+	marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
+		.mul(numerator)
+		.div(denomenator);
+	marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
+		.mul(numerator)
+		.div(denomenator);
+	marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
+
+	netUserPosition.quoteAssetAmount = currentValue;
+
+	const cost = calculatePositionPNL(marketNewK, netUserPosition);
+
+	return cost;
+}
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateRepegCost(
+	market: Market,
+	marketIndex: BN,
+	newPeg: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+	netUserPosition.quoteAssetAmount = currentValue;
+	const prevMarketPrice = calculateMarkPrice(market);
+	const marketNewPeg = Object.assign({}, market);
+	marketNewPeg.amm = Object.assign({}, market.amm);
+
+	// const marketNewPeg = JSON.parse(JSON.stringify(market));
+	marketNewPeg.amm.pegMultiplier = newPeg;
+
+	console.log(
+		'Price moves from',
+		convertToNumber(prevMarketPrice),
+		'to',
+		convertToNumber(calculateMarkPrice(marketNewPeg))
+	);
+
+	const cost = calculatePositionPNL(marketNewPeg, netUserPosition);
+
+	return cost;
+}
+
+/**
+ * Helper function calculating terminal price of amm
+ *
+ * @param market
+ * @returns cost : Precision MARK_PRICE_PRECISION
+ */
+export function calculateTerminalPrice(market: Market) {
+	if (!market.initialized) {
+		return new BN(0);
+	}
+
+	const directionToClose = market.baseAssetAmount.gt(ZERO)
+		? PositionDirection.SHORT
+		: PositionDirection.LONG;
+
+	const [newQuoteAssetReserve, newBaseAssetReserve] =
+		calculateAmmReservesAfterSwap(
+			market.amm,
+			'base',
+			market.baseAssetAmount.abs(),
+			getSwapDirection('base', directionToClose)
+		);
+	const terminalPrice = newQuoteAssetReserve
+		.mul(MARK_PRICE_PRECISION)
+		.mul(market.amm.pegMultiplier)
+		.div(PEG_PRECISION)
+		.div(newBaseAssetReserve);
+
+	return terminalPrice;
+}

package/src/math/funding.ts

@@ -1,11 +1,11 @@
 import { BN } from '@project-serum/anchor';
+import { PriceData } from '@pythnetwork/client';
 import {
 	AMM_RESERVE_PRECISION,
 	MARK_PRICE_PRECISION,
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { PythClient } from '../pythClient';
 import { Market } from '../types';
 import { calculateMarkPrice } from './market';
 
@@ -18,7 +18,7 @@ import { calculateMarkPrice } from './market';
  */
 export async function calculateAllEstimatedFundingRate(
 	market: Market,
-	pythClient: PythClient,
+	oraclePriceData: PriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
 	// periodAdjustment
@@ -64,16 +64,40 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour,
 		secondsInHour.sub(timeSinceLastOracleTwapUpdate)
 	);
-	const oraclePriceData = await pythClient.getPriceData(market.amm.oracle);
+
+	// verify pyth input is positive for live update
+	let oracleStablePriceNum = 0;
+	let oracleInputCount = 0;
+	if (oraclePriceData.price >= 0) {
+		oracleStablePriceNum += oraclePriceData.price;
+		oracleInputCount += 1;
+	}
+	if (oraclePriceData.previousPrice >= 0) {
+		oracleStablePriceNum += oraclePriceData.previousPrice;
+		oracleInputCount += 1;
+	}
+
+	oracleStablePriceNum = oracleStablePriceNum / oracleInputCount;
 	const oraclePriceStableWithMantissa = new BN(
-		((oraclePriceData.price + oraclePriceData.previousPrice) / 2) *
-			MARK_PRICE_PRECISION.toNumber()
+		oracleStablePriceNum * MARK_PRICE_PRECISION.toNumber()
 	);
 
-	const oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
-		.mul(lastOracleTwapWithMantissa)
-		.add(timeSinceLastMarkChange.mul(oraclePriceStableWithMantissa))
-		.div(timeSinceLastOracleTwapUpdate.add(oracleTwapTimeSinceLastUpdate));
+	let oracleTwapWithMantissa = lastOracleTwapWithMantissa;
+
+	const oracleLiveVsTwap = oraclePriceStableWithMantissa
+		.sub(lastOracleTwapWithMantissa)
+		.abs()
+		.mul(MARK_PRICE_PRECISION)
+		.mul(new BN(100))
+		.div(lastOracleTwapWithMantissa);
+
+	// verify pyth live input is within 10% of last twap for live update
+	if (oracleLiveVsTwap.lte(MARK_PRICE_PRECISION.mul(new BN(10)))) {
+		oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
+			.mul(lastOracleTwapWithMantissa)
+			.add(timeSinceLastMarkChange.mul(oraclePriceStableWithMantissa))
+			.div(timeSinceLastOracleTwapUpdate.add(oracleTwapTimeSinceLastUpdate));
+	}
 
 	const twapSpread = markTwapWithMantissa.sub(oracleTwapWithMantissa);
 
@@ -139,22 +163,20 @@ export async function calculateAllEstimatedFundingRate(
 	}
 
 	if (largerSide.gt(ZERO)) {
-		cappedAltEst = smallerSide.mul(twapSpread).div(largerSide);
-
+		// funding smaller flow
+		cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
 		const feePoolTopOff = feePoolSize
 			.mul(MARK_PRICE_PRECISION.div(QUOTE_PRECISION))
-			.mul(AMM_RESERVE_PRECISION)
-			.div(largerSide);
-
-		cappedAltEst = cappedAltEst.add(feePoolTopOff);
+			.mul(AMM_RESERVE_PRECISION);
+		cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
 
 		cappedAltEst = cappedAltEst
 			.mul(MARK_PRICE_PRECISION)
 			.mul(new BN(100))
 			.div(oracleTwapWithMantissa)
-			.mul(periodAdjustment)
-			.div(hoursInDay);
-		if (cappedAltEst.abs().gt(interpEst.abs())) {
+			.mul(periodAdjustment);
+
+		if (cappedAltEst.abs().gte(interpEst.abs())) {
 			cappedAltEst = interpEst;
 		}
 	} else {
@@ -173,21 +195,21 @@ export async function calculateAllEstimatedFundingRate(
 /**
  *
  * @param market
- * @param pythClient
+ * @param oraclePriceData
  * @param periodAdjustment
  * @param estimationMethod
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateEstimatedFundingRate(
 	market: Market,
-	pythClient: PythClient,
+	oraclePriceData: PriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod: 'interpolated' | 'lowerbound' | 'capped'
 ): Promise<BN> {
 	const [_1, _2, lowerboundEst, cappedAltEst, interpEst] =
 		await calculateAllEstimatedFundingRate(
 			market,
-			pythClient,
+			oraclePriceData,
 			periodAdjustment
 		);
 
@@ -211,13 +233,13 @@ export async function calculateEstimatedFundingRate(
  */
 export async function calculateLongShortFundingRate(
 	market: Market,
-	pythClient: PythClient,
+	oraclePriceData: PriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
 	const [_1, _2, _, cappedAltEst, interpEst] =
 		await calculateAllEstimatedFundingRate(
 			market,
-			pythClient,
+			oraclePriceData,
 			periodAdjustment
 		);
 
@@ -240,13 +262,13 @@ export async function calculateLongShortFundingRate(
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
 	market: Market,
-	pythClient: PythClient,
+	oraclePriceData: PriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
 	const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] =
 		await calculateAllEstimatedFundingRate(
 			market,
-			pythClient,
+			oraclePriceData,
 			periodAdjustment
 		);