@drift-labs/sdk 0.2.0-temp.2 → 2.0.1

package/lib/math/spotBalance.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getSignedTokenAmount = 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, spotMarket, balanceType) {
+    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;
+    let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
+        balance = balance.add(numericConstants_1.ONE);
+    }
+    return balance;
+}
+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')
+        ? spotMarket.cumulativeDepositInterest
+        : spotMarket.cumulativeBorrowInterest;
+    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+exports.getTokenAmount = getTokenAmount;
+function getSignedTokenAmount(tokenAmount, balanceType) {
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+        return tokenAmount;
+    }
+    else {
+        return tokenAmount.abs().neg();
+    }
+}
+exports.getSignedTokenAmount = getSignedTokenAmount;
+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(spotDecimals));
+    return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
+}
+exports.getTokenValue = getTokenValue;
+function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.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, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceAssetWeight));
+            break;
+        default:
+            assetWeight = new anchor_1.BN(spotMarket.initialAssetWeight);
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateAssetWeight = calculateAssetWeight;
+function calculateLiabilityWeight(balanceAmount, spotMarket, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.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, 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);
+            break;
+        default:
+            assetWeight = spotMarket.initialLiabilityWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateLiabilityWeight = calculateLiabilityWeight;
+function calculateUtilization(bank) {
+    const tokenDepositAmount = getTokenAmount(bank.depositBalance, bank, types_1.SpotBalanceType.DEPOSIT);
+    const tokenBorrowAmount = getTokenAmount(bank.borrowBalance, bank, types_1.SpotBalanceType.BORROW);
+    let utilization;
+    if (tokenBorrowAmount.eq(numericConstants_1.ZERO) && tokenDepositAmount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.ZERO;
+    }
+    else if (tokenDepositAmount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION;
+    }
+    else {
+        utilization = tokenBorrowAmount
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(tokenDepositAmount);
+    }
+    return utilization;
+}
+exports.calculateUtilization = calculateUtilization;
+function calculateInterestRate(bank) {
+    const utilization = calculateUtilization(bank);
+    let interestRate;
+    if (utilization.gt(new anchor_1.BN(bank.optimalUtilization))) {
+        const surplusUtilization = utilization.sub(new anchor_1.BN(bank.optimalUtilization));
+        const borrowRateSlope = new anchor_1.BN(bank.maxBorrowRate - bank.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(bank.optimalUtilization)));
+        interestRate = new anchor_1.BN(bank.optimalBorrowRate).add(surplusUtilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION));
+    }
+    else {
+        const borrowRateSlope = new anchor_1.BN(bank.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(bank.optimalUtilization)));
+        interestRate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    }
+    return interestRate;
+}
+exports.calculateInterestRate = calculateInterestRate;
+function calculateDepositRate(bank) {
+    const utilization = calculateUtilization(bank);
+    const borrowRate = calculateBorrowRate(bank);
+    const depositRate = borrowRate
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    return depositRate;
+}
+exports.calculateDepositRate = calculateDepositRate;
+function calculateBorrowRate(bank) {
+    return calculateInterestRate(bank);
+}
+exports.calculateBorrowRate = calculateBorrowRate;
+function calculateInterestAccumulated(bank, now) {
+    const interestRate = calculateInterestRate(bank);
+    const timeSinceLastUpdate = now.sub(bank.lastInterestTs);
+    const modifiedBorrowRate = interestRate.mul(timeSinceLastUpdate);
+    const utilization = calculateUtilization(bank);
+    const modifiedDepositRate = modifiedBorrowRate
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    const borrowInterest = bank.cumulativeBorrowInterest
+        .mul(modifiedBorrowRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .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_RATE_PRECISION);
+    return { borrowInterest, depositInterest };
+}
+exports.calculateInterestAccumulated = calculateInterestAccumulated;
+function calculateWithdrawLimit(spotMarket, now) {
+    const marketDepositTokenAmount = getTokenAmount(spotMarket.depositBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const marketBorrowTokenAmount = getTokenAmount(spotMarket.borrowBalance, spotMarket, types_1.SpotBalanceType.BORROW);
+    const twentyFourHours = new anchor_1.BN(60 * 60 * 24);
+    const sinceLast = now.sub(spotMarket.lastTwapTs);
+    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, twentyFourHours.sub(sinceLast));
+    const borrowTokenTwapLive = spotMarket.borrowTokenTwap
+        .mul(sinceStart)
+        .add(marketBorrowTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceStart));
+    const depositTokenTwapLive = spotMarket.depositTokenTwap
+        .mul(sinceStart)
+        .add(marketDepositTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceStart));
+    const maxBorrowTokens = anchor_1.BN.min(anchor_1.BN.max(marketDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new anchor_1.BN(5)))); // between ~15-80% utilization with friction on twap
+    const minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.min(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), spotMarket.withdrawGuardThreshold), depositTokenTwapLive));
+    return {
+        borrowLimit: maxBorrowTokens.sub(marketBorrowTokenAmount),
+        withdrawLimit: marketDepositTokenAmount.sub(minDepositTokens),
+    };
+}
+exports.calculateWithdrawLimit = calculateWithdrawLimit;

