@drift-labs/sdk 0.2.0-master.29 → 0.2.0-master.30

package/lib/math/amm.d.ts

@@ -19,7 +19,7 @@ export declare function calculateBidAskPrice(amm: AMM, oraclePriceData: OraclePr
  * @param baseAssetReserves
  * @param quoteAssetReserves
  * @param pegMultiplier
- * @returns price : Precision MARK_PRICE_PRECISION
+ * @returns price : Precision PRICE_PRECISION
  */
 export declare function calculatePrice(baseAssetReserves: BN, quoteAssetReserves: BN, pegMultiplier: BN): BN;
 export declare type AssetType = 'quote' | 'base';
@@ -64,7 +64,7 @@ export declare function getSwapDirection(inputAssetType: AssetType, positionDire
  * Helper function calculating terminal price of amm
  *
  * @param market
- * @returns cost : Precision MARK_PRICE_PRECISION
+ * @returns cost : Precision PRICE_PRECISION
  */
 export declare function calculateTerminalPrice(market: PerpMarketAccount): BN;
 export declare function calculateMaxBaseAssetAmountToTrade(amm: AMM, limit_price: BN, direction: PositionDirection, oraclePriceData?: OraclePriceData): [BN, PositionDirection];

package/lib/math/amm.js

@@ -127,14 +127,14 @@ exports.calculateBidAskPrice = calculateBidAskPrice;
  * @param baseAssetReserves
  * @param quoteAssetReserves
  * @param pegMultiplier
- * @returns price : Precision MARK_PRICE_PRECISION
+ * @returns price : Precision PRICE_PRECISION
  */
 function calculatePrice(baseAssetReserves, quoteAssetReserves, pegMultiplier) {
     if (baseAssetReserves.abs().lte(numericConstants_1.ZERO)) {
         return new anchor_1.BN(0);
     }
     return quoteAssetReserves
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .mul(pegMultiplier)
         .div(numericConstants_1.PEG_PRECISION)
         .div(baseAssetReserves);
@@ -187,10 +187,10 @@ exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
 function calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
     // inventory skew
     const [openBids, openAsks] = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
-    const totalLiquidity = anchor_1.BN.max(openBids.abs().add(openAsks.abs()), new anchor_1.BN(1));
-    const inventoryScale = anchor_1.BN.min(netBaseAssetAmount.abs(), totalLiquidity)
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(5)))
-        .div(totalLiquidity)
+    const minSideLiquidity = anchor_1.BN.max(new anchor_1.BN(1), anchor_1.BN.min(openBids.abs(), openAsks.abs()));
+    const inventoryScale = anchor_1.BN.min(netBaseAssetAmount.abs(), minSideLiquidity)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10)))
+        .div(minSideLiquidity)
         .toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
     return inventoryScale;
 }
@@ -203,7 +203,7 @@ function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuote
         .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
     const localBaseAssetValue = netBaseAssetAmount
         .mul(markPrice)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
     const effectiveLeverage = localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
         (Math.max(0, totalFeeMinusDistributions.toNumber()) + 1) +
         1 / numericConstants_1.QUOTE_PRECISION.toNumber();
@@ -353,7 +353,7 @@ exports.getSwapDirection = getSwapDirection;
  * Helper function calculating terminal price of amm
  *
  * @param market
