@kodiak-finance/orderly-perp 4.7.4

package/dist/index.d.ts

@@ -0,0 +1,599 @@
+import { API, OrderSide } from '@kodiak-finance/orderly-types';
+import { Decimal } from '@kodiak-finance/orderly-utils';
+
+declare global {
+    interface Window {
+        __ORDERLY_VERSION__?: {
+            [key: string]: string;
+        };
+    }
+}
+declare const _default: "4.7.4";
+
+/**
+ * Calculates the notional value of a single position.
+ * @param qty The quantity of the position.
+ * @param mark_price The price of the position.
+ * @returns The notional value of the position.
+ */
+declare function notional(qty: number, mark_price: number): number;
+/**
+ * Calculates the total notional value of all positions.
+ * @param positions The array of positions.
+ * @returns The total notional value of all positions.
+ */
+declare function totalNotional(positions: API.Position[]): number;
+type UnrealPnLInputs = {
+    markPrice: number;
+    openPrice: number;
+    qty: number;
+};
+/**
+ * Calculates the unrealized profit or loss of a single position.
+ * @param inputs The inputs for calculating the unrealized profit or loss.
+ * @returns The unrealized profit or loss of the position.
+ */
+declare function unrealizedPnL(inputs: UnrealPnLInputs): number;
+type UnrealPnLROIInputs = {
+    positionQty: number;
+    openPrice: number;
+    IMR: number;
+    unrealizedPnL: number;
+};
+/**
+ * Calculates the return on investment (ROI) of a single position's unrealized profit or loss.
+ * @param inputs The inputs for calculating the ROI.
+ * @returns The ROI of the position's unrealized profit or loss.
+ */
+declare function unrealizedPnLROI(inputs: UnrealPnLROIInputs): number;
+/**
+ * Calculates the total unrealized profit or loss of all positions.
+ * @param positions The array of positions.
+ * @returns The total unrealized profit or loss of all positions.
+ */
+declare function totalUnrealizedPnL(positions: API.Position[]): number;
+type LiqPriceInputs = {
+    markPrice: number;
+    totalCollateral: number;
+    positionQty: number;
+    positions: Pick<API.PositionExt, "position_qty" | "mark_price" | "mmr">[];
+    MMR: number;
+};
+/**
+ * Calculates the liquidation price of a single position.
+ * @param inputs The inputs for calculating the liquidation price.
+ * @returns The liquidation price of the position.
+ */
+declare function liqPrice(inputs: LiqPriceInputs): number | null;
+type MMInputs = {
+    positionQty: number;
+    markPrice: number;
+    MMR: number;
+};
+/**
+ * Calculates the maintenance margin of a position.
+ * @param inputs The inputs for calculating the maintenance margin.
+ * @returns The maintenance margin of the position.
+ */
+declare function maintenanceMargin(inputs: MMInputs): number;
+type UnsettlementPnLInputs = {
+    positionQty: number;
+    markPrice: number;
+    costPosition: number;
+    sumUnitaryFunding: number;
+    lastSumUnitaryFunding: number;
+};
+/**
+ * Calculates the unrealized profit or loss of each position.
+ * @param inputs The inputs for calculating the unrealized profit or loss.
+ * @returns The unrealized profit or loss of each position.
+ */
+declare function unsettlementPnL(inputs: UnsettlementPnLInputs): number;
+type TotalUnsettlementPnLInputs = {
+    positions: (API.Position & {
+        sum_unitary_funding: number;
+    })[];
+    sumUnitaryFunding: number;
+};
+/**
+ * Calculates the total unrealized profit or loss of all positions.
+ * @param positions The array of positions.
+ * @returns The total unrealized profit or loss of all positions.
+ */
+declare function totalUnsettlementPnL(positions: (API.Position & {
+    sum_unitary_funding: number;
+})[]): number;
+type MMRInputs = {
+    baseMMR: number;
+    baseIMR: number;
+    IMRFactor: number;
+    positionNotional: number;
+    IMR_factor_power: number;
+};
+/**
+ * Calculates the maintenance margin requirement (MMR) of a position.
+ * @param inputs The inputs for calculating the MMR.
+ * @returns The MMR of the position.
+ */
+declare function MMR$1(inputs: MMRInputs): number;
+/**
+ * Calculates the profit or loss for take profit.
+ * @returns The profit or loss for take profit.
+ */
+declare function estPnLForTP(inputs: {
+    positionQty: number;
+    entryPrice: number;
+    price: number;
+}): number;
+/**
+ * Calculates the estimated price for take profit.
+ */
+declare function estPriceForTP(inputs: {
+    positionQty: number;
+    entryPrice: number;
+    pnl: number;
+}): number;
+/**
+ * Calculates the estimated offset for take profit.
+ */
+declare function estOffsetForTP(inputs: {
+    price: number;
+    entryPrice: number;
+}): number;
+/**
+ * Calculates the estimated price from offset for take profit.
+ */
+declare function estPriceFromOffsetForTP(inputs: {
+    offset: number;
+    entryPrice: number;
+}): number;
+/**
+ * Calculates the PnL for stop loss.
+ */
+declare function estPnLForSL(inputs: {
+    positionQty: number;
+    entryPrice: number;
+}): number;
+/**
+ * calculate the max position notional
+ * max_notional = ( (1/ (leverage * imr_factor) ) ^ (1/0.8)
+ */
+declare function maxPositionNotional(inputs: {
+    /** symbol leverage */
+    leverage: number;
+    IMRFactor: number;
+}): number;
+/**
+ * symbol_leverage_max = 1 / ( imr_factor * notional ^ 0.8 )
+ */
+declare function maxPositionLeverage(inputs: {
+    IMRFactor: number;
+    notional: number;
+}): number;
+
+type positions_LiqPriceInputs = LiqPriceInputs;
+type positions_MMInputs = MMInputs;
+type positions_MMRInputs = MMRInputs;
+type positions_TotalUnsettlementPnLInputs = TotalUnsettlementPnLInputs;
+type positions_UnrealPnLInputs = UnrealPnLInputs;
+type positions_UnrealPnLROIInputs = UnrealPnLROIInputs;
+type positions_UnsettlementPnLInputs = UnsettlementPnLInputs;
+declare const positions_estOffsetForTP: typeof estOffsetForTP;
+declare const positions_estPnLForSL: typeof estPnLForSL;
+declare const positions_estPnLForTP: typeof estPnLForTP;
+declare const positions_estPriceForTP: typeof estPriceForTP;
+declare const positions_estPriceFromOffsetForTP: typeof estPriceFromOffsetForTP;
+declare const positions_liqPrice: typeof liqPrice;
+declare const positions_maintenanceMargin: typeof maintenanceMargin;
+declare const positions_maxPositionLeverage: typeof maxPositionLeverage;
+declare const positions_maxPositionNotional: typeof maxPositionNotional;
+declare const positions_notional: typeof notional;
+declare const positions_totalNotional: typeof totalNotional;
+declare const positions_totalUnrealizedPnL: typeof totalUnrealizedPnL;
+declare const positions_totalUnsettlementPnL: typeof totalUnsettlementPnL;
+declare const positions_unrealizedPnL: typeof unrealizedPnL;
+declare const positions_unrealizedPnLROI: typeof unrealizedPnLROI;
+declare const positions_unsettlementPnL: typeof unsettlementPnL;
+declare namespace positions {
+  export { type positions_LiqPriceInputs as LiqPriceInputs, type positions_MMInputs as MMInputs, MMR$1 as MMR, type positions_MMRInputs as MMRInputs, type positions_TotalUnsettlementPnLInputs as TotalUnsettlementPnLInputs, type positions_UnrealPnLInputs as UnrealPnLInputs, type positions_UnrealPnLROIInputs as UnrealPnLROIInputs, type positions_UnsettlementPnLInputs as UnsettlementPnLInputs, positions_estOffsetForTP as estOffsetForTP, positions_estPnLForSL as estPnLForSL, positions_estPnLForTP as estPnLForTP, positions_estPriceForTP as estPriceForTP, positions_estPriceFromOffsetForTP as estPriceFromOffsetForTP, positions_liqPrice as liqPrice, positions_maintenanceMargin as maintenanceMargin, positions_maxPositionLeverage as maxPositionLeverage, positions_maxPositionNotional as maxPositionNotional, positions_notional as notional, positions_totalNotional as totalNotional, positions_totalUnrealizedPnL as totalUnrealizedPnL, positions_totalUnsettlementPnL as totalUnsettlementPnL, positions_unrealizedPnL as unrealizedPnL, positions_unrealizedPnLROI as unrealizedPnLROI, positions_unsettlementPnL as unsettlementPnL };
+}
+
+type ResultOptions = {
+    dp: number;
+};
+type TotalValueInputs = {
+    totalUnsettlementPnL: number;
+    USDCHolding: number;
+    nonUSDCHolding: {
+        holding: number;
+        indexPrice: number;
+    }[];
+};
+/**
+ * User's total asset value (denominated in USDC), including assets that cannot be used as collateral.
+ */
+declare function totalValue(inputs: TotalValueInputs): Decimal;
+/**
+ * Total value of available collateral in the user's account (denominated in USDC).
+ */
+type FreeCollateralInputs = {
+    totalCollateral: Decimal;
+    totalInitialMarginWithOrders: number;
+};
+/**
+ * Calculate free collateral.
+ */
+declare function freeCollateral(inputs: FreeCollateralInputs): Decimal;
+type TotalCollateralValueInputs = {
+    USDCHolding: number;
+    nonUSDCHolding: {
+        holding: number;
+        indexPrice: number;
+        collateralCap: number;
+        collateralRatio: Decimal;
+    }[];
+    unsettlementPnL: number;
+};
+/**
+ * Calculate total collateral.
+ */
+declare function totalCollateral(inputs: TotalCollateralValueInputs): Decimal;
+declare function initialMarginWithOrder(): void;
+type PositionNotionalWithOrderInputs = {
+    markPrice: number;
+    positionQtyWithOrders: number;
+};
+/**
+ * Sum of notional value for a symbol's position and orders.
+ */
+declare function positionNotionalWithOrder_by_symbol(inputs: PositionNotionalWithOrderInputs): Decimal;
+type PositionQtyWithOrderInputs = {
+    positionQty: number;
+    buyOrdersQty: number;
+    sellOrdersQty: number;
+};
+/**
+ *  Sum of position quantity and orders quantity for a symbol.
+ */
+declare function positionQtyWithOrders_by_symbol(inputs: PositionQtyWithOrderInputs): number;
+type IMRInputs = {
+    /**
+     * effective max leverage
+     */
+    maxLeverage: number;
+    baseIMR: number;
+    IMR_Factor: number;
+    positionNotional: number;
+    ordersNotional: number;
+    IMR_factor_power?: number;
+};
+/**
+ * Initial margin rate for a symbol.
+ * Max(1 / Max Account Leverage, Base IMR i, IMR Factor i * Abs(Position Notional i + Order Notional i)^(4/5))
+ */
+declare function IMR(inputs: IMRInputs): number;
+declare function buyOrdersFilter_by_symbol(orders: API.Order[], symbol: string): API.Order[];
+declare function sellOrdersFilter_by_symbol(orders: API.Order[], symbol: string): API.Order[];
+/**
+ * Get the quantity of a specified symbol from the list of positions.
+ */
+declare function getQtyFromPositions(positions: API.Position[], symbol: string): number;
+/**
+ * Get the quantity of long and short orders for a specified symbol from the list of orders.
+ */
+declare function getQtyFromOrdersBySide(orders: API.Order[], symbol: string, side: OrderSide): number;
+declare function getPositonsAndOrdersNotionalBySymbol(inputs: {
+    positions: API.Position[];
+    orders: API.Order[];
+    symbol: string;
+    markPrice: number;
+}): number;
+type TotalInitialMarginWithOrdersInputs = {
+    positions: API.Position[];
+    orders: API.Order[];
+    markPrices: {
+        [key: string]: number;
+    };
+    symbolInfo: any;
+    IMR_Factors: {
+        [key: string]: number;
+    };
+} & Pick<IMRInputs, "maxLeverage">;
+/**
+ * @deprecated
+ * Calculate the total initial margin used by the user (including positions and orders).
+ */
+declare function totalInitialMarginWithOrders(inputs: TotalInitialMarginWithOrdersInputs): number;
+declare function totalInitialMarginWithQty(inputs: {
+    positions: API.Position[];
+    markPrices: {
+        [key: string]: number;
+    };
+    symbolInfo: any;
+    IMR_Factors: {
+        [key: string]: number;
+    };
+    /**
+     * account max leverage
+     */
+    maxLeverage: number;
+}): number;
+/**
+ * Group orders by symbol, as a symbol can have multiple orders.
+ */
+declare function groupOrdersBySymbol(orders: API.Order[]): {
+    [key: string]: API.Order[];
+};
+/**
+ * Extracts all unique symbols from positions and orders.
+ * @param positions - An array of position objects.
+ * @param orders - An array of order objects.
+ * @returns An array of unique symbols.
+ */
+declare function extractSymbols(positions: Pick<API.Position, "symbol">[], orders: Pick<API.Order, "symbol">[]): string[];
+type OtherIMsInputs = {
+    positions: API.Position[];
+    markPrices: {
+        [key: string]: number;
+    };
+    /**
+     * account max leverage
+     */
+    maxLeverage: number;
+    symbolInfo: any;
+    IMR_Factors: {
+        [key: string]: number;
+    };
+};
+/**
+ * Total margin used by other symbols (except the current symbol).
+ */
+declare function otherIMs(inputs: OtherIMsInputs): number;
+type MaxQtyInputs = {
+    symbol: string;
+    baseMaxQty: number;
+    /**
+     * Total collateral of the user (denominated in USDC), can be calculated from totalCollateral.
+     * @see totalCollateral
+     */
+    totalCollateral: number;
+    maxLeverage: number;
+    baseIMR: number;
+    /**
+     * @see otherIMs
+     */
+    otherIMs: number;
+    markPrice: number;
+    positionQty: number;
+    buyOrdersQty: number;
+    sellOrdersQty: number;
+    IMR_Factor: number;
+    takerFeeRate: number;
+};
+/**
+ * Maximum order quantity.
+ */
+declare function maxQty(side: OrderSide, inputs: MaxQtyInputs, options?: ResultOptions): number;
+declare function maxQtyByLong(inputs: Omit<MaxQtyInputs, "side">, options?: ResultOptions): number;
+declare function maxQtyByShort(inputs: Omit<MaxQtyInputs, "side">, options?: ResultOptions): number;
+type TotalMarginRatioInputs = {
+    totalCollateral: number;
+    markPrices: {
+        [key: string]: number;
+    };
+    positions: API.Position[];
+};
+/**
+ * total margin ratio
+ */
+declare function totalMarginRatio(inputs: TotalMarginRatioInputs, dp?: number): number;
+type TotalUnrealizedROIInputs = {
+    totalUnrealizedPnL: number;
+    totalValue: number;
+};
+/**
+ * totalUnrealizedROI
+ */
+declare function totalUnrealizedROI(inputs: TotalUnrealizedROIInputs): number;
+/**
+ * current account leverage
+ */
+declare function currentLeverage(totalMarginRatio: number): number;
+type AvailableBalanceInputs = {
+    USDCHolding: number;
+    unsettlementPnL: number;
+};
+declare function availableBalance(inputs: AvailableBalanceInputs): number;
+type AccountMMRInputs = {
+    positionsMMR: number;
+    /**
+     * Notional sum of all positions,
+     * positions.totalNotional()
+     */
+    positionsNotional: number;
+};
+/**
+ * total maintenance margin ratio
+ * @param inputs AccountMMRInputs
+ * @returns number|null
+ */
+declare function MMR(inputs: AccountMMRInputs): number | null;
+declare const collateralRatio: (params: {
+    baseWeight: number;
+    discountFactor: number | null;
+    collateralQty: number;
+    collateralCap: number;
+    indexPrice: number;
+}) => Decimal;
+/** collateral_value_i = min(collateral_qty_i , collateral_cap_i) * weight_i * index_price_i */
+declare const collateralContribution: (params: {
+    collateralQty: number;
+    collateralCap: number;
+    collateralRatio: number;
+    indexPrice: number;
+}) => number;
+declare const LTV: (params: {
+    usdcBalance: number;
+    upnl: number;
+    assets: Array<{
+        qty: number;
+        indexPrice: number;
+        weight: number;
+    }>;
+}) => number;
+/**
+ * max(0, min(USDC_balance, free_collateral - max(upnl, 0)))
+ */
+declare const maxWithdrawalUSDC: (inputs: {
+    USDCBalance: number;
+    freeCollateral: Decimal;
+    upnl: number;
+}) => number;
+/**
+ *
+ * Other collateral: min(collateral_qty_i, free_collateral / (index_price_i × weight_i)
+ * Other collateral with negative USDC: min(collateral_qty_i, free_collateral / (index_price_i × (1 + buffer) × weight_i)
+ * buffer: 0.2%
+ */
+declare const maxWithdrawalOtherCollateral: (inputs: {
+    USDCBalance: number;
+    collateralQty: number;
+    freeCollateral: Decimal;
+    indexPrice: number;
+    weight: Decimal;
+}) => Decimal;
+declare const calcMinimumReceived: (inputs: {
+    amount: number;
+    slippage: number;
+}) => number;
+/**
+ * @deprecated This method will be removed soon. Please update your code to use symbolLeverage directly.
+ */
+declare const maxLeverage: (inputs: {
+    symbolLeverage?: number;
+    accountLeverage: number;
+}) => number;
+
+type account_AccountMMRInputs = AccountMMRInputs;
+type account_AvailableBalanceInputs = AvailableBalanceInputs;
+type account_FreeCollateralInputs = FreeCollateralInputs;
+declare const account_IMR: typeof IMR;
+type account_IMRInputs = IMRInputs;
+declare const account_LTV: typeof LTV;
+declare const account_MMR: typeof MMR;
+type account_MaxQtyInputs = MaxQtyInputs;
+type account_OtherIMsInputs = OtherIMsInputs;
+type account_PositionNotionalWithOrderInputs = PositionNotionalWithOrderInputs;
+type account_PositionQtyWithOrderInputs = PositionQtyWithOrderInputs;
+type account_ResultOptions = ResultOptions;
+type account_TotalCollateralValueInputs = TotalCollateralValueInputs;
+type account_TotalInitialMarginWithOrdersInputs = TotalInitialMarginWithOrdersInputs;
+type account_TotalMarginRatioInputs = TotalMarginRatioInputs;
+type account_TotalUnrealizedROIInputs = TotalUnrealizedROIInputs;
+type account_TotalValueInputs = TotalValueInputs;
+declare const account_availableBalance: typeof availableBalance;
+declare const account_buyOrdersFilter_by_symbol: typeof buyOrdersFilter_by_symbol;
+declare const account_calcMinimumReceived: typeof calcMinimumReceived;
+declare const account_collateralContribution: typeof collateralContribution;
+declare const account_collateralRatio: typeof collateralRatio;
+declare const account_currentLeverage: typeof currentLeverage;
+declare const account_extractSymbols: typeof extractSymbols;
+declare const account_freeCollateral: typeof freeCollateral;
+declare const account_getPositonsAndOrdersNotionalBySymbol: typeof getPositonsAndOrdersNotionalBySymbol;
+declare const account_getQtyFromOrdersBySide: typeof getQtyFromOrdersBySide;
+declare const account_getQtyFromPositions: typeof getQtyFromPositions;
+declare const account_groupOrdersBySymbol: typeof groupOrdersBySymbol;
+declare const account_initialMarginWithOrder: typeof initialMarginWithOrder;
+declare const account_maxLeverage: typeof maxLeverage;
+declare const account_maxQty: typeof maxQty;
+declare const account_maxQtyByLong: typeof maxQtyByLong;
+declare const account_maxQtyByShort: typeof maxQtyByShort;
+declare const account_maxWithdrawalOtherCollateral: typeof maxWithdrawalOtherCollateral;
+declare const account_maxWithdrawalUSDC: typeof maxWithdrawalUSDC;
+declare const account_otherIMs: typeof otherIMs;
+declare const account_positionNotionalWithOrder_by_symbol: typeof positionNotionalWithOrder_by_symbol;
+declare const account_positionQtyWithOrders_by_symbol: typeof positionQtyWithOrders_by_symbol;
+declare const account_sellOrdersFilter_by_symbol: typeof sellOrdersFilter_by_symbol;
+declare const account_totalCollateral: typeof totalCollateral;
+declare const account_totalInitialMarginWithOrders: typeof totalInitialMarginWithOrders;
+declare const account_totalInitialMarginWithQty: typeof totalInitialMarginWithQty;
+declare const account_totalMarginRatio: typeof totalMarginRatio;
+declare const account_totalUnrealizedROI: typeof totalUnrealizedROI;
+declare const account_totalValue: typeof totalValue;
+declare namespace account {
+  export { type account_AccountMMRInputs as AccountMMRInputs, type account_AvailableBalanceInputs as AvailableBalanceInputs, type account_FreeCollateralInputs as FreeCollateralInputs, account_IMR as IMR, type account_IMRInputs as IMRInputs, account_LTV as LTV, account_MMR as MMR, type account_MaxQtyInputs as MaxQtyInputs, type account_OtherIMsInputs as OtherIMsInputs, type account_PositionNotionalWithOrderInputs as PositionNotionalWithOrderInputs, type account_PositionQtyWithOrderInputs as PositionQtyWithOrderInputs, type account_ResultOptions as ResultOptions, type account_TotalCollateralValueInputs as TotalCollateralValueInputs, type account_TotalInitialMarginWithOrdersInputs as TotalInitialMarginWithOrdersInputs, type account_TotalMarginRatioInputs as TotalMarginRatioInputs, type account_TotalUnrealizedROIInputs as TotalUnrealizedROIInputs, type account_TotalValueInputs as TotalValueInputs, account_availableBalance as availableBalance, account_buyOrdersFilter_by_symbol as buyOrdersFilter_by_symbol, account_calcMinimumReceived as calcMinimumReceived, account_collateralContribution as collateralContribution, account_collateralRatio as collateralRatio, account_currentLeverage as currentLeverage, account_extractSymbols as extractSymbols, account_freeCollateral as freeCollateral, account_getPositonsAndOrdersNotionalBySymbol as getPositonsAndOrdersNotionalBySymbol, account_getQtyFromOrdersBySide as getQtyFromOrdersBySide, account_getQtyFromPositions as getQtyFromPositions, account_groupOrdersBySymbol as groupOrdersBySymbol, account_initialMarginWithOrder as initialMarginWithOrder, account_maxLeverage as maxLeverage, account_maxQty as maxQty, account_maxQtyByLong as maxQtyByLong, account_maxQtyByShort as maxQtyByShort, account_maxWithdrawalOtherCollateral as maxWithdrawalOtherCollateral, account_maxWithdrawalUSDC as maxWithdrawalUSDC, account_otherIMs as otherIMs, account_positionNotionalWithOrder_by_symbol as positionNotionalWithOrder_by_symbol, account_positionQtyWithOrders_by_symbol as positionQtyWithOrders_by_symbol, account_sellOrdersFilter_by_symbol as sellOrdersFilter_by_symbol, account_totalCollateral as totalCollateral, account_totalInitialMarginWithOrders as totalInitialMarginWithOrders, account_totalInitialMarginWithQty as totalInitialMarginWithQty, account_totalMarginRatio as totalMarginRatio, account_totalUnrealizedROI as totalUnrealizedROI, account_totalValue as totalValue };
+}
+
+/**
+ * Maximum price when placing an order
+ */
+declare function maxPrice(markprice: number, range: number): number;
+/**
+ * Minimum price when placing an order
+ */
+declare function minPrice(markprice: number, range: number): number;
+/**
+ * Scope price when placing an order
+ * @returns number
+ */
+declare function scopePrice(price: number, scope: number, side: "BUY" | "SELL"): number;
+/**
+ * Calculate the order fee
+ */
+declare function orderFee(inputs: {
+    /**
+     * Order quantity
+     */
+    qty: number;
+    price: number;
+    futuresTakeFeeRate: number;
+}): number;
+type EstimatedLiquidationPriceInputs = {
+    totalCollateral: number;
+    markPrice: number;
+    baseMMR: number;
+    baseIMR: number;
+    IMR_Factor: number;
+    orderFee: number;
+    positions: Pick<API.PositionExt, "position_qty" | "mark_price" | "symbol" | "mmr">[];
+    newOrder: {
+        symbol: string;
+        qty: number;
+        price: number;
+    };
+};
+/**
+ * Estimated liquidation price
+ * @param inputs
+ * @returns
+ */
+declare function estLiqPrice(inputs: EstimatedLiquidationPriceInputs): number;
+type EstimatedLeverageInputs = {
+    totalCollateral: number;
+    positions: Pick<API.PositionExt, "position_qty" | "mark_price" | "symbol">[];
+    newOrder: {
+        symbol: string;
+        qty: number;
+        price: number;
+    };
+};
+/**
+ * Estimated leverage
+ * @param inputs EstimtedLeverageInputs
+ * @returns number
+ */
+declare function estLeverage(inputs: EstimatedLeverageInputs): number | null;
+
+type order_EstimatedLeverageInputs = EstimatedLeverageInputs;
+type order_EstimatedLiquidationPriceInputs = EstimatedLiquidationPriceInputs;
+declare const order_estLeverage: typeof estLeverage;
+declare const order_estLiqPrice: typeof estLiqPrice;
+declare const order_maxPrice: typeof maxPrice;
+declare const order_minPrice: typeof minPrice;
+declare const order_orderFee: typeof orderFee;
+declare const order_scopePrice: typeof scopePrice;
+declare namespace order {
+  export { type order_EstimatedLeverageInputs as EstimatedLeverageInputs, type order_EstimatedLiquidationPriceInputs as EstimatedLiquidationPriceInputs, order_estLeverage as estLeverage, order_estLiqPrice as estLiqPrice, order_maxPrice as maxPrice, order_minPrice as minPrice, order_orderFee as orderFee, order_scopePrice as scopePrice };
+}
+
+export { account, order, order as orderUtils, positions, _default as version };