@drift-labs/sdk 0.1.36-master.5 → 0.2.0-master.0

package/lib/math/oracles.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOracleValid = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const index_1 = require("../index");
+function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
+    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
+    const isOraclePriceTooVolatile = oraclePriceData.price
+        .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
+        .gt(oracleGuardRails.validity.tooVolatileRatio) ||
+        amm.lastOraclePriceTwap
+            .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
+            .gt(oracleGuardRails.validity.tooVolatileRatio);
+    const isConfidenceTooLarge = oraclePriceData.price
+        .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
+        .lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+    const oracleIsStale = oraclePriceData.slot
+        .sub(new index_1.BN(slot))
+        .gt(oracleGuardRails.validity.slotsBeforeStale);
+    return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
+        oracleIsStale ||
+        isOraclePriceNonPositive ||
+        isOraclePriceTooVolatile ||
+        isConfidenceTooLarge);
+}
+exports.isOracleValid = isOracleValid;

package/lib/math/orders.d.ts

@@ -1,5 +1,10 @@
+/// <reference types="bn.js" />
 import { ClearingHouseUser } from '../clearingHouseUser';
 import { Order } from '../types';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
 export declare function isOrderRiskIncreasing(user: ClearingHouseUser, order: Order): boolean;
 export declare function isOrderRiskIncreasingInSameDirection(user: ClearingHouseUser, order: Order): boolean;
 export declare function isOrderReduceOnly(user: ClearingHouseUser, order: Order): boolean;
+export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
+export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN;

package/lib/math/orders.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@project-serum/anchor");
+const auction_1 = require("./auction");
 function isOrderRiskIncreasing(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
@@ -71,3 +73,31 @@ function isOrderReduceOnly(user, order) {
     return true;
 }
 exports.isOrderReduceOnly = isOrderReduceOnly;
+function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
+    const remainder = baseAssetAmount.mod(stepSize);
+    return baseAssetAmount.sub(remainder);
+}
+exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
+function getLimitPrice(order, oraclePriceData, slot) {
+    let limitPrice;
+    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+        if (order.postOnly) {
+            limitPrice = (0, types_1.isVariant)(order.direction, 'long')
+                ? anchor_1.BN.min(order.price, floatingPrice)
+                : anchor_1.BN.max(order.price, floatingPrice);
+        }
+        else {
+            limitPrice = floatingPrice;
+        }
+    }
+    else if ((0, types_1.isVariant)(order.orderType, 'market') ||
+        (0, types_1.isVariant)(order.orderType, 'triggerMarket')) {
+        limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
+    }
+    else {
+        limitPrice = order.price;
+    }
+    return limitPrice;
+}
+exports.getLimitPrice = getLimitPrice;

package/lib/math/position.d.ts

@@ -1,14 +1,16 @@
 /// <reference types="bn.js" />
 import { BN } from '../';
-import { Market, PositionDirection, UserPosition } from '../types';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, PositionDirection, UserPosition } from '../types';
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
  * @param market
  * @param userPosition
+ * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
-export declare function calculateBaseAssetValue(market: Market, userPosition: UserPosition): BN;
+export declare function calculateBaseAssetValue(market: MarketAccount, userPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
 /**
  * calculatePositionPNL
  * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
@@ -17,14 +19,15 @@ export declare function calculateBaseAssetValue(market: Market, userPosition: Us
  * @param withFunding (adds unrealized funding payment pnl to result)
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
-export declare function calculatePositionPNL(market: Market, marketPosition: UserPosition, withFunding?: boolean): BN;
+export declare function calculatePositionPNL(market: MarketAccount, marketPosition: UserPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
 /**
  *
  * @param market
  * @param marketPosition
  * @returns // TODO-PRECISION
  */
-export declare function calculatePositionFundingPNL(market: Market, marketPosition: UserPosition): BN;
+export declare function calculatePositionFundingPNL(market: MarketAccount, marketPosition: UserPosition): BN;
+export declare function positionIsAvailable(position: UserPosition): boolean;
 /**
  *
  * @param userPosition

package/lib/math/position.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
@@ -10,24 +10,38 @@ const amm_1 = require("./amm");
  * = market value of closing entire position
  * @param market
  * @param userPosition
+ * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
-function calculateBaseAssetValue(market, userPosition) {
+function calculateBaseAssetValue(market, userPosition, oraclePriceData) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     const directionToClose = findDirectionToClose(userPosition);
-    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
+    let prepegAmm;
+    if (market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
+        prepegAmm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
+        };
+    }
+    else {
+        prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    }
+    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
     switch (directionToClose) {
         case types_1.PositionDirection.SHORT:
-            return market.amm.quoteAssetReserve
+            return prepegAmm.quoteAssetReserve
                 .sub(newQuoteAssetReserve)
-                .mul(market.amm.pegMultiplier)
+                .mul(prepegAmm.pegMultiplier)
                 .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
         case types_1.PositionDirection.LONG:
             return newQuoteAssetReserve
-                .sub(market.amm.quoteAssetReserve)
-                .mul(market.amm.pegMultiplier)
+                .sub(prepegAmm.quoteAssetReserve)
+                .mul(prepegAmm.pegMultiplier)
                 .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
                 .add(numericConstants_1.ONE);
     }
@@ -41,11 +55,11 @@ exports.calculateBaseAssetValue = calculateBaseAssetValue;
  * @param withFunding (adds unrealized funding payment pnl to result)
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
-function calculatePositionPNL(market, marketPosition, withFunding = false) {
+function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
     if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    const baseAssetValue = calculateBaseAssetValue(market, marketPosition);
+    const baseAssetValue = calculateBaseAssetValue(market, marketPosition, oraclePriceData);
     let pnl;
     if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
         pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
@@ -86,6 +100,10 @@ function calculatePositionFundingPNL(market, marketPosition) {
     return perPositionFundingRate;
 }
 exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
+function positionIsAvailable(position) {
+    return position.baseAssetAmount.eq(numericConstants_1.ZERO) && position.openOrders.eq(numericConstants_1.ZERO);
+}
+exports.positionIsAvailable = positionIsAvailable;
 /**
  *
  * @param userPosition

package/lib/math/repeg.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+import { AMM } from '../types';
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateAdjustKCost(amm: AMM, numerator: BN, denomenator: BN): BN;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateRepegCost(amm: AMM, newPeg: BN): BN;
+export declare function calculateBudgetedKBN(x: BN, y: BN, budget: BN, Q: BN, d: BN): [BN, BN];
+export declare function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN];
+export declare function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN;

package/lib/math/repeg.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateBudgetedKBN = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const assert_1 = require("../assert/assert");
+const numericConstants_1 = require("../constants/numericConstants");
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateAdjustKCost(amm, numerator, denomenator) {
+    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = amm.baseAssetReserve;
+    const y = amm.quoteAssetReserve;
+    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 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.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(numericConstants_1.PEG_PRECISION);
+    return cost.mul(new anchor_1.BN(-1));
+}
+exports.calculateAdjustKCost = calculateAdjustKCost;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateRepegCost(amm, newPeg) {
+    const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
+    const cost = dqar
+        .mul(newPeg.sub(amm.pegMultiplier))
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(numericConstants_1.PEG_PRECISION);
+    return cost;
+}
+exports.calculateRepegCost = calculateRepegCost;
+function calculateBudgetedKBN(x, y, budget, Q, d) {
+    (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))) {
+        dSign = new anchor_1.BN(-1);
+    }
+    const pegged_y_d_d = y
+        .mul(d)
+        .mul(d)
+        .mul(Q)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION);
+    const numer1 = pegged_y_d_d;
+    const numer2 = C.mul(d)
+        .div(numericConstants_1.QUOTE_PRECISION)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .mul(dSign);
+    const denom1 = C.mul(x)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    const denom2 = pegged_y_d_d;
+    const numerator = numer1.sub(numer2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    const denominator = denom1.add(denom2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    return [numerator, denominator];
+}
+exports.calculateBudgetedKBN = calculateBudgetedKBN;
+function calculateBudgetedK(amm, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*d*d*Q)
+    // numer
+    //   =  y*d*d*Q - Cxd - Cdd
+    //   =  y/x*Q*d*d - Cd - Cd/x
+    //   = mark      - C/d - C/(x)
+    //   =  mark/C    - 1/d - 1/x
+    // denom
+    // = C*x*x + C*x*d + y*d*d*Q
+    // = x/d**2 + 1 / d + mark/C
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    const x = amm.baseAssetReserve;
+    const y = amm.quoteAssetReserve;
+    const d = amm.netBaseAssetAmount;
+    const Q = amm.pegMultiplier;
+    const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
+    return [numerator, denominator];
+}
+exports.calculateBudgetedK = calculateBudgetedK;
+function calculateBudgetedPeg(amm, cost, targetPrice) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    const targetPeg = targetPrice
+        .mul(amm.baseAssetReserve)
+        .div(amm.quoteAssetReserve)
+        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION));
+    const k = amm.sqrtK.mul(amm.sqrtK);
+    const x = amm.baseAssetReserve;
+    const y = amm.quoteAssetReserve;
+    const d = amm.netBaseAssetAmount;
+    const Q = amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+    const pegChangeDirection = targetPeg.sub(Q);
+    const useTargetPeg = (deltaQuoteAssetReserves.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
+        (deltaQuoteAssetReserves.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
+    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));
+    return newPeg;
+}
+exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/math/trade.d.ts

@@ -1,13 +1,16 @@
 /// <reference types="bn.js" />
-import { Market, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
+import { OraclePriceData } from '../oracles/types';
 export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
  * @param direction
  * @param amount
  * @param market
+ * @param inputAssetType which asset is being traded
+ * @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
@@ -18,7 +21,7 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  *
  * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: Market, inputAssetType?: AssetType): [BN, BN, BN, BN];
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -27,23 +30,25 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * @param inputAssetType
  * @param useSpread
  * @return
- * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
+ * 	| '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: Market, inputAssetType?: AssetType, useSpread?: boolean): [BN, BN];
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN];
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.
+ * @param outputAssetType which asset to trade.
+ * @param useSpread whether or not to consider the spread when calculating the trade size
  * @returns trade direction/size in order to push price to a targetPrice,
  *
  * [
- *   direction => direction of trade required, TODO-PRECISION
+ *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, TODO-PRECISION
- *   targetPrice => the target price TODO-PRECISION
+ *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
+ *   targetPrice => the target price MARK_PRICE_PRECISION
  * ]
  */
-export declare function calculateTargetPriceTrade(market: Market, targetPrice: BN, pct?: BN, outputAssetType?: AssetType): [PositionDirection, BN, BN, BN];
+export declare function calculateTargetPriceTrade(market: MarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];

package/lib/math/trade.js

@@ -8,12 +8,15 @@ const numericConstants_1 = require("../constants/numericConstants");
 const market_1 = require("./market");
 const amm_1 = require("./amm");
 const utils_1 = require("./utils");
+const types_2 = require("../types");
 const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
  * @param direction
  * @param amount
  * @param market
+ * @param inputAssetType which asset is being traded
+ * @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
@@ -24,19 +27,50 @@ const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
  *
  * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
  */
-function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote') {
-    const oldPrice = (0, market_1.calculateMarkPrice)(market);
+function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
+    let oldPrice;
+    if (useSpread && market.amm.baseSpread > 0) {
+        if ((0, types_2.isVariant)(direction, 'long')) {
+            oldPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+        }
+        else {
+            oldPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
+        }
+    }
+    else {
+        oldPrice = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+    }
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType);
-    const entryPrice = (0, amm_1.calculatePrice)(acquiredBase, acquiredQuote, market.amm.pegMultiplier).mul(new anchor_1.BN(-1));
-    const newPrice = (0, amm_1.calculatePrice)(market.amm.baseAssetReserve.sub(acquiredBase), market.amm.quoteAssetReserve.sub(acquiredQuote), market.amm.pegMultiplier);
+    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
+    const swapDirection = (0, types_2.isVariant)(direction, 'long')
+        ? types_1.SwapDirection.REMOVE
+        : types_1.SwapDirection.ADD;
+    const quoteAssetAmountAcquired = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), market.amm.pegMultiplier, swapDirection);
+    const entryPrice = quoteAssetAmountAcquired
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(acquiredBase.abs());
+    let amm;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
+        amm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
+        };
+    }
+    else {
+        amm = market.amm;
+    }
+    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBase), amm.quoteAssetReserve.sub(acquiredQuote), amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
-        (0, assert_1.assert)(newPrice.lt(oldPrice));
+        (0, assert_1.assert)(newPrice.lte(oldPrice));
     }
     else {
-        (0, assert_1.assert)(oldPrice.lt(newPrice));
+        (0, assert_1.assert)(oldPrice.lte(newPrice));
     }
     const pctMaxSlippage = newPrice
         .sub(oldPrice)
