@katanaperps/katana-perps-sdk 0.0.0-placeholder

package/dist/tests/orderbook/quantities/determineMaximumReduceOnlyQuantityAvailableAtPriceLevel.test.js

@@ -0,0 +1,138 @@
+"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 { expect } = chai;
+function makeAPosition(marketSymbol, quantity) {
+    // All empty values are not used by the function under test
+    return {
+        market: marketSymbol,
+        quantity: (0, _pipmath_1.pipToDecimal)((0, _pipmath_1.decimalToPip)(quantity)),
+        maximumQuantity: '',
+        entryPrice: '',
+        exitPrice: '',
+        markPrice: '',
+        indexPrice: '1',
+        liquidationPrice: '',
+        value: '',
+        realizedPnL: '',
+        unrealizedPnL: '',
+        marginRequirement: '',
+        leverage: '',
+        totalFunding: '',
+        totalOpen: '',
+        totalClose: '',
+        adlQuintile: 0,
+        openedByFillId: '',
+        lastFillId: '',
+        time: 0,
+    };
+}
+function makeAStandingOrder(args) {
+    return {
+        market: args.marketSymbol,
+        side: args.side,
+        originalQuantity: (0, _pipmath_1.pipToDecimal)((0, _pipmath_1.decimalToPip)(args.quantity)),
+        executedQuantity: (0, _pipmath_1.pipToDecimal)(BigInt(0)),
+        price: (0, _pipmath_1.pipToDecimal)((0, _pipmath_1.decimalToPip)(args.price)),
+    };
+}
+describe('orderbook/quantities', () => {
+    describe('determineMaximumReduceOnlyQuantityAvailableAtPriceLevel', () => {
+        const fooMarketSymbol = 'FOO-USD';
+        const makeOrder = (side, price, marketSymbol = fooMarketSymbol) => makeAStandingOrder({
+            marketSymbol,
+            side,
+            quantity: '1',
+            price,
+        });
+        it('should succeed for a long position and sell orders', () => {
+            const runScenario = (limitPrice, expectedQtyAvailable) => expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)(limitPrice),
+                position: makeAPosition(fooMarketSymbol, '3'),
+                orderSide: 'sell',
+                walletsStandingOrders: [
+                    makeOrder('sell', '10'),
+                    makeOrder('sell', '11'),
+                    makeOrder('sell', '12'),
+                ],
+            })).to.eql((0, _pipmath_1.decimalToPip)(expectedQtyAvailable));
+            runScenario('9', '3');
+            runScenario('10', '2');
+            runScenario('11', '1');
+            runScenario('12', '0');
+            runScenario('13', '0');
+        });
+        it('should succeed for a short position and buy orders', () => {
+            const runScenario = (limitPrice, expectedQtyAvailable) => expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)(limitPrice),
+                position: makeAPosition(fooMarketSymbol, '-3'),
+                orderSide: 'buy',
+                walletsStandingOrders: [
+                    makeOrder('buy', '10'),
+                    makeOrder('buy', '9'),
+                    makeOrder('buy', '8'),
+                ],
+            })).to.eql((0, _pipmath_1.decimalToPip)(expectedQtyAvailable));
+            runScenario('11', '3');
+            runScenario('10', '2');
+            runScenario('9', '1');
+            runScenario('8', '0');
+            runScenario('7', '0');
+        });
+        it('should ignore orders in other markets or on the other side of the book (long position)', () => {
+            expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)('1'),
+                position: makeAPosition(fooMarketSymbol, '3'),
+                orderSide: 'sell',
+                walletsStandingOrders: [
+                    makeOrder('buy', '1'), // Wrong side
+                    makeOrder('sell', '1', 'BAR-USD'), // Wrong market
+                ],
+            })).to.eql((0, _pipmath_1.decimalToPip)('3'));
+        });
+        it('should ignore orders in other markets or on the other side of the book (short position)', () => {
+            expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)('1'),
+                position: makeAPosition(fooMarketSymbol, '-3'),
+                orderSide: 'buy',
+                walletsStandingOrders: [
+                    makeOrder('sell', '1'), // Wrong side
+                    makeOrder('buy', '1', 'BAR-USD'), // Wrong market
+                ],
+            })).to.eql((0, _pipmath_1.decimalToPip)('3'));
+        });
+        it('should return zero for a long position and a buy order', () => {
+            expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)('123'),
+                position: makeAPosition(fooMarketSymbol, '123'),
+                orderSide: 'buy',
+                walletsStandingOrders: [],
+            })).to.eql(BigInt(0));
+        });
+        it('should return zero for a short position and a sell order', () => {
+            expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)('123'),
+                position: makeAPosition(fooMarketSymbol, '-123'),
+                orderSide: 'sell',
+                walletsStandingOrders: [],
+            })).to.eql(BigInt(0));
+        });
+        it('should return zero for a closed position', () => {
+            expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)('123'),
+                position: makeAPosition(fooMarketSymbol, '0'),
+                orderSide: 'buy',
+                walletsStandingOrders: [],
+            })).to.eql(BigInt(0));
+            expect(orderbook.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel({
+                limitPrice: (0, _pipmath_1.decimalToPip)('123'),
+                position: makeAPosition(fooMarketSymbol, '0'),
+                orderSide: 'sell',
+                walletsStandingOrders: [],
+            })).to.eql(BigInt(0));
+        });
+    });
+});

