@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.26

package/src/clearingHouseUser.ts

@@ -7,7 +7,7 @@ import {
 	MarginCategory,
 	Order,
 	UserAccount,
-	UserPosition,
+	PerpPosition,
 } from './types';
 import { calculateEntryPrice } from './math/position';
 import {
@@ -20,8 +20,8 @@ import {
 	AMM_RESERVE_PRECISION,
 	PRICE_TO_QUOTE_PRECISION,
 	MARGIN_PRECISION,
-	BANK_WEIGHT_PRECISION,
-	BANK_BALANCE_PRECISION_EXP,
+	SPOT_MARKET_WEIGHT_PRECISION,
+	SPOT_MARKET_BALANCE_PRECISION_EXP,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -38,13 +38,13 @@ import {
 	PositionDirection,
 	calculateTradeSlippage,
 	BN,
-	BankAccount,
+	SpotMarketAccount,
 } from '.';
 import {
 	getTokenAmount,
 	calculateAssetWeight,
 	calculateLiabilityWeight,
-} from './math/bankBalance';
+} from './math/spotBalance';
 import {
 	calculateBaseAssetValueWithOracle,
 	calculateWorstCaseBaseAssetAmount,
@@ -120,15 +120,16 @@ export class ClearingHouseUser {
 	 * @param marketIndex
 	 * @returns userPosition
 	 */
-	public getUserPosition(marketIndex: BN): UserPosition | undefined {
-		return this.getUserAccount().positions.find((position) =>
+	public getUserPosition(marketIndex: BN): PerpPosition | undefined {
+		return this.getUserAccount().perpPositions.find((position) =>
 			position.marketIndex.eq(marketIndex)
 		);
 	}
 
-	public getEmptyPosition(marketIndex: BN): UserPosition {
+	public getEmptyPosition(marketIndex: BN): PerpPosition {
 		return {
 			baseAssetAmount: ZERO,
+			remainderBaseAssetAmount: ZERO,
 			lastCumulativeFundingRate: ZERO,
 			marketIndex,
 			quoteAssetAmount: ZERO,
@@ -144,7 +145,7 @@ export class ClearingHouseUser {
 		};
 	}
 
-	public getClonedPosition(position: UserPosition): UserPosition {
+	public getClonedPosition(position: PerpPosition): PerpPosition {
 		const clonedPosition = Object.assign({}, position);
 		return clonedPosition;
 	}
@@ -187,11 +188,13 @@ export class ClearingHouseUser {
 	 * @returns : the dust base asset amount (ie, < stepsize)
 	 * @returns : pnl from settle
 	 */
-	public getSettledLPPosition(marketIndex: BN): [UserPosition, BN, BN] {
+	public getSettledLPPosition(marketIndex: BN): [PerpPosition, BN, BN] {
 		const _position = this.getUserPosition(marketIndex);
 		const position = this.getClonedPosition(_position);
 
-		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
+		const market = this.clearingHouse.getPerpMarketAccount(
+			position.marketIndex
+		);
 		const nShares = position.lpShares;
 
 		const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
@@ -210,24 +213,33 @@ export class ClearingHouseUser {
 			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;
+		function standardize(amount, stepsize) {
+			const remainder = amount.abs().mod(stepsize).mul(sign(amount));
+			const standardizedAmount = amount.sub(remainder);
+			return [standardizedAmount, remainder];
 		}
-		const standardizedBaa = deltaBaa.sub(remainderBaa);
 
-		const reaminderPerLP = remainderBaa.mul(AMM_RESERVE_PRECISION).div(nShares);
+		const [standardizedBaa, remainderBaa] = standardize(
+			deltaBaa,
+			market.amm.baseAssetAmountStepSize
+		);
 
-		position.lastNetBaseAssetAmountPerLp =
-			market.amm.marketPositionPerLp.baseAssetAmount.sub(reaminderPerLP);
+		position.remainderBaseAssetAmount =
+			position.remainderBaseAssetAmount.add(remainderBaa);
+
+		if (
+			position.remainderBaseAssetAmount
+				.abs()
+				.gte(market.amm.baseAssetAmountStepSize)
+		) {
+			const [newStandardizedBaa, newRemainderBaa] = standardize(
+				position.remainderBaseAssetAmount,
+				market.amm.baseAssetAmountStepSize
+			);
+			position.baseAssetAmount =
+				position.baseAssetAmount.add(newStandardizedBaa);
+			position.remainderBaseAssetAmount = newRemainderBaa;
+		}
 
 		let updateType;
 		if (position.baseAssetAmount.eq(ZERO)) {
@@ -300,32 +312,35 @@ export class ClearingHouseUser {
 	/**
 	 * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
 	 */
-	public getMarginRequirement(type: MarginCategory): BN {
+	public getMarginRequirement(
+		type: MarginCategory,
+		liquidationBuffer?: BN
+	): BN {
 		return this.getUserAccount()
-			.positions.reduce((marginRequirement, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
+			.perpPositions.reduce((marginRequirement, perpPosition) => {
+				const market = this.clearingHouse.getPerpMarketAccount(
+					perpPosition.marketIndex
 				);
 
-				if (marketPosition.lpShares.gt(ZERO)) {
+				if (perpPosition.lpShares.gt(ZERO)) {
 					// is an lp
 					// clone so we dont mutate the position
-					marketPosition = this.getClonedPosition(marketPosition);
+					perpPosition = this.getClonedPosition(perpPosition);
 
 					// settle position
 					const [settledPosition, dustBaa, _] = this.getSettledLPPosition(
 						market.marketIndex
 					);
-					marketPosition.baseAssetAmount =
+					perpPosition.baseAssetAmount =
 						settledPosition.baseAssetAmount.add(dustBaa);
-					marketPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+					perpPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
 
 					// open orders
 					let openAsks;
 					if (market.amm.maxBaseAssetReserve > market.amm.baseAssetReserve) {
 						openAsks = market.amm.maxBaseAssetReserve
 							.sub(market.amm.baseAssetReserve)
-							.mul(marketPosition.lpShares)
+							.mul(perpPosition.lpShares)
 							.div(market.amm.sqrtK)
 							.mul(new BN(-1));
 					} else {
@@ -336,39 +351,55 @@ export class ClearingHouseUser {
 					if (market.amm.minBaseAssetReserve < market.amm.baseAssetReserve) {
 						openBids = market.amm.baseAssetReserve
 							.sub(market.amm.minBaseAssetReserve)
-							.mul(marketPosition.lpShares)
+							.mul(perpPosition.lpShares)
 							.div(market.amm.sqrtK);
 					} else {
 						openBids = ZERO;
 					}
 
-					marketPosition.openAsks = marketPosition.openAsks.add(openAsks);
-					marketPosition.openBids = marketPosition.openBids.add(openBids);
+					perpPosition.openAsks = perpPosition.openAsks.add(openAsks);
+					perpPosition.openBids = perpPosition.openBids.add(openBids);
+				}
+
+				let valuationPrice = this.getOracleDataForMarket(
+					market.marketIndex
+				).price;
+
+				if (isVariant(market.status, 'settlement')) {
+					valuationPrice = market.settlementPrice;
 				}
 
 				const worstCaseBaseAssetAmount =
-					calculateWorstCaseBaseAssetAmount(marketPosition);
+					calculateWorstCaseBaseAssetAmount(perpPosition);
 
 				const worstCaseAssetValue = worstCaseBaseAssetAmount
 					.abs()
-					.mul(this.getOracleDataForMarket(market.marketIndex).price)
+					.mul(valuationPrice)
 					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
 
-				return marginRequirement.add(
-					worstCaseAssetValue
-						.mul(
-							new BN(
-								calculateMarketMarginRatio(
-									market,
-									worstCaseBaseAssetAmount.abs(),
-									type
-								)
+				const positionMarginRequirement = worstCaseAssetValue
+					.mul(
+						new BN(
+							calculateMarketMarginRatio(
+								market,
+								worstCaseBaseAssetAmount.abs(),
+								type
 							)
 						)
-						.div(MARGIN_PRECISION)
-				);
+					)
+					.div(MARGIN_PRECISION);
+
+				if (liquidationBuffer !== undefined) {
+					positionMarginRequirement.add(
+						worstCaseAssetValue.mul(liquidationBuffer).div(MARGIN_PRECISION)
+					);
+				}
+
+				return marginRequirement.add(positionMarginRequirement);
 			}, ZERO)
-			.add(this.getBankLiabilityValue(undefined, type));
+			.add(
+				this.getSpotMarketLiabilityValue(undefined, type, liquidationBuffer)
+			);
 	}
 
 	/**
@@ -381,8 +412,8 @@ export class ClearingHouseUser {
 	/**
 	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getMaintenanceMarginRequirement(): BN {
-		return this.getMarginRequirement('Maintenance');
+	public getMaintenanceMarginRequirement(liquidationBuffer?: BN): BN {
+		return this.getMarginRequirement('Maintenance', liquidationBuffer);
 	}
 
 	/**
@@ -394,19 +425,22 @@ export class ClearingHouseUser {
 		marketIndex?: BN,
 		withWeightMarginCategory?: MarginCategory
 	): BN {
+		const quoteSpotMarket = this.clearingHouse.getQuoteSpotMarketAccount();
 		return this.getUserAccount()
-			.positions.filter((pos) =>
+			.perpPositions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
 			)
-			.reduce((unrealizedPnl, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
+			.reduce((unrealizedPnl, perpPosition) => {
+				const market = this.clearingHouse.getPerpMarketAccount(
+					perpPosition.marketIndex
 				);
+				const oraclePriceData = this.getOracleDataForMarket(market.marketIndex);
+
 				let positionUnrealizedPnl = calculatePositionPNL(
 					market,
-					marketPosition,
+					perpPosition,
 					withFunding,
-					this.getOracleDataForMarket(market.marketIndex)
+					oraclePriceData
 				);
 
 				if (withWeightMarginCategory !== undefined) {
@@ -415,11 +449,13 @@ export class ClearingHouseUser {
 							.mul(
 								calculateUnrealizedAssetWeight(
 									market,
+									quoteSpotMarket,
 									positionUnrealizedPnl,
-									withWeightMarginCategory
+									withWeightMarginCategory,
+									oraclePriceData
 								)
 							)
-							.div(new BN(BANK_WEIGHT_PRECISION));
+							.div(new BN(SPOT_MARKET_WEIGHT_PRECISION));
 					}
 				}
 
@@ -433,60 +469,70 @@ export class ClearingHouseUser {
 	 */
 	public getUnrealizedFundingPNL(marketIndex?: BN): BN {
 		return this.getUserAccount()
-			.positions.filter((pos) =>
+			.perpPositions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
 			)
-			.reduce((pnl, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
+			.reduce((pnl, perpPosition) => {
+				const market = this.clearingHouse.getPerpMarketAccount(
+					perpPosition.marketIndex
 				);
-				return pnl.add(calculatePositionFundingPNL(market, marketPosition));
+				return pnl.add(calculatePositionFundingPNL(market, perpPosition));
 			}, ZERO);
 	}
 
-	public getBankLiabilityValue(
-		bankIndex?: BN,
-		withWeightMarginCategory?: MarginCategory
+	public getSpotMarketLiabilityValue(
+		marketIndex?: BN,
+		withWeightMarginCategory?: MarginCategory,
+		liquidationBuffer?: BN
 	): BN {
-		return this.getUserAccount().bankBalances.reduce(
-			(totalLiabilityValue, bankBalance) => {
+		return this.getUserAccount().spotPositions.reduce(
+			(totalLiabilityValue, spotPosition) => {
 				if (
-					bankBalance.balance.eq(ZERO) ||
-					isVariant(bankBalance.balanceType, 'deposit') ||
-					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
+					spotPosition.balance.eq(ZERO) ||
+					isVariant(spotPosition.balanceType, 'deposit') ||
+					(marketIndex !== undefined &&
+						!spotPosition.marketIndex.eq(marketIndex))
 				) {
 					return totalLiabilityValue;
 				}
 
 				// Todo this needs to account for whether it's based on initial or maintenance requirements
-				const bankAccount: BankAccount = this.clearingHouse.getBankAccount(
-					bankBalance.bankIndex
-				);
+				const spotMarketAccount: SpotMarketAccount =
+					this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
 
 				const tokenAmount = getTokenAmount(
-					bankBalance.balance,
-					bankAccount,
-					bankBalance.balanceType
+					spotPosition.balance,
+					spotMarketAccount,
+					spotPosition.balanceType
 				);
 
 				let liabilityValue = tokenAmount
-					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.mul(
+						this.getOracleDataForSpotMarket(spotMarketAccount.marketIndex).price
+					)
 					.div(MARK_PRICE_PRECISION)
 					.div(
 						new BN(10).pow(
-							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+							new BN(spotMarketAccount.decimals).sub(
+								SPOT_MARKET_BALANCE_PRECISION_EXP
+							)
 						)
 					);
 
 				if (withWeightMarginCategory !== undefined) {
-					const weight = calculateLiabilityWeight(
+					let weight = calculateLiabilityWeight(
 						tokenAmount,
-						bankAccount,
+						spotMarketAccount,
 						withWeightMarginCategory
 					);
+
+					if (liquidationBuffer !== undefined) {
+						weight = weight.add(liquidationBuffer);
+					}
+
 					liabilityValue = liabilityValue
 						.mul(weight)
-						.div(BANK_WEIGHT_PRECISION);
+						.div(SPOT_MARKET_WEIGHT_PRECISION);
 				}
 
 				return totalLiabilityValue.add(liabilityValue);
@@ -495,46 +541,50 @@ export class ClearingHouseUser {
 		);
 	}
 
-	public getBankAssetValue(
-		bankIndex?: BN,
+	public getSpotMarketAssetValue(
+		marketIndex?: BN,
 		withWeightMarginCategory?: MarginCategory
 	): BN {
-		return this.getUserAccount().bankBalances.reduce(
-			(totalAssetValue, bankBalance) => {
+		return this.getUserAccount().spotPositions.reduce(
+			(totalAssetValue, spotPosition) => {
 				if (
-					bankBalance.balance.eq(ZERO) ||
-					isVariant(bankBalance.balanceType, 'borrow') ||
-					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
+					spotPosition.balance.eq(ZERO) ||
+					isVariant(spotPosition.balanceType, 'borrow') ||
+					(marketIndex !== undefined &&
+						!spotPosition.marketIndex.eq(marketIndex))
 				) {
 					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 spotMarketAccount: SpotMarketAccount =
+					this.clearingHouse.getSpotMarketAccount(spotPosition.marketIndex);
 
 				const tokenAmount = getTokenAmount(
-					bankBalance.balance,
-					bankAccount,
-					bankBalance.balanceType
+					spotPosition.balance,
+					spotMarketAccount,
+					spotPosition.balanceType
 				);
 
 				let assetValue = tokenAmount
-					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.mul(
+						this.getOracleDataForSpotMarket(spotMarketAccount.marketIndex).price
+					)
 					.div(MARK_PRICE_PRECISION)
 					.div(
 						new BN(10).pow(
-							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+							new BN(spotMarketAccount.decimals).sub(
+								SPOT_MARKET_BALANCE_PRECISION_EXP
+							)
 						)
 					);
 				if (withWeightMarginCategory !== undefined) {
 					const weight = calculateAssetWeight(
 						tokenAmount,
-						bankAccount,
+						spotMarketAccount,
 						withWeightMarginCategory
 					);
-					assetValue = assetValue.mul(weight).div(BANK_WEIGHT_PRECISION);
+					assetValue = assetValue.mul(weight).div(SPOT_MARKET_WEIGHT_PRECISION);
 				}
 
 				return totalAssetValue.add(assetValue);
@@ -543,9 +593,12 @@ export class ClearingHouseUser {
 		);
 	}
 
-	public getNetBankValue(withWeightMarginCategory?: MarginCategory): BN {
-		return this.getBankAssetValue(undefined, withWeightMarginCategory).sub(
-			this.getBankLiabilityValue(undefined, withWeightMarginCategory)
+	public getNetSpotMarketValue(withWeightMarginCategory?: MarginCategory): BN {
+		return this.getSpotMarketAssetValue(
+			undefined,
+			withWeightMarginCategory
+		).sub(
+			this.getSpotMarketLiabilityValue(undefined, withWeightMarginCategory)
 		);
 	}
 
@@ -554,7 +607,7 @@ export class ClearingHouseUser {
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getTotalCollateral(marginCategory: MarginCategory = 'Initial'): BN {
-		return this.getBankAssetValue(undefined, marginCategory).add(
+		return this.getSpotMarketAssetValue(undefined, marginCategory).add(
 			this.getUnrealizedPNL(true, undefined, marginCategory)
 		);
 	}
@@ -564,14 +617,14 @@ export class ClearingHouseUser {
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	getTotalPositionValue(): BN {
-		return this.getUserAccount().positions.reduce(
-			(positionValue, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
+		return this.getUserAccount().perpPositions.reduce(
+			(positionValue, perpPosition) => {
+				const market = this.clearingHouse.getPerpMarketAccount(
+					perpPosition.marketIndex
 				);
 				const posVal = calculateBaseAssetValueWithOracle(
 					market,
-					marketPosition,
+					perpPosition,
 					this.getOracleDataForMarket(market.marketIndex)
 				);
 
@@ -591,7 +644,7 @@ export class ClearingHouseUser {
 	): BN {
 		const userPosition =
 			this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
-		const market = this.clearingHouse.getMarketAccount(
+		const market = this.clearingHouse.getPerpMarketAccount(
 			userPosition.marketIndex
 		);
 		return calculateBaseAssetValueWithOracle(
@@ -602,7 +655,7 @@ export class ClearingHouseUser {
 	}
 
 	public getPositionSide(
-		currentPosition: Pick<UserPosition, 'baseAssetAmount'>
+		currentPosition: Pick<PerpPosition, 'baseAssetAmount'>
 	): PositionDirection | undefined {
 		if (currentPosition.baseAssetAmount.gt(ZERO)) {
 			return PositionDirection.LONG;
@@ -618,11 +671,13 @@ export class ClearingHouseUser {
 	 * @returns : Precision MARK_PRICE_PRECISION
 	 */
 	public getPositionEstimatedExitPriceAndPnl(
-		position: UserPosition,
+		position: PerpPosition,
 		amountToClose?: BN,
 		useAMMClose = false
 	): [BN, BN] {
-		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
+		const market = this.clearingHouse.getPerpMarketAccount(
+			position.marketIndex
+		);
 
 		const entryPrice = calculateEntryPrice(position);
 
@@ -637,7 +692,7 @@ export class ClearingHouseUser {
 				lastCumulativeFundingRate: position.lastCumulativeFundingRate,
 				marketIndex: position.marketIndex,
 				quoteAssetAmount: position.quoteAssetAmount,
-			} as UserPosition;
+			} as PerpPosition;
 		}
 
 		let baseAssetValue: BN;
@@ -695,7 +750,7 @@ export class ClearingHouseUser {
 		marketIndex: BN | number,
 		category: MarginCategory = 'Initial'
 	): BN {
-		const market = this.clearingHouse.getMarketAccount(marketIndex);
+		const market = this.clearingHouse.getPerpMarketAccount(marketIndex);
 
 		const marginRatioCategory = calculateMarketMarginRatio(
 			market,
@@ -723,13 +778,19 @@ export class ClearingHouseUser {
 		return this.getTotalCollateral().mul(TEN_THOUSAND).div(totalPositionValue);
 	}
 
-	public canBeLiquidated(): [boolean, BN] {
+	public canBeLiquidated(): boolean {
 		const totalCollateral = this.getTotalCollateral();
-		const partialMaintenanceRequirement =
-			this.getMaintenanceMarginRequirement();
-		const marginRatio = this.getMarginRatio();
-		const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
-		return [canLiquidate, marginRatio];
+
+		// if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
+		let liquidationBuffer = undefined;
+		if (this.getUserAccount().beingLiquidated) {
+			liquidationBuffer = new BN(
+				this.clearingHouse.getStateAccount().liquidationMarginBufferRatio
+			);
+		}
+		const maintenanceRequirement =
+			this.getMaintenanceMarginRequirement(liquidationBuffer);
+		return totalCollateral.lt(maintenanceRequirement);
 	}
 
 	/**
@@ -737,12 +798,12 @@ export class ClearingHouseUser {
 	 * @returns
 	 */
 	public needsToSettleFundingPayment(): boolean {
-		for (const userPosition of this.getUserAccount().positions) {
+		for (const userPosition of this.getUserAccount().perpPositions) {
 			if (userPosition.baseAssetAmount.eq(ZERO)) {
 				continue;
 			}
 
-			const market = this.clearingHouse.getMarketAccount(
+			const market = this.clearingHouse.getPerpMarketAccount(
 				userPosition.marketIndex
 			);
 			if (
@@ -763,13 +824,13 @@ export class ClearingHouseUser {
 
 	/**
 	 * Calculate the liquidation price of a position, with optional parameter to calculate the liquidation price after a trade
-	 * @param marketPosition
+	 * @param PerpPosition
 	 * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
 	 * @param partial
 	 * @returns Precision : MARK_PRICE_PRECISION
 	 */
 	public liquidationPrice(
-		marketPosition: Pick<UserPosition, 'marketIndex'>,
+		perpPosition: Pick<PerpPosition, 'marketIndex'>,
 		positionBaseSizeChange: BN = ZERO
 	): BN {
 		// solves formula for example canBeLiquidated below
@@ -788,22 +849,23 @@ export class ClearingHouseUser {
 
 		// calculate the total position value ignoring any value from the target market of the trade
 		const totalPositionValueExcludingTargetMarket =
-			this.getTotalPositionValueExcludingMarket(marketPosition.marketIndex);
+			this.getTotalPositionValueExcludingMarket(perpPosition.marketIndex);
 
-		const currentMarketPosition =
-			this.getUserPosition(marketPosition.marketIndex) ||
-			this.getEmptyPosition(marketPosition.marketIndex);
+		const currentPerpPosition =
+			this.getUserPosition(perpPosition.marketIndex) ||
+			this.getEmptyPosition(perpPosition.marketIndex);
 
-		const currentMarketPositionBaseSize = currentMarketPosition.baseAssetAmount;
+		const currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
 
-		const proposedBaseAssetAmount = currentMarketPositionBaseSize.add(
+		const proposedBaseAssetAmount = currentPerpPositionBaseSize.add(
 			positionBaseSizeChange
 		);
 
 		// calculate position for current market after trade
-		const proposedMarketPosition: UserPosition = {
-			marketIndex: marketPosition.marketIndex,
+		const proposedPerpPosition: PerpPosition = {
+			marketIndex: perpPosition.marketIndex,
 			baseAssetAmount: proposedBaseAssetAmount,
+			remainderBaseAssetAmount: ZERO,
 			quoteAssetAmount: new BN(0),
 			lastCumulativeFundingRate: ZERO,
 			quoteEntryAmount: new BN(0),
@@ -819,25 +881,25 @@ export class ClearingHouseUser {
 
 		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);
 
-		const market = this.clearingHouse.getMarketAccount(
-			proposedMarketPosition.marketIndex
+		const market = this.clearingHouse.getPerpMarketAccount(
+			proposedPerpPosition.marketIndex
 		);
 
-		const proposedMarketPositionValue = calculateBaseAssetValueWithOracle(
+		const proposedPerpPositionValue = calculateBaseAssetValueWithOracle(
 			market,
-			proposedMarketPosition,
+			proposedPerpPosition,
 			this.getOracleDataForMarket(market.marketIndex)
 		);
 
 		// total position value after trade
 		const totalPositionValueAfterTrade =
-			totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
+			totalPositionValueExcludingTargetMarket.add(proposedPerpPositionValue);
 
 		const marginRequirementExcludingTargetMarket =
-			this.getUserAccount().positions.reduce(
+			this.getUserAccount().perpPositions.reduce(
 				(totalMarginRequirement, position) => {
-					if (!position.marketIndex.eq(marketPosition.marketIndex)) {
-						const market = this.clearingHouse.getMarketAccount(
+					if (!position.marketIndex.eq(perpPosition.marketIndex)) {
+						const market = this.clearingHouse.getPerpMarketAccount(
 							position.marketIndex
 						);
 						const positionValue = calculateBaseAssetValueWithOracle(
@@ -872,19 +934,19 @@ export class ClearingHouseUser {
 		// if the position value after the trade is less than free collateral, there is no liq price
 		if (
 			totalPositionValueAfterTrade.lte(freeCollateralExcludingTargetMarket) &&
-			proposedMarketPosition.baseAssetAmount.abs().gt(ZERO)
+			proposedPerpPosition.baseAssetAmount.abs().gt(ZERO)
 		) {
 			return new BN(-1);
 		}
 
 		const marginRequirementAfterTrade =
 			marginRequirementExcludingTargetMarket.add(
-				proposedMarketPositionValue
+				proposedPerpPositionValue
 					.mul(
 						new BN(
 							calculateMarketMarginRatio(
 								market,
-								proposedMarketPosition.baseAssetAmount.abs(),
+								proposedPerpPosition.baseAssetAmount.abs(),
 								'Maintenance'
 							)
 						)
@@ -896,7 +958,7 @@ export class ClearingHouseUser {
 		);
 
 		const marketMaxLeverage = this.getMaxLeverage(
-			proposedMarketPosition.marketIndex,
+			proposedPerpPosition.marketIndex,
 			'Maintenance'
 		);
 
@@ -920,8 +982,8 @@ export class ClearingHouseUser {
 		let markPriceAfterTrade;
 		if (positionBaseSizeChange.eq(ZERO)) {
 			markPriceAfterTrade = calculateMarkPrice(
-				this.clearingHouse.getMarketAccount(marketPosition.marketIndex),
-				this.getOracleDataForMarket(marketPosition.marketIndex)
+				this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex),
+				this.getOracleDataForMarket(perpPosition.marketIndex)
 			);
 		} else {
 			const direction = positionBaseSizeChange.gt(ZERO)
@@ -930,9 +992,9 @@ export class ClearingHouseUser {
 			markPriceAfterTrade = calculateTradeSlippage(
 				direction,
 				positionBaseSizeChange.abs(),
-				this.clearingHouse.getMarketAccount(marketPosition.marketIndex),
+				this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex),
 				'base',
-				this.getOracleDataForMarket(marketPosition.marketIndex)
+				this.getOracleDataForMarket(perpPosition.marketIndex)
 			)[3]; // newPrice after swap
 		}
 
@@ -1036,21 +1098,22 @@ export class ClearingHouseUser {
 			// current leverage is greater than max leverage - can only reduce position size
 
 			if (!targetingSameSide) {
-				const market = this.clearingHouse.getMarketAccount(targetMarketIndex);
-				const marketPositionValue = this.getPositionValue(
+				const market =
+					this.clearingHouse.getPerpMarketAccount(targetMarketIndex);
+				const perpPositionValue = this.getPositionValue(
 					targetMarketIndex,
 					oracleData
 				);
 				const totalCollateral = this.getTotalCollateral();
 				const marginRequirement = this.getInitialMarginRequirement();
-				const marginFreedByClosing = marketPositionValue
+				const marginFreedByClosing = perpPositionValue
 					.mul(new BN(market.marginRatioInitial))
 					.div(MARGIN_PRECISION);
 				const marginRequirementAfterClosing =
 					marginRequirement.sub(marginFreedByClosing);
 
 				if (marginRequirementAfterClosing.gt(totalCollateral)) {
-					maxPositionSize = marketPositionValue;
+					maxPositionSize = perpPositionValue;
 				} else {
 					const freeCollateralAfterClose = totalCollateral.sub(
 						marginRequirementAfterClosing
@@ -1058,7 +1121,7 @@ export class ClearingHouseUser {
 					const buyingPowerAfterClose = freeCollateralAfterClose
 						.mul(this.getMaxLeverage(targetMarketIndex))
 						.div(TEN_THOUSAND);
-					maxPositionSize = marketPositionValue.add(buyingPowerAfterClose);
+					maxPositionSize = perpPositionValue.add(buyingPowerAfterClose);
 				}
 			} else {
 				// do nothing if targetting same side
@@ -1107,7 +1170,7 @@ export class ClearingHouseUser {
 		if (tradeSide === PositionDirection.SHORT)
 			tradeQuoteAmount = tradeQuoteAmount.neg();
 
-		const currentMarketPositionAfterTrade = currentPositionQuoteAmount
+		const currentPerpPositionAfterTrade = currentPositionQuoteAmount
 			.add(tradeQuoteAmount)
 			.abs();
 
@@ -1116,7 +1179,7 @@ export class ClearingHouseUser {
 
 		const totalCollateral = this.getTotalCollateral();
 		if (totalCollateral.gt(ZERO)) {
-			const newLeverage = currentMarketPositionAfterTrade
+			const newLeverage = currentPerpPositionAfterTrade
 				.add(totalPositionAfterTradeExcludingTargetMarket)
 				.abs()
 				.mul(TEN_THOUSAND)
@@ -1133,7 +1196,7 @@ export class ClearingHouseUser {
 	 * @returns feeForQuote : Precision QUOTE_PRECISION
 	 */
 	public calculateFeeForQuoteAmount(quoteAmount: BN): BN {
-		const feeStructure = this.clearingHouse.getStateAccount().feeStructure;
+		const feeStructure = this.clearingHouse.getStateAccount().perpFeeStructure;
 
 		return quoteAmount
 			.mul(feeStructure.feeNumerator)
@@ -1146,33 +1209,34 @@ export class ClearingHouseUser {
 	 * @returns positionValue : Precision QUOTE_PRECISION
 	 */
 	private getTotalPositionValueExcludingMarket(marketToIgnore: BN): BN {
-		const currentMarketPosition =
+		const currentPerpPosition =
 			this.getUserPosition(marketToIgnore) ||
 			this.getEmptyPosition(marketToIgnore);
 
 		const oracleData = this.getOracleDataForMarket(marketToIgnore);
 
-		let currentMarketPositionValueUSDC = ZERO;
-		if (currentMarketPosition) {
-			currentMarketPositionValueUSDC = this.getPositionValue(
+		let currentPerpPositionValueUSDC = ZERO;
+		if (currentPerpPosition) {
+			currentPerpPositionValueUSDC = this.getPositionValue(
 				marketToIgnore,
 				oracleData
 			);
 		}
 
-		return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
+		return this.getTotalPositionValue().sub(currentPerpPositionValueUSDC);
 	}
 
 	private getOracleDataForMarket(marketIndex: BN): OraclePriceData {
 		const oracleKey =
-			this.clearingHouse.getMarketAccount(marketIndex).amm.oracle;
+			this.clearingHouse.getPerpMarketAccount(marketIndex).amm.oracle;
 		const oracleData =
 			this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
 
 		return oracleData;
 	}
-	private getOracleDataForBank(bankIndex: BN): OraclePriceData {
-		const oracleKey = this.clearingHouse.getBankAccount(bankIndex).oracle;
+	private getOracleDataForSpotMarket(marketIndex: BN): OraclePriceData {
+		const oracleKey =
+			this.clearingHouse.getSpotMarketAccount(marketIndex).oracle;
 
 		const oracleData =
 			this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;