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

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

@@ -0,0 +1,773 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chai = tslib_1.__importStar(require("chai"));
+const _pipmath_1 = require("#pipmath");
+const orderbook = tslib_1.__importStar(require("#orderbook/index"));
+const testHelpers = tslib_1.__importStar(require("#tests/testHelpers"));
+const request_1 = require("#types/enums/request");
+const { expect } = chai;
+/**
+ * Default market: ETH-USD, index price 100, 10x leverage (IMF 0.1), MMF 0.05,
+ * a flat 0.1% taker fee, no incremental IMF, and no execution price limits.
+ */
+const defaultMarket = {
+    market: 'ETH-USD',
+    indexPrice: '100.00000000',
+    maximumPositionSize: '1000000.00000000',
+    initialMarginFraction: '0.10000000',
+    maintenanceMarginFraction: '0.05000000',
+    basePositionSize: '1000000.00000000',
+    incrementalPositionSize: '1.00000000',
+    incrementalInitialMarginFraction: '0.01000000',
+    marketOrderExecutionPriceLimit: '0.00000000',
+    limitOrderExecutionPriceLimit: '0.00000000',
+};
+/**
+ * Default wallet: 1,000 quote balance, no positions, no held collateral.
+ */
+const defaultWallet = {
+    equity: '1000.00000000',
+    heldCollateral: '0.00000000',
+    quoteBalance: '1000.00000000',
+    marginRatio: '0.00000000',
+    makerFeeRate: '0.00000000',
+    takerFeeRate: '0.00100000',
+    positions: [],
+};
+const level = (price, size, numOrders = 1) => ({
+    price: (0, _pipmath_1.decimalToPip)(price),
+    size: (0, _pipmath_1.decimalToPip)(size),
+    numOrders,
+    type: 'limit',
+});
+const position = (overrides) => ({
+    quantity: '0.00000000',
+    maximumQuantity: '0.00000000',
+    entryPrice: '0.00000000',
+    exitPrice: '0.00000000',
+    markPrice: '0.00000000',
+    indexPrice: '0.00000000',
+    liquidationPrice: '0.00000000',
+    value: '0.00000000',
+    realizedPnL: '0.00000000',
+    unrealizedPnL: '0.00000000',
+    marginRequirement: '0.00000000',
+    leverage: '0.00000000',
+    totalFunding: '0.00000000',
+    totalOpen: '0.00000000',
+    totalClose: '0.00000000',
+    adlQuintile: 0,
+    openedByFillId: '',
+    lastFillId: '',
+    time: 0,
+    ...overrides,
+});
+/** A 5-unit long ETH-USD position at index price 100, 10x leverage (margin 50). */
+const longEthPosition = position({
+    market: 'ETH-USD',
+    quantity: '5.00000000',
+    indexPrice: '100.00000000',
+    marginRequirement: '50.00000000',
+});
+/** A wallet holding {@link longEthPosition} (equity 100, free collateral 50). */
+const longEthWallet = {
+    ...defaultWallet,
+    quoteBalance: '-400.00000000',
+    equity: '100.00000000',
+    marginRatio: '0.25000000',
+    positions: [longEthPosition],
+};
+const runEstimate = (args) => orderbook.calculateBuySellPanelEstimate({
+    market: defaultMarket,
+    wallet: defaultWallet,
+    orderBook: { asks: [], bids: [] },
+    ...args,
+});
+describe('orderbook/buySellPanelEstimate', () => {
+    describe('calculateBuySellPanelEstimate', () => {
+        it('estimates a market buy that crosses multiple levels (base quantity)', () => {
+            const estimate = runEstimate({
+                orderBook: {
+                    asks: [level('100', '10'), level('101', '10')],
+                    bids: [],
+                },
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('15') },
+            });
+            // 10 @ 100 + 5 @ 101 = 1,505 quote
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('15'));
+            testHelpers.assertBigintsEqual(estimate.tradeQuoteQuantity, (0, _pipmath_1.decimalToPip)('1505'));
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+            expect(estimate.selfTradeEncountered).to.equal(false);
+            expect(estimate.freeCollateralExceeded).to.equal(false);
+            expect(estimate.maximumPositionSizeExceeded).to.equal(false);
+        });
+        it('computes cost as the change in available collateral (margin + fees)', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            // Notional 500, IMF 0.1 => margin 50; taker fee 500 * 0.1% = 0.5
+            testHelpers.assertBigintsEqual(estimate.cost, (0, _pipmath_1.decimalToPip)('50.5'));
+            testHelpers.assertBigintsEqual(estimate.tradeQuoteQuantity, (0, _pipmath_1.decimalToPip)('500'));
+        });
+        it('charges the taker gas fee per matched maker order', () => {
+            const estimate = runEstimate({
+                // A single level of 5 made up of 2 maker orders
+                orderBook: { asks: [level('100', '5', 2)], bids: [] },
+                takerTradeGasFee: (0, _pipmath_1.decimalToPip)('0.1'),
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            // Margin 50 + taker trade fee 0.5 + gas 0.1 * 2 orders = 50.7
+            testHelpers.assertBigintsEqual(estimate.cost, (0, _pipmath_1.decimalToPip)('50.7'));
+        });
+        it('caps the taker trade fee at 5% of the fill quote', () => {
+            const estimate = runEstimate({
+                wallet: { ...defaultWallet, takerFeeRate: '0.10000000' }, // 10%, above the cap
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            // Notional 500: margin 50 + taker fee capped at 5% of 500 = 25 (not 50) => 75
+            testHelpers.assertBigintsEqual(estimate.cost, (0, _pipmath_1.decimalToPip)('75'));
+        });
+        it('gives the trade fee priority over the gas fee within the 5% cap', () => {
+            const estimate = runEstimate({
+                wallet: { ...defaultWallet, takerFeeRate: '0.05000000' }, // exactly 5%
+                takerTradeGasFee: (0, _pipmath_1.decimalToPip)('5'), // would apply, but no budget remains
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            // Trade fee consumes the whole 5% (25 of 500), so the gas fee is coerced to 0 => 75
+            testHelpers.assertBigintsEqual(estimate.cost, (0, _pipmath_1.decimalToPip)('75'));
+        });
+        it('supports quote-denominated quantities', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                order: { side: request_1.OrderSide.buy, quoteQuantity: (0, _pipmath_1.decimalToPip)('500') },
+            });
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('5'));
+            testHelpers.assertBigintsEqual(estimate.tradeQuoteQuantity, (0, _pipmath_1.decimalToPip)('500'));
+        });
+        it('rests the unfilled remainder of a crossing limit order (gtc)', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '4')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('10'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.gtc,
+                },
+            });
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('4'));
+            // 6 remaining rests on the books
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('6'));
+        });
+        it('cancels the remainder of an ioc limit order', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '4')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('10'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.ioc,
+                },
+            });
+            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({
+                orderBook: { asks: [level('100', '10')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('5'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.gtx,
+                },
+            });
+            expect(estimate.postOnlyWouldCross).to.equal(true);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+        });
+        it('rests a non-crossing post-only (gtx) order in full', () => {
+            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)('90'),
+                    timeInForce: request_1.TimeInForce.gtx,
+                },
+            });
+            expect(estimate.postOnlyWouldCross).to.equal(false);
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('5'));
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+        });
+        it('flags a fill-or-kill order that cannot be fully filled', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '4')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('10'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.fok,
+                },
+            });
+            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({
+                wallet: { ...defaultWallet, heldCollateral: '30.00000000' },
+                orderBook: { asks: [level('100', '10')], bids: [] },
+                walletsStandingOrders: [
+                    {
+                        market: 'ETH-USD',
+                        side: request_1.OrderSide.sell,
+                        price: '100.00000000',
+                        originalQuantity: '3.00000000',
+                        executedQuantity: '0.00000000',
+                        status: 'open',
+                    },
+                ],
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            expect(estimate.selfTradeEncountered).to.equal(true);
+            // Only the 2 units not belonging to the wallet are actually traded
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('2'));
+            testHelpers.assertBigintsEqual(estimate.tradeQuoteQuantity, (0, _pipmath_1.decimalToPip)('200'));
+            // Freeing the 30 held by the canceled own order more than offsets the new
+            // position’s margin (20) and fee (0.2): collateral increases.
+            testHelpers.assertBigintsEqual(estimate.cost, (0, _pipmath_1.decimalToPip)('-9.8'));
+        });
+        it('flags an order that exceeds free collateral', () => {
+            const estimate = runEstimate({
+                wallet: {
+                    ...defaultWallet,
+                    equity: '60.00000000',
+                    quoteBalance: '60.00000000',
+                },
+                orderBook: { asks: [level('100', '1000')], bids: [] },
+                // Notional 50,000 => margin 5,000, far above 60 of equity
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('500') },
+            });
+            expect(estimate.freeCollateralExceeded).to.equal(true);
+        });
+        it('flags a resting order that exceeds available collateral', () => {
+            const estimate = runEstimate({
+                wallet: {
+                    ...defaultWallet,
+                    equity: '100.00000000',
+                    quoteBalance: '100.00000000',
+                },
+                orderBook: { asks: [level('100', '10')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    // 30 @ 50 => 1,500 quote, margin 150 > 100 available
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('30'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('50'),
+                    timeInForce: request_1.TimeInForce.gtc,
+                },
+            });
+            expect(estimate.availableCollateralExceeded).to.equal(true);
+            expect(estimate.freeCollateralExceeded).to.equal(false);
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('30'));
+            // 30 @ 50 => 1,500 notional, held 150; available was 100, so the cost is
+            // allowed to exceed available collateral (150, not clamped to 100).
+            testHelpers.assertBigintsEqual(estimate.cost, (0, _pipmath_1.decimalToPip)('150'));
+        });
+        it('flags available collateral when a partially-crossing limit order rests an unaffordable remainder', () => {
+            const estimate = runEstimate({
+                wallet: {
+                    ...defaultWallet,
+                    equity: '100.00000000',
+                    quoteBalance: '100.00000000',
+                },
+                // Only 2 of liquidity at the limit price; the rest rests on the books.
+                orderBook: { asks: [level('100', '2')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('100'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.gtc,
+                },
+            });
+            // 2 fills (affordable), 98 rests => held 98 * 100 * 0.1 = 980 > ~80 free
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('2'));
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('98'));
+            expect(estimate.freeCollateralExceeded).to.equal(false);
+            expect(estimate.availableCollateralExceeded).to.equal(true);
+        });
+        it('flags an order that exceeds the maximum position size', () => {
+            const estimate = runEstimate({
+                market: { ...defaultMarket, maximumPositionSize: '4.00000000' },
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            expect(estimate.maximumPositionSizeExceeded).to.equal(true);
+        });
+        it('flags a market order that exceeds the execution price limit', () => {
+            const estimate = runEstimate({
+                market: {
+                    ...defaultMarket,
+                    marketOrderExecutionPriceLimit: '0.00500000', // 0.5%
+                },
+                orderBook: {
+                    asks: [level('100', '10'), level('101', '10')],
+                    bids: [level('99', '10')],
+                },
+                // baseline = (100 + 99) / 2 = 99.5; max execution price = 100.0
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('15') },
+            });
+            expect(estimate.executionPriceLimitExceeded).to.equal(true);
+            // 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: {
+                    ...defaultMarket,
+                    limitOrderExecutionPriceLimit: '0.05000000', // 5%
+                },
+                orderBook: {
+                    asks: [level('100', '10')],
+                    bids: [level('100', '10')],
+                },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('5'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('200'), // far above baseline 100
+                },
+            });
+            expect(estimate.executionPriceLimitExceeded).to.equal(true);
+        });
+        it('computes the account-wide liquidation price for a new long', () => {
+            const estimate = runEstimate({
+                wallet: {
+                    ...defaultWallet,
+                    equity: '60.00000000',
+                    quoteBalance: '60.00000000',
+                },
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            // quoteBalanceAfter = 60 - 500 - 0.5 = -440.5; long 5 @ MMF 0.05:
+            //   -440.5 + 5P = 0.25P => P = 440.5 / 4.75 = 92.73684210
+            testHelpers.assertBigintsEqual(estimate.liquidationPrice ?? BigInt(-1), (0, _pipmath_1.decimalToPip)('92.73684210'));
+        });
+        it('returns a null liquidation price when the position is fully closed', () => {
+            const estimate = runEstimate({
+                wallet: {
+                    ...defaultWallet,
+                    quoteBalance: '-400.00000000',
+                    equity: '100.00000000',
+                    marginRatio: '0.25000000',
+                    positions: [longEthPosition],
+                },
+                orderBook: { bids: [level('100', '10')], asks: [] },
+                order: {
+                    side: request_1.OrderSide.sell,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('5'),
+                    reduceOnly: true,
+                },
+            });
+            expect(estimate.liquidationPrice).to.equal(null);
+            // Closing the long frees its 50 of margin (less the 0.5 fee)
+            testHelpers.assertBigintsEqual(estimate.cost, (0, _pipmath_1.decimalToPip)('-49.5'));
+        });
+        it('clamps a reduce-only order to the position size', () => {
+            const estimate = runEstimate({
+                wallet: {
+                    ...defaultWallet,
+                    quoteBalance: '-400.00000000',
+                    equity: '100.00000000',
+                    marginRatio: '0.25000000',
+                    positions: [longEthPosition],
+                },
+                orderBook: { bids: [level('100', '100')], asks: [] },
+                order: {
+                    side: request_1.OrderSide.sell,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('10'),
+                    reduceOnly: true,
+                },
+            });
+            // Only 5 (the position size) can be reduced
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('5'));
+        });
+        it('flags a reduce-only order that would not reduce the position', () => {
+            const estimate = runEstimate({
+                wallet: {
+                    ...defaultWallet,
+                    quoteBalance: '-400.00000000',
+                    equity: '100.00000000',
+                    marginRatio: '0.25000000',
+                    positions: [longEthPosition],
+                },
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                // A buy does not reduce an existing long
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('5'),
+                    reduceOnly: true,
+                },
+            });
+            expect(estimate.reduceOnlyWouldNotReducePosition).to.equal(true);
+        });
+        it('flags a reduce-only order placed with no open position', () => {
+            const estimate = runEstimate({
+                orderBook: { bids: [level('100', '10')], asks: [] },
+                order: {
+                    side: request_1.OrderSide.sell,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('5'),
+                    reduceOnly: true,
+                },
+            });
+            expect(estimate.reduceOnlyNoOpenPosition).to.equal(true);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+        });
+        it('rests a reduce-only limit order up to the open position size', () => {
+            const estimate = runEstimate({
+                wallet: longEthWallet,
+                orderBook: { asks: [], bids: [] },
+                order: {
+                    side: request_1.OrderSide.sell,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('3'),
+                    limitPrice: (0, _pipmath_1.decimalToPip)('110'), // above the market: does not cross
+                    reduceOnly: true,
+                    timeInForce: request_1.TimeInForce.gtc,
+                },
+            });
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('0'));
+            // The reducing portion (<= position size of 5) rests on the books
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('3'));
+            expect(estimate.reduceOnlyOpenPositionSizeExceeded).to.equal(false);
+        });
+        it('flags a reduce-only limit order whose resting quantity exceeds the open position size', () => {
+            const estimate = runEstimate({
+                wallet: longEthWallet,
+                orderBook: { asks: [], bids: [] },
+                order: {
+                    side: request_1.OrderSide.sell,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('8'), // exceeds the position of 5
+                    limitPrice: (0, _pipmath_1.decimalToPip)('110'),
+                    reduceOnly: true,
+                    timeInForce: request_1.TimeInForce.gtc,
+                },
+            });
+            // The order is still reported as resting, but flagged as not fully reducing
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('8'));
+            expect(estimate.reduceOnlyOpenPositionSizeExceeded).to.equal(true);
+        });
+        it('fills a reduce-only market order up to the full position size regardless of same-side standing orders', () => {
+            const estimate = runEstimate({
+                wallet: longEthWallet,
+                orderBook: { bids: [level('100', '100')], asks: [] },
+                walletsStandingOrders: [
+                    {
+                        market: 'ETH-USD',
+                        side: request_1.OrderSide.sell, // same side as the reduce-only sell
+                        price: '100.00000000',
+                        originalQuantity: '3.00000000',
+                        executedQuantity: '0.00000000',
+                        status: 'open',
+                    },
+                ],
+                order: {
+                    side: request_1.OrderSide.sell,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('10'),
+                    reduceOnly: true,
+                },
+            });
+            // The standing sell does not cap the market reduce-only fill: the full
+            // position of 5 is reduced
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('5'));
+        });
+        it('does not flag maximum position size for a crossing limit order on account of standing orders', () => {
+            const estimate = runEstimate({
+                market: { ...defaultMarket, maximumPositionSize: '10.00000000' },
+                wallet: {
+                    ...defaultWallet,
+                    equity: '100000.00000000',
+                    quoteBalance: '100000.00000000',
+                },
+                orderBook: { asks: [level('100', '3')], bids: [] },
+                walletsStandingOrders: [
+                    {
+                        market: 'ETH-USD',
+                        side: request_1.OrderSide.buy,
+                        price: '90.00000000',
+                        originalQuantity: '8.00000000',
+                        executedQuantity: '0.00000000',
+                        status: 'open',
+                    },
+                ],
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('6'), // <= MPS of 10
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.gtc,
+                },
+            });
+            // Order qty 6 <= MPS 10; the 8 standing buy is excluded from the check
+            // for a crossing order (it would get canceled after the incoming order
+            // is executed)
+            expect(estimate.maximumPositionSizeExceeded).to.equal(false);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('3'));
+            testHelpers.assertBigintsEqual(estimate.makerBaseQuantity, (0, _pipmath_1.decimalToPip)('3'));
+        });
+        it('flags maximum position size for a market order whose requested quantity exceeds it despite thin liquidity', () => {
+            const estimate = runEstimate({
+                market: { ...defaultMarket, maximumPositionSize: '4.00000000' },
+                orderBook: { asks: [level('100', '2')], bids: [] },
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            expect(estimate.maximumPositionSizeExceeded).to.equal(true);
+            // Only the 2 of available liquidity is fillable
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('2'));
+        });
+        it('excludes untriggered stop orders (status active) from self-trade detection', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '10')], bids: [] },
+                walletsStandingOrders: [
+                    {
+                        market: 'ETH-USD',
+                        side: request_1.OrderSide.sell,
+                        price: '100.00000000',
+                        originalQuantity: '3.00000000',
+                        executedQuantity: '0.00000000',
+                        status: 'active', // untriggered stop order
+                    },
+                ],
+                order: { side: request_1.OrderSide.buy, baseQuantity: (0, _pipmath_1.decimalToPip)('5') },
+            });
+            // The untriggered stop order is ignored: no self-trade, full 5 is traded
+            expect(estimate.selfTradeEncountered).to.equal(false);
+            testHelpers.assertBigintsEqual(estimate.tradeBaseQuantity, (0, _pipmath_1.decimalToPip)('5'));
+        });
+        it('resolves the available-collateral slider so that a ratio of 1 consumes all of it', () => {
+            const ratio = _pipmath_1.oneInPips; // 100%
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '1000')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    availableCollateralRatio: ratio,
+                },
+            });
+            // available collateral = 1,000; cost should approach but not exceed it
+            const target = (0, _pipmath_1.multiplyPips)((0, _pipmath_1.decimalToPip)('1000'), ratio);
+            expect(estimate.cost <= target).to.equal(true);
+            expect(target - estimate.cost <= (0, _pipmath_1.decimalToPip)('1')).to.equal(true);
+            // The quantity is bound by collateral (margin 10/unit + fee), ~99 base —
+            // NOT the full 1,000 of available book liquidity, and it stays feasible.
+            expect(estimate.tradeBaseQuantity < (0, _pipmath_1.decimalToPip)('150')).to.equal(true);
+            expect(estimate.tradeBaseQuantity > (0, _pipmath_1.decimalToPip)('90')).to.equal(true);
+            expect(estimate.freeCollateralExceeded).to.equal(false);
+        });
+        it('does not gulp all crossable liquidity for a 100% slider on a limit order', () => {
+            const estimate = runEstimate({
+                orderBook: { asks: [level('100', '1000')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    limitPrice: (0, _pipmath_1.decimalToPip)('100'),
+                    timeInForce: request_1.TimeInForce.gtc,
+                    availableCollateralRatio: _pipmath_1.oneInPips,
+                },
+            });
+            // Collateral-bound (~99), not the 1,000 of liquidity up to the limit price.
+            expect(estimate.tradeBaseQuantity < (0, _pipmath_1.decimalToPip)('150')).to.equal(true);
+            expect(estimate.tradeBaseQuantity > (0, _pipmath_1.decimalToPip)('90')).to.equal(true);
+            expect(estimate.freeCollateralExceeded).to.equal(false);
+        });
+        it('applies an initial margin fraction override (higher margin, higher cost)', () => {
+            const baseArgs = {
+                orderBook: { asks: [level('100', '100')], bids: [] },
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('5'),
+                },
+            };
+            const withoutOverride = runEstimate(baseArgs);
+            const withOverride = runEstimate({
+                ...baseArgs,
+                walletInitialMarginFractionOverrides: [
+                    {
+                        wallet: '0xwallet',
+                        market: 'ETH-USD',
+                        initialMarginFractionOverride: '0.20000000', // 20% vs 10%
+                    },
+                ],
+            });
+            // Margin doubles from 50 to 100, raising the cost by ~50
+            testHelpers.assertBigintsEqual(withOverride.cost - withoutOverride.cost, (0, _pipmath_1.decimalToPip)('50'));
+        });
+        it('requires exactly one quantity input', () => {
+            expect(() => orderbook.calculateBuySellPanelEstimate({
+                market: defaultMarket,
+                wallet: defaultWallet,
+                orderBook: { asks: [], bids: [] },
+                // @ts-expect-error intentionally providing two quantity inputs
+                order: {
+                    side: request_1.OrderSide.buy,
+                    baseQuantity: (0, _pipmath_1.decimalToPip)('1'),
+                    quoteQuantity: (0, _pipmath_1.decimalToPip)('1'),
+                },
+            })).to.throw();
+        });
+    });
+});