package/dist/tests/orderbook/quantities.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=quantities.test.d.ts.map

package/dist/tests/orderbook/quantities.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantities.test.d.ts","sourceRoot":"","sources":["../../../src/tests/orderbook/quantities.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+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");
+describe('orderbook/quantities', () => {
+    describe('calculateGrossFillQuantities', () => {
+        const runScenario = (args) => {
+            const takerQuantities = orderbook.calculateGrossFillQuantities(args.makerSideOrders, {
+                side: args.takerOrder.side,
+                quantity: (0, _pipmath_1.decimalToPip)(args.takerOrder.quantity),
+                isQuantityInQuote: args.takerOrder.isQuantityInQuote,
+                limitPrice: args.takerOrder.limitPrice ?
+                    (0, _pipmath_1.decimalToPip)(args.takerOrder.limitPrice)
+                    : undefined,
+            });
+            testHelpers.assertBigintsEqual(takerQuantities.baseQuantity, (0, _pipmath_1.decimalToPip)(args.expectedBaseFillQuantity));
+            testHelpers.assertBigintsEqual(takerQuantities.quoteQuantity, (0, _pipmath_1.decimalToPip)(args.expectedQuoteFillQuantity));
+        };
+        it('should succeed', () => {
+            const sellSideMakerOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') }, // 1 quote
+                { price: (0, _pipmath_1.decimalToPip)('2'), size: (0, _pipmath_1.decimalToPip)('10') }, // 20 quote
+                { price: (0, _pipmath_1.decimalToPip)('3'), size: (0, _pipmath_1.decimalToPip)('100') }, // 300 quote
+            ];
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '0.5',
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '0.5',
+                expectedQuoteFillQuantity: '0.5',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '1',
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '1',
+                expectedQuoteFillQuantity: '1',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '6',
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '6',
+                expectedQuoteFillQuantity: '11',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '11',
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '11',
+                expectedQuoteFillQuantity: '21',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '61',
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '61',
+                expectedQuoteFillQuantity: '171',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '200', // More than available liquidity
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '111',
+                expectedQuoteFillQuantity: '321',
+            });
+        });
+        it('should succeed for a taker quantity specified in quote', () => {
+            const sellSideMakerOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') }, // 1 quote
+                { price: (0, _pipmath_1.decimalToPip)('2'), size: (0, _pipmath_1.decimalToPip)('10') }, // 20 quote
+                { price: (0, _pipmath_1.decimalToPip)('3'), size: (0, _pipmath_1.decimalToPip)('100') }, // 300 quote
+            ];
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '0.5',
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '0.5',
+                expectedQuoteFillQuantity: '0.5',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '1',
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '1',
+                expectedQuoteFillQuantity: '1',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '11',
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '6',
+                expectedQuoteFillQuantity: '11',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '21',
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '11',
+                expectedQuoteFillQuantity: '21',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '171',
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '61',
+                expectedQuoteFillQuantity: '171',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '1000', // More than available liquidity
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '111',
+                expectedQuoteFillQuantity: '321',
+            });
+        });
+        it('should support multiple orders per price level', () => {
+            const sellSideMakerOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') },
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') },
+                { price: (0, _pipmath_1.decimalToPip)('2'), size: (0, _pipmath_1.decimalToPip)('1') },
+            ];
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '1.5',
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '1.5',
+                expectedQuoteFillQuantity: '1.5',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '1.5',
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '1.5',
+                expectedQuoteFillQuantity: '1.5',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '3',
+                    isQuantityInQuote: false,
+                },
+                expectedBaseFillQuantity: '3',
+                expectedQuoteFillQuantity: '4',
+            });
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '4',
+                    isQuantityInQuote: true,
+                },
+                expectedBaseFillQuantity: '3',
+                expectedQuoteFillQuantity: '4',
+            });
+        });
+        it('should limit by price (buy)', () => {
+            const sellSideMakerOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') }, // 1 quote
+                { price: (0, _pipmath_1.decimalToPip)('2'), size: (0, _pipmath_1.decimalToPip)('1') }, // 2 quote
+                { price: (0, _pipmath_1.decimalToPip)('3'), size: (0, _pipmath_1.decimalToPip)('1') }, // 3 quote
+            ];
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '1000', // More than available liquidity
+                    isQuantityInQuote: false,
+                    limitPrice: '2',
+                },
+                expectedBaseFillQuantity: '2',
+                expectedQuoteFillQuantity: '3',
+            });
+        });
+        it('should limit by price (sell)', () => {
+            const buySideMakerOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('3'), size: (0, _pipmath_1.decimalToPip)('1') }, // 3 quote
+                { price: (0, _pipmath_1.decimalToPip)('2'), size: (0, _pipmath_1.decimalToPip)('1') }, // 2 quote
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') }, // 1 quote
+            ];
+            runScenario({
+                makerSideOrders: buySideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.sell,
+                    quantity: '1000', // More than available liquidity
+                    isQuantityInQuote: false,
+                    limitPrice: '2',
+                },
+                expectedBaseFillQuantity: '2',
+                expectedQuoteFillQuantity: '5',
+            });
+        });
+        it('should return zero if the limit price does not cross the spread (buy)', () => {
+            const sellSideMakerOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') },
+            ];
+            runScenario({
+                makerSideOrders: sellSideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.buy,
+                    quantity: '1',
+                    isQuantityInQuote: false,
+                    limitPrice: '0.5',
+                },
+                expectedBaseFillQuantity: '0',
+                expectedQuoteFillQuantity: '0',
+            });
+        });
+        it('should return zero if the limit price does not cross the spread (sell)', () => {
+            const buySideMakerOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('1'), size: (0, _pipmath_1.decimalToPip)('1') },
+            ];
+            runScenario({
+                makerSideOrders: buySideMakerOrders,
+                takerOrder: {
+                    side: request_1.OrderSide.sell,
+                    quantity: '1',
+                    isQuantityInQuote: false,
+                    limitPrice: '2',
+                },
+                expectedBaseFillQuantity: '0',
+                expectedQuoteFillQuantity: '0',
+            });
+        });
+        it('should support double-pip precision', () => {
+            const makerSideOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('3'), size: (0, _pipmath_1.decimalToPip)('1') },
+            ];
+            const takerQuantities = orderbook.calculateGrossFillQuantities(makerSideOrders, {
+                side: request_1.OrderSide.buy,
+                quantity: (0, _pipmath_1.decimalToPip)('1'),
+                isQuantityInQuote: false,
+            }, false);
+            testHelpers.assertBigintsEqual(takerQuantities.baseQuantity, (0, _pipmath_1.decimalToPip)('1'));
+            testHelpers.assertBigintsEqual(takerQuantities.quoteQuantity, (0, _pipmath_1.decimalToPip)('3'));
+            const takerQuantities2p = orderbook.calculateGrossFillQuantities(makerSideOrders, {
+                side: request_1.OrderSide.buy,
+                quantity: (0, _pipmath_1.decimalToPip)('1'),
+                isQuantityInQuote: false,
+            }, true);
+            testHelpers.assertBigintsEqual(takerQuantities2p.baseQuantity, BigInt(10000000000000000));
+            testHelpers.assertBigintsEqual(takerQuantities2p.quoteQuantity, BigInt(30000000000000000));
+        });
+        it('should support double-pip precision (taker quantity specified in quote)', () => {
+            const makerSideOrders = [
+                { price: (0, _pipmath_1.decimalToPip)('3'), size: (0, _pipmath_1.decimalToPip)('1') },
+            ];
+            const takerQuantities = orderbook.calculateGrossFillQuantities(makerSideOrders, {
+                side: request_1.OrderSide.buy,
+                quantity: (0, _pipmath_1.decimalToPip)('1'), // 1/3 of the available quote
+                isQuantityInQuote: true,
+            }, false);
+            testHelpers.assertBigintsEqual(takerQuantities.baseQuantity, (0, _pipmath_1.decimalToPip)('0.33333333'));
+            testHelpers.assertBigintsEqual(takerQuantities.quoteQuantity, (0, _pipmath_1.decimalToPip)('1'));
+            const takerQuantities2p = orderbook.calculateGrossFillQuantities(makerSideOrders, {
+                side: request_1.OrderSide.buy,
+                quantity: (0, _pipmath_1.decimalToPip)('1'), // 1/3 of the available quote
+                isQuantityInQuote: true,
+            }, true);
+            testHelpers.assertBigintsEqual(takerQuantities2p.baseQuantity, BigInt(3333333333333333));
+            testHelpers.assertBigintsEqual(takerQuantities2p.quoteQuantity, BigInt(10000000000000000));
+        });
+    });
+});

