@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.12

package/lib/idl/clearing_house.json

@@ -2027,14 +2027,6 @@
                             "defined": "PoolBalance"
                         }
                     },
-                    {
-                        "name": "unsettledProfit",
-                        "type": "u128"
-                    },
-                    {
-                        "name": "unsettledLoss",
-                        "type": "u128"
-                    },
                     {
                         "name": "imfFactor",
                         "type": "u128"
@@ -2275,6 +2267,10 @@
                             ]
                         }
                     },
+                    {
+                        "name": "nextLiquidationId",
+                        "type": "u16"
+                    },
                     {
                         "name": "beingLiquidated",
                         "type": "bool"
@@ -2413,7 +2409,7 @@
                     },
                     {
                         "name": "quoteAssetAmount",
-                        "type": "u128"
+                        "type": "i128"
                     },
                     {
                         "name": "userPnl",
@@ -2615,11 +2611,19 @@
                     },
                     {
                         "name": "quoteAssetAmountLong",
-                        "type": "u128"
+                        "type": "i128"
                     },
                     {
                         "name": "quoteAssetAmountShort",
-                        "type": "u128"
+                        "type": "i128"
+                    },
+                    {
+                        "name": "quoteEntryAmountLong",
+                        "type": "i128"
+                    },
+                    {
+                        "name": "quoteEntryAmountShort",
+                        "type": "i128"
                     },
                     {
                         "name": "lastFundingRate",
@@ -3061,11 +3065,11 @@
                     },
                     {
                         "name": "quoteAssetAmount",
-                        "type": "u128"
+                        "type": "i128"
                     },
                     {
                         "name": "quoteEntryAmount",
-                        "type": "u128"
+                        "type": "i128"
                     },
                     {
                         "name": "lastCumulativeFundingRate",
@@ -3083,10 +3087,6 @@
                         "name": "openOrders",
                         "type": "u128"
                     },
-                    {
-                        "name": "unsettledPnl",
-                        "type": "i128"
-                    },
                     {
                         "name": "openBids",
                         "type": "i128"
@@ -3279,6 +3279,29 @@
                 ]
             }
         },
+        {
+            "name": "PositionUpdateType",
+            "type": {
+                "kind": "enum",
+                "variants": [
+                    {
+                        "name": "Open"
+                    },
+                    {
+                        "name": "Increase"
+                    },
+                    {
+                        "name": "Reduce"
+                    },
+                    {
+                        "name": "Close"
+                    },
+                    {
+                        "name": "Flip"
+                    }
+                ]
+            }
+        },
         {
             "name": "LiquidationMultiplierType",
             "type": {
@@ -3813,12 +3836,12 @@
                     "index": false
                 },
                 {
-                    "name": "makerUnsettledPnl",
+                    "name": "makerPnl",
                     "type": "i128",
                     "index": false
                 },
                 {
-                    "name": "takerUnsettledPnl",
+                    "name": "takerPnl",
                     "type": "i128",
                     "index": false
                 },
@@ -3923,6 +3946,11 @@
                     "type": "i128",
                     "index": false
                 },
+                {
+                    "name": "liquidationId",
+                    "type": "u16",
+                    "index": false
+                },
                 {
                     "name": "liquidatePerp",
                     "type": {
@@ -3952,6 +3980,46 @@
                     "index": false
                 }
             ]
+        },
+        {
+            "name": "SettlePnlRecord",
+            "fields": [
+                {
+                    "name": "ts",
+                    "type": "i64",
+                    "index": false
+                },
+                {
+                    "name": "marketIndex",
+                    "type": "u64",
+                    "index": false
+                },
+                {
+                    "name": "pnl",
+                    "type": "i128",
+                    "index": false
+                },
+                {
+                    "name": "baseAssetAmount",
+                    "type": "i128",
+                    "index": false
+                },
+                {
+                    "name": "quoteAssetAmountAfter",
+                    "type": "i128",
+                    "index": false
+                },
+                {
+                    "name": "quoteEntryAmount",
+                    "type": "i128",
+                    "index": false
+                },
+                {
+                    "name": "oraclePrice",
+                    "type": "i128",
+                    "index": false
+                }
+            ]
         }
     ],
     "errors": [
@@ -4457,6 +4525,16 @@
         },
         {
             "code": 6100,
+            "name": "InvalidPositionLastFundingRate",
+            "msg": "InvalidPositionLastFundingRate"
+        },
+        {
+            "code": 6101,
+            "name": "InvalidPositionDelta",
+            "msg": "InvalidPositionDelta"
+        },
+        {
+            "code": 6102,
             "name": "DefaultError",
             "msg": "DefaultError"
         }

