@drift-labs/sdk 0.1.36-master.5 → 0.1.36-master.6

package/lib/accounts/bulkAccountLoader.d.ts

@@ -16,6 +16,7 @@ export declare class BulkAccountLoader {
     loadPromise?: Promise<void>;
     loadPromiseResolver: () => void;
     lastTimeLoadingPromiseCleared: number;
+    mostRecentSlot: number;
     constructor(connection: Connection, commitment: Commitment, pollingFrequency: number);
     addAccount(publicKey: PublicKey, callback: (buffer: Buffer) => void): string;
     removeAccount(publicKey: PublicKey, callbackId: string): void;

package/lib/accounts/bulkAccountLoader.js

@@ -20,6 +20,7 @@ class BulkAccountLoader {
         this.accountData = new Map();
         this.errorCallbacks = new Map();
         this.lastTimeLoadingPromiseCleared = Date.now();
+        this.mostRecentSlot = 0;
         this.connection = connection;
         this.commitment = commitment;
         this.pollingFrequency = pollingFrequency;
@@ -127,6 +128,9 @@ class BulkAccountLoader {
                 return;
             }
             const newSlot = rpcResponse.result.context.slot;
+            if (newSlot > this.mostRecentSlot) {
+                this.mostRecentSlot = newSlot;
+            }
             for (const i in accountsToLoad) {
                 const accountToLoad = accountsToLoad[i];
                 const key = accountToLoad.publicKey.toString();

package/lib/index.d.ts

@@ -25,6 +25,7 @@ export * from './math/funding';
 export * from './math/insuranceFund';
 export * from './math/market';
 export * from './math/position';
+export * from './math/oracles';
 export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';

package/lib/index.js

@@ -44,6 +44,7 @@ __exportStar(require("./math/funding"), exports);
 __exportStar(require("./math/insuranceFund"), exports);
 __exportStar(require("./math/market"), exports);
 __exportStar(require("./math/position"), exports);
+__exportStar(require("./math/oracles"), exports);
 __exportStar(require("./math/amm"), exports);
 __exportStar(require("./math/trade"), exports);
 __exportStar(require("./math/orders"), exports);

package/lib/math/oracles.d.ts

@@ -0,0 +1,3 @@
+import { AMM, OracleGuardRails } from '../types';
+import { OraclePriceData } from '../oracles/types';
+export declare function isOracleValid(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;

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

@@ -8,6 +8,8 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  * @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 +20,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: Market, inputAssetType?: AssetType, useSpread?: boolean): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -27,7 +29,7 @@ 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];
@@ -37,13 +39,15 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
  * @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: Market, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, 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,14 +27,38 @@ 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', useSpread = true) {
+    let oldPrice;
+    if (useSpread && market.amm.baseSpread > 0) {
+        if ((0, types_2.isVariant)(direction, 'long')) {
+            oldPrice = (0, market_1.calculateAskPrice)(market);
+        }
+        else {
+            oldPrice = (0, market_1.calculateBidPrice)(market);
+        }
+    }
+    else {
+        oldPrice = (0, market_1.calculateMarkPrice)(market);
+    }
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType);
+    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, useSpread);
     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);
+    let amm;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve } = (0, amm_1.calculateSpreadReserves)(market.amm, direction);
+        amm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: market.amm.sqrtK,
+            pegMultiplier: market.amm.pegMultiplier,
+        };
+    }
+    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));
     }
@@ -59,7 +86,7 @@ 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) {
@@ -92,35 +119,50 @@ 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', 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 bidPriceBefore = (0, market_1.calculateBidPrice)(market);
+    const askPriceBefore = (0, market_1.calculateAskPrice)(market);
+    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;
+    let baseAssetReserveBefore;
+    let quoteAssetReserveBefore;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve } = (0, amm_1.calculateSpreadReserves)(market.amm, direction);
+        baseAssetReserveBefore = baseAssetReserve;
+        quoteAssetReserveBefore = quoteAssetReserve;
+    }
+    else {
+        baseAssetReserveBefore = market.amm.baseAssetReserve;
+        quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+    }
     const peg = market.amm.pegMultiplier;
     const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
     const k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
@@ -128,7 +170,20 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     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

package/lib/oracles/pythClient.js

@@ -38,6 +38,7 @@ class PythClient {
                 confidence: convertPythPrice(priceData.confidence, priceData.exponent),
                 twap: convertPythPrice(priceData.twap.value, priceData.exponent),
                 twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
+                hasSufficientNumberOfDataPoints: true,
             };
         });
     }

