@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.14

package/src/clearingHouseConfig.ts

@@ -18,6 +18,7 @@ export type ClearingHouseConfig = {
 	bankIndexes?: BN[];
 	oracleInfos?: OracleInfo[];
 	env?: DriftEnv;
+	userStats?: boolean;
 };
 
 type ClearingHouseSubscriptionConfig =

package/src/clearingHouseUser.ts

@@ -21,6 +21,7 @@ import {
 	PRICE_TO_QUOTE_PRECISION,
 	MARGIN_PRECISION,
 	BANK_WEIGHT_PRECISION,
+	BANK_BALANCE_PRECISION_EXP,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -32,17 +33,26 @@ import {
 	calculateBaseAssetValue,
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
+	calculateUnsettledAssetWeight,
+	calculateMarketMarginRatio,
 	PositionDirection,
 	calculateTradeSlippage,
 	BN,
 	BankAccount,
 } from '.';
-import { getTokenAmount } from './math/bankBalance';
+import {
+	getTokenAmount,
+	calculateAssetWeight,
+	calculateLiabilityWeight,
+} from './math/bankBalance';
+import {
+	calculateMarginBaseAssetValue,
+	calculateWorstCaseBaseAssetAmount,
+} from './math/margin';
 import { OraclePriceData } from './oracles/types';
 import { ClearingHouseUserConfig } from './clearingHouseUserConfig';
 import { PollingUserAccountSubscriber } from './accounts/pollingUserAccountSubscriber';
 import { WebSocketUserAccountSubscriber } from './accounts/webSocketUserAccountSubscriber';
-
 export class ClearingHouseUser {
 	clearingHouse: ClearingHouse;
 	userAccountPublicKey: PublicKey;
@@ -124,9 +134,13 @@ export class ClearingHouseUser {
 			quoteAssetAmount: ZERO,
 			quoteEntryAmount: ZERO,
 			openOrders: ZERO,
-			unsettledPnl: ZERO,
 			openBids: ZERO,
 			openAsks: ZERO,
+			realizedPnl: ZERO,
+			lpShares: ZERO,
+			lastFeePerLp: ZERO,
+			lastNetBaseAssetAmountPerLp: ZERO,
+			lastNetQuoteAssetAmountPerLp: ZERO,
 		};
 	}
 
@@ -162,6 +176,98 @@ export class ClearingHouseUser {
 		return userAccountRPCResponse.value !== null;
 	}
 
+	/**
+	 * calculates the market position if the lp position was settled
+	 * @returns : userPosition
+	 */
+	public getSettledLPPosition(marketIndex: BN): [UserPosition, BN] {
+		const position = this.getUserPosition(marketIndex);
+		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
+		const nShares = position.lpShares;
+
+		const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
+			.sub(position.lastNetBaseAssetAmountPerLp)
+			.mul(nShares)
+			.div(AMM_RESERVE_PRECISION);
+		const deltaQaa = market.amm.marketPositionPerLp.quoteAssetAmount
+			.sub(position.lastNetQuoteAssetAmountPerLp)
+			.mul(nShares)
+			.div(AMM_RESERVE_PRECISION);
+
+		function sign(v: BN) {
+			const sign = { true: new BN(1), false: new BN(-1) }[
+				v.gte(ZERO).toString()
+			];
+			return sign;
+		}
+
+		const remainder = deltaBaa
+			.abs()
+			.mod(market.amm.baseAssetAmountStepSize)
+			.mul(sign(deltaBaa));
+		const _standardizedBaa = deltaBaa.sub(remainder);
+
+		let remainderBaa;
+		if (_standardizedBaa.abs().gte(market.amm.baseAssetAmountStepSize)) {
+			remainderBaa = remainder;
+		} else {
+			remainderBaa = deltaBaa;
+		}
+		const standardizedBaa = deltaBaa.sub(remainderBaa);
+
+		const reaminderPerLP = remainderBaa.mul(AMM_RESERVE_PRECISION).div(nShares);
+
+		position.baseAssetAmount = position.baseAssetAmount.add(standardizedBaa);
+		position.quoteAssetAmount = position.quoteAssetAmount.add(deltaQaa);
+
+		position.lastNetBaseAssetAmountPerLp =
+			market.amm.marketPositionPerLp.baseAssetAmount.sub(reaminderPerLP);
+
+		let updateType;
+		if (position.baseAssetAmount.eq(ZERO)) {
+			updateType = 'open';
+		} else if (sign(position.baseAssetAmount).eq(sign(deltaBaa))) {
+			updateType = 'increase';
+		} else if (position.baseAssetAmount.abs().gt(deltaBaa.abs())) {
+			updateType = 'reduce';
+		} else if (position.baseAssetAmount.abs().eq(deltaBaa.abs())) {
+			updateType = 'close';
+		} else {
+			updateType = 'flip';
+		}
+
+		let newQuoteEntry;
+		let pnl;
+		if (updateType == 'open' || updateType == 'increase') {
+			newQuoteEntry = position.quoteEntryAmount.add(deltaQaa);
+			pnl = 0;
+		} else if (updateType == 'reduce' || updateType == 'close') {
+			newQuoteEntry = position.quoteEntryAmount.sub(
+				position.quoteEntryAmount
+					.mul(deltaBaa.abs())
+					.div(position.baseAssetAmount.abs())
+			);
+			pnl = position.quoteEntryAmount.sub(newQuoteEntry);
+		} else {
+			newQuoteEntry = deltaQaa.sub(
+				deltaQaa.mul(position.baseAssetAmount.abs()).div(deltaBaa.abs())
+			);
+			pnl = position.quoteEntryAmount.add(deltaQaa.sub(newQuoteEntry));
+		}
+		position.quoteEntryAmount = newQuoteEntry;
+
+		if (position.baseAssetAmount.gt(ZERO)) {
+			position.lastCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+		} else if (position.baseAssetAmount.lt(ZERO)) {
+			position.lastCumulativeFundingRate =
+				market.amm.cumulativeFundingRateShort;
+		} else {
+			position.lastCumulativeFundingRate = ZERO;
+		}
+
+		return [position, pnl];
+	}
+
 	/**
 	 * calculates Buying Power = FC * MAX_LEVERAGE
 	 * @returns : Precision QUOTE_PRECISION
@@ -184,26 +290,43 @@ export class ClearingHouseUser {
 	}
 
 	public getInitialMarginRequirement(): BN {
-		return this.getUserAccount()
-			.positions.reduce((marginRequirement, marketPosition) => {
+		const postionMarginRequirement = this.getUserAccount().positions.reduce(
+			(marginRequirement, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return marginRequirement.add(
-					calculateBaseAssetValue(
+				const worstCaseBaseAssetAmount =
+					calculateWorstCaseBaseAssetAmount(marketPosition);
+
+				const worstCaseAssetValue = worstCaseBaseAssetAmount
+					.abs()
+					.mul(this.getOracleDataForMarket(market.marketIndex).price)
+					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
+				const marketMarginRatio = new BN(
+					calculateMarketMarginRatio(
 						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
+						worstCaseBaseAssetAmount.abs(),
+						'Initial'
 					)
-						.mul(new BN(market.marginRatioInitial))
-						.div(MARGIN_PRECISION)
 				);
-			}, ZERO)
-			.add(this.getTotalLiability());
+				return marginRequirement.add(
+					worstCaseAssetValue.mul(marketMarginRatio).div(MARGIN_PRECISION)
+				);
+			},
+			ZERO
+		);
+
+		const bankMarginRequirement = this.getBankLiabilityValue(
+			undefined,
+			'Initial'
+		);
+
+		return bankMarginRequirement.add(postionMarginRequirement);
 	}
 
 	/**
-	 * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
 	 */
 	public getMaintenanceMarginRequirement(): BN {
 		return this.getUserAccount()
@@ -211,24 +334,40 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
+				const worstCaseBaseAssetAmount =
+					calculateWorstCaseBaseAssetAmount(marketPosition);
+
+				const worstCaseAssetValue = worstCaseBaseAssetAmount
+					.abs()
+					.mul(this.getOracleDataForMarket(market.marketIndex).price)
+					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
 				return marginRequirement.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
-						.mul(new BN(market.marginRatioMaintenance))
+					worstCaseAssetValue
+						.mul(
+							new BN(
+								calculateMarketMarginRatio(
+									market,
+									worstCaseBaseAssetAmount.abs(),
+									'Maintenance'
+								)
+							)
+						)
 						.div(MARGIN_PRECISION)
 				);
 			}, ZERO)