package/lib/index.d.ts

@@ -34,6 +34,7 @@ export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
+export * from './math/margin';
 export * from './orders';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';

package/lib/index.js

@@ -57,6 +57,7 @@ __exportStar(require("./math/amm"), exports);
 __exportStar(require("./math/trade"), exports);
 __exportStar(require("./math/orders"), exports);
 __exportStar(require("./math/repeg"), exports);
+__exportStar(require("./math/margin"), exports);
 __exportStar(require("./orders"), exports);
 __exportStar(require("./orderParams"), exports);
 __exportStar(require("./slot/SlotSubscriber"), exports);

package/lib/math/bankBalance.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="bn.js" />
-import { BankAccount, BankBalanceType } from '../types';
+import { BankAccount, BankBalanceType, MarginCategory } from '../types';
 import { BN } from '@project-serum/anchor';
 export declare function getBalance(tokenAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
 export declare function getTokenAmount(balanceAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, bank: BankAccount, marginCategory: MarginCategory): BN;
+export declare function calculateLiabilityWeight(balanceAmount: BN, bank: BankAccount, marginCategory: MarginCategory): BN;
 export declare function calculateInterestAccumulated(bank: BankAccount, now: BN): {
     borrowInterest: BN;
     depositInterest: BN;

package/lib/math/bankBalance.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateInterestAccumulated = exports.getTokenAmount = exports.getBalance = void 0;
+exports.calculateInterestAccumulated = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenAmount = exports.getBalance = void 0;
 const types_1 = require("../types");
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
+const margin_1 = require("./margin");
 function getBalance(tokenAmount, bank, balanceType) {
     const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
     const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
@@ -24,6 +25,58 @@ function getTokenAmount(balanceAmount, bank, balanceType) {
     return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 exports.getTokenAmount = getTokenAmount;
+function calculateAssetWeight(balanceAmount, bank, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(bank.decimals));
+    let sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.initialAssetWeight);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.maintenanceAssetWeight);
+            break;
+        default:
+            assetWeight = bank.initialAssetWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateAssetWeight = calculateAssetWeight;
+function calculateLiabilityWeight(balanceAmount, bank, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(bank.decimals));
+    let sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.initialLiabilityWeight, numericConstants_1.BANK_WEIGHT_PRECISION);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.maintenanceLiabilityWeight, numericConstants_1.BANK_WEIGHT_PRECISION);
+            break;
+        default:
+            assetWeight = bank.initialLiabilityWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateLiabilityWeight = calculateLiabilityWeight;
 function calculateInterestAccumulated(bank, now) {
     const token_deposit_amount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
     const token_borrow_amount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);

package/lib/math/margin.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, UserPosition } from '..';
+export declare function calculateSizePremiumLiabilityWeight(size: BN, // AMM_RESERVE_PRECISION
+imfFactor: BN, liabilityWeight: BN, precision: BN): BN;
+export declare function calculateSizeDiscountAssetWeight(size: BN, // AMM_RESERVE_PRECISION
+imfFactor: BN, assetWeight: BN): BN;
+export declare function calculateOraclePriceForPerpMargin(marketPosition: UserPosition, market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarginBaseAssetValue(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculateWorstCaseBaseAssetAmount(marketPosition: UserPosition): BN;

package/lib/math/margin.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorstCaseBaseAssetAmount = exports.calculateMarginBaseAssetValue = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
+const utils_1 = require("./utils");
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@project-serum/anchor");
+function calculateSizePremiumLiabilityWeight(size, // AMM_RESERVE_PRECISION
+imfFactor, liabilityWeight, precision) {
+    if (imfFactor.eq(numericConstants_1.ZERO)) {
+        return liabilityWeight;
+    }
+    const sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
+    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.BANK_IMF_PRECISION.div(imfFactor))));
+    const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(sizeSqrt // 1e5
+        .mul(imfFactor)
+        .div(new anchor_1.BN(100000).mul(numericConstants_1.BANK_IMF_PRECISION).div(precision)) // 1e5
+    );
+    const maxLiabilityWeight = anchor_1.BN.max(liabilityWeight, sizePremiumLiabilityWeight);
+    return maxLiabilityWeight;
+}
+exports.calculateSizePremiumLiabilityWeight = calculateSizePremiumLiabilityWeight;
+function calculateSizeDiscountAssetWeight(size, // AMM_RESERVE_PRECISION
+imfFactor, assetWeight) {
+    if (imfFactor.eq(numericConstants_1.ZERO)) {
+        return assetWeight;
+    }
+    const sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
+    const imfNumerator = numericConstants_1.BANK_IMF_PRECISION.add(numericConstants_1.BANK_IMF_PRECISION.div(new anchor_1.BN(10)));
+    const sizeDiscountAssetWeight = imfNumerator.mul(numericConstants_1.BANK_WEIGHT_PRECISION).div(numericConstants_1.BANK_IMF_PRECISION.add(sizeSqrt // 1e5
+        .mul(imfFactor)
+        .div(new anchor_1.BN(100000)) // 1e5
+    ));
+    const minAssetWeight = anchor_1.BN.min(assetWeight, sizeDiscountAssetWeight);
+    return minAssetWeight;
+}
+exports.calculateSizeDiscountAssetWeight = calculateSizeDiscountAssetWeight;
+function calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceData) {
+    const oraclePriceOffset = anchor_1.BN.min(new anchor_1.BN(market.amm.maxSpread)
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BID_ASK_SPREAD_PRECISION), oraclePriceData.confidence.add(new anchor_1.BN(market.amm.baseSpread)
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BID_ASK_SPREAD_PRECISION)));
+    let marginPrice;
+    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
+    }
+    else {
+        marginPrice = oraclePriceData.price.add(oraclePriceOffset);
+    }
+    return marginPrice;
+}
+exports.calculateOraclePriceForPerpMargin = calculateOraclePriceForPerpMargin;
+function calculateMarginBaseAssetValue(market, marketPosition, oraclePriceData) {
+    const marginPrice = calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceData);
+    const baseAssetValue = marketPosition.baseAssetAmount
+        .abs()
+        .mul(marginPrice)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+    return baseAssetValue;
+}
+exports.calculateMarginBaseAssetValue = calculateMarginBaseAssetValue;
+function calculateWorstCaseBaseAssetAmount(marketPosition) {
+    const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
+    const allAsks = marketPosition.baseAssetAmount.add(marketPosition.openAsks);
+    if (allBids.abs().gt(allAsks.abs())) {
+        return allBids;
+    }
+    else {
+        return allAsks;
+    }
+}
+exports.calculateWorstCaseBaseAssetAmount = calculateWorstCaseBaseAssetAmount;