package/dist/tests/testHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare const assertBigintsEqual: (a: unknown, b: unknown, message?: string) => void;
+//# sourceMappingURL=testHelpers.d.ts.map

package/dist/tests/testHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testHelpers.d.ts","sourceRoot":"","sources":["../../src/tests/testHelpers.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB,MAC1B,OAAO,KACP,OAAO,uBAET,IAWF,CAAC"}

package/dist/tests/testHelpers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertBigintsEqual = void 0;
+const tslib_1 = require("tslib");
+const chai = tslib_1.__importStar(require("chai"));
+const { expect } = chai;
+const assertBigintsEqual = (a, b, message = '') => {
+    if (typeof a !== 'bigint') {
+        throw new Error(`First argument: Expected bigint, got ${String(a)}`);
+    }
+    if (typeof b !== 'bigint') {
+        throw new Error(`Second argument: Expected bigint, got ${String(b)}`);
+    }
+    expect(a.toString()).to.eql(b.toString(), `${message}Expected ${b.toString()}, got ${a.toString()}`);
+};
+exports.assertBigintsEqual = assertBigintsEqual;

package/dist/tests/utils/deriveBaseURL.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deriveBaseURL.test.d.ts.map

package/dist/tests/utils/deriveBaseURL.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveBaseURL.test.d.ts","sourceRoot":"","sources":["../../../src/tests/utils/deriveBaseURL.test.ts"],"names":[],"mappings":""}

