@drift-labs/sdk 2.12.0-beta.2 → 2.12.0

package/lib/math/orders.js

@@ -7,7 +7,7 @@ const anchor_1 = require("@project-serum/anchor");
 const auction_1 = require("./auction");
 const amm_1 = require("./amm");
 function isOrderRiskIncreasing(user, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
+    if (types_1.isVariant(order.status, 'init')) {
         return false;
     }
     const position = user.getPerpPosition(order.marketIndex) ||
@@ -17,12 +17,12 @@ function isOrderRiskIncreasing(user, order) {
         return true;
     }
     // if position is long and order is long
-    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, 'long')) {
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
         return true;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        (0, types_1.isVariant)(order.direction, 'short')) {
+        types_1.isVariant(order.direction, 'short')) {
         return true;
     }
     const baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
@@ -34,7 +34,7 @@ function isOrderRiskIncreasing(user, order) {
 }
 exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
 function isOrderRiskIncreasingInSameDirection(user, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
+    if (types_1.isVariant(order.status, 'init')) {
         return false;
     }
     const position = user.getPerpPosition(order.marketIndex) ||
@@ -44,31 +44,31 @@ function isOrderRiskIncreasingInSameDirection(user, order) {
         return true;
     }
     // if position is long and order is long
-    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, 'long')) {
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
         return true;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        (0, types_1.isVariant)(order.direction, 'short')) {
+        types_1.isVariant(order.direction, 'short')) {
         return true;
     }
     return false;
 }
 exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
 function isOrderReduceOnly(user, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
+    if (types_1.isVariant(order.status, 'init')) {
         return false;
     }
     const position = user.getPerpPosition(order.marketIndex) ||
         user.getEmptyPosition(order.marketIndex);
     // if position is long and order is long
     if (position.baseAssetAmount.gte(numericConstants_1.ZERO) &&
-        (0, types_1.isVariant)(order.direction, 'long')) {
+        types_1.isVariant(order.direction, 'long')) {
         return false;
     }
     // if position is short and order is short
     if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
-        (0, types_1.isVariant)(order.direction, 'short')) {
+        types_1.isVariant(order.direction, 'short')) {
         return false;
     }
     return true;
