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

package/lib/clearingHouseConfig.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="bn.js" />
+import { ConfirmOptions, Connection, PublicKey } from '@solana/web3.js';
+import { IWallet } from './types';
+import { BN } from '@project-serum/anchor';
+import { OracleInfo } from './oracles/types';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { DriftEnv } from './config';
+export declare type ClearingHouseConfig = {
+    connection: Connection;
+    wallet: IWallet;
+    programID: PublicKey;
+    accountSubscription?: ClearingHouseSubscriptionConfig;
+    opts?: ConfirmOptions;
+    txSenderConfig?: TxSenderConfig;
+    userIds?: number[];
+    activeUserId?: number;
+    marketIndexes?: BN[];
+    bankIndexes?: BN[];
+    oracleInfos?: OracleInfo[];
+    env?: DriftEnv;
+};
+declare type ClearingHouseSubscriptionConfig = {
+    type: 'websocket';
+} | {
+    type: 'polling';
+    accountLoader: BulkAccountLoader;
+};
+declare type TxSenderConfig = {
+    type: 'retry';
+    timeout?: number;
+    retrySleep?: number;
+    additionalConnections?: Connection[];
+};
+export {};

package/lib/clearingHouseConfig.js

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

package/lib/clearingHouseUser.d.ts

@@ -4,27 +4,20 @@ import { PublicKey } from '@solana/web3.js';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { ClearingHouse } from './clearingHouse';
-import { MarginCategory, Order, SettlementStateAccount, UserAccount, UserOrdersAccount, UserPosition, UserPositionsAccount } from './types';
-import { UserAccountSubscriber, UserAccountEvents } from './accounts/types';
+import { MarginCategory, Order, UserAccount, UserPosition } from './types';
+import { UserAccountSubscriber, UserAccountEvents, DataAndSlot } from './accounts/types';
 import { PositionDirection, BN } from '.';
