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

package/lib/clearingHouse.js

@@ -45,6 +45,7 @@ const retryTxSender_1 = require("./tx/retryTxSender");
 const clearingHouseUser_1 = require("./clearingHouseUser");
 const config_1 = require("./config");
 const banks_1 = require("./constants/banks");
+const clearingHouseUserStats_1 = require("./clearingHouseUserStats");
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -72,6 +73,13 @@ class ClearingHouse {
                     type: 'websocket',
                 };
         this.createUsers(userIds, this.userAccountSubscriptionConfig);
+        if (config.userStats) {
+            this.userStats = new clearingHouseUserStats_1.ClearingHouseUserStats({
+                clearingHouse: this,
+                userStatsAccountPublicKey: (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey),
+                accountSubscription: this.userAccountSubscriptionConfig,
+            });
+        }
         let marketIndexes = config.marketIndexes;
         let bankIndexes = config.bankIndexes;
         let oracleInfos = config.oracleInfos;
@@ -112,6 +120,9 @@ class ClearingHouse {
     }
     async subscribe() {
         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);
         return this.isSubscribed;
     }
@@ -128,6 +139,9 @@ class ClearingHouse {
     }
     async unsubscribe() {
         const unsubscribePromises = this.unsubscribeUsers().concat(this.accountSubscriber.unsubscribe());
+        if (this.userStats !== undefined) {
+            unsubscribePromises.concat(this.userStats.unsubscribe());
+        }
         await Promise.all(unsubscribePromises);
         this.isSubscribed = false;
     }
@@ -188,6 +202,7 @@ class ClearingHouse {
             await Promise.all(this.subscribeUsers());
         }
         this.activeUserId = activeUserId;
+        this.userStatsAccountPublicKey = undefined;
     }
     async switchActiveUser(userId) {
         this.activeUserId = userId;
@@ -202,7 +217,12 @@ class ClearingHouse {
     }
     async initializeUserAccount(userId = 0, name = userName_1.DEFAULT_USER_NAME) {
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
-        const tx = new web3_js_1.Transaction().add(initializeUserAccountIx);
+        const tx = new web3_js_1.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];
     }
@@ -212,6 +232,7 @@ class ClearingHouse {
         const initializeUserAccountIx = 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,
@@ -221,6 +242,18 @@ class ClearingHouse {
         });
         return [userAccountPublicKey, initializeUserAccountIx];
     }
+    async getInitializeUserStatsIx() {
+        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(),
+            },
+        });
+    }
     getUser(userId) {
         userId = userId !== null && userId !== void 0 ? userId : this.activeUserId;
         if (!this.users.has(userId)) {
@@ -231,6 +264,16 @@ class ClearingHouse {
     getUsers() {
         return [...this.users.values()];
     }
+    getUserStats() {
+        return this.userStats;
+    }
+    getUserStatsAccountPublicKey() {
+        if (this.userStatsAccountPublicKey) {
+            return this.userStatsAccountPublicKey;
+        }
+        this.userStatsAccountPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.wallet.publicKey);
+        return this.userStatsAccountPublicKey;
+    }
     async getUserAccountPublicKey() {
         return this.getUser().userAccountPublicKey;
     }
@@ -511,6 +554,9 @@ class ClearingHouse {
         const depositCollateralIx = fromUserId != null
             ? await this.getTransferDepositIx(amount, bankIndex, fromUserId, userId)
             : await this.getDepositInstruction(amount, bankIndex, userTokenAccount, userId, false, 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
         if (createWSOLTokenAccount) {
@@ -523,11 +569,11 @@ class ClearingHouse {
         const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(userId, name);
         const depositCollateralIx = await this.getDepositInstruction(amount, bankIndex, associateTokenPublicKey, userId, false, false);
-        const tx = new web3_js_1.Transaction()
-            .add(createAssociatedAccountIx)
-            .add(mintToIx)
-            .add(initializeUserAccountIx)
-            .add(depositCollateralIx);
+        const tx = new web3_js_1.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, []);
         return [txSig, userAccountPublicKey];
     }
@@ -607,6 +653,82 @@ class ClearingHouse {
             },
         });
     }
+    async settleLP(settleeUserAccountPublicKey, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.settleLPIx(settleeUserAccountPublicKey, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async settleLPIx(settleeUserAccountPublicKey, marketIndex) {
+        const settleeUserAccount = (await this.program.account.user.fetch(settleeUserAccountPublicKey));
+        const userPositions = settleeUserAccount.positions;
+        const remainingAccounts = [];
+        let foundMarket = false;
+        for (const position of userPositions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                const marketPublicKey = await (0, pda_1.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,
+        });
+    }
+    async removeLiquidity(marketIndex, sharesToBurn) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getRemoveLiquidityIx(marketIndex, sharesToBurn)), [], this.opts);
+        return txSig;
+    }
+    async getRemoveLiquidityIx(marketIndex, sharesToBurn) {
+        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,
+        });
+    }
+    async addLiquidity(amount, marketIndex) {
+        const { txSig, slot } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getAddLiquidityIx(amount, marketIndex)), [], this.opts);
+        this.marketLastSlotCache.set(marketIndex.toNumber(), slot);
+        return txSig;
+    }
+    async getAddLiquidityIx(amount, marketIndex) {
+        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,
+        });
+    }
     async openPosition(direction, amount, marketIndex, limitPrice) {
         return await this.placeAndTake({
             orderType: types_1.OrderType.MARKET,
@@ -634,6 +756,7 @@ class ClearingHouse {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -713,7 +836,9 @@ class ClearingHouse {
         return txSig;
     }
     async getFillOrderIx(userAccountPublicKey, userAccount, order, makerInfo) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const fillerPublicKey = await this.getUserAccountPublicKey();
+        const fillerStatsPublicKey = this.getUserStatsAccountPublicKey();
         const marketIndex = order.marketIndex;
         const marketAccount = this.getMarketAccount(marketIndex);
         const oracleAccountMap = new Map();
@@ -773,6 +898,11 @@ class ClearingHouse {
                 isWritable: true,
                 isSigner: false,
             });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
+                isWritable: true,
+                isSigner: false,
+            });
         }
         const orderId = order.orderId;
         const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
