@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.2

package/src/clearingHouseUser.ts

@@ -6,16 +6,10 @@ import {
 	isVariant,
 	MarginCategory,
 	Order,
-	SettlementStateAccount,
 	UserAccount,
-	UserOrdersAccount,
 	UserPosition,
-	UserPositionsAccount,
 } from './types';
-import {
-	calculateEntryPrice,
-	calculateSettledPositionPNL,
-} from './math/position';
+import { calculateEntryPrice } from './math/position';
 import {
 	MARK_PRICE_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -26,30 +20,33 @@ import {
 	AMM_RESERVE_PRECISION,
 	PRICE_TO_QUOTE_PRECISION,
 	MARGIN_PRECISION,
+	BANK_WEIGHT_PRECISION,
 } from './constants/numericConstants';
-import { UserAccountSubscriber, UserAccountEvents } from './accounts/types';
+import {
+	UserAccountSubscriber,
+	UserAccountEvents,
+	DataAndSlot,
+} from './accounts/types';
 import {
 	calculateMarkPrice,
 	calculateBaseAssetValue,
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
 	PositionDirection,
-	getUserOrdersAccountPublicKey,
 	calculateTradeSlippage,
 	BN,
+	BankAccount,
 } from '.';
-import { getUserAccountPublicKey } from './addresses';
-import {
-	getClearingHouseUser,
-	getWebSocketClearingHouseUserConfig,
-} from './factory/clearingHouseUser';
+import { getTokenAmount } from './math/bankBalance';
+import { OraclePriceData } from './oracles/types';
+import { ClearingHouseUserConfig } from './clearingHouseUserConfig';
+import { PollingUserAccountSubscriber } from './accounts/pollingUserAccountSubscriber';
+import { WebSocketUserAccountSubscriber } from './accounts/webSocketUserAccountSubscriber';
 
 export class ClearingHouseUser {
 	clearingHouse: ClearingHouse;
-	authority: PublicKey;
+	userAccountPublicKey: PublicKey;
 	accountSubscriber: UserAccountSubscriber;
-	userAccountPublicKey?: PublicKey;
-	userOrdersAccountPublicKey?: PublicKey;
 	_isSubscribed = false;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 
@@ -61,34 +58,21 @@ export class ClearingHouseUser {
 		this._isSubscribed = val;
 	}
 
-	/**
-	 * @deprecated You should use getClearingHouseUser factory method instead
-	 * @param clearingHouse
-	 * @param authority
-	 * @returns
-	 */
-	public static from(
-		clearingHouse: ClearingHouse,
-		authority: PublicKey
-	): ClearingHouseUser {
-		if (clearingHouse.accountSubscriber.type !== 'websocket')
-			throw 'This method only works for clearing houses with a websocket account listener. Try using the getClearingHouseUser factory method to initialize a ClearingHouseUser instead';
-
-		const config = getWebSocketClearingHouseUserConfig(
-			clearingHouse,
-			authority
-		);
-		return getClearingHouseUser(config);
-	}
-
-	public constructor(
-		clearingHouse: ClearingHouse,
-		authority: PublicKey,
-		accountSubscriber: UserAccountSubscriber
-	) {
-		this.clearingHouse = clearingHouse;
-		this.authority = authority;
-		this.accountSubscriber = accountSubscriber;
+	public constructor(config: ClearingHouseUserConfig) {
+		this.clearingHouse = config.clearingHouse;
+		this.userAccountPublicKey = config.userAccountPublicKey;
+		if (config.accountSubscription?.type === 'polling') {
+			this.accountSubscriber = new PollingUserAccountSubscriber(
+				config.clearingHouse.program,
+				config.userAccountPublicKey,
+				config.accountSubscription.accountLoader
+			);
+		} else {
+			this.accountSubscriber = new WebSocketUserAccountSubscriber(
+				config.clearingHouse.program,
+				config.userAccountPublicKey
+			);
+		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
 	}
 
@@ -97,9 +81,6 @@ export class ClearingHouseUser {
 	 * @returns SusbcriptionSuccess result
 	 */
 	public async subscribe(): Promise<boolean> {
-		// Clearing house should already be subscribed, but await for the subscription just incase to avoid race condition
-		await this.clearingHouse.subscribe();
-
 		this.isSubscribed = await this.accountSubscriber.subscribe();
 		return this.isSubscribed;
 	}
@@ -117,15 +98,11 @@ export class ClearingHouseUser {
 	}
 
 	public getUserAccount(): UserAccount {
-		return this.accountSubscriber.getUserAccount();
+		return this.accountSubscriber.getUserAccountAndSlot().data;
 	}
 
-	public getUserPositionsAccount(): UserPositionsAccount {
-		return this.accountSubscriber.getUserPositionsAccount();
-	}
-
-	public getUserOrdersAccount(): UserOrdersAccount | undefined {
-		return this.accountSubscriber.getUserOrdersAccount();
+	public getUserAccountAndSlot(): DataAndSlot<UserAccount> | undefined {
+		return this.accountSubscriber.getUserAccountAndSlot();
 	}
 
 	/**
@@ -134,7 +111,7 @@ export class ClearingHouseUser {
 	 * @returns userPosition
 	 */
 	public getUserPosition(marketIndex: BN): UserPosition | undefined {
-		return this.getUserPositionsAccount().positions.find((position) =>
+		return this.getUserAccount().positions.find((position) =>
 			position.marketIndex.eq(marketIndex)
 		);
 	}
@@ -145,7 +122,11 @@ export class ClearingHouseUser {
 			lastCumulativeFundingRate: ZERO,
 			marketIndex,
 			quoteAssetAmount: ZERO,
+			quoteEntryAmount: ZERO,
 			openOrders: ZERO,
+			unsettledPnl: ZERO,
+			openBids: ZERO,
+			openAsks: ZERO,
 		};
 	}
 
@@ -154,7 +135,7 @@ export class ClearingHouseUser {
 	 * @returns Order
 	 */
 	public getOrder(orderId: BN): Order | undefined {
-		return this.getUserOrdersAccount().orders.find((order) =>
+		return this.getUserAccount().orders.find((order) =>
 			order.orderId.eq(orderId)
 		);
 	}
@@ -164,40 +145,19 @@ export class ClearingHouseUser {
 	 * @returns Order
 	 */
 	public getOrderByUserOrderId(userOrderId: number): Order | undefined {
-		return this.getUserOrdersAccount().orders.find(
+		return this.getUserAccount().orders.find(
 			(order) => order.userOrderId === userOrderId
 		);
 	}
 
-	public async getUserAccountPublicKey(): Promise<PublicKey> {
-		if (this.userAccountPublicKey) {
-			return this.userAccountPublicKey;
-		}
-
-		this.userAccountPublicKey = await getUserAccountPublicKey(
-			this.clearingHouse.program.programId,
-			this.authority
-		);
+	public getUserAccountPublicKey(): PublicKey {
 		return this.userAccountPublicKey;
 	}
 
-	public async getUserOrdersAccountPublicKey(): Promise<PublicKey> {
-		if (this.userOrdersAccountPublicKey) {
-			return this.userOrdersAccountPublicKey;
-		}
-
-		this.userOrdersAccountPublicKey = await getUserOrdersAccountPublicKey(
-			this.clearingHouse.program.programId,
-			await this.getUserAccountPublicKey()
-		);
-		return this.userOrdersAccountPublicKey;
-	}
-
 	public async exists(): Promise<boolean> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
 		const userAccountRPCResponse =
 			await this.clearingHouse.connection.getParsedAccountInfo(
-				userAccountPublicKey
+				this.userAccountPublicKey
 			);
 		return userAccountRPCResponse.value !== null;
 	}
@@ -224,34 +184,44 @@ export class ClearingHouseUser {
 	}
 
 	public getInitialMarginRequirement(): BN {
-		return this.getUserPositionsAccount().positions.reduce(
-			(marginRequirement, marketPosition) => {
-				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+		return this.getUserAccount()
+			.positions.reduce((marginRequirement, marketPosition) => {
+				const market = this.clearingHouse.getMarketAccount(
+					marketPosition.marketIndex
+				);
 				return marginRequirement.add(
-					calculateBaseAssetValue(market, marketPosition)
+					calculateBaseAssetValue(
+						market,
+						marketPosition,
+						this.getOracleDataForMarket(market.marketIndex)
+					)
 						.mul(new BN(market.marginRatioInitial))
 						.div(MARGIN_PRECISION)
 				);
-			},
-			ZERO
-		);
+			}, ZERO)
+			.add(this.getTotalLiability());
 	}
 
 	/**
 	 * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
 	 */
 	public getPartialMarginRequirement(): BN {
-		return this.getUserPositionsAccount().positions.reduce(
-			(marginRequirement, marketPosition) => {
-				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+		return this.getUserAccount()
+			.positions.reduce((marginRequirement, marketPosition) => {
+				const market = this.clearingHouse.getMarketAccount(
+					marketPosition.marketIndex
+				);
 				return marginRequirement.add(
-					calculateBaseAssetValue(market, marketPosition)
+					calculateBaseAssetValue(
+						market,
+						marketPosition,
+						this.getOracleDataForMarket(market.marketIndex)
+					)
 						.mul(new BN(market.marginRatioPartial))
 						.div(MARGIN_PRECISION)
 				);
-			},
-			ZERO
-		);
+			}, ZERO)
+			.add(this.getTotalLiability());
 	}
 
 	/**
@@ -259,42 +229,158 @@ export class ClearingHouseUser {
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN {
-		return this.getUserPositionsAccount()
+		return this.getUserAccount()
 			.positions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
 			)
 			.reduce((pnl, marketPosition) => {
-				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+				const market = this.clearingHouse.getMarketAccount(
+					marketPosition.marketIndex
+				);
 				return pnl.add(
-					calculatePositionPNL(market, marketPosition, withFunding)
+					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);
+			}, ZERO);
+	}
+
 	/**
 	 * calculates unrealized funding payment pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getUnrealizedFundingPNL(marketIndex?: BN): BN {
-		return this.getUserPositionsAccount()
+		return this.getUserAccount()
 			.positions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
 			)
 			.reduce((pnl, marketPosition) => {
-				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+				const market = this.clearingHouse.getMarketAccount(
+					marketPosition.marketIndex
+				);
 				return pnl.add(calculatePositionFundingPNL(market, marketPosition));
 			}, ZERO);
 	}
 
+	public getTotalLiability(): BN {
+		return this.getUserAccount().bankBalances.reduce(
+			(totalAssetValue, bankBalance) => {
+				if (
+					bankBalance.balance.eq(ZERO) ||
+					isVariant(bankBalance.balanceType, 'deposit')
+				) {
+					return totalAssetValue;
+				}
+
+				// Todo this needs to account for whether it's based on initial or maintenance requirements
+				const bankAccount: BankAccount = this.clearingHouse.getBankAccount(
+					bankBalance.bankIndex
+				);
+
+				const tokenAmount = getTokenAmount(
+					bankBalance.balance,
+					bankAccount,
+					bankBalance.balanceType
+				);
+				return totalAssetValue.add(
+					tokenAmount
+						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+						.mul(bankAccount.initialLiabilityWeight)
+						.div(BANK_WEIGHT_PRECISION)
+						.div(MARK_PRICE_PRECISION)
+				);
+			},
+			ZERO
+		);
+	}
+
+	public getCollateralValue(bankIndex?: BN): BN {
+		return this.getUserAccount().bankBalances.reduce(
+			(totalAssetValue, bankBalance) => {
+				if (
+					bankBalance.balance.eq(ZERO) ||
+					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
+				) {
+					return totalAssetValue;
+				}
+
+				// Todo this needs to account for whether it's based on initial or maintenance requirements
+				const bankAccount: BankAccount = this.clearingHouse.getBankAccount(
+					bankBalance.bankIndex
+				);
+
+				let tokenAmount = getTokenAmount(
+					bankBalance.balance,
+					bankAccount,
+					bankBalance.balanceType
+				);
+
+				if (isVariant(bankBalance.balanceType, 'borrow')) {
+					tokenAmount = tokenAmount.mul(new BN(-1));
+				}
+
+				return totalAssetValue.add(
+					tokenAmount
+						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+						.div(MARK_PRICE_PRECISION)
+				);
+			},
+			ZERO
+		);
+	}
+
 	/**
 	 * calculates TotalCollateral: collateral + unrealized pnl
+	 * TODO: rename to total equity (for perpetuals swaps)
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getTotalCollateral(): BN {
-		return (
-			this.getUserAccount().collateral.add(this.getUnrealizedPNL(true)) ??
-			new BN(0)
-		);
+		return this.getUserAccount()
+			.bankBalances.reduce((totalAssetValue, bankBalance) => {
+				if (
+					bankBalance.balance.eq(ZERO) ||
+					isVariant(bankBalance.balanceType, 'borrow')
+				) {
+					return totalAssetValue;
+				}
+
+				// Todo this needs to account for whether it's based on initial or maintenance requirements
+				const bankAccount: BankAccount = this.clearingHouse.getBankAccount(
+					bankBalance.bankIndex
+				);
+
+				const tokenAmount = getTokenAmount(
+					bankBalance.balance,
+					bankAccount,
+					bankBalance.balanceType
+				);
+				return totalAssetValue.add(
+					tokenAmount
+						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+						.mul(bankAccount.initialAssetWeight)
+						.div(BANK_WEIGHT_PRECISION)
+						.div(MARK_PRICE_PRECISION)
+				);
+			}, ZERO)
+			.add(this.getUnrealizedPNL(true))
+			.add(this.getUnsettledPNL());
 	}
 
 	/**
@@ -302,11 +388,17 @@ export class ClearingHouseUser {
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	getTotalPositionValue(): BN {
-		return this.getUserPositionsAccount().positions.reduce(
+		return this.getUserAccount().positions.reduce(
 			(positionValue, marketPosition) => {
-				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+				const market = this.clearingHouse.getMarketAccount(
+					marketPosition.marketIndex
+				);
 				return positionValue.add(
-					calculateBaseAssetValue(market, marketPosition)
+					calculateBaseAssetValue(
+						market,
+						marketPosition,
+						this.getOracleDataForMarket(market.marketIndex)
+					)
 				);
 			},
 			ZERO
@@ -317,11 +409,16 @@ export class ClearingHouseUser {
 	 * calculates position value from closing 100%
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getPositionValue(marketIndex: BN): BN {
+	public getPositionValue(
+		marketIndex: BN,
+		oraclePriceData: OraclePriceData
+	): BN {
 		const userPosition =
 			this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
-		const market = this.clearingHouse.getMarket(userPosition.marketIndex);
-		return calculateBaseAssetValue(market, userPosition);
+		const market = this.clearingHouse.getMarketAccount(
+			userPosition.marketIndex
+		);
+		return calculateBaseAssetValue(market, userPosition, oraclePriceData);
 	}
 
 	public getPositionSide(
@@ -344,13 +441,15 @@ export class ClearingHouseUser {
 		position: UserPosition,
 		amountToClose?: BN
 	): [BN, BN] {
-		const market = this.clearingHouse.getMarket(position.marketIndex);
+		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
 
 		const entryPrice = calculateEntryPrice(position);
 
+		const oraclePriceData = this.getOracleDataForMarket(position.marketIndex);
+
 		if (amountToClose) {
 			if (amountToClose.eq(ZERO)) {
-				return [calculateMarkPrice(market), ZERO];
+				return [calculateMarkPrice(market, oraclePriceData), ZERO];
 			}
 			position = {
 				baseAssetAmount: amountToClose,
@@ -360,7 +459,11 @@ export class ClearingHouseUser {
 			} as UserPosition;
 		}
 
-		const baseAssetValue = calculateBaseAssetValue(market, position);
+		const baseAssetValue = calculateBaseAssetValue(
+			market,
+			position,
+			oraclePriceData
+		);
 		if (position.baseAssetAmount.eq(ZERO)) {
 			return [ZERO, ZERO];
 		}
@@ -401,7 +504,7 @@ export class ClearingHouseUser {
 		marketIndex: BN | number,
 		category: MarginCategory = 'Initial'
 	): BN {
-		const market = this.clearingHouse.getMarket(marketIndex);
+		const market = this.clearingHouse.getMarketAccount(marketIndex);
 		let marginRatioCategory: number;
 
 		switch (category) {
@@ -451,14 +554,14 @@ export class ClearingHouseUser {
 	 * @returns
 	 */
 	public needsToSettleFundingPayment(): boolean {
-		const marketsAccount = this.clearingHouse.getMarketsAccount();
-		for (const userPosition of this.getUserPositionsAccount().positions) {
+		for (const userPosition of this.getUserAccount().positions) {
 			if (userPosition.baseAssetAmount.eq(ZERO)) {
 				continue;
 			}
 
-			const market =
-				marketsAccount.markets[userPosition.marketIndex.toNumber()];
+			const market = this.clearingHouse.getMarketAccount(
+				userPosition.marketIndex
+			);
 			if (
 				market.amm.cumulativeFundingRateLong.eq(
 					userPosition.lastCumulativeFundingRate
@@ -522,18 +625,23 @@ export class ClearingHouseUser {
 			lastCumulativeFundingRate:
 				currentMarketPosition.lastCumulativeFundingRate,
 			quoteAssetAmount: new BN(0),
+			quoteEntryAmount: new BN(0),
 			openOrders: new BN(0),
+			unsettledPnl: new BN(0),
+			openBids: new BN(0),
+			openAsks: new BN(0),
 		};
 
 		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);
 
-		const market = this.clearingHouse.getMarket(
+		const market = this.clearingHouse.getMarketAccount(
 			proposedMarketPosition.marketIndex
 		);
 
 		const proposedMarketPositionValue = calculateBaseAssetValue(
 			market,
-			proposedMarketPosition
+			proposedMarketPosition,
+			this.getOracleDataForMarket(market.marketIndex)
 		);
 
 		// total position value after trade
@@ -541,11 +649,17 @@ export class ClearingHouseUser {
 			totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
 
 		const marginRequirementExcludingTargetMarket =
-			this.getUserPositionsAccount().positions.reduce(
+			this.getUserAccount().positions.reduce(
 				(totalMarginRequirement, position) => {
 					if (!position.marketIndex.eq(marketPosition.marketIndex)) {
-						const market = this.clearingHouse.getMarket(position.marketIndex);
-						const positionValue = calculateBaseAssetValue(market, position);
+						const market = this.clearingHouse.getMarketAccount(
+							position.marketIndex
+						);
+						const positionValue = calculateBaseAssetValue(
+							market,
+							position,
+							this.getOracleDataForMarket(market.marketIndex)
+						);
 						const marketMarginRequirement = positionValue
 							.mul(
 								partial
@@ -612,7 +726,8 @@ export class ClearingHouseUser {
 		let markPriceAfterTrade;
 		if (positionBaseSizeChange.eq(ZERO)) {
 			markPriceAfterTrade = calculateMarkPrice(
-				this.clearingHouse.getMarket(marketPosition.marketIndex)
+				this.clearingHouse.getMarketAccount(marketPosition.marketIndex),
+				this.getOracleDataForMarket(marketPosition.marketIndex)
 			);
 		} else {
 			const direction = positionBaseSizeChange.gt(ZERO)
@@ -621,8 +736,9 @@ export class ClearingHouseUser {
 			markPriceAfterTrade = calculateTradeSlippage(
 				direction,
 				positionBaseSizeChange.abs(),
-				this.clearingHouse.getMarket(marketPosition.marketIndex),
-				'base'
+				this.clearingHouse.getMarketAccount(marketPosition.marketIndex),
+				'base',
+				this.getOracleDataForMarket(marketPosition.marketIndex)
 			)[3]; // newPrice after swap
 		}
 
@@ -661,7 +777,8 @@ export class ClearingHouseUser {
 			{
 				marketIndex: positionMarketIndex,
 			},
-			closeBaseAmount
+			closeBaseAmount,
+			true
 		);
 	}
 
@@ -704,10 +821,12 @@ export class ClearingHouseUser {
 			? true
 			: targetSide === currentPositionSide;
 
+		const oracleData = this.getOracleDataForMarket(targetMarketIndex);
+
 		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
 		const oppositeSizeValueUSDC = targetingSameSide
 			? ZERO
-			: this.getPositionValue(targetMarketIndex);
+			: this.getPositionValue(targetMarketIndex, oracleData);
 
 		let maxPositionSize = this.getBuyingPower(targetMarketIndex);
 		if (maxPositionSize.gte(ZERO)) {
@@ -724,8 +843,11 @@ export class ClearingHouseUser {
 			// current leverage is greater than max leverage - can only reduce position size
 
 			if (!targetingSameSide) {
-				const market = this.clearingHouse.getMarket(targetMarketIndex);
-				const marketPositionValue = this.getPositionValue(targetMarketIndex);
+				const market = this.clearingHouse.getMarketAccount(targetMarketIndex);
+				const marketPositionValue = this.getPositionValue(
+					targetMarketIndex,
+					oracleData
+				);
 				const totalCollateral = this.getTotalCollateral();
 				const marginRequirement = this.getInitialMarginRequirement();
 				const marginFreedByClosing = marketPositionValue
@@ -774,7 +896,12 @@ export class ClearingHouseUser {
 			this.getUserPosition(targetMarketIndex) ||
 			this.getEmptyPosition(targetMarketIndex);
 
-		let currentPositionQuoteAmount = this.getPositionValue(targetMarketIndex);
+		const oracleData = this.getOracleDataForMarket(targetMarketIndex);
+
+		let currentPositionQuoteAmount = this.getPositionValue(
+			targetMarketIndex,
+			oracleData
+		);
 
 		const currentSide =
 			currentPosition && currentPosition.baseAssetAmount.isNeg()
@@ -830,70 +957,33 @@ export class ClearingHouseUser {
 			this.getUserPosition(marketToIgnore) ||
 			this.getEmptyPosition(marketToIgnore);
 
+		const oracleData = this.getOracleDataForMarket(marketToIgnore);
+
 		let currentMarketPositionValueUSDC = ZERO;
 		if (currentMarketPosition) {
-			currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore);
+			currentMarketPositionValueUSDC = this.getPositionValue(
+				marketToIgnore,
+				oracleData
+			);
 		}
 
 		return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
 	}
 
-	public getClaimableCollateral(settlementState: SettlementStateAccount): BN {
-		return this.getSettledPositionValue()
-			.mul(
-				settlementState.collateralAvailableToClaim.sub(
-					this.getUserAccount().lastCollateralAvailableToClaim
-				)
-			)
-			.div(settlementState.totalSettlementValue);
-	}
-
-	public getSettledPositionValue(): BN {
-		return BN.max(
-			this.getUserAccount()
-				.collateral.add(
-					this.getUnrealizedFundingPNL().div(PRICE_TO_QUOTE_PRECISION)
-				)
-				.add(this.getSettledPositionsPNL()),
-			ZERO
-		);
-	}
+	private getOracleDataForMarket(marketIndex: BN): OraclePriceData {
+		const oracleKey =
+			this.clearingHouse.getMarketAccount(marketIndex).amm.oracle;
+		const oracleData =
+			this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
 
-	public getSettledPositionsPNL(): BN {
-		return this.getUserPositionsAccount().positions.reduce(
-			(pnl, marketPosition) => {
-				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-				return pnl.add(calculateSettledPositionPNL(market, marketPosition));
-			},
-			ZERO
-		);
+		return oracleData;
 	}
+	private getOracleDataForBank(bankIndex: BN): OraclePriceData {
+		const oracleKey = this.clearingHouse.getBankAccount(bankIndex).oracle;
 
-	public async estimateClaimableCollateral(): Promise<BN> {
-		const currentCollateralVaultBalance = new BN(
-			(
-				await this.clearingHouse.connection.getTokenAccountBalance(
-					this.clearingHouse.getStateAccount().collateralVault
-				)
-			).value.amount
-		);
-		const currentInsuranceVaultBalance = new BN(
-			(
-				await this.clearingHouse.connection.getTokenAccountBalance(
-					this.clearingHouse.getStateAccount().insuranceVault
-				)
-			).value.amount
-		);
-
-		const totalClaimableCollateral = currentCollateralVaultBalance.add(
-			currentInsuranceVaultBalance
-		);
-		const totalEstimatedSettlementValue =
-			await this.clearingHouse.getTotalSettlementSize();
-		const userSettledPositionValue = await this.getSettledPositionValue();
+		const oracleData =
+			this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
 
-		return totalClaimableCollateral
-			.mul(userSettledPositionValue)
-			.div(totalEstimatedSettlementValue);
+		return oracleData;
 	}
 }