-			.add(this.getTotalLiability());
+			.add(this.getBankLiabilityValue(undefined, 'Maintenance'));
 	}
 
 	/**
 	 * calculates unrealized position price pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN {
+	public getUnrealizedPNL(
+		withFunding?: boolean,
+		marketIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount()
 			.positions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
@@ -237,28 +376,28 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return pnl.add(
-					calculatePositionPNL(
-						market,
-						marketPosition,
-						withFunding,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
+				let pnl0 = calculatePositionPNL(
+					market,
+					marketPosition,
+					withFunding,
+					this.getOracleDataForMarket(market.marketIndex)
 				);
-			}, ZERO);
-	}
 
-	/**
-	 * calculates unrealized position price pnl
-	 * @returns : Precision QUOTE_PRECISION
-	 */
-	public getUnsettledPNL(marketIndex?: BN): BN {
-		return this.getUserAccount()
-			.positions.filter((pos) =>
-				marketIndex ? pos.marketIndex === marketIndex : true
-			)
-			.reduce((pnl, marketPosition) => {
-				return pnl.add(marketPosition.unsettledPnl);
+				if (withWeightMarginCategory !== undefined) {
+					if (pnl0.gt(ZERO)) {
+						pnl0 = pnl0
+							.mul(
+								calculateUnsettledAssetWeight(
+									market,
+									pnl0,
+									withWeightMarginCategory
+								)
+							)
+							.div(new BN(BANK_WEIGHT_PRECISION));
+					}
+				}
+
+				return pnl.add(pnl0);
 			}, ZERO);
 	}
 