@@ -780,7 +910,9 @@ class ClearingHouse {
             accounts: {
                 state: await this.getStatePublicKey(),
                 filler: fillerPublicKey,
+                fillerStats: fillerStatsPublicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -863,6 +995,7 @@ class ClearingHouse {
     }
     async getPlaceAndTakeIx(orderParams, makerInfo) {
         orderParams = this.getOrderParams(orderParams);
+        const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
@@ -876,11 +1009,17 @@ class ClearingHouse {
                 isSigner: false,
                 isWritable: true,
             });
+            remainingAccounts.push({
+                pubkey: makerInfo.makerStats,
+                isSigner: false,
+                isWritable: true,
+            });
         }
         return await this.program.instruction.placeAndTake(orderParams, makerOrderId, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -893,22 +1032,19 @@ class ClearingHouse {
     }
     async getPlaceAndMakeIx(orderParams, takerInfo) {
         orderParams = this.getOrderParams(orderParams);
+        const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const userAccountPublicKey = await this.getUserAccountPublicKey();
         const remainingAccounts = this.getRemainingAccounts({
             writableMarketIndex: orderParams.marketIndex,
-            writableBankIndex: numericConstants_1.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, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 taker: takerInfo.taker,
+                takerStats: takerInfo.takerStats,
                 authority: this.wallet.publicKey,
             },
             remainingAccounts,
@@ -919,7 +1055,7 @@ class ClearingHouse {
      * @param marketIndex
      * @returns
      */
-    async closePosition(marketIndex) {
+    async closePosition(marketIndex, limitPrice) {
         const userPosition = this.getUser().getUserPosition(marketIndex);
         if (!userPosition) {
             throw Error(`No position in market ${marketIndex.toString()}`);
@@ -928,8 +1064,9 @@ class ClearingHouse {
             orderType: types_1.OrderType.MARKET,
             marketIndex,
             direction: (0, position_1.findDirectionToClose)(userPosition),
-            baseAssetAmount: userPosition.baseAssetAmount,
+            baseAssetAmount: userPosition.baseAssetAmount.abs(),
             reduceOnly: true,
+            price: limitPrice,
         });
     }
     async settlePNLs(users, marketIndex) {
@@ -1016,7 +1153,9 @@ class ClearingHouse {
         return txSig;
     }
     async getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount) {
+        const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, userAccount.authority);
         const liquidatorPublicKey = await this.getUserAccountPublicKey();
+        const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
         const remainingAccounts = this.getRemainingAccountsForLiquidation({
             writableMarketIndex: marketIndex,
             userAccount,
@@ -1026,7 +1165,9 @@ class ClearingHouse {
                 state: await this.getStatePublicKey(),
                 authority: this.wallet.publicKey,
                 user: userAccountPublicKey,
+                userStats: userStatsPublicKey,
                 liquidator: liquidatorPublicKey,
+                liquidatorStats: liquidatorStatsPublicKey,
             },
             remainingAccounts: remainingAccounts,
         });
@@ -1093,6 +1234,46 @@ class ClearingHouse {
             remainingAccounts: remainingAccounts,
         });
     }
+    async resolvePerpBankruptcy(userAccountPublicKey, userAccount, marketIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex)), [], this.opts);
+        return txSig;
+    }
+    async getResolvePerpBankruptcyIx(userAccountPublicKey, userAccount, marketIndex) {
+        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,
+        });
+    }
+    async resolveBorrowBankruptcy(userAccountPublicKey, userAccount, bankIndex) {
+        const { txSig } = await this.txSender.send((0, utils_1.wrapInTx)(await this.getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex)), [], this.opts);
+        return txSig;
+    }
+    async getResolveBorrowBankruptcyIx(userAccountPublicKey, userAccount, bankIndex) {
+        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) {
         const liquidateeUserAccount = params.userAccount;
         const oracleAccountMap = new Map();

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

package/lib/clearingHouseUser.js

@@ -71,6 +71,11 @@ class ClearingHouseUser {
             openOrders: 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
@@ -411,12 +499,17 @@ 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),
             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);