- * @returns cost : Precision MARK_PRICE_PRECISION
+ * @returns cost : Precision PRICE_PRECISION
  */
 function calculateTerminalPrice(market) {
     const directionToClose = market.amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
@@ -361,7 +361,7 @@ function calculateTerminalPrice(market) {
         : types_1.PositionDirection.LONG;
     const [newQuoteAssetReserve, newBaseAssetReserve] = calculateAmmReservesAfterSwap(market.amm, 'base', market.amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
     const terminalPrice = newQuoteAssetReserve
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .mul(market.amm.pegMultiplier)
         .div(numericConstants_1.PEG_PRECISION)
         .div(newBaseAssetReserve);
@@ -371,7 +371,7 @@ exports.calculateTerminalPrice = calculateTerminalPrice;
 function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, oraclePriceData) {
     const invariant = amm.sqrtK.mul(amm.sqrtK);
     const newBaseAssetReserveSquared = invariant
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .mul(amm.pegMultiplier)
         .div(limit_price)
         .div(numericConstants_1.PEG_PRECISION);

package/lib/math/conversion.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToNumber = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
-const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PRECISION) => {
+const convertToNumber = (bigNumber, precision = numericConstants_1.PRICE_PRECISION) => {
     if (!bigNumber)
         return 0;
     return (bigNumber.div(precision).toNumber() +

package/lib/math/funding.js

@@ -32,15 +32,15 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
     const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
     const markTwapTimeSinceLastUpdate = anchor_1.BN.max(secondsInHour, anchor_1.BN.max(numericConstants_1.ZERO, secondsInHour.sub(timeSinceLastMarkChange)));
-    const baseAssetPriceWithMantissa = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+    const baseAssetPriceWithMantissa = (0, market_1.calculateReservePrice)(market, oraclePriceData);
     const markTwapWithMantissa = markTwapTimeSinceLastUpdate
         .mul(lastMarkTwapWithMantissa)
         .add(timeSinceLastMarkChange.mul(baseAssetPriceWithMantissa))
         .div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
     // calculate real-time (predicted) oracle twap
     // note: oracle twap depends on `when the chord is struck` (market is trade)
-    const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
-    const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
+    const lastOracleTwapWithMantissa = market.amm.historicalOracleData.lastOraclePriceTwap;
+    const lastOraclePriceTwapTs = market.amm.historicalOracleData.lastOraclePriceTwapTs;
     const oracleInvalidDuration = anchor_1.BN.max(numericConstants_1.ZERO, lastMarkPriceTwapTs.sub(lastOraclePriceTwapTs));
     const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
     const oracleTwapTimeSinceLastUpdate = anchor_1.BN.max(ONE, anchor_1.BN.min(secondsInHour, anchor_1.BN.max(ONE, secondsInHour.sub(timeSinceLastOracleTwapUpdate))));
@@ -51,11 +51,11 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
         const oracleLiveVsTwap = oraclePrice
             .sub(lastOracleTwapWithMantissa)
             .abs()
-            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .mul(numericConstants_1.PRICE_PRECISION)
             .mul(new anchor_1.BN(100))
             .div(lastOracleTwapWithMantissa);
         // verify pyth live input is within 10% of last twap for live update
-        if (oracleLiveVsTwap.lte(numericConstants_1.MARK_PRICE_PRECISION.mul(new anchor_1.BN(10)))) {
+        if (oracleLiveVsTwap.lte(numericConstants_1.PRICE_PRECISION.mul(new anchor_1.BN(10)))) {
             oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
                 .mul(lastOracleTwapWithMantissa)
                 .add(timeSinceLastMarkChange.mul(oraclePrice))
@@ -68,7 +68,7 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
         .div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
     const twapSpread = lastMarkTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
     const twapSpreadPct = twapSpread
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .mul(new anchor_1.BN(100))
         .div(shrunkLastOracleTwapwithMantissa);
     const lowerboundEst = twapSpreadPct
@@ -82,7 +82,7 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     const interpRateQuote = twapSpreadPct
         .mul(periodAdjustment)
         .div(hoursInDay)
-        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION));
+        .div(numericConstants_1.PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION));
     let feePoolSize = calculateFundingPool(market);
     if (interpRateQuote.lt(new anchor_1.BN(0))) {
         feePoolSize = feePoolSize.mul(new anchor_1.BN(-1));
@@ -129,11 +129,11 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
         // funding smaller flow
         cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
         const feePoolTopOff = feePoolSize
-            .mul(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION))
+            .mul(numericConstants_1.PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION))
             .mul(numericConstants_1.AMM_RESERVE_PRECISION);
         cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
         cappedAltEst = cappedAltEst
-            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .mul(numericConstants_1.PRICE_PRECISION)
             .mul(new anchor_1.BN(100))
             .div(oracleTwapWithMantissa)
             .mul(periodAdjustment);

package/lib/math/margin.js

@@ -10,7 +10,7 @@ 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 sizeSqrt = (0, utils_1.squareRootBN)(size.mul(new anchor_1.BN(10)).add(new anchor_1.BN(1))); //1e9 -> 1e10 -> 1e5
     const denom0 = anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor));
     (0, assert_1.assert)(denom0.gt(numericConstants_1.ZERO));
     const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor))));
