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

package/src/clearingHouse.ts

@@ -41,6 +41,7 @@ import {
 	getMarketPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeySync,
+	getUserStatsAccountPublicKey,
 } from './addresses/pda';
 import {
 	ClearingHouseAccountSubscriber,
@@ -62,6 +63,7 @@ import { ClearingHouseUser } from './clearingHouseUser';
 import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
 import { getMarketsBanksAndOraclesForSubscription } from './config';
 import { WRAPPED_SOL_MINT } from './constants/banks';
+import { ClearingHouseUserStats } from './clearingHouseUserStats';
 
 /**
  * # ClearingHouse
@@ -74,6 +76,7 @@ export class ClearingHouse {
 	provider: AnchorProvider;
 	opts?: ConfirmOptions;
 	users = new Map<number, ClearingHouseUser>();
+	userStats?: ClearingHouseUserStats;
 	activeUserId: number;
 	userAccountSubscriptionConfig: ClearingHouseUserAccountSubscriptionConfig;
 	accountSubscriber: ClearingHouseAccountSubscriber;
@@ -117,6 +120,16 @@ export class ClearingHouse {
 						type: 'websocket',
 				  };
 		this.createUsers(userIds, this.userAccountSubscriptionConfig);
+		if (config.userStats) {
+			this.userStats = new ClearingHouseUserStats({
+				clearingHouse: this,
+				userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+					this.program.programId,
+					this.wallet.publicKey
+				),
+				accountSubscription: this.userAccountSubscriptionConfig,
+			});
+		}
 
 		let marketIndexes = config.marketIndexes;
 		let bankIndexes = config.bankIndexes;
@@ -188,6 +201,9 @@ export class ClearingHouse {
 		const subscribePromises = this.subscribeUsers().concat(
 			this.accountSubscriber.subscribe()
 		);
+		if (this.userStats !== undefined) {
+			subscribePromises.concat(this.userStats.subscribe());
+		}
 		this.isSubscribed = (await Promise.all(subscribePromises)).reduce(
 			(success, prevSuccess) => success && prevSuccess
 		);
@@ -213,6 +229,9 @@ export class ClearingHouse {
 		const unsubscribePromises = this.unsubscribeUsers().concat(
 			this.accountSubscriber.unsubscribe()
 		);
+		if (this.userStats !== undefined) {
+			unsubscribePromises.concat(this.userStats.unsubscribe());
+		}
 		await Promise.all(unsubscribePromises);
 		this.isSubscribed = false;
 	}
@@ -302,6 +321,7 @@ export class ClearingHouse {
 		}
 
 		this.activeUserId = activeUserId;
+		this.userStatsAccountPublicKey = undefined;
 	}
 
 	public async switchActiveUser(userId: number): Promise<void> {
@@ -325,7 +345,12 @@ export class ClearingHouse {
 		const [userAccountPublicKey, initializeUserAccountIx] =
 			await this.getInitializeUserInstructions(userId, name);
 
-		const tx = new Transaction().add(initializeUserAccountIx);
+		const tx = new Transaction();
+		if (userId === 0) {
+			// not the safest assumption, can explicitly check if user stats account exists if it causes problems
+			tx.add(await this.getInitializeUserStatsIx());
+		}
+		tx.add(initializeUserAccountIx);
 		const { txSig } = await this.txSender.send(tx, [], this.opts);
 		return [txSig, userAccountPublicKey];
 	}
@@ -345,6 +370,7 @@ export class ClearingHouse {
 			await this.program.instruction.initializeUser(userId, nameBuffer, {
 				accounts: {
 					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.wallet.publicKey,
 					payer: this.wallet.publicKey,
 					rent: anchor.web3.SYSVAR_RENT_PUBKEY,
@@ -356,6 +382,19 @@ export class ClearingHouse {
 		return [userAccountPublicKey, initializeUserAccountIx];
 	}
 
+	async getInitializeUserStatsIx(): Promise<TransactionInstruction> {
+		return await this.program.instruction.initializeUserStats({
+			accounts: {
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				payer: this.wallet.publicKey,
+				rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+				systemProgram: anchor.web3.SystemProgram.programId,
+				state: await this.getStatePublicKey(),
+			},
+		});
+	}
+
 	public getUser(userId?: number): ClearingHouseUser {
 		userId = userId ?? this.activeUserId;
 		if (!this.users.has(userId)) {
@@ -368,6 +407,23 @@ export class ClearingHouse {
 		return [...this.users.values()];
 	}
 
+	public getUserStats(): ClearingHouseUserStats {
+		return this.userStats;
+	}
+
+	userStatsAccountPublicKey: PublicKey;
+	public getUserStatsAccountPublicKey(): PublicKey {
+		if (this.userStatsAccountPublicKey) {
+			return this.userStatsAccountPublicKey;
+		}
+
+		this.userStatsAccountPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey
+		);
+		return this.userStatsAccountPublicKey;
+	}
+
 	public async getUserAccountPublicKey(): Promise<PublicKey> {
 		return this.getUser().userAccountPublicKey;
 	}
@@ -831,6 +887,9 @@ export class ClearingHouse {
 						false
 				  );
 
+		if (userId === 0) {
+			tx.add(await this.getInitializeUserStatsIx());
+		}
 		tx.add(initializeUserAccountIx).add(depositCollateralIx);
 
 		// Close the wrapped sol account at the end of the transaction
@@ -880,11 +939,12 @@ export class ClearingHouse {
 			false
 		);
 
-		const tx = new Transaction()
-			.add(createAssociatedAccountIx)
-			.add(mintToIx)
-			.add(initializeUserAccountIx)
-			.add(depositCollateralIx);
+		const tx = new Transaction().add(createAssociatedAccountIx).add(mintToIx);
+
+		if (userId === 0) {
+			tx.add(await this.getInitializeUserStatsIx());
+		}
+		tx.add(initializeUserAccountIx).add(depositCollateralIx);
 
 		const txSig = await this.program.provider.sendAndConfirm(tx, []);
 
@@ -1056,6 +1116,135 @@ export class ClearingHouse {
 		});
 	}
 
+	public async settleLP(
+		settleeUserAccountPublicKey: PublicKey,
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.settleLPIx(settleeUserAccountPublicKey, marketIndex)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async settleLPIx(
+		settleeUserAccountPublicKey: PublicKey,
+		marketIndex: BN
+	): Promise<TransactionInstruction> {
+		const settleeUserAccount = (await this.program.account.user.fetch(
+			settleeUserAccountPublicKey
+		)) as UserAccount;
+		const userPositions = settleeUserAccount.positions;
+		const remainingAccounts = [];
+
+		let foundMarket = false;
+		for (const position of userPositions) {
+			if (!positionIsAvailable(position)) {
+				const marketPublicKey = await getMarketPublicKey(
+					this.program.programId,
+					position.marketIndex
+				);
+				remainingAccounts.push({
+					pubkey: marketPublicKey,
+					isWritable: true,
+					isSigner: false,
+				});
+
+				if (marketIndex.eq(position.marketIndex)) {
+					foundMarket = true;
+				}
+			}
+		}
+
+		if (!foundMarket) {
+			console.log(
+				'Warning: lp is not in the market specified -- tx will likely fail'
+			);
+		}
+
+		return this.program.instruction.settleLp(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: settleeUserAccountPublicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
+	public async removeLiquidity(
+		marketIndex: BN,
+		sharesToBurn?: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getRemoveLiquidityIx(marketIndex, sharesToBurn)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getRemoveLiquidityIx(
+		marketIndex: BN,
+		sharesToBurn?: BN
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: marketIndex,
+		});
+
+		if (sharesToBurn == undefined) {
+			const userAccount = this.getUserAccount();
+			const marketPosition = userAccount.positions.filter((position) =>
+				position.marketIndex.eq(marketIndex)
+			)[0];
+			sharesToBurn = marketPosition.lpShares;
+			console.log('burning lp shares:', sharesToBurn.toString());
+		}
+
+		return this.program.instruction.removeLiquidity(sharesToBurn, marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
+	public async addLiquidity(
+		amount: BN,
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig, slot } = await this.txSender.send(
+			wrapInTx(await this.getAddLiquidityIx(amount, marketIndex)),
+			[],
+			this.opts
+		);
+		this.marketLastSlotCache.set(marketIndex.toNumber(), slot);
+		return txSig;
+	}
+
+	public async getAddLiquidityIx(
+		amount: BN,
+		marketIndex: BN
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const remainingAccounts = this.getRemainingAccounts({
+			writableMarketIndex: marketIndex,
+		});
+
+		return this.program.instruction.addLiquidity(amount, marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
 	public async openPosition(
 		direction: PositionDirection,
 		amount: BN,
@@ -1101,6 +1290,7 @@ export class ClearingHouse {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
 				authority: this.wallet.publicKey,
 			},
 			remainingAccounts,
@@ -1228,7 +1418,13 @@ export class ClearingHouse {
 		order: Order,
 		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const fillerPublicKey = await this.getUserAccountPublicKey();
+		const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const marketIndex = order.marketIndex;
 		const marketAccount = this.getMarketAccount(marketIndex);
@@ -1298,6 +1494,11 @@ export class ClearingHouse {
 				isWritable: true,
 				isSigner: false,
 			});
+			remainingAccounts.push({
+				pubkey: makerInfo.makerStats,
+				isWritable: true,
+				isSigner: false,
+			});
 		}
 
 		const orderId = order.orderId;
@@ -1307,7 +1508,9 @@ export class ClearingHouse {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				filler: fillerPublicKey,
+				fillerStats: fillerStatsPublicKey,
 				user: userAccountPublicKey,
+				userStats: userStatsPublicKey,
 				authority: this.wallet.publicKey,
 			},
 			remainingAccounts,
@@ -1426,6 +1629,7 @@ export class ClearingHouse {
 		makerInfo?: MakerInfo
 	): Promise<TransactionInstruction> {
 		orderParams = this.getOrderParams(orderParams);
+		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
@@ -1441,6 +1645,11 @@ export class ClearingHouse {
 				isSigner: false,
 				isWritable: true,
 			});
+			remainingAccounts.push({
+				pubkey: makerInfo.makerStats,
+				isSigner: false,
+				isWritable: true,
+			});
 		}
 
 		return await this.program.instruction.placeAndTake(
@@ -1450,6 +1659,7 @@ export class ClearingHouse {
 				accounts: {
 					state: await this.getStatePublicKey(),
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
 					authority: this.wallet.publicKey,
 				},
 				remainingAccounts,
@@ -1477,20 +1687,14 @@ export class ClearingHouse {
 		takerInfo: TakerInfo
 	): Promise<TransactionInstruction> {
 		orderParams = this.getOrderParams(orderParams);
+		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccounts({
 			writableMarketIndex: orderParams.marketIndex,
-			writableBankIndex: QUOTE_ASSET_BANK_INDEX,
 		});
 
 		const takerOrderId = takerInfo!.order!.orderId;
-		remainingAccounts.push({
-			pubkey: takerInfo.taker,
-			isSigner: false,
-			isWritable: true,
-		});
-
 		return await this.program.instruction.placeAndMake(
 			orderParams,
 			takerOrderId,
@@ -1498,7 +1702,9 @@ export class ClearingHouse {
 				accounts: {
 					state: await this.getStatePublicKey(),
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
 					taker: takerInfo.taker,
+					takerStats: takerInfo.takerStats,
 					authority: this.wallet.publicKey,
 				},
 				remainingAccounts,
@@ -1511,7 +1717,10 @@ export class ClearingHouse {
 	 * @param marketIndex
 	 * @returns
 	 */
-	public async closePosition(marketIndex: BN): Promise<TransactionSignature> {
+	public async closePosition(
+		marketIndex: BN,
+		limitPrice?: BN
+	): Promise<TransactionSignature> {
 		const userPosition = this.getUser().getUserPosition(marketIndex);
 		if (!userPosition) {
 			throw Error(`No position in market ${marketIndex.toString()}`);
@@ -1521,8 +1730,9 @@ export class ClearingHouse {
 			orderType: OrderType.MARKET,
 			marketIndex,
 			direction: findDirectionToClose(userPosition),
-			baseAssetAmount: userPosition.baseAssetAmount,
+			baseAssetAmount: userPosition.baseAssetAmount.abs(),
 			reduceOnly: true,
+			price: limitPrice,
 		});
 	}
 
@@ -1577,6 +1787,7 @@ export class ClearingHouse {
 		const marketAccountMap = new Map<number, AccountMeta>();
 		const oracleAccountMap = new Map<string, AccountMeta>();
 		const bankAccountMap = new Map<number, AccountMeta>();
+
 		for (const position of settleeUserAccount.positions) {
 			if (!positionIsAvailable(position)) {
 				const market = this.getMarketAccount(position.marketIndex);
@@ -1672,7 +1883,13 @@ export class ClearingHouse {
 		marketIndex: BN,
 		maxBaseAssetAmount: BN
 	): Promise<TransactionInstruction> {
+		const userStatsPublicKey = getUserStatsAccountPublicKey(
+			this.program.programId,
+			userAccount.authority
+		);
+
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
 		const remainingAccounts = this.getRemainingAccountsForLiquidation({
 			writableMarketIndex: marketIndex,
@@ -1687,7 +1904,9 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					authority: this.wallet.publicKey,
 					user: userAccountPublicKey,
+					userStats: userStatsPublicKey,
 					liquidator: liquidatorPublicKey,
+					liquidatorStats: liquidatorStatsPublicKey,
 				},
 				remainingAccounts: remainingAccounts,
 			}
@@ -1855,6 +2074,90 @@ export class ClearingHouse {
 		);
 	}
 
+	public async resolvePerpBankruptcy(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getResolvePerpBankruptcyIx(
+					userAccountPublicKey,
+					userAccount,
+					marketIndex
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getResolvePerpBankruptcyIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		marketIndex: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+			writableMarketIndex: marketIndex,
+			userAccount,
+		});
+
+		return await this.program.instruction.resolvePerpBankruptcy(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				authority: this.wallet.publicKey,
+				user: userAccountPublicKey,
+				liquidator: liquidatorPublicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
+	public async resolveBorrowBankruptcy(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(
+				await this.getResolveBorrowBankruptcyIx(
+					userAccountPublicKey,
+					userAccount,
+					bankIndex
+				)
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getResolveBorrowBankruptcyIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount,
+		bankIndex: BN
+	): Promise<TransactionInstruction> {
+		const liquidatorPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+			writableBankIndexes: [bankIndex],
+			userAccount,
+		});
+
+		return await this.program.instruction.resolveBorrowBankruptcy(bankIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				authority: this.wallet.publicKey,
+				user: userAccountPublicKey,
+				liquidator: liquidatorPublicKey,
+			},
+			remainingAccounts: remainingAccounts,
+		});
+	}
+
 	getRemainingAccountsForLiquidation(params: {
 		userAccount: UserAccount;
 		writableMarketIndex?: BN;

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

@@ -53,7 +53,6 @@ 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;
@@ -137,6 +136,11 @@ export class ClearingHouseUser {
 			openOrders: ZERO,
 			openBids: ZERO,
 			openAsks: ZERO,
+			realizedPnl: ZERO,
+			lpShares: ZERO,
+			lastFeePerLp: ZERO,
+			lastNetBaseAssetAmountPerLp: ZERO,
+			lastNetQuoteAssetAmountPerLp: ZERO,
 		};
 	}
 
@@ -172,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
@@ -716,13 +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),
 			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);
@@ -753,14 +853,17 @@ export class ClearingHouseUser {
 							position,
 							this.getOracleDataForMarket(market.marketIndex)
 						);
-						const marketMarginRequirement = positionValue;
-						new BN(
-							calculateMarketMarginRatio(
-								market,
-								position.baseAssetAmount.abs(),
-								'Maintenance'
+						const marketMarginRequirement = positionValue
+							.mul(
+								new BN(
+									calculateMarketMarginRatio(
+										market,
+										position.baseAssetAmount.abs(),
+										'Maintenance'
+									)
+								)
 							)
-						).div(MARGIN_PRECISION);
+							.div(MARGIN_PRECISION);
 						totalMarginRequirement = totalMarginRequirement.add(
 							marketMarginRequirement
 						);