+import { OraclePriceData } from './oracles/types';
+import { ClearingHouseUserConfig } from './clearingHouseUserConfig';
 export declare class ClearingHouseUser {
     clearingHouse: ClearingHouse;
-    authority: PublicKey;
+    userAccountPublicKey: PublicKey;
     accountSubscriber: UserAccountSubscriber;
-    userAccountPublicKey?: PublicKey;
-    userOrdersAccountPublicKey?: PublicKey;
     _isSubscribed: boolean;
     eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
     get isSubscribed(): boolean;
     set isSubscribed(val: boolean);
-    /**
-     * @deprecated You should use getClearingHouseUser factory method instead
-     * @param clearingHouse
-     * @param authority
-     * @returns
-     */
-    static from(clearingHouse: ClearingHouse, authority: PublicKey): ClearingHouseUser;
-    constructor(clearingHouse: ClearingHouse, authority: PublicKey, accountSubscriber: UserAccountSubscriber);
+    constructor(config: ClearingHouseUserConfig);
     /**
      * Subscribe to ClearingHouseUser state accounts
      * @returns SusbcriptionSuccess result
@@ -36,8 +29,7 @@ export declare class ClearingHouseUser {
     fetchAccounts(): Promise<void>;
     unsubscribe(): Promise<void>;
     getUserAccount(): UserAccount;
-    getUserPositionsAccount(): UserPositionsAccount;
-    getUserOrdersAccount(): UserOrdersAccount | undefined;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount> | undefined;
     /**
      * Gets the user's current position for a given market. If the user has no position returns undefined
      * @param marketIndex
@@ -55,8 +47,7 @@ export declare class ClearingHouseUser {
      * @returns Order
      */
     getOrderByUserOrderId(userOrderId: number): Order | undefined;
-    getUserAccountPublicKey(): Promise<PublicKey>;
-    getUserOrdersAccountPublicKey(): Promise<PublicKey>;
+    getUserAccountPublicKey(): PublicKey;
     exists(): Promise<boolean>;
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
@@ -78,13 +69,21 @@ export declare class ClearingHouseUser {
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN;
+    /**
+     * calculates unrealized position price pnl
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getUnsettledPNL(marketIndex?: BN): BN;
     /**
      * calculates unrealized funding payment pnl
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedFundingPNL(marketIndex?: BN): BN;
+    getTotalLiability(): BN;
+    getCollateralValue(bankIndex?: BN): BN;
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
+     * TODO: rename to total equity (for perpetuals swaps)
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalCollateral(): BN;
@@ -97,7 +96,7 @@ export declare class ClearingHouseUser {
      * calculates position value from closing 100%
      * @returns : Precision QUOTE_PRECISION
      */
-    getPositionValue(marketIndex: BN): BN;
+    getPositionValue(marketIndex: BN, oraclePriceData: OraclePriceData): BN;
     getPositionSide(currentPosition: Pick<UserPosition, 'baseAssetAmount'>): PositionDirection | undefined;
     /**
      * calculates average exit price for closing 100% of position
@@ -183,8 +182,6 @@ export declare class ClearingHouseUser {
      * @returns positionValue : Precision QUOTE_PRECISION
      */
     private getTotalPositionValueExcludingMarket;
-    getClaimableCollateral(settlementState: SettlementStateAccount): BN;
-    getSettledPositionValue(): BN;
-    getSettledPositionsPNL(): BN;
-    estimateClaimableCollateral(): Promise<BN>;
+    private getOracleDataForMarket;
+    private getOracleDataForBank;
 }

package/lib/clearingHouseUser.js

@@ -1,27 +1,25 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClearingHouseUser = void 0;
 const types_1 = require("./types");
 const position_1 = require("./math/position");
 const numericConstants_1 = require("./constants/numericConstants");
 const _1 = require(".");
-const addresses_1 = require("./addresses");
-const clearingHouseUser_1 = require("./factory/clearingHouseUser");
+const bankBalance_1 = require("./math/bankBalance");
+const pollingUserAccountSubscriber_1 = require("./accounts/pollingUserAccountSubscriber");
+const webSocketUserAccountSubscriber_1 = require("./accounts/webSocketUserAccountSubscriber");
 class ClearingHouseUser {
-    constructor(clearingHouse, authority, accountSubscriber) {
+    constructor(config) {
+        var _a;
         this._isSubscribed = false;
-        this.clearingHouse = clearingHouse;
-        this.authority = authority;
-        this.accountSubscriber = accountSubscriber;
+        this.clearingHouse = config.clearingHouse;
+        this.userAccountPublicKey = config.userAccountPublicKey;
+        if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
+            this.accountSubscriber = new pollingUserAccountSubscriber_1.PollingUserAccountSubscriber(config.clearingHouse.program, config.userAccountPublicKey, config.accountSubscription.accountLoader);
+        }
+        else {
+            this.accountSubscriber = new webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber(config.clearingHouse.program, config.userAccountPublicKey);
+        }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
     }
     get isSubscribed() {
@@ -30,52 +28,29 @@ class ClearingHouseUser {
     set isSubscribed(val) {
         this._isSubscribed = val;
     }
-    /**
-     * @deprecated You should use getClearingHouseUser factory method instead
-     * @param clearingHouse
-     * @param authority
-     * @returns
-     */
-    static from(clearingHouse, authority) {
-        if (clearingHouse.accountSubscriber.type !== 'websocket')
-            throw 'This method only works for clearing houses with a websocket account listener. Try using the getClearingHouseUser factory method to initialize a ClearingHouseUser instead';
-        const config = (0, clearingHouseUser_1.getWebSocketClearingHouseUserConfig)(clearingHouse, authority);
-        return (0, clearingHouseUser_1.getClearingHouseUser)(config);
-    }
     /**
      * Subscribe to ClearingHouseUser state accounts
      * @returns SusbcriptionSuccess result
      */
-    subscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Clearing house should already be subscribed, but await for the subscription just incase to avoid race condition
-            yield this.clearingHouse.subscribe();
-            this.isSubscribed = yield this.accountSubscriber.subscribe();
-            return this.isSubscribed;
-        });
+    async subscribe() {
+        this.isSubscribed = await this.accountSubscriber.subscribe();
+        return this.isSubscribed;
     }
     /**
      *	Forces the accountSubscriber to fetch account updates from rpc
      */
-    fetchAccounts() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.accountSubscriber.fetch();
-        });
+    async fetchAccounts() {
+        await this.accountSubscriber.fetch();
     }
-    unsubscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.accountSubscriber.unsubscribe();
-            this.isSubscribed = false;
-        });
+    async unsubscribe() {
+        await this.accountSubscriber.unsubscribe();
+        this.isSubscribed = false;
     }
     getUserAccount() {
-        return this.accountSubscriber.getUserAccount();
-    }
-    getUserPositionsAccount() {
-        return this.accountSubscriber.getUserPositionsAccount();
+        return this.accountSubscriber.getUserAccountAndSlot().data;
     }
-    getUserOrdersAccount() {
-        return this.accountSubscriber.getUserOrdersAccount();
+    getUserAccountAndSlot() {
+        return this.accountSubscriber.getUserAccountAndSlot();
     }
     /**
      * Gets the user's current position for a given market. If the user has no position returns undefined
@@ -83,7 +58,7 @@ class ClearingHouseUser {
      * @returns userPosition
      */
     getUserPosition(marketIndex) {
-        return this.getUserPositionsAccount().positions.find((position) => position.marketIndex.eq(marketIndex));
+        return this.getUserAccount().positions.find((position) => position.marketIndex.eq(marketIndex));
     }
     getEmptyPosition(marketIndex) {
         return {
@@ -91,7 +66,11 @@ class ClearingHouseUser {
             lastCumulativeFundingRate: numericConstants_1.ZERO,
             marketIndex,
             quoteAssetAmount: numericConstants_1.ZERO,
+            quoteEntryAmount: numericConstants_1.ZERO,
             openOrders: numericConstants_1.ZERO,
+            unsettledPnl: numericConstants_1.ZERO,
+            openBids: numericConstants_1.ZERO,
+            openAsks: numericConstants_1.ZERO,
         };
     }
     /**
@@ -99,39 +78,21 @@ class ClearingHouseUser {
      * @returns Order
      */
     getOrder(orderId) {
-        return this.getUserOrdersAccount().orders.find((order) => order.orderId.eq(orderId));
+        return this.getUserAccount().orders.find((order) => order.orderId.eq(orderId));
     }
     /**
      * @param userOrderId
      * @returns Order
      */
     getOrderByUserOrderId(userOrderId) {
-        return this.getUserOrdersAccount().orders.find((order) => order.userOrderId === userOrderId);
+        return this.getUserAccount().orders.find((order) => order.userOrderId === userOrderId);
     }
     getUserAccountPublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.userAccountPublicKey) {
-                return this.userAccountPublicKey;
-            }
-            this.userAccountPublicKey = yield (0, addresses_1.getUserAccountPublicKey)(this.clearingHouse.program.programId, this.authority);
-            return this.userAccountPublicKey;
-        });
-    }
-    getUserOrdersAccountPublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.userOrdersAccountPublicKey) {
-                return this.userOrdersAccountPublicKey;
-            }
-            this.userOrdersAccountPublicKey = yield (0, _1.getUserOrdersAccountPublicKey)(this.clearingHouse.program.programId, yield this.getUserAccountPublicKey());
-            return this.userOrdersAccountPublicKey;
-        });
+        return this.userAccountPublicKey;
     }
-    exists() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userAccountPublicKey = yield this.getUserAccountPublicKey();
-            const userAccountRPCResponse = yield this.clearingHouse.connection.getParsedAccountInfo(userAccountPublicKey);
-            return userAccountRPCResponse.value !== null;
-        });
+    async exists() {
+        const userAccountRPCResponse = await this.clearingHouse.connection.getParsedAccountInfo(this.userAccountPublicKey);
+        return userAccountRPCResponse.value !== null;
     }
     /**
      * calculates Buying Power = FC * MAX_LEVERAGE
@@ -153,34 +114,49 @@ class ClearingHouseUser {
         return freeCollateral.gte(numericConstants_1.ZERO) ? freeCollateral : numericConstants_1.ZERO;
     }
     getInitialMarginRequirement() {
-        return this.getUserPositionsAccount().positions.reduce((marginRequirement, marketPosition) => {
-            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-            return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition)
+        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.marginRatioInitial))
                 .div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO);
+        }, numericConstants_1.ZERO)
+            .add(this.getTotalLiability());
     }
     /**
      * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
      */
     getPartialMarginRequirement() {
-        return this.getUserPositionsAccount().positions.reduce((marginRequirement, marketPosition) => {
-            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-            return marginRequirement.add((0, _1.calculateBaseAssetValue)(market, marketPosition)
+        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))
                 .div(numericConstants_1.MARGIN_PRECISION));
-        }, numericConstants_1.ZERO);
+        }, numericConstants_1.ZERO)
+            .add(this.getTotalLiability());
     }
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedPNL(withFunding, marketIndex) {
-        return this.getUserPositionsAccount()
+        return this.getUserAccount()
             .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
             .reduce((pnl, marketPosition) => {
-            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-            return pnl.add((0, _1.calculatePositionPNL)(market, marketPosition, withFunding));
+            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);
         }, numericConstants_1.ZERO);
     }
     /**
@@ -188,39 +164,88 @@ class ClearingHouseUser {
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedFundingPNL(marketIndex) {
-        return this.getUserPositionsAccount()
+        return this.getUserAccount()
             .positions.filter((pos) => marketIndex ? pos.marketIndex === marketIndex : true)
             .reduce((pnl, marketPosition) => {
-            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+            const market = this.clearingHouse.getMarketAccount(marketPosition.marketIndex);
             return pnl.add((0, _1.calculatePositionFundingPNL)(market, marketPosition));
         }, numericConstants_1.ZERO);
     }
+    getTotalLiability() {
+        return this.getUserAccount().bankBalances.reduce((totalAssetValue, bankBalance) => {
+            if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
+                (0, types_1.isVariant)(bankBalance.balanceType, 'deposit')) {
+                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.initialLiabilityWeight)
+                .div(numericConstants_1.BANK_WEIGHT_PRECISION)
+                .div(numericConstants_1.MARK_PRICE_PRECISION));
+        }, numericConstants_1.ZERO);
+    }
+    getCollateralValue(bankIndex) {
+        return this.getUserAccount().bankBalances.reduce((totalAssetValue, bankBalance) => {
+            if (bankBalance.balance.eq(numericConstants_1.ZERO) ||
+                (bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))) {
+                return totalAssetValue;
+            }
+            // Todo this needs to account for whether it's based on initial or maintenance requirements
+            const bankAccount = 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
+                .mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+                .div(numericConstants_1.MARK_PRICE_PRECISION));
+        }, numericConstants_1.ZERO);
+    }
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
+     * TODO: rename to total equity (for perpetuals swaps)
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalCollateral() {
-        var _a;
-        return ((_a = this.getUserAccount().collateral.add(this.getUnrealizedPNL(true))) !== null && _a !== void 0 ? _a : new _1.BN(0));
+        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());
     }
     /**
      * calculates sum of position value across all positions
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalPositionValue() {
-        return this.getUserPositionsAccount().positions.reduce((positionValue, marketPosition) => {
-            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-            return positionValue.add((0, _1.calculateBaseAssetValue)(market, marketPosition));
+        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)));
         }, numericConstants_1.ZERO);
     }
     /**
      * calculates position value from closing 100%
      * @returns : Precision QUOTE_PRECISION
      */
-    getPositionValue(marketIndex) {
+    getPositionValue(marketIndex, oraclePriceData) {
         const userPosition = this.getUserPosition(marketIndex) || this.getEmptyPosition(marketIndex);
-        const market = this.clearingHouse.getMarket(userPosition.marketIndex);
-        return (0, _1.calculateBaseAssetValue)(market, userPosition);
+        const market = this.clearingHouse.getMarketAccount(userPosition.marketIndex);
+        return (0, _1.calculateBaseAssetValue)(market, userPosition, oraclePriceData);
     }
     getPositionSide(currentPosition) {
         if (currentPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
@@ -238,11 +263,12 @@ class ClearingHouseUser {
      * @returns : Precision MARK_PRICE_PRECISION
      */
     getPositionEstimatedExitPriceAndPnl(position, amountToClose) {
-        const market = this.clearingHouse.getMarket(position.marketIndex);
+        const market = this.clearingHouse.getMarketAccount(position.marketIndex);
         const entryPrice = (0, position_1.calculateEntryPrice)(position);
+        const oraclePriceData = this.getOracleDataForMarket(position.marketIndex);
         if (amountToClose) {
             if (amountToClose.eq(numericConstants_1.ZERO)) {
-                return [(0, _1.calculateMarkPrice)(market), numericConstants_1.ZERO];
+                return [(0, _1.calculateMarkPrice)(market, oraclePriceData), numericConstants_1.ZERO];
             }
             position = {
                 baseAssetAmount: amountToClose,
@@ -251,7 +277,7 @@ class ClearingHouseUser {
                 quoteAssetAmount: position.quoteAssetAmount,
             };
         }
-        const baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position);
+        const baseAssetValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
         if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
             return [numericConstants_1.ZERO, numericConstants_1.ZERO];
         }
@@ -284,7 +310,7 @@ class ClearingHouseUser {
      * @returns : Precision TEN_THOUSAND
      */
     getMaxLeverage(marketIndex, category = 'Initial') {
-        const market = this.clearingHouse.getMarket(marketIndex);
+        const market = this.clearingHouse.getMarketAccount(marketIndex);
         let marginRatioCategory;
         switch (category) {
             case 'Initial':
@@ -326,12 +352,11 @@ class ClearingHouseUser {
      * @returns
      */
     needsToSettleFundingPayment() {
-        const marketsAccount = this.clearingHouse.getMarketsAccount();
-        for (const userPosition of this.getUserPositionsAccount().positions) {
+        for (const userPosition of this.getUserAccount().positions) {
             if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
                 continue;
             }
-            const market = marketsAccount.markets[userPosition.marketIndex.toNumber()];
+            const market = this.clearingHouse.getMarketAccount(userPosition.marketIndex);
             if (market.amm.cumulativeFundingRateLong.eq(userPosition.lastCumulativeFundingRate) ||
                 market.amm.cumulativeFundingRateShort.eq(userPosition.lastCumulativeFundingRate)) {
                 continue;
@@ -371,18 +396,22 @@ class ClearingHouseUser {
             baseAssetAmount: proposedBaseAssetAmount,
             lastCumulativeFundingRate: currentMarketPosition.lastCumulativeFundingRate,
             quoteAssetAmount: new _1.BN(0),
+            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),
         };
         if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
             return new _1.BN(-1);
-        const market = this.clearingHouse.getMarket(proposedMarketPosition.marketIndex);
-        const proposedMarketPositionValue = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition);
+        const market = this.clearingHouse.getMarketAccount(proposedMarketPosition.marketIndex);
+        const proposedMarketPositionValue = (0, _1.calculateBaseAssetValue)(market, proposedMarketPosition, this.getOracleDataForMarket(market.marketIndex));
         // total position value after trade
         const totalPositionValueAfterTrade = totalPositionValueExcludingTargetMarket.add(proposedMarketPositionValue);
-        const marginRequirementExcludingTargetMarket = this.getUserPositionsAccount().positions.reduce((totalMarginRequirement, position) => {
+        const marginRequirementExcludingTargetMarket = this.getUserAccount().positions.reduce((totalMarginRequirement, position) => {
             if (!position.marketIndex.eq(marketPosition.marketIndex)) {
-                const market = this.clearingHouse.getMarket(position.marketIndex);
-                const positionValue = (0, _1.calculateBaseAssetValue)(market, position);
+                const market = this.clearingHouse.getMarketAccount(position.marketIndex);
+                const positionValue = (0, _1.calculateBaseAssetValue)(market, position, this.getOracleDataForMarket(market.marketIndex));
                 const marketMarginRequirement = positionValue
                     .mul(partial
                     ? new _1.BN(market.marginRatioPartial)
@@ -426,13 +455,13 @@ class ClearingHouseUser {
         }
         let markPriceAfterTrade;
         if (positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
-            markPriceAfterTrade = (0, _1.calculateMarkPrice)(this.clearingHouse.getMarket(marketPosition.marketIndex));
+            markPriceAfterTrade = (0, _1.calculateMarkPrice)(this.clearingHouse.getMarketAccount(marketPosition.marketIndex), this.getOracleDataForMarket(marketPosition.marketIndex));
         }
         else {
             const direction = positionBaseSizeChange.gt(numericConstants_1.ZERO)
                 ? _1.PositionDirection.LONG
                 : _1.PositionDirection.SHORT;
-            markPriceAfterTrade = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.clearingHouse.getMarket(marketPosition.marketIndex), 'base')[3]; // newPrice after swap
+            markPriceAfterTrade = (0, _1.calculateTradeSlippage)(direction, positionBaseSizeChange.abs(), this.clearingHouse.getMarketAccount(marketPosition.marketIndex), 'base', this.getOracleDataForMarket(marketPosition.marketIndex))[3]; // newPrice after swap
         }
         if (priceDelta.gt(markPriceAfterTrade)) {
             return new _1.BN(-1);
@@ -457,7 +486,7 @@ class ClearingHouseUser {
             .neg();
         return this.liquidationPrice({
             marketIndex: positionMarketIndex,
-        }, closeBaseAmount);
+        }, closeBaseAmount, true);
     }
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
@@ -490,10 +519,11 @@ class ClearingHouseUser {
         const targetingSameSide = !currentPosition
             ? true
             : targetSide === currentPositionSide;
+        const oracleData = this.getOracleDataForMarket(targetMarketIndex);
         // add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
         const oppositeSizeValueUSDC = targetingSameSide
             ? numericConstants_1.ZERO
-            : this.getPositionValue(targetMarketIndex);
+            : this.getPositionValue(targetMarketIndex, oracleData);
         let maxPositionSize = this.getBuyingPower(targetMarketIndex);
         if (maxPositionSize.gte(numericConstants_1.ZERO)) {
             if (oppositeSizeValueUSDC.eq(numericConstants_1.ZERO)) {
@@ -508,8 +538,8 @@ class ClearingHouseUser {
         else {
             // current leverage is greater than max leverage - can only reduce position size
             if (!targetingSameSide) {
-                const market = this.clearingHouse.getMarket(targetMarketIndex);
-                const marketPositionValue = this.getPositionValue(targetMarketIndex);
+                const market = this.clearingHouse.getMarketAccount(targetMarketIndex);
+                const marketPositionValue = this.getPositionValue(targetMarketIndex, oracleData);
                 const totalCollateral = this.getTotalCollateral();
                 const marginRequirement = this.getInitialMarginRequirement();
                 const marginFreedByClosing = marketPositionValue
@@ -547,7 +577,8 @@ class ClearingHouseUser {
     accountLeverageRatioAfterTrade(targetMarketIndex, tradeQuoteAmount, tradeSide) {
         const currentPosition = this.getUserPosition(targetMarketIndex) ||
             this.getEmptyPosition(targetMarketIndex);
-        let currentPositionQuoteAmount = this.getPositionValue(targetMarketIndex);
+        const oracleData = this.getOracleDataForMarket(targetMarketIndex);
+        let currentPositionQuoteAmount = this.getPositionValue(targetMarketIndex, oracleData);
         const currentSide = currentPosition && currentPosition.baseAssetAmount.isNeg()
             ? _1.PositionDirection.SHORT
             : _1.PositionDirection.LONG;
@@ -591,39 +622,22 @@ class ClearingHouseUser {
     getTotalPositionValueExcludingMarket(marketToIgnore) {
         const currentMarketPosition = this.getUserPosition(marketToIgnore) ||
             this.getEmptyPosition(marketToIgnore);
+        const oracleData = this.getOracleDataForMarket(marketToIgnore);
         let currentMarketPositionValueUSDC = numericConstants_1.ZERO;
         if (currentMarketPosition) {
-            currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore);
+            currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore, oracleData);
         }
         return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
     }
-    getClaimableCollateral(settlementState) {
-        return this.getSettledPositionValue()
-            .mul(settlementState.collateralAvailableToClaim.sub(this.getUserAccount().lastCollateralAvailableToClaim))
-            .div(settlementState.totalSettlementValue);
-    }
-    getSettledPositionValue() {
-        return _1.BN.max(this.getUserAccount()
-            .collateral.add(this.getUnrealizedFundingPNL().div(numericConstants_1.PRICE_TO_QUOTE_PRECISION))
-            .add(this.getSettledPositionsPNL()), numericConstants_1.ZERO);
-    }
-    getSettledPositionsPNL() {
-        return this.getUserPositionsAccount().positions.reduce((pnl, marketPosition) => {
-            const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
-            return pnl.add((0, position_1.calculateSettledPositionPNL)(market, marketPosition));
-        }, numericConstants_1.ZERO);
+    getOracleDataForMarket(marketIndex) {
+        const oracleKey = this.clearingHouse.getMarketAccount(marketIndex).amm.oracle;
+        const oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
     }
-    estimateClaimableCollateral() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentCollateralVaultBalance = new _1.BN((yield this.clearingHouse.connection.getTokenAccountBalance(this.clearingHouse.getStateAccount().collateralVault)).value.amount);
-            const currentInsuranceVaultBalance = new _1.BN((yield this.clearingHouse.connection.getTokenAccountBalance(this.clearingHouse.getStateAccount().insuranceVault)).value.amount);
-            const totalClaimableCollateral = currentCollateralVaultBalance.add(currentInsuranceVaultBalance);
-            const totalEstimatedSettlementValue = yield this.clearingHouse.getTotalSettlementSize();
-            const userSettledPositionValue = yield this.getSettledPositionValue();
-            return totalClaimableCollateral
-                .mul(userSettledPositionValue)
-                .div(totalEstimatedSettlementValue);
-        });
+    getOracleDataForBank(bankIndex) {
+        const oracleKey = this.clearingHouse.getBankAccount(bankIndex).oracle;
+        const oracleData = this.clearingHouse.getOraclePriceDataAndSlot(oracleKey).data;
+        return oracleData;
     }
 }
 exports.ClearingHouseUser = ClearingHouseUser;