@@ -82,7 +82,7 @@ exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
 function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
     let limitPrice;
     if (hasAuctionPrice(order, slot)) {
-        limitPrice = (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
+        limitPrice = auction_1.getAuctionPrice(order, slot, oraclePriceData.price);
     }
     else if (order.oraclePriceOffset !== 0) {
         limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
@@ -99,15 +99,15 @@ exports.getLimitPrice = getLimitPrice;
 function hasLimitPrice(order, slot) {
     return (order.price.gt(numericConstants_1.ZERO) ||
         order.oraclePriceOffset != 0 ||
-        !(0, auction_1.isAuctionComplete)(order, slot));
+        !auction_1.isAuctionComplete(order, slot));
 }
 exports.hasLimitPrice = hasLimitPrice;
 function hasAuctionPrice(order, slot) {
-    return isMarketOrder(order) && !(0, auction_1.isAuctionComplete)(order, slot);
+    return isMarketOrder(order) && !auction_1.isAuctionComplete(order, slot);
 }
 exports.hasAuctionPrice = hasAuctionPrice;
 function isFillableByVAMM(order, market, oraclePriceData, slot, ts) {
-    return (((0, auction_1.isAuctionComplete)(order, slot) &&
+    return ((auction_1.isAuctionComplete(order, slot) &&
         !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
         isOrderExpired(order, ts));
 }
@@ -118,19 +118,19 @@ function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData,
     }
     const limitPrice = getLimitPrice(order, oraclePriceData, slot);
     let baseAssetAmount;
-    const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    const updatedAMM = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
     if (limitPrice !== undefined) {
         baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, updatedAMM, limitPrice, oraclePriceData);
     }
     else {
         baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
     }
-    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(updatedAMM, order.direction);
+    const maxBaseAssetAmount = amm_1.calculateMaxBaseAssetAmountFillable(updatedAMM, order.direction);
     return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
 }
 exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
 function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, oraclePriceData) {
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(amm, limitPrice, order.direction, oraclePriceData);
+    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(amm, limitPrice, order.direction, oraclePriceData);
     const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, amm.orderStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
@@ -144,12 +144,12 @@ function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, or
 }
 exports.calculateBaseAssetAmountToFillUpToLimitPrice = calculateBaseAssetAmountToFillUpToLimitPrice;
 function isSameDirection(firstDirection, secondDirection) {
-    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
-        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
+    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
+        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
 }
 function isOrderExpired(order, ts) {
     if (mustBeTriggered(order) ||
-        !(0, types_1.isVariant)(order.status, 'open') ||
+        !types_1.isVariant(order.status, 'open') ||
         order.maxTs.eq(numericConstants_1.ZERO)) {
         return false;
     }
@@ -157,19 +157,19 @@ function isOrderExpired(order, ts) {
 }
 exports.isOrderExpired = isOrderExpired;
 function isMarketOrder(order) {
-    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle']);
+    return types_1.isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'oracle']);
 }
 exports.isMarketOrder = isMarketOrder;
 function isLimitOrder(order) {
-    return (0, types_1.isOneOfVariant)(order.orderType, ['limit', 'triggerLimit']);
+    return types_1.isOneOfVariant(order.orderType, ['limit', 'triggerLimit']);
 }
 exports.isLimitOrder = isLimitOrder;
 function mustBeTriggered(order) {
-    return (0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']);
+    return types_1.isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']);
 }
 exports.mustBeTriggered = mustBeTriggered;
 function isTriggered(order) {
-    return (0, types_1.isOneOfVariant)(order.triggerCondition, [
+    return types_1.isOneOfVariant(order.triggerCondition, [
         'triggeredAbove',
         'triggeredBelow',
     ]);

package/lib/math/position.js

@@ -23,7 +23,7 @@ function calculateBaseAssetValue(market, userPosition, oraclePriceData, useSprea
     let prepegAmm;
     if (!skipUpdate) {
         if (market.amm.baseSpread > 0 && useSpread) {
-            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
+            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, directionToClose, oraclePriceData);
             prepegAmm = {
                 baseAssetReserve,
                 quoteAssetReserve,
@@ -32,13 +32,13 @@ function calculateBaseAssetValue(market, userPosition, oraclePriceData, useSprea
             };
         }
         else {
-            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+            prepegAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
         }
     }
     else {
         prepegAmm = market.amm;
     }
-    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
+    const [newQuoteAssetReserve, _] = amm_1.calculateAmmReservesAfterSwap(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), amm_1.getSwapDirection('base', directionToClose));
     switch (directionToClose) {
         case types_1.PositionDirection.SHORT:
             return prepegAmm.quoteAssetReserve
@@ -67,7 +67,7 @@ function calculatePositionPNL(market, perpPosition, withFunding = false, oracleP
     if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return perpPosition.quoteAssetAmount;
     }
-    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    const baseAssetValue = margin_1.calculateBaseAssetValueWithOracle(market, perpPosition, oraclePriceData);
     const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
         ? new __1.BN(-1)
         : new __1.BN(1);
@@ -86,7 +86,7 @@ function calculateClaimablePnl(market, spotMarket, perpPosition, oraclePriceData
     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)));
+        const excessPnlPool = __1.BN.max(numericConstants_1.ZERO, market_1.calculateNetUserPnlImbalance(market, spotMarket, oraclePriceData).mul(new __1.BN(-1)));
         const maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount.sub(perpPosition.quoteEntryAmount), numericConstants_1.ZERO).add(excessPnlPool);
         unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
     }

package/lib/math/repeg.js

@@ -77,7 +77,7 @@ function calculateRepegCost(amm, newPeg) {
 }
 exports.calculateRepegCost = calculateRepegCost;
 function calculateBudgetedKBN(x, y, budget, Q, d) {
-    (0, assert_1.assert)(Q.gt(new anchor_1.BN(0)));
+    assert_1.assert(Q.gt(new anchor_1.BN(0)));
     const C = budget.mul(new anchor_1.BN(-1));
     let dSign = new anchor_1.BN(1);
     if (d.lt(new anchor_1.BN(0))) {

package/lib/math/spotBalance.js

@@ -8,11 +8,11 @@ const margin_1 = require("./margin");
 const numericConstants_2 = require("../constants/numericConstants");
 function getBalance(tokenAmount, spotMarket, balanceType) {
     const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
-    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
         ? spotMarket.cumulativeDepositInterest
         : spotMarket.cumulativeBorrowInterest;
     let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
-    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
+    if (!balance.eq(numericConstants_1.ZERO) && types_1.isVariant(balanceType, 'borrow')) {
         balance = balance.add(numericConstants_1.ONE);
     }
     return balance;
@@ -20,14 +20,14 @@ function getBalance(tokenAmount, spotMarket, balanceType) {
 exports.getBalance = getBalance;
 function getTokenAmount(balanceAmount, spotMarket, balanceType) {
     const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
-    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
         ? spotMarket.cumulativeDepositInterest
         : spotMarket.cumulativeBorrowInterest;
     return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 exports.getTokenAmount = getTokenAmount;
 function getSignedTokenAmount(tokenAmount, balanceType) {
-    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+    if (types_1.isVariant(balanceType, 'deposit')) {
         return tokenAmount;
     }
     else {
@@ -57,7 +57,7 @@ function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
+            assetWeight = margin_1.calculateSizeDiscountAssetWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
             break;
         case 'Maintenance':
             assetWeight = new anchor_1.BN(spotMarket.maintenanceAssetWeight);
@@ -83,10 +83,10 @@ function calculateLiabilityWeight(balanceAmount, spotMarket, marginCategory) {
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            assetWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         case 'Maintenance':
-            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            assetWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         default:
             assetWeight = spotMarket.initialLiabilityWeight;

package/lib/math/spotPosition.js

@@ -8,15 +8,15 @@ function isSpotPositionAvailable(position) {
 }
 exports.isSpotPositionAvailable = isSpotPositionAvailable;
 function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceData) {
-    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+    const tokenAmount = spotBalance_1.getSignedTokenAmount(spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
     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.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
     }
     else {
-        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
     }
 }

package/lib/math/trade.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="bn.js" />
-import { PerpMarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection, SpotMarketAccount } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
 import { OraclePriceData } from '../oracles/types';
 import { DLOB } from '../dlob/DLOB';
+import { PublicKey } from '@solana/web3.js';
+import { Orderbook } from '@project-serum/serum';
 export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
@@ -64,6 +66,36 @@ export declare function calculateTargetPriceTrade(market: PerpMarketAccount, tar
  * @param oraclePriceData
  * @param dlob
  * @param slot
- * @param minPerpAuctionDuration
+ * @param usersToSkip
  */
-export declare function calculateEstimatedPerpEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: PerpMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, slot: number, minPerpAuctionDuration: number): [BN, BN];
+export declare function calculateEstimatedPerpEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: PerpMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, slot: number, usersToSkip?: Map<PublicKey, boolean>): {
+    entryPrice: BN;
+    priceImpact: BN;
+    bestPrice: BN;
+    worstPrice: BN;
+    baseFilled: BN;
+    quoteFilled: BN;
+};
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or serum)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param serumBids
+ * @param serumAsks
+ * @param slot
+ * @param usersToSkip
+ */
+export declare function calculateEstimatedSpotEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: SpotMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, serumBids: Orderbook, serumAsks: Orderbook, slot: number, usersToSkip?: Map<PublicKey, boolean>): {
+    entryPrice: BN;
+    priceImpact: BN;
+    bestPrice: BN;
+    worstPrice: BN;
+    baseFilled: BN;
+    quoteFilled: BN;
+};