@@ -59,22 +93,22 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  * @param inputAssetType
  * @param useSpread
  * @return
- * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
+ * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', useSpread = true) {
+function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
     const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve } = (0, amm_1.calculateSpreadReserves)(market.amm, direction);
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
         amm = {
             baseAssetReserve,
             quoteAssetReserve,
-            sqrtK: market.amm.sqrtK,
-            pegMultiplier: market.amm.pegMultiplier,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
         };
     }
     else {
@@ -92,43 +126,72 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.
+ * @param outputAssetType which asset to trade.
+ * @param useSpread whether or not to consider the spread when calculating the trade size
  * @returns trade direction/size in order to push price to a targetPrice,
  *
  * [
- *   direction => direction of trade required, TODO-PRECISION
+ *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, TODO-PRECISION
- *   targetPrice => the target price TODO-PRECISION
+ *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
+ *   targetPrice => the target price MARK_PRICE_PRECISION
  * ]
  */
-function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote') {
+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);
+    const markPriceBefore = (0, market_1.calculateMarkPrice)(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);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
         targetPrice = markPriceBefore.add(priceGapScaled);
+        direction = types_1.PositionDirection.LONG;
     }
     else {
         const priceGap = markPriceBefore.sub(targetPrice);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
         targetPrice = markPriceBefore.sub(priceGapScaled);
+        direction = types_1.PositionDirection.SHORT;
     }