@@ -29,7 +29,7 @@ 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 sizeSqrt = (0, utils_1.squareRootBN)(size.mul(new anchor_1.BN(10)).add(new anchor_1.BN(1))); //1e9 -> 1e10 -> 1e5
     const imfNumerator = numericConstants_1.SPOT_MARKET_IMF_PRECISION.add(numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(new anchor_1.BN(10)));
     const sizeDiscountAssetWeight = imfNumerator
         .mul(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION)
@@ -61,7 +61,7 @@ function calculateBaseAssetValueWithOracle(market, perpPosition, oraclePriceData
     return perpPosition.baseAssetAmount
         .abs()
         .mul(oraclePriceData.price)
-        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+        .div(numericConstants_1.AMM_RESERVE_PRECISION);
 }
 exports.calculateBaseAssetValueWithOracle = calculateBaseAssetValueWithOracle;
 function calculateWorstCaseBaseAssetAmount(perpPosition) {

package/lib/math/market.d.ts

@@ -6,21 +6,21 @@ import { OraclePriceData } from '../oracles/types';
  * Calculates market mark price
  *
  * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
+ * @return markPrice : Precision PRICE_PRECISION
  */
-export declare function calculateMarkPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateReservePrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 /**
  * Calculates market bid price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return bidPrice : Precision PRICE_PRECISION
  */
 export declare function calculateBidPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 /**
  * Calculates market ask price
  *
  * @param market
- * @return askPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision PRICE_PRECISION
  */
 export declare function calculateAskPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: PerpMarketAccount): PerpMarketAccount;

package/lib/math/market.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateReservePrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
@@ -11,18 +11,18 @@ const spotBalance_1 = require("./spotBalance");
  * Calculates market mark price
  *
  * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
+ * @return markPrice : Precision PRICE_PRECISION
  */