package/lib/math/spotMarket.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+import { SpotMarketAccount } from '../types';
+export declare function castNumberToSpotPrecision(value: number, spotMarket: SpotMarketAccount): BN;

package/lib/math/spotMarket.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castNumberToSpotPrecision = void 0;
+const anchor_1 = require("@project-serum/anchor");
+function castNumberToSpotPrecision(value, spotMarket) {
+    return new anchor_1.BN(value * Math.pow(10, spotMarket.decimals));
+}
+exports.castNumberToSpotPrecision = castNumberToSpotPrecision;

package/lib/math/spotPosition.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotPosition } from '../types';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+export declare function isSpotPositionAvailable(position: SpotPosition): boolean;
+export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];

package/lib/math/spotPosition.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const spotBalance_1 = require("./spotBalance");
+function isSpotPositionAvailable(position) {
+    return position.scaledBalance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
+}
+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 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);
+        return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+    }
+    else {
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+    }
+}
+exports.getWorstCaseTokenAmounts = getWorstCaseTokenAmounts;

package/lib/math/trade.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="bn.js" />
-import { MarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
 import { OraclePriceData } from '../oracles/types';
@@ -13,15 +13,15 @@ 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: MarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -33,7 +33,7 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN];
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN];
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades
@@ -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: MarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];
+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];
@@ -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;
 /**
@@ -130,28 +130,28 @@ 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 reservePriceBefore = (0, market_1.calculateReservePrice)(market, oraclePriceData);
     const bidPriceBefore = (0, market_1.calculateBidPrice)(market, oraclePriceData);
     const askPriceBefore = (0, market_1.calculateAskPrice)(market, oraclePriceData);
     let direction;
-    if (targetPrice.gt(markPriceBefore)) {
-        const priceGap = targetPrice.sub(markPriceBefore);
+    if (targetPrice.gt(reservePriceBefore)) {
+        const priceGap = targetPrice.sub(reservePriceBefore);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-        targetPrice = markPriceBefore.add(priceGapScaled);
+        targetPrice = reservePriceBefore.add(priceGapScaled);
         direction = types_1.PositionDirection.LONG;
     }
     else {
-        const priceGap = markPriceBefore.sub(targetPrice);
+        const priceGap = reservePriceBefore.sub(targetPrice);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-        targetPrice = markPriceBefore.sub(priceGapScaled);
+        targetPrice = reservePriceBefore.sub(priceGapScaled);
         direction = types_1.PositionDirection.SHORT;
     }
     let tradeSize;
@@ -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);
@@ -179,7 +179,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         targetPrice.lt(askPriceBefore) &&
         targetPrice.gt(bidPriceBefore)) {
         // no trade, market is at target
-        if (markPriceBefore.gt(targetPrice)) {
+        if (reservePriceBefore.gt(targetPrice)) {
             direction = types_1.PositionDirection.SHORT;
         }
         else {
@@ -188,12 +188,10 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         tradeSize = numericConstants_1.ZERO;
         return [direction, tradeSize, targetPrice, targetPrice];
     }
-    else if (markPriceBefore.gt(targetPrice)) {
+    else if (reservePriceBefore.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
@@ -203,12 +201,10 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
             .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
         baseSize = baseAssetReserveAfter.sub(baseAssetReserveBefore);
     }
-    else if (markPriceBefore.lt(targetPrice)) {
+    else if (reservePriceBefore.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
@@ -226,15 +222,15 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     let tp1 = targetPrice;
     let tp2 = markPriceAfter;
-    let originalDiff = targetPrice.sub(markPriceBefore);
+    let originalDiff = targetPrice.sub(reservePriceBefore);
     if (direction == types_1.PositionDirection.SHORT) {
         tp1 = markPriceAfter;
         tp2 = targetPrice;
-        originalDiff = markPriceBefore.sub(targetPrice);
+        originalDiff = reservePriceBefore.sub(targetPrice);
     }
     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' +

package/lib/oracles/pythClient.js

@@ -29,7 +29,7 @@ function convertPythPrice(price, exponent) {
     exponent = Math.abs(exponent);
     const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs());
     return new anchor_1.BN(price * Math.pow(10, exponent))
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(pythPrecision);
 }
 exports.convertPythPrice = convertPythPrice;

package/lib/oracles/quoteAssetOracleClient.js

@@ -4,7 +4,7 @@ exports.QuoteAssetOracleClient = exports.QUOTE_ORACLE_PRICE_DATA = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 exports.QUOTE_ORACLE_PRICE_DATA = {
-    price: numericConstants_1.MARK_PRICE_PRECISION,
+    price: numericConstants_1.PRICE_PRECISION,
     slot: new anchor_1.BN(0),
     confidence: new anchor_1.BN(1),
     hasSufficientNumberOfDataPoints: true,

package/lib/oracles/switchboardClient.js

@@ -53,6 +53,6 @@ function getSwitchboardProgram(connection) {
 function convertSwitchboardDecimal(switchboardDecimal) {
     const switchboardPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(switchboardDecimal.scale));
     return switchboardDecimal.mantissa
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.PRICE_PRECISION)
         .div(switchboardPrecision);
 }

package/lib/orderParams.d.ts

@@ -1,16 +1,16 @@
 /// <reference types="bn.js" />
 import { OptionalOrderParams, OrderTriggerCondition } from './types';
 import { BN } from '@project-serum/anchor';
-export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
     price: BN;
 }): OptionalOrderParams;
-export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
     triggerCondition: OrderTriggerCondition;
     triggerPrice: BN;
 }): OptionalOrderParams;
-export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
     triggerCondition: OrderTriggerCondition;
     triggerPrice: BN;
     price: BN;
 }): OptionalOrderParams;
-export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'>): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'>): OptionalOrderParams;

package/lib/orderParams.js

@@ -3,18 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
 function getLimitOrderParams(params) {
-    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
+    return Object.assign({}, params, {
+        orderType: types_1.OrderType.LIMIT,
+    });
 }
 exports.getLimitOrderParams = getLimitOrderParams;
 function getTriggerMarketOrderParams(params) {
-    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
+    return Object.assign({}, params, {
+        orderType: types_1.OrderType.TRIGGER_MARKET,
+    });
 }
 exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
 function getTriggerLimitOrderParams(params) {
-    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
+    return Object.assign({}, params, {
+        orderType: types_1.OrderType.TRIGGER_LIMIT,
+    });
 }
 exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
 function getMarketOrderParams(params) {
-    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
+    return Object.assign({}, params, {
+        orderType: types_1.OrderType.MARKET,
+    });
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/serum/serumFulfillmentConfigMap.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from '@solana/web3.js';
+import { SerumV3FulfillmentConfigAccount } from '../types';
+import { DriftClient } from '../driftClient';
+export declare class SerumFulfillmentConfigMap {
+    driftClient: DriftClient;
+    map: Map<number, SerumV3FulfillmentConfigAccount>;
+    constructor(driftClient: DriftClient);
+    add(marketIndex: number, serumMarketAddress: PublicKey): Promise<void>;
+    get(marketIndex: number): SerumV3FulfillmentConfigAccount;
+}

package/lib/serum/serumFulfillmentConfigMap.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerumFulfillmentConfigMap = void 0;
+class SerumFulfillmentConfigMap {
+    constructor(driftClient) {
+        this.map = new Map();
+        this.driftClient = driftClient;
+    }
+    async add(marketIndex, serumMarketAddress) {
+        const account = await this.driftClient.getSerumV3FulfillmentConfig(serumMarketAddress);
+        this.map.set(marketIndex, account);
+    }
+    get(marketIndex) {
+        return this.map.get(marketIndex);
+    }
+}
+exports.SerumFulfillmentConfigMap = SerumFulfillmentConfigMap;

package/lib/serum/serumSubscriber.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="bn.js" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { Market, Orderbook } from '@project-serum/serum';
+import { SerumMarketSubscriberConfig } from './types';
+import { BN } from '@project-serum/anchor';
+export declare class SerumSubscriber {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountLoader: BulkAccountLoader;
+    market: Market;
+    subscribed: boolean;
+    asksAddress: PublicKey;
+    asks: Orderbook;
+    asksCallbackId: string;
+    lastAsksSlot: number;
+    bidsAddress: PublicKey;
+    bids: Orderbook;
+    bidsCallbackId: string;
+    lastBidsSlot: number;
+    constructor(config: SerumMarketSubscriberConfig);
+    subscribe(): Promise<void>;
+    getBestBid(): BN | undefined;
+    getBestAsk(): BN | undefined;
+    unsubscribe(): Promise<void>;
+}

package/lib/serum/serumSubscriber.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerumSubscriber = void 0;
+const serum_1 = require("@project-serum/serum");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+class SerumSubscriber {
+    constructor(config) {
+        this.connection = config.connection;
+        this.programId = config.programId;
+        this.marketAddress = config.marketAddress;
+        this.accountLoader = config.accountSubscription.accountLoader;
+    }
+    async subscribe() {
+        if (this.subscribed) {
+            return;
+        }
+        this.market = await serum_1.Market.load(this.connection, this.marketAddress, undefined, this.programId);
+        this.asksAddress = this.market.asksAddress;
+        this.asks = await this.market.loadAsks(this.connection);
+        this.asksCallbackId = this.accountLoader.addAccount(this.asksAddress, (buffer, slot) => {
+            this.lastAsksSlot = slot;
+            this.asks = serum_1.Orderbook.decode(this.market, buffer);
+        });
+        this.bidsAddress = this.market.bidsAddress;
+        this.bids = await this.market.loadBids(this.connection);
+        this.bidsCallbackId = this.accountLoader.addAccount(this.bidsAddress, (buffer, slot) => {
+            this.lastBidsSlot = slot;
+            this.bids = serum_1.Orderbook.decode(this.market, buffer);
+        });
+        this.subscribed = true;
+    }
+    getBestBid() {
+        const bestBid = this.bids.getL2(1)[0];
+        if (!bestBid) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestBid[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
+    getBestAsk() {
+        const bestAsk = this.asks.getL2(1)[0];
+        if (!bestAsk) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestAsk[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
+    async unsubscribe() {
+        if (!this.subscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+        this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+        this.subscribed = false;
+    }
+}
+exports.SerumSubscriber = SerumSubscriber;