package/dist/tests/utils/deriveBaseURL.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chai = tslib_1.__importStar(require("chai"));
+const _constants_1 = require("#constants");
+const _utils_1 = require("#utils");
+const { expect } = chai;
+describe('deriveBaseURL', () => {
+    it('should return the overrideBaseURL if provided', () => {
+        const overrideBaseURL = 'https://example.com/api';
+        const baseURL = (0, _utils_1.deriveBaseURL)({ overrideBaseURL, api: 'rest' });
+        expect(baseURL).to.equal(overrideBaseURL);
+    });
+    it('should return the baseRestApiURL if provided', () => {
+        const baseRestApiURL = 'https://api.example.com';
+        const baseURL = (0, _utils_1.deriveBaseURL)({ baseRestApiURL, api: 'rest' });
+        expect(baseURL).to.equal(baseRestApiURL);
+    });
+    it('should return the baseWebSocketURL if provided for rest API', () => {
+        const baseWebSocketURL = 'wss://websocket-test.example.com/';
+        const baseURL = (0, _utils_1.deriveBaseURL)({ baseWebSocketURL, api: 'rest' });
+        expect(baseURL).to.equal('https://api-test.example.com/');
+    });
+    it('should return the baseWebSocketURL if provided for websocket API', () => {
+        const baseWebSocketURL = 'wss://websocket.example.com';
+        const baseURL = (0, _utils_1.deriveBaseURL)({ baseWebSocketURL, api: 'websocket' });
+        expect(baseURL).to.equal(baseWebSocketURL);
+    });
+    it('should return the baseRestApiURL if provided for websocket API', () => {
+        const baseRestApiURL = 'https://api.example.com/';
+        const baseURL = (0, _utils_1.deriveBaseURL)({ baseRestApiURL, api: 'websocket' });
+        expect(baseURL).to.equal('wss://websocket.example.com/');
+    });
+    it('should return the production URL if no options are provided', () => {
+        const baseURL = (0, _utils_1.deriveBaseURL)({ api: 'rest' });
+        expect(baseURL).to.equal(_constants_1.URLS.production.v1.rest);
+    });
+    it('should return the sandbox URL if sandbox option is true', () => {
+        const baseURL = (0, _utils_1.deriveBaseURL)({ sandbox: true, api: 'rest' });
+        expect(baseURL).to.equal(_constants_1.URLS.sandbox.v1.rest);
+    });
+    it('should throw an error if baseURL cannot be derived', () => {
+        // @ts-expect-error - testing failure
+        expect(() => (0, _utils_1.deriveBaseURL)({ api: 'invalid' })).to.throw(/Invalid configuration/);
+    });
+});