-function calculateMarkPrice(market, oraclePriceData) {
+function calculateReservePrice(market, oraclePriceData) {
     const newAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
     return (0, amm_1.calculatePrice)(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
 }
-exports.calculateMarkPrice = calculateMarkPrice;
+exports.calculateReservePrice = calculateReservePrice;
 /**
  * Calculates market bid price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return bidPrice : Precision PRICE_PRECISION
  */
 function calculateBidPrice(market, oraclePriceData) {
     const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
@@ -33,7 +33,7 @@ exports.calculateBidPrice = calculateBidPrice;
  * Calculates market ask price
  *
  * @param market
- * @return askPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision PRICE_PRECISION
  */
 function calculateAskPrice(market, oraclePriceData) {
     const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
@@ -51,7 +51,7 @@ function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
 }
 exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
 function calculateMarkOracleSpread(market, oraclePriceData) {
-    const markPrice = calculateMarkPrice(market, oraclePriceData);
+    const markPrice = calculateReservePrice(market, oraclePriceData);
     return calculateOracleSpread(markPrice, oraclePriceData);
 }
 exports.calculateMarkOracleSpread = calculateMarkOracleSpread;

package/lib/math/oracles.js

@@ -16,9 +16,9 @@ exports.oraclePriceBands = oraclePriceBands;
 function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
     const isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
     const isOraclePriceTooVolatile = oraclePriceData.price
-        .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
+        .div(index_1.BN.max(numericConstants_1.ONE, amm.historicalOracleData.lastOraclePriceTwap))
         .gt(oracleGuardRails.validity.tooVolatileRatio) ||
-        amm.lastOraclePriceTwap
+        amm.historicalOracleData.lastOraclePriceTwap
             .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
             .gt(oracleGuardRails.validity.tooVolatileRatio);
     const isConfidenceTooLarge = new index_1.BN(amm.baseSpread)
@@ -28,7 +28,7 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         .gt(new index_1.BN(amm.maxSpread));
     const oracleIsStale = oraclePriceData.slot
         .sub(new index_1.BN(slot))
-        .gt(oracleGuardRails.validity.slotsBeforeStale);
+        .gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
     return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
         oracleIsStale ||
         isOraclePriceNonPositive ||
@@ -37,17 +37,15 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
 }
 exports.isOracleValid = isOracleValid;
 function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
-    const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
     const sinceStart = index_1.BN.max(numericConstants_1.ZERO, new index_1.BN(60 * 5).sub(sinceLastUpdate));
-    const oracleTwap5min = amm.lastOraclePriceTwap5min
+    const oracleTwap5min = amm.historicalOracleData.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 oracleSpreadPct = oracleSpread.mul(numericConstants_1.PRICE_PRECISION).div(oracleTwap5min);
     const tooDivergent = oracleSpreadPct
         .abs()
         .gte(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(oracleGuardRails.priceDivergence.markOracleDivergenceNumerator).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator));

package/lib/math/position.d.ts

@@ -33,13 +33,13 @@ export declare function positionIsAvailable(position: PerpPosition): boolean;
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
 export declare function calculateEntryPrice(userPosition: PerpPosition): BN;
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
 export declare function calculateCostBasis(userPosition: PerpPosition): BN;
 export declare function findDirectionToClose(userPosition: PerpPosition): PositionDirection;

package/lib/math/position.js

@@ -75,7 +75,7 @@ function calculatePositionPNL(market, perpPosition, withFunding = false, oracleP
         .mul(baseAssetValueSign)
         .add(perpPosition.quoteAssetAmount);
     if (withFunding) {
-        const fundingRatePnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const fundingRatePnL = calculatePositionFundingPNL(market, perpPosition);
         pnl = pnl.add(fundingRatePnL);
     }
     return pnl;
@@ -83,7 +83,7 @@ function calculatePositionPNL(market, perpPosition, withFunding = false, oracleP
 exports.calculatePositionPNL = calculatePositionPNL;
 function calculateClaimablePnl(market, spotMarket, perpPosition, oraclePriceData) {
     const unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
-    const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+    const fundingPnL = calculatePositionFundingPNL(market, perpPosition);
     let unsettledPnl = unrealizedPnl.add(fundingPnL);
     if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
         const excessPnlPool = __1.BN.max(numericConstants_1.ZERO, (0, market_1.calculateNetUserPnlImbalance)(market, spotMarket, oraclePriceData).mul(new __1.BN(-1)));
@@ -116,14 +116,14 @@ function calculatePositionFundingPNL(market, perpPosition) {
         .sub(perpPosition.lastCumulativeFundingRate)
         .mul(perpPosition.baseAssetAmount)
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
+        .div(numericConstants_1.FUNDING_RATE_BUFFER_PRECISION)
         .mul(new __1.BN(-1));
     return perPositionFundingRate;
 }
 exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
 function positionIsAvailable(position) {
     return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
-        position.openOrders.eq(numericConstants_1.ZERO) &&
+        position.openOrders === 0 &&
         position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
         position.lpShares.eq(numericConstants_1.ZERO));
 }
@@ -131,14 +131,14 @@ exports.positionIsAvailable = positionIsAvailable;
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
 function calculateEntryPrice(userPosition) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     return userPosition.quoteEntryAmount
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(userPosition.baseAssetAmount)
         .abs();
@@ -147,14 +147,14 @@ exports.calculateEntryPrice = calculateEntryPrice;
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: 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.PRICE_PRECISION)
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(userPosition.baseAssetAmount)
         .abs();
@@ -173,6 +173,6 @@ function positionCurrentDirection(userPosition) {
 }
 exports.positionCurrentDirection = positionCurrentDirection;
 function isEmptyPosition(userPosition) {
-    return (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders.eq(numericConstants_1.ZERO));
+    return userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders === 0;
 }
 exports.isEmptyPosition = isEmptyPosition;

package/lib/math/repeg.js

@@ -18,13 +18,13 @@ function calculateAdjustKCost(amm, numerator, denomenator) {
     const d = amm.netBaseAssetAmount;
     const Q = amm.pegMultiplier;
     const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
-    const p = numerator.mul(numericConstants_1.MARK_PRICE_PRECISION).div(denomenator);
+    const p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
     const cost = quoteScale
         .div(x.add(d))
         .sub(quoteScale
         .mul(p)
-        .div(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(x.mul(p).div(numericConstants_1.MARK_PRICE_PRECISION).add(d)))
+        .div(numericConstants_1.PRICE_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PRICE_PRECISION).add(d)))
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(numericConstants_1.PEG_PRECISION);
     return cost.mul(new anchor_1.BN(-1));
@@ -74,7 +74,8 @@ function calculateBudgetedKBN(x, y, budget, Q, d) {
     // protocol is spending to increase k
     if (C.lt(numericConstants_1.ZERO)) {
         // thus denom1 is negative and solution is unstable
-        if (denom1.lt(pegged_y_d_d.abs())) {
+        if (denom1.abs().gt(denom2.abs())) {
+            console.log('denom1 > denom2', denom1.toString(), denom2.toString());
             console.log('budget cost exceeds stable K solution');
             return [new anchor_1.BN(10000), new anchor_1.BN(1)];
         }
@@ -129,8 +130,8 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     if (deltaQuoteAssetReserves.eq(numericConstants_1.ZERO) || useTargetPeg) {
         return targetPeg;
     }
-    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    const deltaPegMultiplier = C.mul(numericConstants_1.PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
+    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.PRICE_PRECISION));
     return newPeg;
 }
 exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/math/spotBalance.js

@@ -6,7 +6,7 @@ const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const margin_1 = require("./margin");
 function getBalance(tokenAmount, spotMarket, balanceType) {
-    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - spotMarket.decimals));
+    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
     const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
         ? spotMarket.cumulativeDepositInterest
         : spotMarket.cumulativeBorrowInterest;
@@ -18,7 +18,7 @@ function getBalance(tokenAmount, spotMarket, balanceType) {
 }
 exports.getBalance = getBalance;
 function getTokenAmount(balanceAmount, spotMarket, balanceType) {
-    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - spotMarket.decimals));
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
     const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
         ? spotMarket.cumulativeDepositInterest
         : spotMarket.cumulativeBorrowInterest;
@@ -38,7 +38,7 @@ function getTokenValue(tokenAmount, spotDecimals, oraclePriceData) {
     if (tokenAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(10 + spotDecimals - 6));
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(spotDecimals));
     return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
 }
 exports.getTokenValue = getTokenValue;
