@katanaperps/katana-perps-sdk 0.0.0-placeholder

package/dist/orderbook/quantities.d.ts

@@ -0,0 +1,112 @@
+import { BigNumber } from 'bignumber.js';
+import { OrderSide } from '#types/enums/request';
+import type { L2OrderBook, OrderBookLevelL1, OrderBookLevelL2 } from '#types/orderBook';
+import type { KatanaPerpsInitialMarginFractionOverride, KatanaPerpsMarket, KatanaPerpsOrder, KatanaPerpsPosition, KatanaPerpsWallet } from '#types/rest/endpoints/index';
+export type LeverageParameters = Pick<KatanaPerpsMarket, 'maximumPositionSize' | 'initialMarginFraction' | 'maintenanceMarginFraction' | 'basePositionSize' | 'incrementalPositionSize' | 'incrementalInitialMarginFraction'>;
+export type LeverageParametersBigInt = Record<keyof LeverageParameters, bigint>;
+type Position = {
+    market: string;
+    quantity: bigint;
+    indexPrice: bigint;
+    marginRequirement: bigint;
+};
+/**
+ * Price and Size values form the {@link OrderBookLevelL1} type
+ */
+export type PriceAndSize = Pick<OrderBookLevelL1, 'price' | 'size'>;
+/**
+ * Standing orders
+ */
+export type StandingOrder = Pick<KatanaPerpsOrder, 'market' | 'side' | 'originalQuantity' | 'executedQuantity' | 'price'>;
+type ActiveStandingOrder = StandingOrder & {
+    price: string;
+};
+type ActiveStandingOrderBigInt = Pick<ActiveStandingOrder, 'side'> & {
+    openQuantity: bigint;
+    price: bigint;
+};
+export declare function isActiveStandingOrder(order: StandingOrder): order is ActiveStandingOrder;
+export declare const asksTickRoundingMode: 0;
+export declare const bidsTickRoundingMode: 1;
+export declare const nullLevel: OrderBookLevelL2;
+/**
+ * Returns the initial margin fraction for a position or an order.
+ *
+ * Use {@link convertToLeverageParametersBigInt} to convert a {@link KatanaPerpsMarket}
+ * or {@link LeverageParameters} object to {@link LeverageParametersBigInt}.
+ */
+export declare function calculateInitialMarginFractionWithOverride(args: {
+    /** Signed */
+    baseQuantity: bigint;
+    initialMarginFractionOverride: bigint | null;
+    leverageParameters: LeverageParametersBigInt;
+}): bigint;
+export declare function calculateMaximumInitialMarginFractionOverride(market: Pick<KatanaPerpsMarket, 'market' | 'initialMarginFraction'>, wallet: Pick<KatanaPerpsWallet, 'positions' | 'freeCollateral' | 'heldCollateral'>, walletInitialMarginFractionOverrides: KatanaPerpsInitialMarginFractionOverride[]): string;
+export declare function convertToActiveStandingOrderBigInt(order: ActiveStandingOrder): ActiveStandingOrderBigInt;
+export declare function convertToLeverageParametersBigInt(leverageParameters: LeverageParameters): LeverageParametersBigInt;
+/**
+ * Converts a {@link KatanaPerpsPosition} object to one used by some functions in this
+ * file.
+ */
+export declare function convertToPositionBigInt(position: KatanaPerpsPosition): Position;
+/**
+ * Determines the liquidity available in the given order book (asks or bids)
+ * for a given taker quantity (which may be expressed in base or quote asset)
+ * and price (optional).
+ * In other words, it performs very basic order matching to provide an estimate
+ * of the base and quote quantities with which a taker order of the given
+ * size (quantity) and limit price (optional) would be filled.
+ *
+ * The taker order may represent a limit or a market order: If a limit price is
+ * given, it is matched as a limit order (which necessitates specifying whether
+ * it's a buy or a sell). Otherwise it is matched as a market order.
+ *
+ * The provided list of orders or price levels (asks or bids) is expected to be
+ * sorted by best price (ascending for asks (lowest first), descending for bids
+ * (highest first)). Multiple orders per price level are supported.
+ *
+ * To support high-precision calculations in which pip-precision is
+ * insufficient, the result may optionally be returned in double-pip precision;
+ * the returned values then represent numbers with 16 decimals instead of 8.
+ *
+ * @param returnInDoublePipPrecision - Defaults to false
+ */
+export declare function calculateGrossFillQuantities(makerSideOrders: Iterable<PriceAndSize>, takerOrder: {
+    side: OrderSide;
+    quantity: bigint;
+    isQuantityInQuote: boolean;
+    limitPrice?: bigint;
+}, returnInDoublePipPrecision?: boolean): {
+    baseQuantity: bigint;
+    quoteQuantity: bigint;
+};
+/**
+ * Reduce-only orders may only be on the books if their execution would in fact
+ * result in a reduction of an open position. That is, if any of the wallet's
+ * other standing orders would be matched and executed first and reduce the
+ * position, any reduce-only liquidity newly added to the books may not exceed
+ * the remaining size of the position.
+ *
+ * This function returns the size of the given open position minus the combined
+ * size of all the wallet's standing orders on the other side of the book that
+ * are priced better (higher for buys, lower for sells) or equal to the provided
+ * limit price.
+ */
+export declare function determineMaximumReduceOnlyQuantityAvailableAtPriceLevel(args: {
+    limitPrice: bigint;
+    position: KatanaPerpsPosition;
+    orderSide: OrderSide;
+    walletsStandingOrders: StandingOrder[];
+}): bigint;
+/**
+ * Helper function to re-aggregate L2 orderbook price levels at a larger (more zeroes) tick size
+ */
+export declare function aggregateL2OrderBookAtTickSize(inputBook: L2OrderBook, tickSize: bigint): L2OrderBook;
+/**
+ * Adjusts prices in pips to account for tick size by discarding insignificant digits using
+ * specified rounding mode. Ex price 123456789 at tick size 1 is 123456789, at tick size 10
+ * 123456780, at 100 123456700, etc
+ */
+export declare function adjustPriceToTickSize(price: bigint, tickSize: bigint, roundingMode?: BigNumber.RoundingMode): bigint;
+export {};
+//# sourceMappingURL=quantities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quantities.d.ts","sourceRoot":"","sources":["../../src/orderbook/quantities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAezC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EACV,wCAAwC,EACxC,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAErC,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,iBAAiB,EACf,qBAAqB,GACrB,uBAAuB,GACvB,2BAA2B,GAC3B,kBAAkB,GAClB,yBAAyB,GACzB,kCAAkC,CACrC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,kBAAkB,EAAE,MAAM,CAAC,CAAC;AAEhF,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAC9B,gBAAgB,EAChB,QAAQ,GAAG,MAAM,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,OAAO,CACtE,CAAC;AACF,KAAK,mBAAmB,GAAG,aAAa,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAC7D,KAAK,yBAAyB,GAAG,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,GAAG;IACnE,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,GACnB,KAAK,IAAI,mBAAmB,CAE9B;AAED,eAAO,MAAM,oBAAoB,GAAqB,CAAC;AAEvD,eAAO,MAAM,oBAAoB,GAAuB,CAAC;AAEzD,eAAO,MAAM,SAAS,EAAE,gBAKvB,CAAC;AAwBF;;;;;GAKG;AACH,wBAAgB,0CAA0C,CAAC,IAAI,EAAE;IAC/D,aAAa;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,6BAA6B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,kBAAkB,EAAE,wBAAwB,CAAC;CAC9C,GAAG,MAAM,CAQT;AAED,wBAAgB,6CAA6C,CAC3D,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,QAAQ,GAAG,uBAAuB,CAAC,EACnE,MAAM,EAAE,IAAI,CACV,iBAAiB,EACjB,WAAW,GAAG,gBAAgB,GAAG,gBAAgB,CAClD,EACD,oCAAoC,EAAE,wCAAwC,EAAE,UA0CjF;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,mBAAmB,GACzB,yBAAyB,CAQ3B;AAED,wBAAgB,iCAAiC,CAC/C,kBAAkB,EAAE,kBAAkB,GACrC,wBAAwB,CAiB1B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,mBAAmB,GAC5B,QAAQ,CAOV;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,4BAA4B,CAC1C,eAAe,EAAE,QAAQ,CAAC,YAAY,CAAC,EACvC,UAAU,EAAE;IACV,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,EACD,0BAA0B,UAAQ,GACjC;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB,CA8CA;AA4DD;;;;;;;;;;;GAWG;AACH,wBAAgB,uDAAuD,CAAC,IAAI,EAAE;IAC5E,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,SAAS,EAAE,SAAS,CAAC;IACrB,qBAAqB,EAAE,aAAa,EAAE,CAAC;CACxC,GAAG,MAAM,CAoCT;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,MAAM,GACf,WAAW,CAoCb;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,SAAS,CAAC,YAAsC,GAC7D,MAAM,CAMR"}