package/lib/math/market.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection, MarginCategory, BankAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 /**
  * Calculates market mark price
@@ -26,3 +26,6 @@ export declare function calculateAskPrice(market: MarketAccount, oraclePriceData
 export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: MarketAccount): MarketAccount;
 export declare function calculateMarkOracleSpread(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateOracleSpread(price: BN, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarketMarginRatio(market: MarketAccount, size: BN, marginCategory: MarginCategory): number;
+export declare function calculateUnsettledAssetWeight(market: MarketAccount, unsettledPnl: BN, marginCategory: MarginCategory): BN;
+export declare function calculateMarketAvailablePNL(market: MarketAccount, bank: BankAccount): BN;

package/lib/math/market.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+exports.calculateMarketAvailablePNL = exports.calculateUnsettledAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+const anchor_1 = require("@project-serum/anchor");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
+const margin_1 = require("./margin");
+const numericConstants_1 = require("../constants/numericConstants");
+const bankBalance_1 = require("./bankBalance");
 /**
  * Calculates market mark price
  *
@@ -55,3 +59,33 @@ function calculateOracleSpread(price, oraclePriceData) {
     return price.sub(oraclePriceData.price);
 }
 exports.calculateOracleSpread = calculateOracleSpread;
+function calculateMarketMarginRatio(market, size, marginCategory) {
+    let marginRatio;
+    switch (marginCategory) {
+        case 'Initial':
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, market.imfFactor, new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
+            break;
+        case 'Maintenance':
+            marginRatio = market.marginRatioMaintenance;
+            break;
+    }
+    return marginRatio;
+}
+exports.calculateMarketMarginRatio = calculateMarketMarginRatio;
+function calculateUnsettledAssetWeight(market, unsettledPnl, marginCategory) {
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unsettledPnl, market.unsettledImfFactor, new anchor_1.BN(market.unsettledInitialAssetWeight));
+            break;
+        case 'Maintenance':
+            assetWeight = new anchor_1.BN(market.unsettledMaintenanceAssetWeight);
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateUnsettledAssetWeight = calculateUnsettledAssetWeight;
+function calculateMarketAvailablePNL(market, bank) {
+    return (0, bankBalance_1.getTokenAmount)(market.pnlPool.balance, bank, types_1.BankBalanceType.DEPOSIT);
+}
+exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;

package/lib/math/position.d.ts

@@ -17,9 +17,11 @@ export declare function calculateBaseAssetValue(market: MarketAccount, userPosit
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export declare function calculatePositionPNL(market: MarketAccount, marketPosition: UserPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+export declare function calculateUnsettledPnl(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
 /**
  *
  * @param market
@@ -34,6 +36,12 @@ export declare function positionIsAvailable(position: UserPosition): boolean;
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
 export declare function calculateEntryPrice(userPosition: UserPosition): BN;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+export declare function calculateCostBasis(userPosition: UserPosition): BN;
 export declare function findDirectionToClose(userPosition: UserPosition): PositionDirection;
 export declare function positionCurrentDirection(userPosition: UserPosition): PositionDirection;
 export declare function isEmptyPosition(userPosition: UserPosition): boolean;

package/lib/math/position.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledPnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
+const margin_1 = require("./margin");
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -53,20 +54,20 @@ exports.calculateBaseAssetValue = calculateBaseAssetValue;
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
     if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    const baseAssetValue = calculateBaseAssetValue(market, marketPosition, oraclePriceData);
-    let pnl;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-        pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-    }
-    else {
-        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
+        return marketPosition.quoteAssetAmount;
     }
+    const baseAssetValue = (0, margin_1.calculateMarginBaseAssetValue)(market, marketPosition, oraclePriceData);
+    const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+        ? new __1.BN(-1)
+        : new __1.BN(1);
+    let pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(marketPosition.quoteAssetAmount);
     if (withFunding) {
         const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
         pnl = pnl.add(fundingRatePnL);
@@ -74,6 +75,19 @@ function calculatePositionPNL(market, marketPosition, withFunding = false, oracl
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
+function calculateUnsettledPnl(market, marketPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, marketPosition, true, oraclePriceData);
+    let unsettledPnl = unrealizedPnl;
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const maxPositivePnl = __1.BN.max(marketPosition.quoteAssetAmount
+            .add(marketPosition.quoteEntryAmount)
+            .add(fundingPnL), numericConstants_1.ZERO);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateUnsettledPnl = calculateUnsettledPnl;
 /**
  *
  * @param market
@@ -103,7 +117,7 @@ exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
 function positionIsAvailable(position) {
     return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
         position.openOrders.eq(numericConstants_1.ZERO) &&
-        position.unsettledPnl.eq(numericConstants_1.ZERO));
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO));
 }
 exports.positionIsAvailable = positionIsAvailable;
 /**
@@ -115,13 +129,29 @@ function calculateEntryPrice(userPosition) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    return userPosition.quoteAssetAmount
+    return userPosition.quoteEntryAmount
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(userPosition.baseAssetAmount)
         .abs();
 }
 exports.calculateEntryPrice = calculateEntryPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+function calculateCostBasis(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateCostBasis = calculateCostBasis;
 function findDirectionToClose(userPosition) {
     return userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
         ? types_1.PositionDirection.SHORT

package/lib/orders.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="bn.js" />
-import { MarketAccount, Order, UserAccount, UserPosition } from './types';
+import { MarketAccount, Order } from './types';
 import { BN } from '.';
 import { OraclePriceData } from '.';
-export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: MarketAccount, order: Order): [UserAccount, UserPosition, MarketAccount] | null;
 export declare function calculateBaseAssetAmountMarketCanExecute(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForLimit(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForTriggerLimit(market: MarketAccount, order: Order): BN;