@@ -160,12 +160,12 @@ function calculateInterestAccumulated(bank, now) {
     const borrowInterest = bank.cumulativeBorrowInterest
         .mul(modifiedBorrowRate)
         .div(numericConstants_1.ONE_YEAR)
-        .div(numericConstants_1.SPOT_MARKET_INTEREST_PRECISION)
+        .div(numericConstants_1.SPOT_MARKET_RATE_PRECISION)
         .add(numericConstants_1.ONE);
     const depositInterest = bank.cumulativeDepositInterest
         .mul(modifiedDepositRate)
         .div(numericConstants_1.ONE_YEAR)
-        .div(numericConstants_1.SPOT_MARKET_INTEREST_PRECISION);
+        .div(numericConstants_1.SPOT_MARKET_RATE_PRECISION);
     return { borrowInterest, depositInterest };
 }
 exports.calculateInterestAccumulated = calculateInterestAccumulated;

package/lib/math/spotPosition.js

@@ -12,11 +12,11 @@ function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceDa
     const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
     const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
     if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
-        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
     }
     else {
-        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
     }
 }

package/lib/math/trade.d.ts

@@ -13,13 +13,13 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  * @param useSpread whether to consider spread with calculating slippage
  * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
  *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
  *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
 export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
 /**
@@ -47,8 +47,8 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
  * [
  *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
  * ]
  */
 export declare function calculateTargetPriceTrade(market: PerpMarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];