package/dist/orderbook/quantities.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adjustPriceToTickSize = exports.aggregateL2OrderBookAtTickSize = exports.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel = exports.calculateGrossFillQuantities = exports.convertToPositionBigInt = exports.convertToLeverageParametersBigInt = exports.convertToActiveStandingOrderBigInt = exports.calculateMaximumInitialMarginFractionOverride = exports.calculateInitialMarginFractionWithOverride = exports.nullLevel = exports.bidsTickRoundingMode = exports.asksTickRoundingMode = exports.isActiveStandingOrder = void 0;
+const bignumber_js_1 = require("bignumber.js");
+const _pipmath_1 = require("#pipmath");
+const request_1 = require("#types/enums/request");
+function isActiveStandingOrder(order) {
+    return typeof order.price !== 'undefined';
+}
+exports.isActiveStandingOrder = isActiveStandingOrder;
+exports.asksTickRoundingMode = bignumber_js_1.BigNumber.ROUND_UP;
+exports.bidsTickRoundingMode = bignumber_js_1.BigNumber.ROUND_DOWN;
+exports.nullLevel = {
+    price: BigInt(0),
+    size: BigInt(0),
+    numOrders: 0,
+    type: 'limit',
+};
+/**
+ * @private
+ */
+function calculateInitialMarginFraction(leverageParameters, baseQuantity) {
+    const absPositionQty = (0, _pipmath_1.absBigInt)(baseQuantity);
+    if (absPositionQty <= leverageParameters.basePositionSize) {
+        return leverageParameters.initialMarginFraction;
+    }
+    return (leverageParameters.initialMarginFraction +
+        (0, _pipmath_1.divideBigInt)(absPositionQty - leverageParameters.basePositionSize, leverageParameters.incrementalPositionSize, _pipmath_1.ROUNDING.RoundUp) *
+            leverageParameters.incrementalInitialMarginFraction);
+}
+/**
+ * Returns the initial margin fraction for a position or an order.
+ *
+ * Use {@link convertToLeverageParametersBigInt} to convert a {@link KatanaPerpsMarket}
+ * or {@link LeverageParameters} object to {@link LeverageParametersBigInt}.
+ */
+function calculateInitialMarginFractionWithOverride(args) {
+    const { initialMarginFractionOverride, leverageParameters, baseQuantity } = args;
+    return (0, _pipmath_1.maxBigInt)(calculateInitialMarginFraction(leverageParameters, baseQuantity), initialMarginFractionOverride ?? BigInt(0));
+}
+exports.calculateInitialMarginFractionWithOverride = calculateInitialMarginFractionWithOverride;
+function calculateMaximumInitialMarginFractionOverride(market, wallet, walletInitialMarginFractionOverrides) {
+    const positionForMarket = wallet.positions &&
+        wallet.positions.find((p) => p.market === market.market);
+    let positionNotionalValue = 0n;
+    if (positionForMarket) {
+        const position = convertToPositionBigInt(positionForMarket);
+        positionNotionalValue = (0, _pipmath_1.multiplyPips)((0, _pipmath_1.absBigInt)(position.quantity), position.indexPrice);
+    }
+    const effectiveInitialMarginFraction = (0, _pipmath_1.decimalToPip)(walletInitialMarginFractionOverrides.find((imfo) => imfo.market === market.market)?.initialMarginFractionOverride || market.initialMarginFraction);
+    const initialMarginRequirement = (0, _pipmath_1.multiplyPips)(positionNotionalValue, effectiveInitialMarginFraction);
+    const potentialHeldOrderValue = (0, _pipmath_1.dividePips)((0, _pipmath_1.decimalToPip)(wallet.heldCollateral), effectiveInitialMarginFraction);
+    const potentialLeveragedValue = positionNotionalValue + potentialHeldOrderValue;
+    const availableCollateralForLeverage = initialMarginRequirement + (0, _pipmath_1.decimalToPip)(wallet.freeCollateral);
+    return (0, _pipmath_1.pipToDecimal)(potentialLeveragedValue === 0n ? _pipmath_1.oneInPips : ((0, _pipmath_1.minBigInt)(_pipmath_1.oneInPips, (0, _pipmath_1.dividePips)(availableCollateralForLeverage, potentialLeveragedValue))));
+}
+exports.calculateMaximumInitialMarginFractionOverride = calculateMaximumInitialMarginFractionOverride;
+function convertToActiveStandingOrderBigInt(order) {
+    return {
+        ...order,
+        openQuantity: (0, _pipmath_1.decimalToPip)(order.originalQuantity) -
+            (0, _pipmath_1.decimalToPip)(order.executedQuantity),
+        price: (0, _pipmath_1.decimalToPip)(order.price),
+    };
+}
+exports.convertToActiveStandingOrderBigInt = convertToActiveStandingOrderBigInt;
+function convertToLeverageParametersBigInt(leverageParameters) {
+    return {
+        maximumPositionSize: (0, _pipmath_1.decimalToPip)(leverageParameters.maximumPositionSize),
+        initialMarginFraction: (0, _pipmath_1.decimalToPip)(leverageParameters.initialMarginFraction),
+        maintenanceMarginFraction: (0, _pipmath_1.decimalToPip)(leverageParameters.maintenanceMarginFraction),
+        basePositionSize: (0, _pipmath_1.decimalToPip)(leverageParameters.basePositionSize),
+        incrementalPositionSize: (0, _pipmath_1.decimalToPip)(leverageParameters.incrementalPositionSize),
+        incrementalInitialMarginFraction: (0, _pipmath_1.decimalToPip)(leverageParameters.incrementalInitialMarginFraction),
+    };
+}
+exports.convertToLeverageParametersBigInt = convertToLeverageParametersBigInt;
+/**
+ * Converts a {@link KatanaPerpsPosition} object to one used by some functions in this
+ * file.
+ */
+function convertToPositionBigInt(position) {
+    return {
+        market: position.market,
+        quantity: (0, _pipmath_1.decimalToPip)(position.quantity),
+        indexPrice: (0, _pipmath_1.decimalToPip)(position.indexPrice),
+        marginRequirement: (0, _pipmath_1.decimalToPip)(position.marginRequirement),
+    };
+}
+exports.convertToPositionBigInt = convertToPositionBigInt;
+/**
+ * Determines the liquidity available in the given order book (asks or bids)
+ * for a given taker quantity (which may be expressed in base or quote asset)
+ * and price (optional).
+ * In other words, it performs very basic order matching to provide an estimate
+ * of the base and quote quantities with which a taker order of the given
+ * size (quantity) and limit price (optional) would be filled.
+ *
+ * The taker order may represent a limit or a market order: If a limit price is
+ * given, it is matched as a limit order (which necessitates specifying whether
+ * it's a buy or a sell). Otherwise it is matched as a market order.
+ *
+ * The provided list of orders or price levels (asks or bids) is expected to be
+ * sorted by best price (ascending for asks (lowest first), descending for bids
+ * (highest first)). Multiple orders per price level are supported.
+ *
+ * To support high-precision calculations in which pip-precision is
+ * insufficient, the result may optionally be returned in double-pip precision;
+ * the returned values then represent numbers with 16 decimals instead of 8.
+ *
+ * @param returnInDoublePipPrecision - Defaults to false
+ */
+function calculateGrossFillQuantities(makerSideOrders, takerOrder, returnInDoublePipPrecision = false) {
+    const takerQuantity2p = takerOrder.quantity * _pipmath_1.oneInPips;
+    let filledBaseQty2p = BigInt(0);
+    let filledQuoteQty2p = BigInt(0);
+    const makeReturnValue = () => {
+        if (returnInDoublePipPrecision) {
+            return {
+                baseQuantity: filledBaseQty2p,
+                quoteQuantity: filledQuoteQty2p,
+            };
+        }
+        return {
+            baseQuantity: filledBaseQty2p / _pipmath_1.oneInPips,
+            quoteQuantity: filledQuoteQty2p / _pipmath_1.oneInPips,
+        };
+    };
+    for (const makerOrder of makerSideOrders) {
+        if (!doOrdersMatch(makerOrder, takerOrder)) {
+            return makeReturnValue();
+        }
+        const maxTakerQuantity2p = takerOrder.isQuantityInQuote ?
+            takerQuantity2p - filledQuoteQty2p
+            : takerQuantity2p - filledBaseQty2p;
+        const tradeQuantities = determineTradeQuantities(makerOrder, maxTakerQuantity2p, takerOrder.isQuantityInQuote);
+        if (tradeQuantities.baseQuantity2p === BigInt(0) ||
+            tradeQuantities.quoteQuantity2p === BigInt(0)) {
+            return makeReturnValue();
+        }
+        filledBaseQty2p += tradeQuantities.baseQuantity2p;
+        filledQuoteQty2p += tradeQuantities.quoteQuantity2p;
+    }
+    return makeReturnValue();
+}
+exports.calculateGrossFillQuantities = calculateGrossFillQuantities;
+/**
+ * Operates in double-pip precision ("2p") (16 decimals)
+ *
+ * @private
+ */
+function determineTradeQuantities(makerOrder, maxTakerQuantity2p, isMaxTakerQuantityInQuote) {
+    const makerQuantity2p = makerOrder.size * _pipmath_1.oneInPips;
+    // Limit by base
+    const fillBaseQty2p = isMaxTakerQuantityInQuote ? makerQuantity2p : ((0, _pipmath_1.minBigInt)(maxTakerQuantity2p, makerQuantity2p));
+    const fillQuoteQty2p = (0, _pipmath_1.multiplyPips)(fillBaseQty2p, makerOrder.price);
+    // Limit by quote
+    if (isMaxTakerQuantityInQuote && maxTakerQuantity2p < fillQuoteQty2p) {
+        return {
+            // Reduce base proportionally to reduction of fillQuoteQty2p
+            baseQuantity2p: (fillBaseQty2p * maxTakerQuantity2p) / fillQuoteQty2p,
+            quoteQuantity2p: maxTakerQuantity2p,
+        };
+    }
+    return {
+        baseQuantity2p: fillBaseQty2p,
+        quoteQuantity2p: fillQuoteQty2p,
+    };
+}
+/**
+ * @private
+ */
+function doOrdersMatch(makerOrder, takerOrder) {
+    if (!takerOrder.limitPrice) {
+        return true;
+    }
+    return ((takerOrder.side === request_1.OrderSide.buy &&
+        takerOrder.limitPrice >= makerOrder.price) ||
+        (takerOrder.side === request_1.OrderSide.sell &&
+            takerOrder.limitPrice <= makerOrder.price));
+}
+/**
+ * Reduce-only orders may only be on the books if their execution would in fact
+ * result in a reduction of an open position. That is, if any of the wallet's
+ * other standing orders would be matched and executed first and reduce the
+ * position, any reduce-only liquidity newly added to the books may not exceed
+ * the remaining size of the position.
+ *
+ * This function returns the size of the given open position minus the combined
+ * size of all the wallet's standing orders on the other side of the book that
+ * are priced better (higher for buys, lower for sells) or equal to the provided
+ * limit price.
+ */
+function determineMaximumReduceOnlyQuantityAvailableAtPriceLevel(args) {
+    const { limitPrice, position, orderSide, walletsStandingOrders } = args;
+    const positionQty = (0, _pipmath_1.decimalToPip)(position.quantity);
+    if (positionQty === BigInt(0)) {
+        return BigInt(0);
+    }
+    if ((orderSide === request_1.OrderSide.buy && positionQty > BigInt(0)) ||
+        (orderSide === request_1.OrderSide.sell && positionQty < BigInt(0))) {
+        // Order does not reduce position
+        return BigInt(0);
+    }
+    const activeStandingOrdersOnSameSide = walletsStandingOrders
+        .filter((order) => order.market === position.market && order.side === orderSide)
+        .filter(isActiveStandingOrder)
+        .map(convertToActiveStandingOrderBigInt);
+    let betterPricedActiveQtyOnTheBooks = BigInt(0);
+    for (const order of activeStandingOrdersOnSameSide) {
+        if ((order.side === request_1.OrderSide.buy && order.price >= limitPrice) ||
+            (order.side === request_1.OrderSide.sell && order.price <= limitPrice)) {
+            betterPricedActiveQtyOnTheBooks += order.openQuantity;
+        }
+    }
+    return (0, _pipmath_1.maxBigInt)((0, _pipmath_1.absBigInt)(positionQty) - betterPricedActiveQtyOnTheBooks, BigInt(0));
+}
+exports.determineMaximumReduceOnlyQuantityAvailableAtPriceLevel = determineMaximumReduceOnlyQuantityAvailableAtPriceLevel;
+/**
+ * Helper function to re-aggregate L2 orderbook price levels at a larger (more zeroes) tick size
+ */
+function aggregateL2OrderBookAtTickSize(inputBook, tickSize) {
+    const askLevelsByPrice = new Map();
+    for (const askLevel of inputBook.asks) {
+        const price = adjustPriceToTickSize(askLevel.price, tickSize, exports.asksTickRoundingMode);
+        const level = askLevelsByPrice.get(price) || { ...exports.nullLevel, price };
+        level.numOrders += askLevel.numOrders;
+        level.size += askLevel.size;
+        askLevelsByPrice.set(price, level);
+    }
+    const bidLevelsByPrice = new Map();
+    for (const bidLevel of inputBook.bids) {
+        const price = adjustPriceToTickSize(bidLevel.price, tickSize, exports.bidsTickRoundingMode);
+        const level = bidLevelsByPrice.get(price) || { ...exports.nullLevel, price };
+        level.numOrders += bidLevel.numOrders;
+        level.size += bidLevel.size;
+        bidLevelsByPrice.set(price, level);
+    }
+    return {
+        ...inputBook,
+        asks: Array.from(askLevelsByPrice.values()),
+        bids: Array.from(bidLevelsByPrice.values()),
+    };
+}
+exports.aggregateL2OrderBookAtTickSize = aggregateL2OrderBookAtTickSize;
+/**
+ * Adjusts prices in pips to account for tick size by discarding insignificant digits using
+ * specified rounding mode. Ex price 123456789 at tick size 1 is 123456789, at tick size 10
+ * 123456780, at 100 123456700, etc
+ */
+function adjustPriceToTickSize(price, tickSize, roundingMode = bignumber_js_1.BigNumber.ROUND_HALF_UP) {
+    const significantDigits = new bignumber_js_1.BigNumber(price.toString())
+        .dividedBy(new bignumber_js_1.BigNumber(tickSize.toString()))
+        .toFixed(0, roundingMode);
+    return BigInt(significantDigits) * tickSize;
+}
+exports.adjustPriceToTickSize = adjustPriceToTickSize;

package/dist/orderbook/utils.d.ts

@@ -0,0 +1,8 @@
+import type { L1OrderBook, L2OrderBook } from '#types/orderBook';
+/**
+ * Derive the level 1 orderbook from a level 2 orderbook
+ *
+ * @internal
+ */
+export declare function L2toL1OrderBook(l2: L2OrderBook): L1OrderBook;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/orderbook/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW,CAoB5D"}

package/dist/orderbook/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.L2toL1OrderBook = void 0;
+/**
+ * Derive the level 1 orderbook from a level 2 orderbook
+ *
+ * @internal
+ */
+function L2toL1OrderBook(l2) {
+    return {
+        ...l2,
+        asks: l2.asks.length ?
+            {
+                price: l2.asks[0].price,
+                size: l2.asks[0].size,
+                numOrders: l2.asks[0].numOrders,
+            }
+            : { price: BigInt(0), size: BigInt(0), numOrders: 0 },
+        bids: l2.bids.length ?
+            {
+                price: l2.bids[0].price,
+                size: l2.bids[0].size,
+                numOrders: l2.bids[0].numOrders,
+            }
+            : { price: BigInt(0), size: BigInt(0), numOrders: 0 },
+    };
+}
+exports.L2toL1OrderBook = L2toL1OrderBook;