-    let direction;
     let tradeSize;
     let baseSize;
-    const baseAssetReserveBefore = market.amm.baseAssetReserve;
-    const quoteAssetReserveBefore = market.amm.quoteAssetReserve;
-    const peg = market.amm.pegMultiplier;
+    let baseAssetReserveBefore;
+    let quoteAssetReserveBefore;
+    let peg = market.amm.pegMultiplier;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
+        baseAssetReserveBefore = baseAssetReserve;
+        quoteAssetReserveBefore = quoteAssetReserve;
+        peg = newPeg;
+    }
+    else {
+        baseAssetReserveBefore = market.amm.baseAssetReserve;
+        quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+    }
     const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
     const k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
     let baseAssetReserveAfter;
     let quoteAssetReserveAfter;
     const biasModifier = new anchor_1.BN(1);
     let markPriceAfter;
-    if (markPriceBefore.gt(targetPrice)) {
+    if (useSpread &&
+        targetPrice.lt(askPriceBefore) &&
+        targetPrice.gt(bidPriceBefore)) {
+        // no trade, market is at target
+        if (markPriceBefore.gt(targetPrice)) {
+            direction = types_1.PositionDirection.SHORT;
+        }
+        else {
+            direction = types_1.PositionDirection.LONG;
+        }
+        tradeSize = numericConstants_1.ZERO;
+        return [direction, tradeSize, targetPrice, targetPrice];
+    }
+    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