package/lib/math/trade.js

@@ -19,13 +19,13 @@ const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
  * @param useSpread whether to consider spread with calculating slippage
  * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
  *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
  *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
 function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
     let oldPrice;
@@ -38,7 +38,7 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
         }
     }
     else {
-        oldPrice = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+        oldPrice = (0, market_1.calculateReservePrice)(market, oraclePriceData);
     }
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
@@ -46,7 +46,7 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
     const entryPrice = acquiredQuoteAssetAmount
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(acquiredBaseReserve.abs());
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
@@ -70,12 +70,12 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     }
     const pctMaxSlippage = newPrice
         .sub(oldPrice)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(oldPrice)
         .abs();
     const pctAvgSlippage = entryPrice
         .sub(oldPrice)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(oldPrice)
         .abs();
     return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice];
@@ -130,15 +130,15 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  * [
  *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
  * ]
  */
 function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote', oraclePriceData, useSpread = true) {
     (0, assert_1.assert)(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
     (0, assert_1.assert)(targetPrice.gt(numericConstants_1.ZERO));
     (0, assert_1.assert)(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
-    const markPriceBefore = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+    const markPriceBefore = (0, market_1.calculateReservePrice)(market, oraclePriceData);
     const bidPriceBefore = (0, market_1.calculateBidPrice)(market, oraclePriceData);
     const askPriceBefore = (0, market_1.calculateAskPrice)(market, oraclePriceData);
     let direction;
@@ -170,7 +170,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         quoteAssetReserveBefore = market.amm.quoteAssetReserve;
     }
     const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
+    const k = invariant.mul(numericConstants_1.PRICE_PRECISION);
     let baseAssetReserveAfter;
     let quoteAssetReserveAfter;
     const biasModifier = new anchor_1.BN(1);
@@ -191,9 +191,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     else if (markPriceBefore.gt(targetPrice)) {
         // overestimate y2
         baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
-        quoteAssetReserveAfter = k
-            .div(numericConstants_1.MARK_PRICE_PRECISION)
-            .div(baseAssetReserveAfter);
+        quoteAssetReserveAfter = k.div(numericConstants_1.PRICE_PRECISION).div(baseAssetReserveAfter);
         markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.SHORT;
         tradeSize = quoteAssetReserveBefore
@@ -206,9 +204,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     else if (markPriceBefore.lt(targetPrice)) {
         // underestimate y2
         baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
-        quoteAssetReserveAfter = k
-            .div(numericConstants_1.MARK_PRICE_PRECISION)
-            .div(baseAssetReserveAfter);
+        quoteAssetReserveAfter = k.div(numericConstants_1.PRICE_PRECISION).div(baseAssetReserveAfter);
         markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.LONG;
         tradeSize = quoteAssetReserveAfter
@@ -234,7 +230,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     const entryPrice = tradeSize
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(baseSize.abs());
     (0, assert_1.assert)(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
     (0, assert_1.assert)(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +