@katanaperps/katana-perps-sdk 2.1.0-beta.14 → 2.1.0-beta.15

package/dist/orderbook/buySellPanelEstimate.d.ts

@@ -120,6 +120,8 @@ export interface BuySellPanelEstimate {
     maximumPositionSizeExceeded: boolean;
     /** `true` if a post-only ({@link TimeInForce.gtx gtx}) order would cross the spread (rejected) */
     postOnlyWouldCross: boolean;
+    /** `true` if an immediate-or-cancel ({@link TimeInForce.ioc ioc}) order matched no liquidity (nothing would execute) */
+    immediateOrCancelWouldNotExecute: boolean;
     /** `true` if a fill-or-kill ({@link TimeInForce.fok fok}) order could not be fully filled (rejected) */
     fillOrKillWouldNotExecute: boolean;
     /** `true` if a reduce-only order is on the same side as the open position (rejected) */

package/dist/orderbook/buySellPanelEstimate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buySellPanelEstimate.d.ts","sourceRoot":"","sources":["../../src/orderbook/buySellPanelEstimate.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"buySellPanelEstimate.d.ts","sourceRoot":"","sources":["../../src/orderbook/buySellPanelEstimate.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EACV,wCAAwC,EACxC,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAUrC;;;;;;;GAOG;AACH,MAAM,MAAM,4BAA4B,GACpC;IACE,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,wBAAwB,CAAC,EAAE,SAAS,CAAC;CACtC,GACD;IACE,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB,CAAC,EAAE,SAAS,CAAC;CACtC,GACD;IACE,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,sFAAsF;IACtF,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAEN;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,0BAA0B;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,GAAG,4BAA4B,CAAC;AAEjC,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,IAAI,CACV,iBAAiB,EACf,QAAQ,GACR,YAAY,GACZ,MAAM,kBAAkB,GACxB,2BAA2B,GAC3B,gCAAgC,GAChC,+BAA+B,CAClC,CAAC;IACF;;;OAGG;IACH,MAAM,EAAE,IAAI,CACV,iBAAiB,EACf,QAAQ,GACR,gBAAgB,GAChB,cAAc,GACd,aAAa,GACb,cAAc,GACd,cAAc,GACd,WAAW,CACd,CAAC;IACF;;;;;OAKG;IACH,SAAS,EAAE;QAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;QAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;KAAE,CAAC;IAClE;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,IAAI,CAC1B,gBAAgB,EACd,QAAQ,GACR,MAAM,GACN,OAAO,GACP,kBAAkB,GAClB,kBAAkB,GAClB,QAAQ,CACX,EAAE,CAAC;IACJ;;;;OAIG;IACH,oCAAoC,CAAC,EAAE,wCAAwC,EAAE,CAAC;IAClF;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,iBAAiB,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,kFAAkF;IAClF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mFAAmF;IACnF,kBAAkB,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,6EAA6E;IAC7E,oBAAoB,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,sBAAsB,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,2BAA2B,EAAE,OAAO,CAAC;IACrC;;;OAGG;IACH,2BAA2B,EAAE,OAAO,CAAC;IACrC,8EAA8E;IAC9E,2BAA2B,EAAE,OAAO,CAAC;IACrC,kGAAkG;IAClG,kBAAkB,EAAE,OAAO,CAAC;IAC5B,wHAAwH;IACxH,gCAAgC,EAAE,OAAO,CAAC;IAC1C,wGAAwG;IACxG,yBAAyB,EAAE,OAAO,CAAC;IACnC,wFAAwF;IACxF,gCAAgC,EAAE,OAAO,CAAC;IAC1C,+EAA+E;IAC/E,wBAAwB,EAAE,OAAO,CAAC;IAClC;;;OAGG;IACH,kCAAkC,EAAE,OAAO,CAAC;CAC7C;AAqiCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,wBAAwB,GAC7B,oBAAoB,CA4BtB"}

package/dist/orderbook/buySellPanelEstimate.js

@@ -24,6 +24,7 @@ function makeEmptyEstimate() {
         executionPriceLimitExceeded: false,
         maximumPositionSizeExceeded: false,
         postOnlyWouldCross: false,
+        immediateOrCancelWouldNotExecute: false,
         fillOrKillWouldNotExecute: false,
         reduceOnlyWouldNotReducePosition: false,
         reduceOnlyNoOpenPosition: false,
@@ -128,7 +129,11 @@ function calculateLiquidationPrice(args) {
  * (self-trades) from other liquidity, and applying execution price limits and
  * taker fees.
  */
-function matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity) {
+function matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity, 
+// When `false`, the order keeps matching through the book past the execution
+// price limit (the breach is still flagged on the result) rather than stopping
+// at it. Used when sizing the slider so it can consume the target collateral.
+enforceExecutionPriceLimit) {
     const isQuantityInQuote = 'quoteQuantity' in quantity;
     // Working copy of own maker-side resting liquidity, indexed by price.
     const standingOrdersCopy = context.marketStandingOrders.map((order) => ({
@@ -159,6 +164,13 @@ function matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity) {
     // Tracks reduce-only fill capacity (real, position-reducing fills only)
     let remainingReduceOnly = reduceOnlyMaximumBaseQuantity;
     for (const level of context.makerLevels) {
+        // Stop once the taker order's quantity is fully consumed.
+        const exhausted = remainingBase !== null ?
+            remainingBase <= BigInt(0)
+            : remainingQuote <= BigInt(0);
+        if (exhausted) {
+            break;
+        }
         // doOrdersMatch
         if (!context.isMarketOrder) {
             const crosses = context.isBuy ?
@@ -168,20 +180,6 @@ function matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity) {
                 break;
             }
         }
-        // Execution price limit (market orders)
-        if ((context.minimumExecutionPrice !== null &&
-            level.price < context.minimumExecutionPrice) ||
-            (context.maximumExecutionPrice !== null &&
-                level.price > context.maximumExecutionPrice)) {
-            result.executionPriceLimitExceeded = true;
-            break;
-        }
-        const exhausted = remainingBase !== null ?
-            remainingBase <= BigInt(0)
-            : remainingQuote <= BigInt(0);
-        if (exhausted) {
-            break;
-        }
         // Determine how much of this level the taker consumes.
         let consumedBase;
         if (remainingBase !== null) {
@@ -197,6 +195,24 @@ function matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity) {
                 consumedBase = (level.size * remainingQuote) / levelQuoteIfFull;
             }
         }
+        // Nothing more can be filled at this (best remaining) price — e.g. a
+        // sub-pip quote remainder left by flooring. The order is complete, so worse
+        // levels it never reaches must not trip the execution price limit.
+        if (consumedBase <= BigInt(0)) {
+            break;
+        }
+        // A trade occurs at this level's price, so apply the execution price limit.
+        // When not enforcing (slider sizing), matching continues but the breach is
+        // still recorded on the result.
+        if ((context.minimumExecutionPrice !== null &&
+            level.price < context.minimumExecutionPrice) ||
+            (context.maximumExecutionPrice !== null &&
+                level.price > context.maximumExecutionPrice)) {
+            result.executionPriceLimitExceeded = true;
+            if (enforceExecutionPriceLimit) {
+                break;
+            }
+        }
         // Split into self-trade (own liquidity) and real fill (other liquidity).
         const ownOrders = ownMakerOrdersByPrice.get(level.price) ?? [];
         let ownSizeAtLevel = BigInt(0);
@@ -272,7 +288,19 @@ function matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity) {
  * @private
  * Produces a complete estimate for a concrete base or quote quantity.
  */
-function runEstimate(context, quantity) {
+function runEstimate(context, quantity, 
+// Whether the *input* quantity is zero. A zero-quantity order does nothing, so
+// none of the time-in-force feasibility flags apply to it. This is based on
+// the input (e.g. the slider ratio) rather than the resolved base quantity: a
+// non-zero slider on an order that cannot execute or rest resolves to a base
+// quantity of zero, yet its time-in-force flags should still be evaluated.
+isZeroQuantity = ('baseQuantity' in quantity ?
+    quantity.baseQuantity
+    : quantity.quoteQuantity) <= BigInt(0), 
+// When `false`, matching continues past the execution price limit (still
+// flagged) instead of stopping at it. Used for slider sizing so the order can
+// be sized to consume the target collateral.
+enforceExecutionPriceLimit = true) {
     const estimate = makeEmptyEstimate();
     // Reduce-only validity and fill capacity.
     let reduceOnlyMaximumBaseQuantity = null;
@@ -297,7 +325,9 @@ function runEstimate(context, quantity) {
             (context.isBuy ?
                 context.limitPrice >= bestMakerPrice
                 : context.limitPrice <= bestMakerPrice));
-    if (context.timeInForce === request_1.TimeInForce.gtx && crossesSpread) {
+    if (context.timeInForce === request_1.TimeInForce.gtx &&
+        crossesSpread &&
+        !isZeroQuantity) {
         estimate.postOnlyWouldCross = true;
         return estimate;
     }
@@ -306,18 +336,39 @@ function runEstimate(context, quantity) {
         estimate.executionPriceLimitExceeded = true;
         return estimate;
     }
-    const fill = matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity);
+    const fill = matchTakerOrder(context, quantity, reduceOnlyMaximumBaseQuantity, enforceExecutionPriceLimit);
     estimate.selfTradeEncountered = fill.selfTradeEncountered;
     estimate.executionPriceLimitExceeded = fill.executionPriceLimitExceeded;
+    // Immediate-or-cancel: the unfilled remainder is canceled rather than rested,
+    // so an order that matched no liquidity would not execute at all.
+    estimate.immediateOrCancelWouldNotExecute =
+        context.timeInForce === request_1.TimeInForce.ioc &&
+            !isZeroQuantity &&
+            fill.tradeBaseQuantity === BigInt(0);
     // Fill-or-kill: the order must be fully filled by crossing liquidity.
-    if (context.timeInForce === request_1.TimeInForce.fok) {
-        const requestedFilled = 'baseQuantity' in quantity ?
-            fill.tradeBaseQuantity + fill.selfTradeBaseQuantity >=
-                quantity.baseQuantity
-            : fill.tradeQuoteQuantity +
-                (0, _pipmath_1.multiplyPips)(fill.selfTradeBaseQuantity, context.indexPrice) >=
-                quantity.quoteQuantity;
-        if (!requestedFilled) {
+    if (context.timeInForce === request_1.TimeInForce.fok && !isZeroQuantity) {
+        let fullyFillable;
+        if ('baseQuantity' in quantity) {
+            // Base quantities are matched exactly (no rounding), so the bounded fill
+            // determines fillability directly.
+            fullyFillable =
+                fill.tradeBaseQuantity + fill.selfTradeBaseQuantity >=
+                    quantity.baseQuantity;
+        }
+        else {
+            // Quote fills are floored to whole base pips, so the achievable quote is
+            // the largest value not exceeding the requested quote and rarely equals it
+            // exactly. Decide fillability from the *total* crossable quote liquidity
+            // instead: re-match with an unbounded budget (every crossable level fills
+            // in full, so no flooring occurs).
+            const unboundedQuote = context.makerLevels.reduce((sum, level) => sum + (0, _pipmath_1.multiplyPips)(level.size, level.price), BigInt(1));
+            const maxFill = matchTakerOrder(context, { quoteQuantity: unboundedQuote }, reduceOnlyMaximumBaseQuantity, enforceExecutionPriceLimit);
+            fullyFillable =
+                maxFill.tradeQuoteQuantity +
+                    (0, _pipmath_1.multiplyPips)(maxFill.selfTradeBaseQuantity, context.indexPrice) >=
+                    quantity.quoteQuantity;
+        }
+        if (!fullyFillable) {
             estimate.fillOrKillWouldNotExecute = true;
             return estimate;
         }
@@ -494,7 +545,9 @@ function resolveBaseQuantityForCollateralRatio(context, ratio) {
         return BigInt(0);
     }
     // Upper bound: all matchable liquidity, plus resting capacity for limit
-    // orders that may add to the books.
+    // orders that may add to the books. Liquidity beyond the execution price limit
+    // is included: the slider matches through the book (the breach is flagged on
+    // the result rather than capping the size).
     let matchableBase = BigInt(0);
     for (const level of context.makerLevels) {
         if (!context.isMarketOrder) {
@@ -505,12 +558,6 @@ function resolveBaseQuantityForCollateralRatio(context, ratio) {
                 break;
             }
         }
-        if ((context.minimumExecutionPrice !== null &&
-            level.price < context.minimumExecutionPrice) ||
-            (context.maximumExecutionPrice !== null &&
-                level.price > context.maximumExecutionPrice)) {
-            break;
-        }
         matchableBase += level.size;
     }
     const canRest = !context.isMarketOrder &&
@@ -537,7 +584,9 @@ function resolveBaseQuantityForCollateralRatio(context, ratio) {
     // plateau and yields the largest quantity that drives available collateral to
     // ~zero while remaining acceptable.
     const isAcceptable = (baseQuantity) => {
-        const e = runEstimate(context, { baseQuantity });
+        // Size against the full book (do not cap at the execution price limit), so a
+        // breach does not prevent the slider from consuming the target collateral.
+        const e = runEstimate(context, { baseQuantity }, undefined, false);
         return (e.cost <= targetCost &&
             !e.freeCollateralExceeded &&
             !e.availableCollateralExceeded);
@@ -585,9 +634,16 @@ function buildContext(args) {
         .filter((level) => level.size > BigInt(0))
         .slice()
         .sort((a, b) => isBuy ? Number(a.price - b.price) : Number(b.price - a.price));
-    // Execution price limits.
-    const bestAsk = args.orderBook.asks.length > 0 ? args.orderBook.asks[0].price : null;
-    const bestBid = args.orderBook.bids.length > 0 ? args.orderBook.bids[0].price : null;
+    // Execution price limits. The best bid/ask are taken defensively (the input
+    // book is not assumed to be sorted), ignoring empty levels.
+    const positiveAsks = args.orderBook.asks.filter((l) => l.size > BigInt(0));
+    const positiveBids = args.orderBook.bids.filter((l) => l.size > BigInt(0));
+    const bestAsk = positiveAsks.length > 0 ?
+        positiveAsks.reduce((best, l) => (l.price < best ? l.price : best), positiveAsks[0].price)
+        : null;
+    const bestBid = positiveBids.length > 0 ?
+        positiveBids.reduce((best, l) => (l.price > best ? l.price : best), positiveBids[0].price)
+        : null;
     const baselinePrice = bestAsk !== null && bestBid !== null ?
         (bestAsk + bestBid) / BigInt(2)
         : indexPrice;
@@ -707,7 +763,12 @@ function calculateBuySellPanelEstimate(args) {
     if (typeof order.baseQuantity !== 'undefined') {
         return runEstimate(context, { baseQuantity: order.baseQuantity });
     }
-    const baseQuantity = resolveBaseQuantityForCollateralRatio(context, order.availableCollateralRatio);
-    return runEstimate(context, { baseQuantity });
+    const ratio = order.availableCollateralRatio;
+    const baseQuantity = resolveBaseQuantityForCollateralRatio(context, ratio);
+    // Base the zero-quantity determination on the slider input, not the resolved
+    // base quantity (which is zero when the order cannot execute or rest). The
+    // slider also matches through the book rather than capping at the execution
+    // price limit (the breach is still flagged).
+    return runEstimate(context, { baseQuantity }, ratio <= BigInt(0), false);
 }
 exports.calculateBuySellPanelEstimate = calculateBuySellPanelEstimate;

package/dist/tests/orderbook/buySellPanelEstimate.test.js

@@ -174,6 +174,70 @@ describe('orderbook/buySellPanelEstimate', () => {
             });
             testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('4'));
             testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+            // Some liquidity matched, so the order executes.
+            expect(estimate.immediateOrCancelWouldNotExecute).to.equal(false);
+        });
+        it('flags an ioc order that matches no liquidity', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '10')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('5'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('99'), // below the best ask: does not cross
+                    timeInForce: request_1.TimeInForce.ioc,
+                },
+            });
+            expect(estimate.immediateOrCancelWouldNotExecute).to.equal(true);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+        });
+        it('flags a non-zero-slider ioc order that matches no liquidity', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '10')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    // Non-zero slider, but the limit price does not cross and ioc can't
+                    // rest, so it resolves to a zero base quantity.
+                    availableCollateralRatio: (0, _pipmath_1.decimalToPip)('0.5'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('99'),
+                    timeInForce: request_1.TimeInForce.ioc,
+                },
+            });
+            expect(estimate.immediateOrCancelWouldNotExecute).to.equal(true);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+        });
+        it('sets no time-in-force flags for a zero-quantity order', () => {
+            for (const timeInForce of [
+                request_1.TimeInForce.gtc,
+                request_1.TimeInForce.gtx,
+                request_1.TimeInForce.ioc,
+                request_1.TimeInForce.fok,
+            ]) {
+                // Crosses the spread (gtx would otherwise flag) with a zero quantity.
+                const estimate = runEstimate({
+                    orderBook: { asks: [level('100', '10')], bids: [] },
+                    order: {
+                        side: request_1.OrderSide.buy,
+                        baseQuantity: (0, _pipmath_1.decimalToPip)('0'),
+                        limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                        timeInForce,
+                    },
+                });
+                expect(estimate.postOnlyWouldCross, timeInForce).to.equal(false);
+                expect(estimate.immediateOrCancelWouldNotExecute, timeInForce).to.equal(false);
+                expect(estimate.fillOrKillWouldNotExecute, timeInForce).to.equal(false);
+            }
+            // A 0% slider resolves to a zero quantity as well.
+            const sliderEstimate = runEstimate({
+                orderBook: { asks: [level('100', '10')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.ioc,
+                    availableCollateralRatio: (0, _pipmath_1.decimalToPip)('0'),
+                },
+            });
+            expect(sliderEstimate.immediateOrCancelWouldNotExecute).to.equal(false);
         });
         it('flags a post-only (gtx) order that would cross the spread', () => {
             const estimate = runEstimate({
@@ -215,6 +279,37 @@ describe('orderbook/buySellPanelEstimate', () => {
             expect(estimate.fillOrKillWouldNotExecute).to.equal(true);
             testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
         });
+        it('fills a quote-denominated fill-or-kill order to the largest quote not exceeding the request', () => {
+            const estimate = runEstimate({
+                // Price 7 does not divide 100 evenly; ample liquidity (700 quote).
+                orderBook: { asks: [level('7', '100')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    quoteQuantity: (0, _pipmath_1.decimalToPip)('100'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('10'),
+                    timeInForce: request_1.TimeInForce.fok,
+                },
+            });
+            // 14.28571428 @ 7 = 99.99999996 (largest quote <= 100); not killed.
+            expect(estimate.fillOrKillWouldNotExecute).to.equal(false);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('14.28571428'));
+            testHelpers.assertBigintsEqual(estimate.tradeQuoteQuantity, (0, _pipmath_1.decimalToPip)('99.99999996'));
+            expect(estimate.tradeQuoteQuantity <= (0, _pipmath_1.decimalToPip)('100')).to.equal(true);
+        });
+        it('kills a quote-denominated fill-or-kill order without enough liquidity', () => {
+            const estimate = runEstimate({
+                // Only 7 of crossable quote (1 @ 7) vs a 100 quote request.
+                orderBook: { asks: [level('7', '1')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    quoteQuantity: (0, _pipmath_1.decimalToPip)('100'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('10'),
+                    timeInForce: request_1.TimeInForce.fok,
+                },
+            });
+            expect(estimate.fillOrKillWouldNotExecute).to.equal(true);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+        });
         it('detects self-trades and frees the matched order’s held collateral', () => {
             // The book’s ask at 100 (size 10) includes the wallet’s own 3-unit sell.
             const estimate = runEstimate({
@@ -323,6 +418,66 @@ describe('orderbook/buySellPanelEstimate', () => {
             // Only the 10 available at 100 (within the limit) are filled
             testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('10'));
         });
+        it('does not flag the execution price limit when the order fills entirely within it', () => {
+            const estimate = runEstimate({
+                market: {
+                    ...defaultMarket,
+                    marketOrderExecutionPriceLimit: '0.01000000', // 1%
+                },
+                orderBook: {
+                    // best ask 100.1, plus worse levels beyond the 1% limit (max ~101.01)
+                    asks: [level('100.1', '10'), level('102', '10'), level('103', '10')],
+                    bids: [level('99.9', '10'), level('98', '10')],
+                },
+                // baseline 100; fully fills 5 @ 100.1 and never reaches the 102 level
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            expect(estimate.executionPriceLimitExceeded).to.equal(false);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('5'));
+        });
+        it('does not flag the execution price limit for a quote order that fills within it', () => {
+            const estimate = runEstimate({
+                market: {
+                    ...defaultMarket,
+                    marketOrderExecutionPriceLimit: '0.01000000', // 1%
+                },
+                orderBook: {
+                    asks: [level('100.1', '10'), level('102', '10'), level('103', '10')],
+                    bids: [level('99.9', '10')],
+                },
+                // 50 quote fills within the best ask (well under its 1,001 quote of
+                // depth); the worse 102 level is never reached.
+                order: { side: request_1.OrderSide.buy, quoteQuantity: (0, _pipmath_1.decimalToPip)('50') },
+            });
+            expect(estimate.executionPriceLimitExceeded).to.equal(false);
+            expect(estimate.tradeBaseQuantity > (0, _pipmath_1.decimalToPip)('0')).to.equal(true);
+        });
+        it('matches a slider order through the book past the execution price limit and flags it', () => {
+            const estimate = runEstimate({
+                market: {
+                    ...defaultMarket,
+                    marketOrderExecutionPriceLimit: '0.01000000', // 1%, max ~101.01
+                },
+                wallet: {
+                    ...defaultWallet,
+                    equity: '100.00000000',
+                    quoteBalance: '100.00000000',
+                },
+                orderBook: {
+                    // Only 2 of liquidity within the limit; the rest is beyond it.
+                    asks: [level('100.1', '2'), level('102', '10'), level('103', '10')],
+                    bids: [level('99.9', '10')],
+                },
+                order: { side: request_1.OrderSide.buy, availableCollateralRatio: _pipmath_1.oneInPips }, // 100%
+            });
+            // The slider sizes the order to consume the available collateral by
+            // matching beyond the limit, and flags the breach rather than capping.
+            expect(estimate.executionPriceLimitExceeded).to.equal(true);
+            expect(estimate.tradeBaseQuantity > (0, _pipmath_1.decimalToPip)('2')).to.equal(true);
+            const target = (0, _pipmath_1.decimalToPip)('100');
+            expect(estimate.cost <= target).to.equal(true);
+            expect(target - estimate.cost <= (0, _pipmath_1.decimalToPip)('1')).to.equal(true);
+        });
         it('flags a limit order whose price is outside the allowed range', () => {
             const estimate = runEstimate({
                 market: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@katanaperps/katana-perps-sdk",
-  "version": "2.1.0-beta.14",
+  "version": "2.1.0-beta.15",
   "description": "Katana Perps SDK for Javascript in the browser and Node.js",
   "repository": "git@github.com:katanaperps/katana-perps-sdk-js.git",
   "license": "MIT",