@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.20

package/lib/clearingHouseConfig.d.ts

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

package/lib/clearingHouseUser.d.ts

@@ -49,6 +49,11 @@ export declare class ClearingHouseUser {
     getOrderByUserOrderId(userOrderId: number): Order | undefined;
     getUserAccountPublicKey(): PublicKey;
     exists(): Promise<boolean>;
+    /**
+     * calculates the market position if the lp position was settled
+     * @returns : userPosition
+     */
+    getSettledLPPosition(marketIndex: BN): [UserPosition, BN];
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
      * @returns : Precision QUOTE_PRECISION
@@ -61,48 +66,43 @@ export declare class ClearingHouseUser {
     getFreeCollateral(): BN;
     getInitialMarginRequirement(): BN;
     /**
-     * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
-     */
-    getPartialMarginRequirement(): BN;
-    /**
-     * calculates unrealized position price pnl
-     * @returns : Precision QUOTE_PRECISION
+     * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
      */
-    getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN;
+    getMaintenanceMarginRequirement(): BN;
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
      */
-    getUnsettledPNL(marketIndex?: BN): BN;
+    getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
     /**
      * calculates unrealized funding payment pnl
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedFundingPNL(marketIndex?: BN): BN;
-    getTotalLiability(): BN;
-    getCollateralValue(bankIndex?: BN): BN;
+    getBankLiabilityValue(bankIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
+    getBankAssetValue(bankIndex?: BN, withWeightMarginCategory?: MarginCategory): BN;
+    getNetBankValue(withWeightMarginCategory?: MarginCategory): BN;
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
-     * TODO: rename to total equity (for perpetuals swaps)
      * @returns : Precision QUOTE_PRECISION
      */
-    getTotalCollateral(): BN;
+    getTotalCollateral(marginCategory?: MarginCategory): BN;
     /**
-     * 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;
     /**
-     * calculates position value from closing 100%
+     * calculates position value in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getPositionValue(marketIndex: BN, oraclePriceData: OraclePriceData): BN;
     getPositionSide(currentPosition: Pick<UserPosition, 'baseAssetAmount'>): PositionDirection | undefined;
     /**
-     * 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
      */
-    getPositionEstimatedExitPriceAndPnl(position: UserPosition, amountToClose?: BN): [BN, BN];
+    getPositionEstimatedExitPriceAndPnl(position: UserPosition, amountToClose?: BN, useAMMClose?: boolean): [BN, BN];
     /**
      * calculates current user leverage across all positions
      * @returns : Precision TEN_THOUSAND
@@ -132,7 +132,7 @@ export declare class ClearingHouseUser {
      * @param partial
      * @returns Precision : MARK_PRICE_PRECISION
      */
-    liquidationPrice(marketPosition: Pick<UserPosition, 'marketIndex'>, positionBaseSizeChange?: BN, partial?: boolean): BN;
+    liquidationPrice(marketPosition: Pick<UserPosition, 'marketIndex'>, positionBaseSizeChange?: BN): BN;
     /**
      * Calculates the estimated liquidation price for a position after closing a quote amount of the position.
      * @param positionMarketIndex

package/lib/clearingHouseUser.js

@@ -6,6 +6,7 @@ const position_1 = require("./math/position");
 const numericConstants_1 = require("./constants/numericConstants");
 const _1 = require(".");
 const bankBalance_1 = require("./math/bankBalance");
+const margin_1 = require("./math/margin");
 const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
 const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
 class ClearingHouseUser {
@@ -68,9 +69,13 @@ class ClearingHouseUser {
             quoteAssetAmount: numericConstants_1.ZERO,
             quoteEntryAmount: numericConstants_1.ZERO,
             openOrders: numericConstants_1.ZERO,
-            unsettledPnl: numericConstants_1.ZERO,
             openBids: numericConstants_1.ZERO,
             openAsks: numericConstants_1.ZERO,
+            realizedPnl: numericConstants_1.ZERO,
+            lpShares: numericConstants_1.ZERO,
+            lastFeePerLp: numericConstants_1.ZERO,
+            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
         };
     }
     /**
@@ -94,6 +99,89 @@ class ClearingHouseUser {
         const userAccountRPCResponse = await this.clearingHouse.connection.getParsedAccountInfo(this.userAccountPublicKey);
         return userAccountRPCResponse.value !== null;
     }
+    /**
+     * calculates the market position if the lp position was settled
+     * @returns : userPosition
+     */
+    getSettledLPPosition(marketIndex) {
+        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(numericConstants_1.AMM_RESERVE_PRECISION);
+        const deltaQaa = market.amm.marketPositionPerLp.quoteAssetAmount
+            .sub(position.lastNetQuoteAssetAmountPerLp)
+            .mul(nShares)
+            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+        function sign(v) {
+            const sign = { true: new _1.BN(1), false: new _1.BN(-1) }[v.gte(numericConstants_1.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(numericConstants_1.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(numericConstants_1.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(numericConstants_1.ZERO)) {
+            position.lastCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+        }
+        else if (position.baseAssetAmount.lt(numericConstants_1.ZERO)) {
+            position.lastCumulativeFundingRate =
+                market.amm.cumulativeFundingRateShort;
+        }
+        else {
+            position.lastCumulativeFundingRate = numericConstants_1.ZERO;
+        }
+        return [position, pnl];
+    }
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
      * @returns : Precision QUOTE_PRECISION
@@ -114,49 +202,55 @@ class ClearingHouseUser {
         return freeCollateral.gte(numericConstants_1.ZERO) ? freeCollateral : numericConstants_1.ZERO;
     }
     getInitialMarginRequirement() {
-        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((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex))
-                .mul(new _1.BN(market.marginRatioInitial))
-                .div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO)
-            .add(this.getTotalLiability());
+            const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(marketPosition);
+            const worstCaseAssetValue = worstCaseBaseAssetAmount
+                .abs()
+                .mul(this.getOracleDataForMarket(market.marketIndex).price)
+                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+            const marketMarginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), 'Initial'));
+            return marginRequirement.add(worstCaseAssetValue.mul(marketMarginRatio).div(numericConstants_1.MARGIN_PRECISION));
+        }, numericConstants_1.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
      */
-    getPartialMarginRequirement() {
+    getMaintenanceMarginRequirement() {
         return this.getUserAccount()
             .positions.reduce((marginRequirement, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex))
-                .mul(new _1.BN(market.marginRatioPartial))
+            const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(marketPosition);
+            const worstCaseAssetValue = worstCaseBaseAssetAmount
+                .abs()
+                .mul(this.getOracleDataForMarket(market.marketIndex).price)
+                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+            return marginRequirement.add(worstCaseAssetValue
+                .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, worstCaseBaseAssetAmount.abs(), 'Maintenance')))
                 .div(numericConstants_1.MARGIN_PRECISION));
         }, numericConstants_1.ZERO)
-            .add(this.getTotalLiability());
+            .add(this.getBankLiabilityValue(undefined, 'Maintenance'));
     }
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
      */
-    getUnrealizedPNL(withFunding, marketIndex) {
+    getUnrealizedPNL(withFunding, marketIndex, withWeightMarginCategory) {
         return this.getUserAccount()
             .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
-            .reduce((pnl, marketPosition) => {
+            .reduce((unrealizedPnl, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return pnl.add((0, _1.calculatePositionPNL)(market, marketPosition, withFunding, this.getOracleDataForMarket(market.marketIndex)));
-        }, numericConstants_1.ZERO);
-    }
-    /**
-     * calculates unrealized position price pnl
-     * @returns : Precision QUOTE_PRECISION
-     */
-    getUnsettledPNL(marketIndex) {
-        return this.getUserAccount()
-            .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
-            .reduce((pnl, marketPosition) => {
-            return pnl.add(marketPosition.unsettledPnl);
+            let positionUnrealizedPnl = (0, _1.calculatePositionPNL)(market, marketPosition, withFunding, this.getOracleDataForMarket(market.marketIndex));
+            if (withWeightMarginCategory !== undefined) {
+                if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                    positionUnrealizedPnl = positionUnrealizedPnl
+                        .mul((0, _1.calculateUnrealizedAssetWeight)(market, positionUnrealizedPnl, withWeightMarginCategory))
+                        .div(new _1.BN(numericConstants_1.BANK_WEIGHT_PRECISION));
+                }
+            }
+            return unrealizedPnl.add(positionUnrealizedPnl);
         }, numericConstants_1.ZERO);
     }
     /**
@@ -171,81 +265,79 @@ class ClearingHouseUser {
             return pnl.add((0, _1.calculatePositionFundingPNL)(market, marketPosition));
         }, numericConstants_1.ZERO);
     }
-    getTotalLiability() {
-        return this.getUserAccount().bankBalances.reduce((totalAssetValue, bankBalance) => {
+    getBankLiabilityValue(bankIndex, withWeightMarginCategory) {
+        return this.getUserAccount().bankBalances.reduce((totalLiabilityValue, bankBalance) => {
             if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
-                (0, types_1.isVariant)(bankBalance.balanceType, 'deposit')) {
-                return totalAssetValue;
+                (0, types_1.isVariant)(bankBalance.balanceType, 'deposit') ||
+                (bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))) {
+                return totalLiabilityValue;
             }
             // Todo this needs to account for whether it's based on initial or maintenance requirements
             const bankAccount = this.clearingHouse.getBankAccount(bankBalance.bankIndex);
             const tokenAmount = (0, bankBalance_1.getTokenAmount)(bankBalance.balance, bankAccount, bankBalance.balanceType);
-            return totalAssetValue.add(tokenAmount
+            let liabilityValue = tokenAmount
                 .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-                .mul(bankAccount.initialLiabilityWeight)
-                .div(numericConstants_1.BANK_WEIGHT_PRECISION)
-                .div(numericConstants_1.MARK_PRICE_PRECISION));
+                .div(numericConstants_1.MARK_PRICE_PRECISION)
+                .div(new _1.BN(10).pow(new _1.BN(bankAccount.decimals).sub(numericConstants_1.BANK_BALANCE_PRECISION_EXP)));
+            if (withWeightMarginCategory !== undefined) {
+                const weight = (0, bankBalance_1.calculateLiabilityWeight)(tokenAmount, bankAccount, withWeightMarginCategory);
+                liabilityValue = liabilityValue
+                    .mul(weight)
+                    .div(numericConstants_1.BANK_WEIGHT_PRECISION);
+            }
+            return totalLiabilityValue.add(liabilityValue);
         }, numericConstants_1.ZERO);
     }
-    getCollateralValue(bankIndex) {
+    getBankAssetValue(bankIndex, withWeightMarginCategory) {
         return this.getUserAccount().bankBalances.reduce((totalAssetValue, bankBalance) => {
             if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
+                (0, types_1.isVariant)(bankBalance.balanceType, 'borrow') ||
                 (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 = this.clearingHouse.getBankAccount(bankBalance.bankIndex);
-            let tokenAmount = (0, bankBalance_1.getTokenAmount)(bankBalance.balance, bankAccount, bankBalance.balanceType);
-            if ((0, types_1.isVariant)(bankBalance.balanceType, 'borrow')) {
-                tokenAmount = tokenAmount.mul(new _1.BN(-1));
-            }
-            return totalAssetValue.add(tokenAmount
+            const tokenAmount = (0, bankBalance_1.getTokenAmount)(bankBalance.balance, bankAccount, bankBalance.balanceType);
+            let assetValue = tokenAmount
                 .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-                .div(numericConstants_1.MARK_PRICE_PRECISION));
+                .div(numericConstants_1.MARK_PRICE_PRECISION)
+                .div(new _1.BN(10).pow(new _1.BN(bankAccount.decimals).sub(numericConstants_1.BANK_BALANCE_PRECISION_EXP)));
+            if (withWeightMarginCategory !== undefined) {
+                const weight = (0, bankBalance_1.calculateAssetWeight)(tokenAmount, bankAccount, withWeightMarginCategory);
+                assetValue = assetValue.mul(weight).div(numericConstants_1.BANK_WEIGHT_PRECISION);
+            }
+            return totalAssetValue.add(assetValue);
         }, numericConstants_1.ZERO);
     }
+    getNetBankValue(withWeightMarginCategory) {
+        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
      */
-    getTotalCollateral() {
-        return this.getUserAccount()
-            .bankBalances.reduce((totalAssetValue, bankBalance) => {
-            if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
-                (0, types_1.isVariant)(bankBalance.balanceType, 'borrow')) {
-                return totalAssetValue;
-            }
-            // Todo this needs to account for whether it's based on initial or maintenance requirements
-            const bankAccount = this.clearingHouse.getBankAccount(bankBalance.bankIndex);
-            const tokenAmount = (0, bankBalance_1.getTokenAmount)(bankBalance.balance, bankAccount, bankBalance.balanceType);
-            return totalAssetValue.add(tokenAmount
-                .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-                .mul(bankAccount.initialAssetWeight)
-                .div(numericConstants_1.BANK_WEIGHT_PRECISION)
-                .div(numericConstants_1.MARK_PRICE_PRECISION));
-        }, numericConstants_1.ZERO)
-            .add(this.getUnrealizedPNL(true))
-            .add(this.getUnsettledPNL());
+    getTotalCollateral(marginCategory = 'Initial') {
+        return this.getBankAssetValue(undefined, marginCategory).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() {
         return this.getUserAccount().positions.reduce((positionValue, marketPosition) => {
             const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
-            return positionValue.add((0, _1.calculateBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex)));
+            const posVal = (0, margin_1.calculateMarginBaseAssetValue)(market, marketPosition, this.getOracleDataForMarket(market.marketIndex));
+            return positionValue.add(posVal);
         }, numericConstants_1.ZERO);
     }
     /**
-     * calculates position value from closing 100%
+     * calculates position value in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getPositionValue(marketIndex, oraclePriceData) {
         const userPosition = this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
         const market = this.clearingHouse.getMarketAccount(userPosition.marketIndex);
-        return (0, _1.calculateBaseAssetValue)(market, userPosition, oraclePriceData);
+        return (0, margin_1.calculateMarginBaseAssetValue)(market, userPosition, oraclePriceData);
     }
     getPositionSide(currentPosition) {
         if (currentPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
@@ -259,10 +351,10 @@ 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
      */
-    getPositionEstimatedExitPriceAndPnl(position, amountToClose) {
+    getPositionEstimatedExitPriceAndPnl(position, amountToClose, useAMMClose = false) {
         const market = this.clearingHouse.getMarketAccount(position.marketIndex);
         const entryPrice = (0, position_1.calculateEntryPrice)(position);
         const oraclePriceData = this.getOracleDataForMarket(position.marketIndex);
@@ -277,7 +369,13 @@ class ClearingHouseUser {
                 quoteAssetAmount: position.quoteAssetAmount,
             };
         }
-        const baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
+        let baseAssetValue;
+        if (useAMMClose) {
+            baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
+        }
+        else {
+            baseAssetValue = (0, margin_1.calculateMarginBaseAssetValue)(market, position, oraclePriceData);
+        }
         if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
             return [numericConstants_1.ZERO, numericConstants_1.ZERO];
         }
@@ -311,21 +409,10 @@ class ClearingHouseUser {
      */
     getMaxLeverage(marketIndex, category = 'Initial') {
         const market = this.clearingHouse.getMarketAccount(marketIndex);
-        let marginRatioCategory;
-        switch (category) {
-            case 'Initial':
-                marginRatioCategory = market.marginRatioInitial;
-                break;
-            case 'Maintenance':
-                marginRatioCategory = market.marginRatioMaintenance;
-                break;
-            case 'Partial':
-                marginRatioCategory = market.marginRatioPartial;
-                break;
-            default:
-                marginRatioCategory = market.marginRatioInitial;
-                break;
-        }
+        const marginRatioCategory = (0, _1.calculateMarketMarginRatio)(market, 
+        // worstCaseBaseAssetAmount.abs(),
+        numericConstants_1.ZERO, // todo
+        category);
         const maxLeverage = numericConstants_1.TEN_THOUSAND.mul(numericConstants_1.TEN_THOUSAND).div(new _1.BN(marginRatioCategory));
         return maxLeverage;
     }
@@ -342,7 +429,7 @@ class ClearingHouseUser {
     }
     canBeLiquidated() {
         const totalCollateral = this.getTotalCollateral();
-        const partialMaintenanceRequirement = this.getPartialMarginRequirement();
+        const partialMaintenanceRequirement = this.getMaintenanceMarginRequirement();
         const marginRatio = this.getMarginRatio();
         const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
         return [canLiquidate, marginRatio];
@@ -372,7 +459,7 @@ class ClearingHouseUser {
      * @param partial
      * @returns Precision : MARK_PRICE_PRECISION
      */
-    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO, partial = false) {
+    liquidationPrice(marketPosition, positionBaseSizeChange = numericConstants_1.ZERO) {
         // solves formula for example canBeLiquidated below
         /* example: assume BTC price is $40k (examine 10% up/down)
 
@@ -394,28 +481,30 @@ class ClearingHouseUser {
         const proposedMarketPosition = {
             marketIndex: marketPosition.marketIndex,
             baseAssetAmount: proposedBaseAssetAmount,
-            lastCumulativeFundingRate: currentMarketPosition.lastCumulativeFundingRate,
             quoteAssetAmount: new _1.BN(0),
+            lastCumulativeFundingRate: numericConstants_1.ZERO,
             quoteEntryAmount: new _1.BN(0),
             openOrders: new _1.BN(0),
-            unsettledPnl: new _1.BN(0),
             openBids: new _1.BN(0),
             openAsks: new _1.BN(0),
+            realizedPnl: numericConstants_1.ZERO,
+            lpShares: numericConstants_1.ZERO,
+            lastFeePerLp: numericConstants_1.ZERO,
+            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
         };
         if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
             return new _1.BN(-1);
         const market = this.clearingHouse.getMarketAccount(proposedMarketPosition.marketIndex);
-        const proposedMarketPositionValue = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition, this.getOracleDataForMarket(market.marketIndex));
+        const proposedMarketPositionValue = (0, margin_1.calculateMarginBaseAssetValue)(market, proposedMarketPosition, this.getOracleDataForMarket(market.marketIndex));
         // total position value after trade
         const totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
         const marginRequirementExcludingTargetMarket = this.getUserAccount().positions.reduce((totalMarginRequirement, position) => {
             if (!position.marketIndex.eq(marketPosition.marketIndex)) {
                 const market = this.clearingHouse.getMarketAccount(position.marketIndex);
-                const positionValue = (0, _1.calculateBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
+                const positionValue = (0, margin_1.calculateMarginBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
                 const marketMarginRequirement = positionValue
-                    .mul(partial
-                    ? new _1.BN(market.marginRatioPartial)
-                    : new _1.BN(market.marginRatioMaintenance))
+                    .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, position.baseAssetAmount.abs(), 'Maintenance')))
                     .div(numericConstants_1.MARGIN_PRECISION);
                 totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
             }
@@ -428,14 +517,10 @@ class ClearingHouseUser {
             return new _1.BN(-1);
         }
         const marginRequirementAfterTrade = marginRequirementExcludingTargetMarket.add(proposedMarketPositionValue
-            .mul(partial
-            ? new _1.BN(market.marginRatioPartial)
-            : new _1.BN(market.marginRatioMaintenance))
+            .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, proposedMarketPosition.baseAssetAmount.abs(), 'Maintenance')))
             .div(numericConstants_1.MARGIN_PRECISION));
         const freeCollateralAfterTrade = totalCollateral.sub(marginRequirementAfterTrade);
-        const marketMaxLeverage = partial
-            ? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-            : this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+        const marketMaxLeverage = this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
         let priceDelta;
         if (proposedBaseAssetAmount.lt(numericConstants_1.ZERO)) {
             priceDelta = freeCollateralAfterTrade
@@ -479,14 +564,14 @@ class ClearingHouseUser {
             this.getEmptyPosition(positionMarketIndex);
         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();
         return this.liquidationPrice({
             marketIndex: positionMarketIndex,
-        }, closeBaseAmount, true);
+        }, closeBaseAmount);
     }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.

package/lib/clearingHouseUserStats.d.ts

@@ -0,0 +1,18 @@
+import { ClearingHouse } from './clearingHouse';
+import { PublicKey } from '@solana/web3.js';
+import { DataAndSlot, UserStatsAccountSubscriber } from './accounts/types';
+import { ClearingHouseUserStatsConfig } from './clearingHouseUserStatsConfig';
+import { ReferrerInfo, UserStatsAccount } from './types';
+export declare class ClearingHouseUserStats {
+    clearingHouse: ClearingHouse;
+    userStatsAccountPublicKey: PublicKey;
+    accountSubscriber: UserStatsAccountSubscriber;
+    isSubscribed: boolean;
+    constructor(config: ClearingHouseUserStatsConfig);
+    subscribe(): Promise<boolean>;
+    fetchAccounts(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+    getAccount(): UserStatsAccount;
+    getReferrerInfo(): ReferrerInfo | undefined;
+}

package/lib/clearingHouseUserStats.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClearingHouseUserStats = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const pollingUserStatsAccountSubscriber_1 = require("./accounts/pollingUserStatsAccountSubscriber");
+const webSocketUserStatsAccountSubsriber_1 = require("./accounts/webSocketUserStatsAccountSubsriber");
+const pda_1 = require("./addresses/pda");
+class ClearingHouseUserStats {
+    constructor(config) {
+        var _a;
+        this.clearingHouse = config.clearingHouse;
+        this.userStatsAccountPublicKey = config.userStatsAccountPublicKey;
+        if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
+            this.accountSubscriber = new pollingUserStatsAccountSubscriber_1.PollingUserStatsAccountSubscriber(config.clearingHouse.program, config.userStatsAccountPublicKey, config.accountSubscription.accountLoader);
+        }
+        else {
+            this.accountSubscriber = new webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber(config.clearingHouse.program, config.userStatsAccountPublicKey);
+        }
+    }
+    async subscribe() {
+        this.isSubscribed = await this.accountSubscriber.subscribe();
+        return this.isSubscribed;
+    }
+    async fetchAccounts() {
+        await this.accountSubscriber.fetch();
+    }
+    async unsubscribe() {
+        await this.accountSubscriber.unsubscribe();
+        this.isSubscribed = false;
+    }
+    getAccountAndSlot() {
+        return this.accountSubscriber.getUserStatsAccountAndSlot();
+    }
+    getAccount() {
+        return this.accountSubscriber.getUserStatsAccountAndSlot().data;
+    }
+    getReferrerInfo() {
+        if (this.getAccount().referrer.equals(web3_js_1.PublicKey.default)) {
+            return undefined;
+        }
+        else {
+            return {
+                referrer: (0, pda_1.getUserAccountPublicKeySync)(this.clearingHouse.program.programId, this.getAccount().referrer, 0),
+                referrerStats: (0, pda_1.getUserStatsAccountPublicKey)(this.clearingHouse.program.programId, this.getAccount().referrer),
+            };
+        }
+    }
+}
+exports.ClearingHouseUserStats = ClearingHouseUserStats;

package/lib/clearingHouseUserStatsConfig.d.ts

@@ -0,0 +1,14 @@
+import { ClearingHouse } from './clearingHouse';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+export declare type ClearingHouseUserStatsConfig = {
+    accountSubscription?: ClearingHouseUserStatsAccountSubscriptionConfig;
+    clearingHouse: ClearingHouse;
+    userStatsAccountPublicKey: PublicKey;
+};
+export declare type ClearingHouseUserStatsAccountSubscriptionConfig = {
+    type: 'websocket';
+} | {
+    type: 'polling';
+    accountLoader: BulkAccountLoader;
+};

package/lib/clearingHouseUserStatsConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config.js

@@ -7,7 +7,7 @@ exports.configs = {
     devnet: {
         ENV: 'devnet',
         PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-        CLEARING_HOUSE_PROGRAM_ID: '9jwr5nC2f9yAraXrg4UzHXmCX3vi9FQkjD6p9e8bRqNa',
+        CLEARING_HOUSE_PROGRAM_ID: '65sz7dRiWDRPZjiRxcTxPM7AE6VK4Nag9HEK6oBJXhJn',
         USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
         MARKETS: markets_1.DevnetMarkets,
         BANKS: banks_1.DevnetBanks,