add additional end price buffer param (#147)

* add additional end price buffer param

* apply additional buffer even if max slippage reached

* add buffer to limitPrice in deriveMarketOrderParams

Author: lowkeynicc

common-ts/src/common-ui-utils/commonUiUtils.ts

@@ -349,6 +349,7 @@ const getMarketAuctionParams = ({
 	duration,
 	auctionStartPriceOffset,
 	auctionEndPriceOffset,
+	additionalEndPriceBuffer,
 }: {
 	direction: PositionDirection;
 	startPriceFromSettings: BN;
@@ -357,13 +358,14 @@ const getMarketAuctionParams = ({
 	duration: number;
 	auctionStartPriceOffset: number;
 	auctionEndPriceOffset: number;
+	additionalEndPriceBuffer?: BN;
 }): AuctionParams => {
 	let auctionStartPrice: BN;
 	let auctionEndPrice: BN;
 	let constrainedBySlippage: boolean;
 
 	const auctionEndPriceBuffer = BigNum.from(PRICE_PRECISION).scale(
-		auctionEndPriceOffset * 100,
+		Math.abs(auctionEndPriceOffset * 100),
 		10000
 	).val;
 
@@ -389,6 +391,12 @@ const getMarketAuctionParams = ({
 		// use BEST (limit price, auction end price) as end price
 		auctionEndPrice = BN.min(limitPrice, auctionEndPrice);
 
+		// apply additional buffer if provided
+		if (additionalEndPriceBuffer) {
+			auctionEndPrice = auctionEndPrice.add(additionalEndPriceBuffer);
+			constrainedBySlippage = limitPrice.lt(auctionEndPrice);
+		}
+
 		auctionStartPrice = BN.min(auctionStartPrice, auctionEndPrice);
 	} else {
 		auctionStartPrice = startPriceFromSettings.add(auctionStartPriceBuffer);
@@ -407,6 +415,12 @@ const getMarketAuctionParams = ({
 		// use BEST (limit price, auction end price) as end price
 		auctionEndPrice = BN.max(limitPrice, auctionEndPrice);
 
+		// apply additional buffer if provided
+		if (additionalEndPriceBuffer) {
+			auctionEndPrice = auctionEndPrice.sub(additionalEndPriceBuffer);
+			constrainedBySlippage = limitPrice.gt(auctionEndPrice);
+		}
+
 		auctionStartPrice = BN.max(auctionStartPrice, auctionEndPrice);
 	}
 
@@ -445,6 +459,7 @@ const deriveMarketOrderParams = ({
 	auctionPriceCaps,
 	slippageTolerance,
 	isOracleOrder,
+	additionalEndPriceBuffer,
 }: {
 	marketType: MarketType;
 	marketIndex: number;
@@ -470,6 +485,7 @@ const deriveMarketOrderParams = ({
 	auctionEndPriceOffsetFrom: TradeOffsetPrice;
 	slippageTolerance: number;
 	isOracleOrder?: boolean;
+	additionalEndPriceBuffer?: BN;
 }): OptionalOrderParams & { constrainedBySlippage?: boolean } => {
 	const priceObject = getPriceObject({
 		oraclePrice,
@@ -481,12 +497,18 @@ const deriveMarketOrderParams = ({
 	});
 
 	// max slippage price
-	const limitPrice = getMarketOrderLimitPrice({
+	let limitPrice = getMarketOrderLimitPrice({
 		direction,
 		baselinePrice: priceObject[auctionStartPriceOffsetFrom],
 		slippageTolerance: allowInfSlippage ? undefined : slippageTolerance,
 	});
 
+	if (additionalEndPriceBuffer) {
+		limitPrice = isVariant(direction, 'long')
+			? limitPrice.add(additionalEndPriceBuffer)
+			: limitPrice.sub(additionalEndPriceBuffer);
+	}
+
 	const auctionParams = getMarketAuctionParams({
 		direction,
 		startPriceFromSettings: priceObject[auctionStartPriceOffsetFrom],
@@ -495,6 +517,7 @@ const deriveMarketOrderParams = ({
 		duration: auctionDuration,
 		auctionStartPriceOffset: auctionStartPriceOffset,
 		auctionEndPriceOffset: auctionEndPriceOffset,
+		additionalEndPriceBuffer,
 	});
 
 	let orderParams = getMarketOrderParams({

common-ts/tests/utils/orders.test.ts

@@ -377,6 +377,40 @@ describe('COMMON_UI_UTILS OrderParams Tests', () => {
 			//@ts-ignore
 			expect(result.constrainedBySlippage).to.equal(false);
 		});
+
+		it('should correctly generate params for LONG non-oracle market order with auction end price NOT capped by slippage AND an additional offset', () => {
+			const result = COMMON_UI_UTILS.deriveMarketOrderParams({
+				marketType: MarketType.PERP,
+				marketIndex: 0,
+				direction: PositionDirection.LONG,
+				maxLeverageSelected: false,
+				maxLeverageOrderSize: new BN(1000).mul(BASE_PRECISION),
+				baseAmount: new BN(1).mul(BASE_PRECISION),
+				reduceOnly: false,
+				allowInfSlippage: true,
+				bestPrice: new BN(99).mul(PRICE_PRECISION),
+				entryPrice: new BN(101).mul(PRICE_PRECISION),
+				oraclePrice: new BN(104).mul(PRICE_PRECISION),
+				worstPrice: new BN(108).mul(PRICE_PRECISION),
+				markPrice: new BN(100).mul(PRICE_PRECISION),
+				auctionDuration: 20,
+				auctionStartPriceOffset: 0,
+				auctionEndPriceOffset: 0,
+				auctionStartPriceOffsetFrom: 'mark',
+				auctionEndPriceOffsetFrom: 'worst',
+				slippageTolerance: 50,
+				isOracleOrder: false,
+				additionalEndPriceBuffer: new BN(100),
+			});
+
+			expect(ENUM_UTILS.toStr(result.orderType)).to.equal(
+				ENUM_UTILS.toStr(OrderType.MARKET)
+			);
+			expect(result.auctionStartPrice?.toString()).to.equal('100000000');
+			expect(result.auctionEndPrice?.toString()).to.equal('108000100');
+			//@ts-ignore
+			expect(result.constrainedBySlippage).to.equal(false);
+		});
 	});
 	describe('getMarketOrderLimitPrice', () => {
 		it('should use the correct price for a LONG with 5% max slippage', () => {