@@ -428,8 +521,9 @@ class ClearingHouseUser {
             if (!position.marketIndex.eq(marketPosition.marketIndex)) {
                 const market = this.clearingHouse.getMarketAccount(position.marketIndex);
                 const positionValue = (0, margin_1.calculateMarginBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
-                const marketMarginRequirement = positionValue;
-                new _1.BN((0, _1.calculateMarketMarginRatio)(market, position.baseAssetAmount.abs(), 'Maintenance')).div(numericConstants_1.MARGIN_PRECISION);
+                const marketMarginRequirement = positionValue
+                    .mul(new _1.BN((0, _1.calculateMarketMarginRatio)(market, position.baseAssetAmount.abs(), 'Maintenance')))
+                    .div(numericConstants_1.MARGIN_PRECISION);
                 totalMarginRequirement = totalMarginRequirement.add(marketMarginRequirement);
             }
             return totalMarginRequirement;

package/lib/clearingHouseUserStats.d.ts

@@ -0,0 +1,17 @@
+import { ClearingHouse } from './clearingHouse';
+import { PublicKey } from '@solana/web3.js';
+import { DataAndSlot, UserStatsAccountSubscriber } from './accounts/types';
+import { ClearingHouseUserStatsConfig } from './clearingHouseUserStatsConfig';
+import { 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;
+}

package/lib/clearingHouseUserStats.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClearingHouseUserStats = void 0;
+const pollingUserStatsAccountSubscriber_1 = require("./accounts/pollingUserStatsAccountSubscriber");
+const webSocketUserStatsAccountSubsriber_1 = require("./accounts/webSocketUserStatsAccountSubsriber");
+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;
+    }
+}
+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/config.js

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

package/lib/factory/bigNum.js

@@ -137,7 +137,8 @@ class BigNum {
      */
     print() {
         (0, assert_1.assert)(this.precision.gte(numericConstants_1.ZERO), 'Tried to print a BN with precision lower than zero');
-        const plainString = this.toString();
+        const isNeg = this.isNeg();
+        const plainString = this.abs().toString();
         const precisionNum = this.precision.toNumber();
         // make a string with at least the precisionNum number of zeroes
         let printString = [
@@ -152,14 +153,11 @@ class BigNum {
         // remove leading zeroes
         printString = printString.replace(/^0+/, '');
         // add zero if leading delim
-        if (this.isNeg()) {
-            if (printString[1] === BigNum.delim)
-                printString = printString.replace('-.', '-0.');
-        }
-        else {
-            if (printString[0] === BigNum.delim)
-                printString = `0${printString}`;
-        }
+        if (printString[0] === BigNum.delim)
+            printString = `0${printString}`;
+        // Add minus if negative
+        if (isNeg)
+            printString = `-${printString}`;
         // remove trailing delim
         if (printString[printString.length - 1] === BigNum.delim)
             printString = printString.slice(0, printString.length - 1);