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

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/amm.js

@@ -8,11 +8,11 @@ const assert_1 = require("../assert/assert");
 const __1 = require("..");
 const repeg_1 = require("./repeg");
 function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetReserve) {
-    return targetPrice
+    return anchor_1.BN.max(targetPrice
         .mul(baseAssetReserve)
         .div(quoteAssetReserve)
         .add(numericConstants_1.PRICE_DIV_PEG.div(new anchor_1.BN(2)))
-        .div(numericConstants_1.PRICE_DIV_PEG);
+        .div(numericConstants_1.PRICE_DIV_PEG), numericConstants_1.ONE);
 }
 exports.calculatePegFromTargetPrice = calculatePegFromTargetPrice;
 function calculateOptimalPegAndBudget(amm, oraclePriceData) {

package/lib/math/bankBalance.d.ts

@@ -1,9 +1,15 @@
 /// <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;
 };
+export declare function calculateWithdrawLimit(bank: BankAccount, now: BN): {
+    borrowLimit: BN;
+    withdrawLimit: 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.calculateWithdrawLimit = 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);
@@ -73,3 +126,25 @@ function calculateInterestAccumulated(bank, now) {
     return { borrowInterest, depositInterest };
 }
 exports.calculateInterestAccumulated = calculateInterestAccumulated;
+function calculateWithdrawLimit(bank, now) {
+    const bankDepositTokenAmount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
+    const bankBorrowTokenAmount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);
+    const twentyFourHours = new anchor_1.BN(60 * 60 * 24);
+    const sinceLast = now.sub(bank.lastUpdated);
+    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, twentyFourHours.sub(sinceLast));
+    const borrowTokenTwapLive = bank.borrowTokenTwap
+        .mul(sinceStart)
+        .add(bankBorrowTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    const depositTokenTwapLive = bank.depositTokenTwap
+        .mul(sinceStart)
+        .add(bankDepositTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    const maxBorrowTokens = anchor_1.BN.min(anchor_1.BN.max(bankDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), bankDepositTokenAmount.sub(bankDepositTokenAmount.div(new anchor_1.BN(10)))); // between ~15-90% utilization with friction on twap
+    const minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.min(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), bank.withdrawGuardThreshold), depositTokenTwapLive));
+    return {
+        borrowLimit: maxBorrowTokens.sub(bankBorrowTokenAmount),
+        withdrawLimit: bankDepositTokenAmount.sub(minDepositTokens),
+    };
+}
+exports.calculateWithdrawLimit = calculateWithdrawLimit;

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/oracles.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="bn.js" />
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
+import { BN } from '../index';
 export declare function isOracleValid(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
+export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, now: BN): boolean;

package/lib/math/oracles.js

@@ -1,19 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOracleValid = void 0;
+exports.isOracleTooDivergent = exports.isOracleValid = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const index_1 = require("../index");
 function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
-    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
+    const isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
     const isOraclePriceTooVolatile = oraclePriceData.price
         .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
         .gt(oracleGuardRails.validity.tooVolatileRatio) ||
         amm.lastOraclePriceTwap
             .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
             .gt(oracleGuardRails.validity.tooVolatileRatio);
-    const isConfidenceTooLarge = oraclePriceData.price
-        .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
-        .lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+    const isConfidenceTooLarge = new index_1.BN(amm.baseSpread)
+        .add(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(oraclePriceData.price)
+        .gt(new index_1.BN(amm.maxSpread));
     const oracleIsStale = oraclePriceData.slot
         .sub(new index_1.BN(slot))
         .gt(oracleGuardRails.validity.slotsBeforeStale);
@@ -24,3 +26,21 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         isConfidenceTooLarge);
 }
 exports.isOracleValid = isOracleValid;
+function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
+    const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, new index_1.BN(60 * 5).sub(sinceLastUpdate));
+    const oracleTwap5min = amm.lastOraclePriceTwap5min
+        .mul(sinceStart)
+        .add(oraclePriceData.price)
+        .mul(sinceLastUpdate)
+        .div(sinceStart.add(sinceLastUpdate));
+    const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+    const oracleSpreadPct = oracleSpread
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(oracleTwap5min);
+    const tooDivergent = oracleSpreadPct
+        .abs()
+        .gte(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(oracleGuardRails.priceDivergence.markOracleDivergenceNumerator).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator));
+    return tooDivergent;
+}
+exports.isOracleTooDivergent = isOracleTooDivergent;

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,8 @@ 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) &&
+        position.lpShares.eq(numericConstants_1.ZERO));
 }
 exports.positionIsAvailable = positionIsAvailable;
 /**
@@ -115,13 +130,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/math/trade.js

@@ -113,8 +113,8 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection);
     const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    const acquiredQuoteAssetamount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
-    return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
+    const acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**

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;

package/lib/orders.js

@@ -1,85 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = void 0;
 const types_1 = require("./types");
 const _1 = require(".");
-const market_1 = require("./math/market");
 const numericConstants_1 = require("./constants/numericConstants");
 const amm_1 = require("./math/amm");
-const position_1 = require("./math/position");
-function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
-        return null;
-    }
-    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-        return null;
-    }
-    const userAccountAfter = Object.assign({}, userAccount);
-    const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = (0, position_1.positionCurrentDirection)(userPosition);
-    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
-        isSameDirection(order.direction, currentPositionDirection);
-    if (increasePosition) {
-        const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
-        const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
-        userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-        userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
-        return [userAccountAfter, userPositionAfter, marketAfter];
-    }
-    else {
-        const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
-        if (reversePosition) {
-            const intermediateMarket = (0, market_1.calculateNewMarketAfterTrade)(userPosition.baseAssetAmount, (0, position_1.findDirectionToClose)(userPosition), market);
-            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
-            let pnl;
-            if ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-            }
-            else {
-                pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
-            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountLeft, order.direction, intermediateMarket);
-            const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
-            userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-            userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-        else {
-            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
-            const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
-            const costBasisRealized = userPosition.quoteAssetAmount
-                .mul(baseAssetAmountSwapped.abs())
-                .div(userPosition.baseAssetAmount.abs());
-            let pnl;
-            if ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(costBasisRealized);
-            }
-            else {
-                pnl = costBasisRealized.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-            userPositionAfter.quoteAssetAmount =
-                userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-    }
-}
-exports.calculateNewStateAfterOrder = calculateNewStateAfterOrder;
-function calculateAmountSwapped(marketBefore, marketAfter) {
-    return {
-        quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-            .sub(marketAfter.amm.quoteAssetReserve)
-            .abs()
-            .mul(marketBefore.amm.pegMultiplier)
-            .div(numericConstants_1.PEG_PRECISION)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO),
-        baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
-    };
-}
 function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
     if ((0, types_1.isVariant)(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order, oraclePriceData);
@@ -103,7 +28,7 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
         }
         limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
     const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);

package/lib/tokenFaucet.d.ts

@@ -21,6 +21,7 @@ export declare class TokenFaucet {
     getFaucetConfigPublicKey(): Promise<PublicKey>;
     initialize(): Promise<TransactionSignature>;
     fetchState(): Promise<any>;
+    private mintToUserIx;
     mintToUser(userTokenAccount: PublicKey, amount: BN): Promise<TransactionSignature>;
     transferMintAuthority(): Promise<TransactionSignature>;
     createAssociatedTokenAccountAndMintTo(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionSignature]>;