@@ -279,14 +418,18 @@ export class ClearingHouseUser {
 			}, ZERO);
 	}
 
-	public getTotalLiability(): BN {
+	public getBankLiabilityValue(
+		bankIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount().bankBalances.reduce(
-			(totalAssetValue, bankBalance) => {
+			(totalLiabilityValue, bankBalance) => {
 				if (
 					bankBalance.balance.eq(ZERO) ||
-					isVariant(bankBalance.balanceType, 'deposit')
+					isVariant(bankBalance.balanceType, 'deposit') ||
+					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
 				) {
-					return totalAssetValue;
+					return totalLiabilityValue;
 				}
 
 				// Todo this needs to account for whether it's based on initial or maintenance requirements
@@ -299,23 +442,42 @@ export class ClearingHouseUser {
 					bankAccount,
 					bankBalance.balanceType
 				);
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.mul(bankAccount.initialLiabilityWeight)
-						.div(BANK_WEIGHT_PRECISION)
-						.div(MARK_PRICE_PRECISION)
-				);
+
+				let liabilityValue = tokenAmount
+					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.div(MARK_PRICE_PRECISION)
+					.div(
+						new BN(10).pow(
+							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+						)
+					);
+
+				if (withWeightMarginCategory !== undefined) {
+					const weight = calculateLiabilityWeight(
+						tokenAmount,
+						bankAccount,
+						withWeightMarginCategory
+					);
+					liabilityValue = liabilityValue
+						.mul(weight)
+						.div(BANK_WEIGHT_PRECISION);
+				}
+
+				return totalLiabilityValue.add(liabilityValue);
 			},
 			ZERO
 		);
 	}
 
-	public getCollateralValue(bankIndex?: BN): BN {
+	public getBankAssetValue(
+		bankIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount().bankBalances.reduce(
 			(totalAssetValue, bankBalance) => {
 				if (
 					bankBalance.balance.eq(ZERO) ||
+					isVariant(bankBalance.balanceType, 'borrow') ||
 					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
 				) {
 					return totalAssetValue;
@@ -326,32 +488,46 @@ export class ClearingHouseUser {
 					bankBalance.bankIndex
 				);
 
-				let tokenAmount = getTokenAmount(
+				const tokenAmount = getTokenAmount(
 					bankBalance.balance,
 					bankAccount,
 					bankBalance.balanceType
 				);
 
-				if (isVariant(bankBalance.balanceType, 'borrow')) {
-					tokenAmount = tokenAmount.mul(new BN(-1));
+				let assetValue = tokenAmount
+					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.div(MARK_PRICE_PRECISION)
+					.div(
+						new BN(10).pow(
+							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+						)
+					);
+				if (withWeightMarginCategory !== undefined) {
+					const weight = calculateAssetWeight(
+						tokenAmount,
+						bankAccount,
+						withWeightMarginCategory
+					);
+					assetValue = assetValue.mul(weight).div(BANK_WEIGHT_PRECISION);
 				}
 
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.div(MARK_PRICE_PRECISION)
-				);
+				return totalAssetValue.add(assetValue);
 			},
 			ZERO
 		);
 	}
 
+	public getNetBankValue(withWeightMarginCategory?: MarginCategory): BN {
+		return this.getBankAssetValue(undefined, withWeightMarginCategory).sub(
+			this.getBankLiabilityValue(undefined, withWeightMarginCategory)
+		);
+	}
+
 	/**
 	 * calculates TotalCollateral: collateral + unrealized pnl
-	 * TODO: rename to total equity (for perpetuals swaps)
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getTotalCollateral(): BN {
+	public getTotalCollateral(marginCategory: MarginCategory = 'Initial'): BN {
 		return this.getUserAccount()
 			.bankBalances.reduce((totalAssetValue, bankBalance) => {
 				if (
@@ -371,20 +547,32 @@ export class ClearingHouseUser {
 					bankAccount,
 					bankBalance.balanceType
 				);
+
+				const weight = calculateAssetWeight(
+					tokenAmount,
+					bankAccount,
+					marginCategory
+				);
+
 				return totalAssetValue.add(
 					tokenAmount
 						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.mul(bankAccount.initialAssetWeight)
+						.mul(weight)
 						.div(BANK_WEIGHT_PRECISION)
 						.div(MARK_PRICE_PRECISION)
+						// Adjust for decimals of bank account
+						.div(
+							new BN(10).pow(
+								new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+							)
+						)
 				);
 			}, ZERO)
-			.add(this.getUnrealizedPNL(true))
-			.add(this.getUnsettledPNL());
+			.add(this.getUnrealizedPNL(true, undefined, marginCategory));
 	}
 
 	/**
-	 * calculates sum of position value across all positions
+	 * calculates sum of position value across all positions in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	getTotalPositionValue(): BN {
@@ -393,20 +581,20 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return positionValue.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
+				const posVal = calculateMarginBaseAssetValue(
+					market,
+					marketPosition,
+					this.getOracleDataForMarket(market.marketIndex)
 				);
+
+				return positionValue.add(posVal);
 			},
 			ZERO
 		);
 	}
 
 	/**
-	 * calculates position value from closing 100%
+	 * calculates position value in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getPositionValue(
@@ -418,7 +606,7 @@ export class ClearingHouseUser {
 		const market = this.clearingHouse.getMarketAccount(
 			userPosition.marketIndex
 		);
-		return calculateBaseAssetValue(market, userPosition, oraclePriceData);
+		return calculateMarginBaseAssetValue(market, userPosition, oraclePriceData);
 	}
 
 	public getPositionSide(
@@ -434,12 +622,13 @@ export class ClearingHouseUser {
 	}
 
 	/**
-	 * calculates average exit price for closing 100% of position
+	 * calculates average exit price (optionally for closing up to 100% of position)
 	 * @returns : Precision MARK_PRICE_PRECISION
 	 */
 	public getPositionEstimatedExitPriceAndPnl(
 		position: UserPosition,
-		amountToClose?: BN
+		amountToClose?: BN,
+		useAMMClose = false
 	): [BN, BN] {
 		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
 
@@ -459,11 +648,21 @@ export class ClearingHouseUser {
 			} as UserPosition;
 		}
 
-		const baseAssetValue = calculateBaseAssetValue(
-			market,
-			position,
-			oraclePriceData
-		);
+		let baseAssetValue: BN;
+
+		if (useAMMClose) {
+			baseAssetValue = calculateBaseAssetValue(
+				market,
+				position,
+				oraclePriceData
+			);
+		} else {
+			baseAssetValue = calculateMarginBaseAssetValue(
+				market,
+				position,
+				oraclePriceData
+			);
+		}
 		if (position.baseAssetAmount.eq(ZERO)) {
 			return [ZERO, ZERO];
 		}
@@ -505,19 +704,13 @@ export class ClearingHouseUser {
 		category: MarginCategory = 'Initial'
 	): BN {
 		const market = this.clearingHouse.getMarketAccount(marketIndex);
-		let marginRatioCategory: number;
-
-		switch (category) {
-			case 'Initial':
-				marginRatioCategory = market.marginRatioInitial;
-				break;
-			case 'Maintenance':
-				marginRatioCategory = market.marginRatioMaintenance;
-				break;
-			default:
-				marginRatioCategory = market.marginRatioInitial;
-				break;
-		}
+
+		const marginRatioCategory = calculateMarketMarginRatio(
+			market,
+			// worstCaseBaseAssetAmount.abs(),
+			ZERO, // todo
+			category
+		);
 		const maxLeverage = TEN_THOUSAND.mul(TEN_THOUSAND).div(
 			new BN(marginRatioCategory)
 		);
@@ -619,14 +812,17 @@ export class ClearingHouseUser {
 		const proposedMarketPosition: UserPosition = {
 			marketIndex: marketPosition.marketIndex,
 			baseAssetAmount: proposedBaseAssetAmount,
-			lastCumulativeFundingRate:
-				currentMarketPosition.lastCumulativeFundingRate,
 			quoteAssetAmount: new BN(0),
+			lastCumulativeFundingRate: ZERO,
 			quoteEntryAmount: new BN(0),
 			openOrders: new BN(0),
-			unsettledPnl: new BN(0),
 			openBids: new BN(0),
 			openAsks: new BN(0),
+			realizedPnl: ZERO,
+			lpShares: ZERO,
+			lastFeePerLp: ZERO,
+			lastNetBaseAssetAmountPerLp: ZERO,
+			lastNetQuoteAssetAmountPerLp: ZERO,
 		};
 
 		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);
@@ -635,7 +831,7 @@ export class ClearingHouseUser {
 			proposedMarketPosition.marketIndex
 		);
 
-		const proposedMarketPositionValue = calculateBaseAssetValue(
+		const proposedMarketPositionValue = calculateMarginBaseAssetValue(
 			market,
 			proposedMarketPosition,
 			this.getOracleDataForMarket(market.marketIndex)
@@ -652,13 +848,21 @@ export class ClearingHouseUser {
 						const market = this.clearingHouse.getMarketAccount(
 							position.marketIndex
 						);
-						const positionValue = calculateBaseAssetValue(
+						const positionValue = calculateMarginBaseAssetValue(
 							market,
 							position,
 							this.getOracleDataForMarket(market.marketIndex)
 						);
 						const marketMarginRequirement = positionValue
-							.mul(new BN(market.marginRatioMaintenance))
+							.mul(
+								new BN(
+									calculateMarketMarginRatio(
+										market,
+										position.baseAssetAmount.abs(),
+										'Maintenance'
+									)
+								)
+							)
 							.div(MARGIN_PRECISION);
 						totalMarginRequirement = totalMarginRequirement.add(
 							marketMarginRequirement
@@ -684,7 +888,15 @@ export class ClearingHouseUser {
 		const marginRequirementAfterTrade =
 			marginRequirementExcludingTargetMarket.add(
 				proposedMarketPositionValue
-					.mul(new BN(market.marginRatioMaintenance))
+					.mul(
+						new BN(
+							calculateMarketMarginRatio(
+								market,
+								proposedMarketPosition.baseAssetAmount.abs(),
+								'Maintenance'
+							)
+						)
+					)
 					.div(MARGIN_PRECISION)
 			);
 		const freeCollateralAfterTrade = totalCollateral.sub(
@@ -755,11 +967,11 @@ export class ClearingHouseUser {
 
 		const closeBaseAmount = currentPosition.baseAssetAmount
 			.mul(closeQuoteAmount)
-			.div(currentPosition.quoteAssetAmount)
+			.div(currentPosition.quoteAssetAmount.abs())
 			.add(
 				currentPosition.baseAssetAmount
 					.mul(closeQuoteAmount)
-					.mod(currentPosition.quoteAssetAmount)
+					.mod(currentPosition.quoteAssetAmount.abs())
 			)
 			.neg();