package/lib/oracles/switchboardClient.js

@@ -39,11 +39,14 @@ class SwitchboardClient {
             const price = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.result);
             const confidence = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound
                 .stdDeviation);
+            const hasSufficientNumberOfDataPoints = aggregatorAccountData.latestConfirmedRound.numSuccess >=
+                aggregatorAccountData.minOracleResults;
             const slot = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
             return {
                 price,
                 slot,
                 confidence,
+                hasSufficientNumberOfDataPoints,
             };
         });
     }

package/lib/oracles/types.d.ts

@@ -6,6 +6,7 @@ export declare type OraclePriceData = {
     price: BN;
     slot: BN;
     confidence: BN;
+    hasSufficientNumberOfDataPoints: boolean;
     twap?: BN;
     twapConfidence?: BN;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.36-master.5",
+	"version": "0.1.36-master.6",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.ts

@@ -24,6 +24,7 @@ export class BulkAccountLoader {
 	loadPromise?: Promise<void>;
 	loadPromiseResolver: () => void;
 	lastTimeLoadingPromiseCleared = Date.now();
+	mostRecentSlot = 0;
 
 	public constructor(
 		connection: Connection,
@@ -159,6 +160,10 @@ export class BulkAccountLoader {
 
 		const newSlot = rpcResponse.result.context.slot;
 
+		if (newSlot > this.mostRecentSlot) {
+			this.mostRecentSlot = newSlot;
+		}
+
 		for (const i in accountsToLoad) {
 			const accountToLoad = accountsToLoad[i];
 			const key = accountToLoad.publicKey.toString();

package/src/index.ts

@@ -26,6 +26,7 @@ export * from './math/funding';
 export * from './math/insuranceFund';
 export * from './math/market';
 export * from './math/position';
+export * from './math/oracles';
 export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';

package/src/math/oracles.ts

@@ -0,0 +1,36 @@
+import { AMM, OracleGuardRails } from '../types';
+import { OraclePriceData } from '../oracles/types';
+import { ONE, ZERO } from '../constants/numericConstants';
+import { BN } from '../index';
+
+export function isOracleValid(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	slot: number
+): boolean {
+	const isOraclePriceNonPositive = oraclePriceData.price.lt(ZERO);
+	const isOraclePriceTooVolatile =
+		oraclePriceData.price
+			.div(BN.max(ONE, amm.lastOraclePriceTwap))
+			.gt(oracleGuardRails.validity.tooVolatileRatio) ||
+		amm.lastOraclePriceTwap
+			.div(BN.max(ONE, oraclePriceData.price))
+			.gt(oracleGuardRails.validity.tooVolatileRatio);
+
+	const isConfidenceTooLarge = oraclePriceData.price
+		.div(BN.max(ONE, oraclePriceData.confidence))
+		.lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+
+	const oracleIsStale = oraclePriceData.slot
+		.sub(new BN(slot))
+		.gt(oracleGuardRails.validity.slotsBeforeStale);
+
+	return !(
+		!oraclePriceData.hasSufficientNumberOfDataPoints ||
+		oracleIsStale ||
+		isOraclePriceNonPositive ||
+		isOraclePriceTooVolatile ||
+		isConfidenceTooLarge
+	);
+}

package/src/math/trade.ts

@@ -7,7 +7,11 @@ import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
 } from '../constants/numericConstants';
-import { calculateMarkPrice } from './market';
+import {
+	calculateBidPrice,
+	calculateAskPrice,
+	calculateMarkPrice,
+} from './market';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
@@ -16,6 +20,7 @@ import {
 	calculateSpreadReserves,
 } from './amm';
 import { squareRootBN } from './utils';
+import { isVariant } from '../types';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -37,6 +42,8 @@ export type PriceImpactUnit =
  * @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
@@ -51,9 +58,20 @@ export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
 	market: Market,
-	inputAssetType: AssetType = 'quote'
+	inputAssetType: AssetType = 'quote',
+	useSpread = true
 ): [BN, BN, BN, BN] {
-	const oldPrice = calculateMarkPrice(market);
+	let oldPrice: BN;
+
+	if (useSpread && market.amm.baseSpread > 0) {
+		if (isVariant(direction, 'long')) {
+			oldPrice = calculateAskPrice(market);
+		} else {
+			oldPrice = calculateBidPrice(market);
+		}
+	} else {
+		oldPrice = calculateMarkPrice(market);
+	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
@@ -61,7 +79,8 @@ export function calculateTradeSlippage(
 		direction,
 		amount,
 		market,
-		inputAssetType
+		inputAssetType,
+		useSpread
 	);
 
 	const entryPrice = calculatePrice(
@@ -70,10 +89,26 @@ export function calculateTradeSlippage(
 		market.amm.pegMultiplier
 	).mul(new BN(-1));
 
+	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+	if (useSpread && market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
+			market.amm,
+			direction
+		);
+		amm = {
+			baseAssetReserve,
+			quoteAssetReserve,
+			sqrtK: market.amm.sqrtK,
+			pegMultiplier: market.amm.pegMultiplier,
+		};
+	} else {
+		amm = market.amm;
+	}
+
 	const newPrice = calculatePrice(
-		market.amm.baseAssetReserve.sub(acquiredBase),
-		market.amm.quoteAssetReserve.sub(acquiredQuote),
-		market.amm.pegMultiplier
+		amm.baseAssetReserve.sub(acquiredBase),
+		amm.quoteAssetReserve.sub(acquiredQuote),
+		amm.pegMultiplier
 	);
 
 	if (direction == PositionDirection.SHORT) {
@@ -104,7 +139,7 @@ export function 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
  */
 export function calculateTradeAcquiredAmounts(
@@ -150,43 +185,63 @@ export function 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
  * ]
  */
 export function calculateTargetPriceTrade(
 	market: Market,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
-	outputAssetType: AssetType = 'quote'
+	outputAssetType: AssetType = 'quote',
+	useSpread = true
 ): [PositionDirection, BN, BN, BN] {
 	assert(market.amm.baseAssetReserve.gt(ZERO));
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
 	const markPriceBefore = calculateMarkPrice(market);
+	const bidPriceBefore = calculateBidPrice(market);
+	const askPriceBefore = calculateAskPrice(market);
 
+	let direction;
 	if (targetPrice.gt(markPriceBefore)) {
 		const priceGap = targetPrice.sub(markPriceBefore);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
 		targetPrice = markPriceBefore.add(priceGapScaled);
+		direction = PositionDirection.LONG;
 	} else {
 		const priceGap = markPriceBefore.sub(targetPrice);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
 		targetPrice = markPriceBefore.sub(priceGapScaled);
+		direction = PositionDirection.SHORT;
 	}
 
-	let direction;
 	let tradeSize;
 	let baseSize;
 
-	const baseAssetReserveBefore = market.amm.baseAssetReserve;
-	const quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+	let baseAssetReserveBefore: BN;
+	let quoteAssetReserveBefore: BN;
+
+	if (useSpread && market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
+			market.amm,
+			direction
+		);
+		baseAssetReserveBefore = baseAssetReserve;
+		quoteAssetReserveBefore = quoteAssetReserve;
+	} else {
+		baseAssetReserveBefore = market.amm.baseAssetReserve;
+		quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+	}
+
 	const peg = market.amm.pegMultiplier;
 	const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
 	const k = invariant.mul(MARK_PRICE_PRECISION);
@@ -196,7 +251,20 @@ export function calculateTargetPriceTrade(
 	const biasModifier = new 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 = PositionDirection.SHORT;
+		} else {
+			direction = PositionDirection.LONG;
+		}
+		tradeSize = ZERO;
+		return [direction, tradeSize, targetPrice, targetPrice];
+	} else if (markPriceBefore.gt(targetPrice)) {
 		// overestimate y2
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).sub(biasModifier)

package/src/oracles/pythClient.ts

@@ -36,6 +36,7 @@ export class PythClient {
 				priceData.twac.value,
 				priceData.exponent
 			),
+			hasSufficientNumberOfDataPoints: true,
 		};
 	}
 }

package/src/oracles/switchboardClient.ts

@@ -48,11 +48,16 @@ export class SwitchboardClient implements OracleClient {
 				.stdDeviation as SwitchboardDecimal
 		);
 
+		const hasSufficientNumberOfDataPoints =
+			aggregatorAccountData.latestConfirmedRound.numSuccess >=
+			aggregatorAccountData.minOracleResults;
+
 		const slot: BN = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
 		return {
 			price,
 			slot,
 			confidence,
+			hasSufficientNumberOfDataPoints,
 		};
 	}
 

package/src/oracles/types.ts

@@ -5,6 +5,7 @@ export type OraclePriceData = {
 	price: BN;
 	slot: BN;
 	confidence: BN;
+	hasSufficientNumberOfDataPoints: boolean;
 	twap?: BN;
 	twapConfidence?: BN;
 };