package/dist/pipmath.d.ts

@@ -0,0 +1,21 @@
+export declare const exchangeDecimals = 8;
+export declare const oneInPips: bigint;
+export declare const MAX_64_BIT_INT: bigint;
+export declare function absBigInt(a: bigint): bigint;
+export declare const assetUnitsToDecimal: (assetUnits: bigint, decimals: number) => string;
+export declare const assetUnitsToPip: (assetUnits: bigint, assetUnitDecimals?: number) => bigint;
+export declare const pipToAssetUnits: (pips: bigint, assetUnitDecimals?: number) => bigint;
+export declare const decimalToPip: (decimal: string) => bigint;
+export declare enum ROUNDING {
+    Truncate = 0,
+    RoundUp = 1,
+    RoundDown = 2
+}
+export declare function divideBigInt(dividend: bigint, divisor: bigint, rounding?: ROUNDING): bigint;
+export declare const dividePips: (valueInPips: bigint, divisorInPips: bigint) => bigint;
+export declare const maxBigInt: (a: bigint, b: bigint) => bigint;
+export declare const minBigInt: (a: bigint, b: bigint) => bigint;
+export declare const multiplyPips: (pipValue1: bigint, pipValue2: bigint, roundUp?: boolean) => bigint;
+export declare const pipToDecimal: (pips: bigint) => string;
+export declare function squareRootBigInt(value: bigint): bigint;
+//# sourceMappingURL=pipmath.d.ts.map

package/dist/pipmath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipmath.d.ts","sourceRoot":"","sources":["../src/pipmath.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,SAAS,QAAiC,CAAC;AACxD,eAAO,MAAM,cAAc,QAAiC,CAAC;AAE7D,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,YACR,MAAM,KACf,MAGF,CAAC;AAEF,eAAO,MAAM,eAAe,eACd,MAAM,iCAEjB,MAGF,CAAC;AAEF,eAAO,MAAM,eAAe,SACpB,MAAM,iCAEX,MAGF,CAAC;AAEF,eAAO,MAAM,YAAY,YAAkC,MAAM,KAAG,MAQnE,CAAC;AAEF,oBAAY,QAAQ;IAClB,QAAQ,IAAI;IACZ,OAAO,IAAI;IACX,SAAS,IAAI;CACd;AAED,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,QAA4B,GACrC,MAAM,CAuBR;AAED,eAAO,MAAM,UAAU,gBACR,MAAM,iBACJ,MAAM,KACpB,MAKF,CAAC;AAEF,eAAO,MAAM,SAAS,MAAyB,MAAM,KAAK,MAAM,KAAG,MAKlE,CAAC;AAEF,eAAO,MAAM,SAAS,MAAyB,MAAM,KAAK,MAAM,KAAG,MAKlE,CAAC;AAEF,eAAO,MAAM,YAAY,cACZ,MAAM,aACN,MAAM,wBAEhB,MAMF,CAAC;AAEF,eAAO,MAAM,YAAY,SAA+B,MAAM,KAAG,MAEhE,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBtD"}

package/dist/pipmath.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootBigInt = exports.pipToDecimal = exports.multiplyPips = exports.minBigInt = exports.maxBigInt = exports.dividePips = exports.divideBigInt = exports.ROUNDING = exports.decimalToPip = exports.pipToAssetUnits = exports.assetUnitsToPip = exports.assetUnitsToDecimal = exports.absBigInt = exports.MAX_64_BIT_INT = exports.oneInPips = exports.exchangeDecimals = void 0;
+const bignumber_js_1 = require("bignumber.js");
+exports.exchangeDecimals = 8;
+exports.oneInPips = BigInt(10 ** exports.exchangeDecimals);
+exports.MAX_64_BIT_INT = BigInt('18446744073709551615');
+function absBigInt(a) {
+    return a < BigInt(0) ? -a : a;
+}
+exports.absBigInt = absBigInt;
+const assetUnitsToDecimal = function assetUnitsToDecimal(assetUnits, decimals) {
+    const bn = new bignumber_js_1.BigNumber(assetUnits.toString());
+    return bn.shiftedBy(decimals * -1).toFixed(exports.exchangeDecimals);
+};
+exports.assetUnitsToDecimal = assetUnitsToDecimal;
+const assetUnitsToPip = function assetUnitsToPip(assetUnits, assetUnitDecimals = 18) {
+    const bn = new bignumber_js_1.BigNumber(assetUnits.toString());
+    return BigInt(bn.shiftedBy(exports.exchangeDecimals - assetUnitDecimals).toFixed(0));
+};
+exports.assetUnitsToPip = assetUnitsToPip;
+const pipToAssetUnits = function pipToAssetUnits(pips, assetUnitDecimals = 18) {
+    const bn = new bignumber_js_1.BigNumber(pips.toString());
+    return BigInt(bn.shiftedBy(assetUnitDecimals - exports.exchangeDecimals).toFixed(0));
+};
+exports.pipToAssetUnits = pipToAssetUnits;
+const decimalToPip = function decimalToPip(decimal) {
+    const bn = new bignumber_js_1.BigNumber(decimal);
+    return BigInt(bn
+        .shiftedBy(exports.exchangeDecimals)
+        .integerValue(bignumber_js_1.BigNumber.ROUND_DOWN)
+        .toString());
+};
+exports.decimalToPip = decimalToPip;
+var ROUNDING;
+(function (ROUNDING) {
+    ROUNDING[ROUNDING["Truncate"] = 0] = "Truncate";
+    ROUNDING[ROUNDING["RoundUp"] = 1] = "RoundUp";
+    ROUNDING[ROUNDING["RoundDown"] = 2] = "RoundDown";
+})(ROUNDING || (exports.ROUNDING = ROUNDING = {}));
+function divideBigInt(dividend, divisor, rounding = ROUNDING.Truncate) {
+    if (divisor < BigInt(0)) {
+        throw new Error(`Division by negative numbers is not supported (got ${dividend.toString()}/${divisor.toString()})`);
+    }
+    const result = dividend / divisor;
+    if (rounding === ROUNDING.RoundUp &&
+        dividend > BigInt(0) && // Truncation is the same as rounding up in negative numbers
+        result * divisor !== dividend) {
+        return result + BigInt(1);
+    }
+    if (rounding === ROUNDING.RoundDown &&
+        dividend < BigInt(0) && // Truncation is the same as rounding down in positive numbers
+        result * divisor !== dividend) {
+        return result - BigInt(1);
+    }
+    return result;
+}
+exports.divideBigInt = divideBigInt;
+const dividePips = function dividePips(valueInPips, divisorInPips) {
+    if (divisorInPips <= BigInt(0)) {
+        return BigInt(0);
+    }
+    return (valueInPips * exports.oneInPips) / divisorInPips;
+};
+exports.dividePips = dividePips;
+const maxBigInt = function maxBigInt(a, b) {
+    if (a >= b) {
+        return a;
+    }
+    return b;
+};
+exports.maxBigInt = maxBigInt;
+const minBigInt = function minBigInt(a, b) {
+    if (a <= b) {
+        return a;
+    }
+    return b;
+};
+exports.minBigInt = minBigInt;
+const multiplyPips = function multiplyPips(pipValue1, pipValue2, roundUp = false) {
+    const pipValuesProduct = pipValue1 * pipValue2;
+    if (roundUp && pipValuesProduct % exports.oneInPips > 0) {
+        return BigInt(1) + pipValuesProduct / exports.oneInPips;
+    }
+    return pipValuesProduct / exports.oneInPips;
+};
+exports.multiplyPips = multiplyPips;
+const pipToDecimal = function pipToDecimal(pips) {
+    return (0, exports.assetUnitsToDecimal)(pips, exports.exchangeDecimals);
+};
+exports.pipToDecimal = pipToDecimal;
+function squareRootBigInt(value) {
+    if (value < BigInt(0)) {
+        throw new Error('Square root of negative numbers is not supported');
+    }
+    if (value === BigInt(0)) {
+        return value;
+    }
+    if (value <= BigInt(3)) {
+        return BigInt(1);
+    }
+    let z = value;
+    let x = value / BigInt(2) + BigInt(1);
+    while (x < z) {
+        z = x;
+        x = (value / x + x) / BigInt(2);
+    }
+    return z;
+}
+exports.squareRootBigInt = squareRootBigInt;

package/dist/signatures.d.ts

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers';
+import type * as types from '#index';
+import type { WithdrawalFromManagedAccountStruct } from './typechain-types/Exchange_v1';
+export type SignTypedData = (domain: ethers.TypedDataDomain, typeData: Record<string, Array<ethers.TypedDataField>>, value: Record<string, any>) => Promise<string>;
+export declare function createPrivateKeyTypedDataSigner(walletPrivateKey: string): SignTypedData;
+export declare const getDomainSeparator: (contractAddress: string, chainId: number, sandbox: boolean) => {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+};
+export declare const getWalletAssociationSignatureTypedData: (data: types.RestRequestAssociateWallet, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getWalletUnlockSignatureTypedData: ({ nonce }: {
+    nonce: string;
+}, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getDelegatedKeyAuthorizationSignatureTypedData: ({ delegatedKey, nonce }: {
+    delegatedKey: string;
+    nonce: string;
+}, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getOrderSignatureTypedData: (data: types.RestRequestOrder, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getOrderCancellationByOrderIdSignatureTypedData: (data: types.RestRequestCancelOrdersByOrderIds, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getOrderCancellationByDelegatedKeySignatureTypedData: (data: types.RestRequestCancelOrdersByDelegatedKey, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getOrderCancellationByMarketSymbolSignatureTypedData: (data: types.RestRequestCancelOrdersByMarket, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getOrderCancellationByWalletSignatureTypedData: (data: types.RestRequestCancelOrders, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare const getOrderCancellationSignatureTypedData: (data: types.RestRequestCancelOrders, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, typeData: Record<string, ethers.TypedDataField[]>, value: Record<string, any>];
+export declare function getSetVaultDetailsSignatureTypedData(data: types.RestRequestSetVaultDetails, contractAddress: string, chainId: number, sandbox: boolean): Parameters<SignTypedData>;
+export declare function getSetVaultXConnectionSignatureTypedData(data: types.RestRequestSetVaultXConnection, contractAddress: string, chainId: number, sandbox: boolean): Parameters<SignTypedData>;
+export declare function getRemoveVaultXConnectionSignatureTypedData(data: types.RestRequestRemoveVaultXConnection, contractAddress: string, chainId: number, sandbox: boolean): Parameters<SignTypedData>;
+export declare const getWithdrawalFromManagedAccountContractStructSignatureTypedData: (data: WithdrawalFromManagedAccountStruct, contractAddress: string, chainId: number, sandbox: boolean) => Promise<Parameters<ethers.JsonRpcSigner['signTypedData']>>;
+export declare const getWithdrawalFromManagedAccountByQuantitySignatureTypedData: (data: types.RestRequestWithdrawFundsFromManagedAccountByQuantity, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, _value: Record<string, any>];
+export declare const getWithdrawalFromManagedAccountBySharesSignatureTypedData: (data: types.RestRequestWithdrawFundsFromManagedAccountByShares, contractAddress: string, chainId: number, sandbox: boolean) => [domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, _value: Record<string, any>];
+export declare function getWithdrawalSignatureTypedData(data: types.RestRequestWithdrawFunds, contractAddress: string, chainId: number, sandbox: boolean): Parameters<SignTypedData>;
+export declare function getInitialMarginFractionOverrideSettingsSignatureTypedData(data: types.RestRequestSetInitialMarginFractionOverride, contractAddress: string, chainId: number, sandbox: boolean): Parameters<SignTypedData>;
+export declare function uint128ToUuid(uint: ethers.BigNumberish): string;
+export declare function uuidToHexString(uuid: string): string;
+export declare function uuidToUint128(uuid: string): bigint;
+//# sourceMappingURL=signatures.d.ts.map

package/dist/signatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signatures.d.ts","sourceRoot":"","sources":["../src/signatures.ts"],"names":[],"mappings":"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"}