@domfi/sdk 0.1.0

package/dist/math.d.cts

@@ -0,0 +1,273 @@
+import { P as PercentP6, U as UsdP6 } from './units-BYd75H7U.cjs';
+export { p as parseUnsignedPercentToP6 } from './units-BYd75H7U.cjs';
+import { Z as TradeDirection } from './types-DJBX-p4X.cjs';
+export { a9 as CheckClosePercentBoundsInput, aa as CheckGroupCollateralCapInput, ab as CheckLeverageBoundsInput, ac as CheckMaxCollateralInput, ad as CheckMinimumPositionSizeInput, ae as CheckOiCapInput, af as CheckSlippageBoundsInput, k as ConstraintCheckResult, ag as checkClosePercentBounds, ah as checkGroupCollateralCap, ai as checkLeverageBounds, aj as checkMaxCollateral, ak as checkMinimumPositionSize, al as checkOiCap, am as checkSlippageBounds } from './types-DJBX-p4X.cjs';
+import { Price, Leverage, WholePercent, Collateral, SignedP18, SignedP6, FeePercent, UnsignedP18 } from './units.cjs';
+export { L as LiquidationMarginInput, a as LiquidationPriceInput, M as MarkValueInput, P as PercentProfitInput, U as UnrealizedPnlInput, c as UnrealizedPnlPercentInput, d as currentPercentProfit, l as liquidationMarginRaw, b as liquidationPriceRaw, m as markValueFromPercentProfit, u as unrealizedPnlFromMarkValue, e as unrealizedPnlPercentFromMarkValue } from './position-BnhSFyGe.cjs';
+import '@domfi/sdk/units';
+import 'viem';
+import '@domfi/sdk/errors';
+import './types-DQft82W7.cjs';
+import './errors.cjs';
+import './referrals.cjs';
+
+/** Solidity `1e2` scale. Leverage values use this scale: 100 == 1x. */
+declare const PRECISION_2 = 100n;
+/** Solidity `1e6` scale. Percent P6 values use this scale: 1% == 1_000_000. */
+declare const PRECISION_6 = 1000000n;
+/** Solidity `1e12` scale used to convert 1e18 open interest into 1e6 USD notional. */
+declare const PRECISION_12 = 1000000000000n;
+/** Solidity `1e18` scale for contract prices and high-precision ratios. */
+declare const PRECISION_18 = 1000000000000000000n;
+/** TradingCallbacksLib.BASE_SPREAD_P: flat 0.001% execution spread, in 1e18 units. */
+declare const BASE_SPREAD_P = 10000000000000n;
+/** TradingCallbacksLib.MAX_GAIN_P: max 900% PnL cap for TP correction. */
+declare const MAX_GAIN_P = 900n;
+/** Contract commit used to generate the checked-in action-critical vectors. */
+declare const mathParityTarget: "domfi-core@a8bba32d92af1f44ae625e839e4ca420aefe89c2";
+
+/** Inputs for converting a PnL percentage target into a trigger price. */
+type PnlPercentPriceInput = {
+    basePrice: Price;
+    pnlPercent: PercentP6;
+    leverage: Leverage;
+    direction: TradeDirection;
+};
+/** Inputs for converting a price-delta percentage into a trigger price. */
+type PriceDeltaPriceInput = {
+    basePrice: Price;
+    priceDeltaPercent: PercentP6;
+    direction: TradeDirection;
+};
+/** Inputs for computing max take-profit distance. */
+type MaxTpDistanceInput = {
+    openPrice: Price;
+    leverage: Leverage;
+    initialLeverage: Leverage;
+};
+/** Inputs for computing max stop-loss distance. */
+type MaxSlDistanceInput = {
+    openPrice: Price;
+    leverage: Leverage;
+    maxSlP: WholePercent;
+};
+/** Inputs for correcting a take-profit price into protocol bounds. */
+type CorrectTpInput = MaxTpDistanceInput & {
+    takeProfit: Price;
+    direction: TradeDirection;
+};
+/** Inputs for correcting a stop-loss price into protocol bounds. */
+type CorrectSlInput = MaxTpDistanceInput & {
+    stopLoss: Price;
+    direction: TradeDirection;
+    maxSlP: WholePercent;
+};
+/** Violation code returned by trigger price validation. */
+type TriggerPriceViolationCode = "tp_wrong_side" | "tp_exceeds_max_distance" | "sl_wrong_side" | "sl_exceeds_max_distance";
+/** Result of trigger price validation. */
+type TriggerPriceValidationResult = {
+    status: "ok";
+} | {
+    status: "violation";
+    code: TriggerPriceViolationCode;
+    message: string;
+};
+/** Inputs for validating take-profit and stop-loss prices together. */
+type ValidateTriggerPricesInput = MaxTpDistanceInput & {
+    direction: TradeDirection;
+    maxSlP: WholePercent;
+    takeProfit?: Price;
+    stopLoss?: Price;
+};
+/** Convert an unsigned PnL percent target into a TP price using contract integer order. */
+declare function tpPriceFromPnlPercent(input: PnlPercentPriceInput): Price;
+/** Convert an unsigned PnL percent target into an SL price using contract integer order. */
+declare function slPriceFromPnlPercent(input: PnlPercentPriceInput): Price;
+/** Convert an unsigned raw price-delta percent into a TP price. */
+declare function tpPriceFromPriceDelta(input: PriceDeltaPriceInput): Price;
+/** Convert an unsigned raw price-delta percent into an SL price. */
+declare function slPriceFromPriceDelta(input: PriceDeltaPriceInput): Price;
+/** Max TP distance from open, derived from TradingCallbacksLib.correctTp. */
+declare function maxTpDistance(input: MaxTpDistanceInput): Price;
+/** Max SL distance from open, derived from TradingCallbacksLib.correctSl. */
+declare function maxSlDistance(input: MaxSlDistanceInput): Price;
+/** Mirror TradingCallbacksLib.correctTp for client-side action preflight. */
+declare function correctTp(input: CorrectTpInput): Price;
+/** Mirror TradingCallbacksLib.correctSl for client-side action preflight. */
+declare function correctSl(input: CorrectSlInput): Price;
+/** Mirror TradingCallbacksLib.correctToNullSl for client-side action preflight. */
+declare function correctToNullSl(input: CorrectSlInput): Price;
+/** Validate TP/SL side and max-distance constraints without throwing on ordinary violations. */
+declare function validateTriggerPrices(input: ValidateTriggerPricesInput): TriggerPriceValidationResult;
+
+/** Inputs for deriving USD notional from collateral and leverage. */
+type NotionalFromCollateralInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+};
+/** Inputs for deriving minimum collateral from requested USD notional and leverage. */
+type CollateralFromNotionalInput = {
+    notionalUsd: UsdP6;
+    leverage: Leverage;
+};
+/** USD P6 notional from collateral and P2 leverage: collateral * leverage / 100. */
+declare function notionalFromCollateral(input: NotionalFromCollateralInput): UsdP6;
+/** Minimal collateral needed so notionalFromCollateral(result) is at least requested notional. */
+declare function collateralFromNotional(input: CollateralFromNotionalInput): Collateral;
+
+/** Inputs for recomputing leverage after adding collateral. */
+type TopUpLeverageInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    topUpAmount: Collateral;
+};
+/** Inputs for recomputing leverage after removing collateral. */
+type RemoveCollateralLeverageInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    removeAmount: Collateral;
+};
+/** Result of a collateral adjustment leverage recomputation. */
+type CollateralAdjustmentLeverageResult = {
+    /** Leverage of the position after the adjustment. */
+    newLeverage: Leverage;
+    /** Collateral of the position after the adjustment. */
+    newCollateral: Collateral;
+    /** Collateral actually added/removed after the contract's recompute (the wallet delta). */
+    effectiveAmount: Collateral;
+};
+/** Inputs for finding the collateral delta needed to reach a target leverage. */
+type ReachLeverageInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    targetLeverage: Leverage;
+};
+/**
+ * Result of a "reach target leverage" computation.
+ *
+ * `requestedAmount` is the value to pass to `topUpCollateral` / `removeCollateral` on-chain.
+ * The contract may transfer a slightly smaller amount after its leverage recompute, so the
+ * actual collateral delta applied to the position is `effectiveAmount` (and `newLeverage` /
+ * `newCollateral` describe the resulting position). `requestedAmount >= effectiveAmount`.
+ */
+type ReachLeverageResult = CollateralAdjustmentLeverageResult & {
+    /** Amount to pass to `topUpCollateral` / `removeCollateral` on-chain; `>= effectiveAmount`. */
+    requestedAmount: Collateral;
+};
+/** Mirror DomfiTrading.topUpCollateral leverage/collateral recomputation including +1 remainder rule. */
+declare function leverageAfterTopUp(input: TopUpLeverageInput): CollateralAdjustmentLeverageResult;
+/**
+ * Collateral to add so a position's leverage drops to (at most) targetLeverage.
+ *
+ * Adding collateral lowers leverage, so targetLeverage must be below the current leverage.
+ * Returns the minimal {@link ReachLeverageResult.requestedAmount} to submit to
+ * `topUpCollateral`; the resulting leverage never exceeds targetLeverage. The canonical
+ * recompute is delegated to {@link leverageAfterTopUp}, so the outcome mirrors
+ * DomfiTrading.topUpCollateral exactly (including the +1 remainder rule).
+ *
+ * Note: leverage is quantized, so with small collateral the nearest achievable leverage may be
+ * strictly below targetLeverage. Protocol min/max leverage is not enforced here; use the
+ * constraint checks for that.
+ */
+declare function topUpToReachLeverage(input: ReachLeverageInput): ReachLeverageResult;
+/**
+ * Collateral that can be removed so a position's leverage rises to (at most) targetLeverage.
+ *
+ * Removing collateral raises leverage, so targetLeverage must be above the current leverage.
+ * Returns the maximum safe {@link ReachLeverageResult.requestedAmount} to submit to
+ * `removeCollateral` — the removal whose resulting leverage is closest to, but never above,
+ * targetLeverage. The canonical recompute is delegated to {@link leverageAfterRemoveCollateral},
+ * so the outcome mirrors DomfiTrading.removeCollateral exactly.
+ *
+ * Throws when no removal reaches above the current leverage without exceeding targetLeverage
+ * (leverage is quantized, so adjacent targets can be unreachable). Protocol min/max leverage is
+ * not enforced here; use the constraint checks for that.
+ */
+declare function removeCollateralToReachLeverage(input: ReachLeverageInput): ReachLeverageResult;
+/** Mirror DomfiTrading.removeCollateral leverage/collateral recomputation with no +1 remainder rule. */
+declare function leverageAfterRemoveCollateral(input: RemoveCollateralLeverageInput): CollateralAdjustmentLeverageResult;
+
+/** Inputs for computing a raw position funding fee from cumulative funding values. */
+type PositionFundingFeeInput = {
+    initialAccFunding: SignedP18;
+    endAccFunding: SignedP18;
+    collateral: Collateral;
+    leverage: Leverage;
+};
+/** Computes the raw signed funding fee using contract integer ordering. */
+declare function positionFundingFeeRaw(input: PositionFundingFeeInput): bigint;
+
+/** Inputs for a flat single-rate trade fee calculation. */
+type TradeFeeInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    feeP: FeePercent;
+};
+/**
+ * Flat single-rate trade fee from collateral, leverage, and one known fee percent. This is a
+ * guarded convenience helper (rejects non-positive leverage); use {@link openingFee} for the
+ * exact maker/taker model, which mirrors the contract view including its zero-leverage behavior.
+ */
+declare function tradeFee(input: TradeFeeInput): Collateral;
+/** Inputs for the maker/taker opening-fee calculation. */
+type OpeningFeeInput = {
+    /** Signed P6 USD notional of the trade (long open positive, short open negative). */
+    tradeSize: SignedP6;
+    /** Signed P6 USD open-interest imbalance (oiLong - oiShort). */
+    oiDelta: SignedP6;
+    leverage: Leverage;
+    makerFeeP: FeePercent;
+    takerFeeP: FeePercent;
+    makerMaxLeverage: Leverage;
+};
+/**
+ * Maker/taker opening fee, mirroring DomfiPairInfos._getBaseOpeningFee. Returns the total base
+ * fee the trader pays; the contract's dev/vault split is an allocation of this same amount.
+ *
+ * When the trade reduces the OI imbalance (`oiDelta * tradeSize < 0`) and `leverage` is within
+ * `makerMaxLeverage`, the imbalance-reducing portion is charged `makerFeeP`; any portion that
+ * overshoots zero imbalance is charged `takerFeeP`. Otherwise the whole notional is taker. The
+ * same function computes closing fees: pass the closing fee params and the inverted tradeSize
+ * sign convention (long close negative, short close positive).
+ */
+declare function openingFee(input: OpeningFeeInput): Collateral;
+
+/** Inputs for contract-parity execution price impact calculation. */
+type PriceImpactInput = {
+    price: Price;
+    /**
+     * Raw on-chain open interest (1e18 token notional). Source from `marketState.rawState.oiLong` /
+     * `oiShort` — NOT the display `longOpenInterest` / `shortOpenInterest`.
+     */
+    oiLong: UnsignedP18;
+    oiShort: UnsignedP18;
+    collateral: Collateral;
+    leverage: Leverage;
+    isOpen: boolean;
+    isLong: boolean;
+};
+/** Result of execution price impact calculation. */
+type PriceImpactResult = {
+    /**
+     * Spread-adjusted execution price. For opens this is the price the contract stores as
+     * `openPrice`; for closes it is the execution price used to settle the close.
+     */
+    priceAfterImpact: Price;
+    /**
+     * Price-impact magnitude in the contract's guard scale (`withinMaxNegativePnlOnOpenP`):
+     * `|price - priceAfterImpact| * 1e20 / price`. Here 1% impact == 1e18 and 100% == 1e20.
+     */
+    priceImpactP: bigint;
+};
+/**
+ * Execution price after spread — a verbatim mirror of TradingCallbacksLib.getTradePriceImpact.
+ *
+ * NOTE: at the pinned contract commit the OI-skew scaling is inert. Integer truncation collapses
+ * `skew` to {-1, 0, 1} and the multiplier to 1, so the spread is a flat 0.001% (BASE_SPREAD_P)
+ * applied against the trader regardless of open interest. The oiLong/oiShort/collateral/leverage
+ * inputs therefore do not affect the result today; they are retained for exact parity and so this
+ * helper tracks the contract automatically if the skew bug is fixed.
+ */
+declare function priceImpact(input: PriceImpactInput): PriceImpactResult;
+
+export { BASE_SPREAD_P, type CollateralAdjustmentLeverageResult, type CollateralFromNotionalInput, type CorrectSlInput, type CorrectTpInput, MAX_GAIN_P, type MaxSlDistanceInput, type MaxTpDistanceInput, type NotionalFromCollateralInput, type OpeningFeeInput, PRECISION_12, PRECISION_18, PRECISION_2, PRECISION_6, PercentP6, type PnlPercentPriceInput, type PositionFundingFeeInput, type PriceDeltaPriceInput, type PriceImpactInput, type PriceImpactResult, type ReachLeverageInput, type ReachLeverageResult, type RemoveCollateralLeverageInput, type TopUpLeverageInput, type TradeFeeInput, type TriggerPriceValidationResult, type TriggerPriceViolationCode, UsdP6, type ValidateTriggerPricesInput, collateralFromNotional, correctSl, correctToNullSl, correctTp, leverageAfterRemoveCollateral, leverageAfterTopUp, mathParityTarget, maxSlDistance, maxTpDistance, notionalFromCollateral, openingFee, positionFundingFeeRaw, priceImpact, removeCollateralToReachLeverage, slPriceFromPnlPercent, slPriceFromPriceDelta, topUpToReachLeverage, tpPriceFromPnlPercent, tpPriceFromPriceDelta, tradeFee, validateTriggerPrices };

package/dist/math.d.ts

@@ -0,0 +1,273 @@
+import { P as PercentP6, U as UsdP6 } from './units-BYd75H7U.js';
+export { p as parseUnsignedPercentToP6 } from './units-BYd75H7U.js';
+import { Z as TradeDirection } from './types-DDgJiEFg.js';
+export { a9 as CheckClosePercentBoundsInput, aa as CheckGroupCollateralCapInput, ab as CheckLeverageBoundsInput, ac as CheckMaxCollateralInput, ad as CheckMinimumPositionSizeInput, ae as CheckOiCapInput, af as CheckSlippageBoundsInput, k as ConstraintCheckResult, ag as checkClosePercentBounds, ah as checkGroupCollateralCap, ai as checkLeverageBounds, aj as checkMaxCollateral, ak as checkMinimumPositionSize, al as checkOiCap, am as checkSlippageBounds } from './types-DDgJiEFg.js';
+import { Price, Leverage, WholePercent, Collateral, SignedP18, SignedP6, FeePercent, UnsignedP18 } from './units.js';
+export { L as LiquidationMarginInput, a as LiquidationPriceInput, M as MarkValueInput, P as PercentProfitInput, U as UnrealizedPnlInput, c as UnrealizedPnlPercentInput, d as currentPercentProfit, l as liquidationMarginRaw, b as liquidationPriceRaw, m as markValueFromPercentProfit, u as unrealizedPnlFromMarkValue, e as unrealizedPnlPercentFromMarkValue } from './position-BnhSFyGe.js';
+import '@domfi/sdk/units';
+import 'viem';
+import '@domfi/sdk/errors';
+import './types-7s13ZSql.js';
+import './errors.js';
+import './referrals.js';
+
+/** Solidity `1e2` scale. Leverage values use this scale: 100 == 1x. */
+declare const PRECISION_2 = 100n;
+/** Solidity `1e6` scale. Percent P6 values use this scale: 1% == 1_000_000. */
+declare const PRECISION_6 = 1000000n;
+/** Solidity `1e12` scale used to convert 1e18 open interest into 1e6 USD notional. */
+declare const PRECISION_12 = 1000000000000n;
+/** Solidity `1e18` scale for contract prices and high-precision ratios. */
+declare const PRECISION_18 = 1000000000000000000n;
+/** TradingCallbacksLib.BASE_SPREAD_P: flat 0.001% execution spread, in 1e18 units. */
+declare const BASE_SPREAD_P = 10000000000000n;
+/** TradingCallbacksLib.MAX_GAIN_P: max 900% PnL cap for TP correction. */
+declare const MAX_GAIN_P = 900n;
+/** Contract commit used to generate the checked-in action-critical vectors. */
+declare const mathParityTarget: "domfi-core@a8bba32d92af1f44ae625e839e4ca420aefe89c2";
+
+/** Inputs for converting a PnL percentage target into a trigger price. */
+type PnlPercentPriceInput = {
+    basePrice: Price;
+    pnlPercent: PercentP6;
+    leverage: Leverage;
+    direction: TradeDirection;
+};
+/** Inputs for converting a price-delta percentage into a trigger price. */
+type PriceDeltaPriceInput = {
+    basePrice: Price;
+    priceDeltaPercent: PercentP6;
+    direction: TradeDirection;
+};
+/** Inputs for computing max take-profit distance. */
+type MaxTpDistanceInput = {
+    openPrice: Price;
+    leverage: Leverage;
+    initialLeverage: Leverage;
+};
+/** Inputs for computing max stop-loss distance. */
+type MaxSlDistanceInput = {
+    openPrice: Price;
+    leverage: Leverage;
+    maxSlP: WholePercent;
+};
+/** Inputs for correcting a take-profit price into protocol bounds. */
+type CorrectTpInput = MaxTpDistanceInput & {
+    takeProfit: Price;
+    direction: TradeDirection;
+};
+/** Inputs for correcting a stop-loss price into protocol bounds. */
+type CorrectSlInput = MaxTpDistanceInput & {
+    stopLoss: Price;
+    direction: TradeDirection;
+    maxSlP: WholePercent;
+};
+/** Violation code returned by trigger price validation. */
+type TriggerPriceViolationCode = "tp_wrong_side" | "tp_exceeds_max_distance" | "sl_wrong_side" | "sl_exceeds_max_distance";
+/** Result of trigger price validation. */
+type TriggerPriceValidationResult = {
+    status: "ok";
+} | {
+    status: "violation";
+    code: TriggerPriceViolationCode;
+    message: string;
+};
+/** Inputs for validating take-profit and stop-loss prices together. */
+type ValidateTriggerPricesInput = MaxTpDistanceInput & {
+    direction: TradeDirection;
+    maxSlP: WholePercent;
+    takeProfit?: Price;
+    stopLoss?: Price;
+};
+/** Convert an unsigned PnL percent target into a TP price using contract integer order. */
+declare function tpPriceFromPnlPercent(input: PnlPercentPriceInput): Price;
+/** Convert an unsigned PnL percent target into an SL price using contract integer order. */
+declare function slPriceFromPnlPercent(input: PnlPercentPriceInput): Price;
+/** Convert an unsigned raw price-delta percent into a TP price. */
+declare function tpPriceFromPriceDelta(input: PriceDeltaPriceInput): Price;
+/** Convert an unsigned raw price-delta percent into an SL price. */
+declare function slPriceFromPriceDelta(input: PriceDeltaPriceInput): Price;
+/** Max TP distance from open, derived from TradingCallbacksLib.correctTp. */
+declare function maxTpDistance(input: MaxTpDistanceInput): Price;
+/** Max SL distance from open, derived from TradingCallbacksLib.correctSl. */
+declare function maxSlDistance(input: MaxSlDistanceInput): Price;
+/** Mirror TradingCallbacksLib.correctTp for client-side action preflight. */
+declare function correctTp(input: CorrectTpInput): Price;
+/** Mirror TradingCallbacksLib.correctSl for client-side action preflight. */
+declare function correctSl(input: CorrectSlInput): Price;
+/** Mirror TradingCallbacksLib.correctToNullSl for client-side action preflight. */
+declare function correctToNullSl(input: CorrectSlInput): Price;
+/** Validate TP/SL side and max-distance constraints without throwing on ordinary violations. */
+declare function validateTriggerPrices(input: ValidateTriggerPricesInput): TriggerPriceValidationResult;
+
+/** Inputs for deriving USD notional from collateral and leverage. */
+type NotionalFromCollateralInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+};
+/** Inputs for deriving minimum collateral from requested USD notional and leverage. */
+type CollateralFromNotionalInput = {
+    notionalUsd: UsdP6;
+    leverage: Leverage;
+};
+/** USD P6 notional from collateral and P2 leverage: collateral * leverage / 100. */
+declare function notionalFromCollateral(input: NotionalFromCollateralInput): UsdP6;
+/** Minimal collateral needed so notionalFromCollateral(result) is at least requested notional. */
+declare function collateralFromNotional(input: CollateralFromNotionalInput): Collateral;
+
+/** Inputs for recomputing leverage after adding collateral. */
+type TopUpLeverageInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    topUpAmount: Collateral;
+};
+/** Inputs for recomputing leverage after removing collateral. */
+type RemoveCollateralLeverageInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    removeAmount: Collateral;
+};
+/** Result of a collateral adjustment leverage recomputation. */
+type CollateralAdjustmentLeverageResult = {
+    /** Leverage of the position after the adjustment. */
+    newLeverage: Leverage;
+    /** Collateral of the position after the adjustment. */
+    newCollateral: Collateral;
+    /** Collateral actually added/removed after the contract's recompute (the wallet delta). */
+    effectiveAmount: Collateral;
+};
+/** Inputs for finding the collateral delta needed to reach a target leverage. */
+type ReachLeverageInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    targetLeverage: Leverage;
+};
+/**
+ * Result of a "reach target leverage" computation.
+ *
+ * `requestedAmount` is the value to pass to `topUpCollateral` / `removeCollateral` on-chain.
+ * The contract may transfer a slightly smaller amount after its leverage recompute, so the
+ * actual collateral delta applied to the position is `effectiveAmount` (and `newLeverage` /
+ * `newCollateral` describe the resulting position). `requestedAmount >= effectiveAmount`.
+ */
+type ReachLeverageResult = CollateralAdjustmentLeverageResult & {
+    /** Amount to pass to `topUpCollateral` / `removeCollateral` on-chain; `>= effectiveAmount`. */
+    requestedAmount: Collateral;
+};
+/** Mirror DomfiTrading.topUpCollateral leverage/collateral recomputation including +1 remainder rule. */
+declare function leverageAfterTopUp(input: TopUpLeverageInput): CollateralAdjustmentLeverageResult;
+/**
+ * Collateral to add so a position's leverage drops to (at most) targetLeverage.
+ *
+ * Adding collateral lowers leverage, so targetLeverage must be below the current leverage.
+ * Returns the minimal {@link ReachLeverageResult.requestedAmount} to submit to
+ * `topUpCollateral`; the resulting leverage never exceeds targetLeverage. The canonical
+ * recompute is delegated to {@link leverageAfterTopUp}, so the outcome mirrors
+ * DomfiTrading.topUpCollateral exactly (including the +1 remainder rule).
+ *
+ * Note: leverage is quantized, so with small collateral the nearest achievable leverage may be
+ * strictly below targetLeverage. Protocol min/max leverage is not enforced here; use the
+ * constraint checks for that.
+ */
+declare function topUpToReachLeverage(input: ReachLeverageInput): ReachLeverageResult;
+/**
+ * Collateral that can be removed so a position's leverage rises to (at most) targetLeverage.
+ *
+ * Removing collateral raises leverage, so targetLeverage must be above the current leverage.
+ * Returns the maximum safe {@link ReachLeverageResult.requestedAmount} to submit to
+ * `removeCollateral` — the removal whose resulting leverage is closest to, but never above,
+ * targetLeverage. The canonical recompute is delegated to {@link leverageAfterRemoveCollateral},
+ * so the outcome mirrors DomfiTrading.removeCollateral exactly.
+ *
+ * Throws when no removal reaches above the current leverage without exceeding targetLeverage
+ * (leverage is quantized, so adjacent targets can be unreachable). Protocol min/max leverage is
+ * not enforced here; use the constraint checks for that.
+ */
+declare function removeCollateralToReachLeverage(input: ReachLeverageInput): ReachLeverageResult;
+/** Mirror DomfiTrading.removeCollateral leverage/collateral recomputation with no +1 remainder rule. */
+declare function leverageAfterRemoveCollateral(input: RemoveCollateralLeverageInput): CollateralAdjustmentLeverageResult;
+
+/** Inputs for computing a raw position funding fee from cumulative funding values. */
+type PositionFundingFeeInput = {
+    initialAccFunding: SignedP18;
+    endAccFunding: SignedP18;
+    collateral: Collateral;
+    leverage: Leverage;
+};
+/** Computes the raw signed funding fee using contract integer ordering. */
+declare function positionFundingFeeRaw(input: PositionFundingFeeInput): bigint;
+
+/** Inputs for a flat single-rate trade fee calculation. */
+type TradeFeeInput = {
+    collateral: Collateral;
+    leverage: Leverage;
+    feeP: FeePercent;
+};
+/**
+ * Flat single-rate trade fee from collateral, leverage, and one known fee percent. This is a
+ * guarded convenience helper (rejects non-positive leverage); use {@link openingFee} for the
+ * exact maker/taker model, which mirrors the contract view including its zero-leverage behavior.
+ */
+declare function tradeFee(input: TradeFeeInput): Collateral;
+/** Inputs for the maker/taker opening-fee calculation. */
+type OpeningFeeInput = {
+    /** Signed P6 USD notional of the trade (long open positive, short open negative). */
+    tradeSize: SignedP6;
+    /** Signed P6 USD open-interest imbalance (oiLong - oiShort). */
+    oiDelta: SignedP6;
+    leverage: Leverage;
+    makerFeeP: FeePercent;
+    takerFeeP: FeePercent;
+    makerMaxLeverage: Leverage;
+};
+/**
+ * Maker/taker opening fee, mirroring DomfiPairInfos._getBaseOpeningFee. Returns the total base
+ * fee the trader pays; the contract's dev/vault split is an allocation of this same amount.
+ *
+ * When the trade reduces the OI imbalance (`oiDelta * tradeSize < 0`) and `leverage` is within
+ * `makerMaxLeverage`, the imbalance-reducing portion is charged `makerFeeP`; any portion that
+ * overshoots zero imbalance is charged `takerFeeP`. Otherwise the whole notional is taker. The
+ * same function computes closing fees: pass the closing fee params and the inverted tradeSize
+ * sign convention (long close negative, short close positive).
+ */
+declare function openingFee(input: OpeningFeeInput): Collateral;
+
+/** Inputs for contract-parity execution price impact calculation. */
+type PriceImpactInput = {
+    price: Price;
+    /**
+     * Raw on-chain open interest (1e18 token notional). Source from `marketState.rawState.oiLong` /
+     * `oiShort` — NOT the display `longOpenInterest` / `shortOpenInterest`.
+     */
+    oiLong: UnsignedP18;
+    oiShort: UnsignedP18;
+    collateral: Collateral;
+    leverage: Leverage;
+    isOpen: boolean;
+    isLong: boolean;
+};
+/** Result of execution price impact calculation. */
+type PriceImpactResult = {
+    /**
+     * Spread-adjusted execution price. For opens this is the price the contract stores as
+     * `openPrice`; for closes it is the execution price used to settle the close.
+     */
+    priceAfterImpact: Price;
+    /**
+     * Price-impact magnitude in the contract's guard scale (`withinMaxNegativePnlOnOpenP`):
+     * `|price - priceAfterImpact| * 1e20 / price`. Here 1% impact == 1e18 and 100% == 1e20.
+     */
+    priceImpactP: bigint;
+};
+/**
+ * Execution price after spread — a verbatim mirror of TradingCallbacksLib.getTradePriceImpact.
+ *
+ * NOTE: at the pinned contract commit the OI-skew scaling is inert. Integer truncation collapses
+ * `skew` to {-1, 0, 1} and the multiplier to 1, so the spread is a flat 0.001% (BASE_SPREAD_P)
+ * applied against the trader regardless of open interest. The oiLong/oiShort/collateral/leverage
+ * inputs therefore do not affect the result today; they are retained for exact parity and so this
+ * helper tracks the contract automatically if the skew bug is fixed.
+ */
+declare function priceImpact(input: PriceImpactInput): PriceImpactResult;
+
+export { BASE_SPREAD_P, type CollateralAdjustmentLeverageResult, type CollateralFromNotionalInput, type CorrectSlInput, type CorrectTpInput, MAX_GAIN_P, type MaxSlDistanceInput, type MaxTpDistanceInput, type NotionalFromCollateralInput, type OpeningFeeInput, PRECISION_12, PRECISION_18, PRECISION_2, PRECISION_6, PercentP6, type PnlPercentPriceInput, type PositionFundingFeeInput, type PriceDeltaPriceInput, type PriceImpactInput, type PriceImpactResult, type ReachLeverageInput, type ReachLeverageResult, type RemoveCollateralLeverageInput, type TopUpLeverageInput, type TradeFeeInput, type TriggerPriceValidationResult, type TriggerPriceViolationCode, UsdP6, type ValidateTriggerPricesInput, collateralFromNotional, correctSl, correctToNullSl, correctTp, leverageAfterRemoveCollateral, leverageAfterTopUp, mathParityTarget, maxSlDistance, maxTpDistance, notionalFromCollateral, openingFee, positionFundingFeeRaw, priceImpact, removeCollateralToReachLeverage, slPriceFromPnlPercent, slPriceFromPriceDelta, topUpToReachLeverage, tpPriceFromPnlPercent, tpPriceFromPriceDelta, tradeFee, validateTriggerPrices };

package/dist/math.js

@@ -0,0 +1 @@
+export{a as positionFundingFeeRaw}from'./chunk-CLOFJTBP.js';export{k as PercentP6,l as UsdP6,g as checkClosePercentBounds,e as checkGroupCollateralCap,a as checkLeverageBounds,c as checkMaxCollateral,b as checkMinimumPositionSize,d as checkOiCap,f as checkSlippageBounds,o as collateralFromNotional,w as correctSl,x as correctToNullSl,v as correctTp,u as maxSlDistance,t as maxTpDistance,n as notionalFromCollateral,i as openingFee,m as parseUnsignedPercentToP6,j as priceImpact,q as slPriceFromPnlPercent,s as slPriceFromPriceDelta,p as tpPriceFromPnlPercent,r as tpPriceFromPriceDelta,h as tradeFee,y as validateTriggerPrices}from'./chunk-7OVWNPZQ.js';import {h,j,b}from'./chunk-SZE5DE54.js';export{e as BASE_SPREAD_P,f as MAX_GAIN_P,c as PRECISION_12,d as PRECISION_18,a as PRECISION_2,b as PRECISION_6,k as currentPercentProfit,m as liquidationMarginRaw,n as liquidationPriceRaw,l as markValueFromPercentProfit,g as mathParityTarget,o as unrealizedPnlFromMarkValue,p as unrealizedPnlPercentFromMarkValue}from'./chunk-SZE5DE54.js';import {g,k}from'./chunk-C5Y2WM7C.js';function w(r){let e=g.toRaw(r.collateral),l=k.toRaw(r.leverage),a=g.toRaw(r.topUpAmount);h(e,"collateral"),h(l,"leverage"),h(a,"topUpAmount");let m=j(e,l,100n),t=e+a,c=m*b,i=t*10000n,g$1=c/i,p=a;if(g$1<=0n)throw new Error("newLeverage must be positive");if(c%i!==0n){if(g$1+=1n,t=m*100n/g$1,t<=e)throw new Error("topUpAmount cannot produce valid collateral");p=t-e;}return {newLeverage:k.fromRaw(g$1),newCollateral:g.fromRaw(t),effectiveAmount:g.fromRaw(p)}}function te(r){let e=g.toRaw(r.collateral),l=k.toRaw(r.leverage),a=k.toRaw(r.targetLeverage);if(h(e,"collateral"),h(l,"leverage"),h(a,"targetLeverage"),a>=l)throw new Error("targetLeverage must be below current leverage to add collateral");let t=j(e,l,100n)*100n,c=t/(e+1n),i=a<c?a:c;if(i<=0n)throw new Error("targetLeverage not reachable by adding collateral");let p=j(t,1n,i)-e;if(p<=0n)throw new Error("targetLeverage not reachable by adding collateral");return {...w({collateral:r.collateral,leverage:r.leverage,topUpAmount:g.fromRaw(p)}),requestedAmount:g.fromRaw(p)}}function ae(r){let e=g.toRaw(r.collateral),l=k.toRaw(r.leverage),a=k.toRaw(r.targetLeverage);if(h(e,"collateral"),h(l,"leverage"),h(a,"targetLeverage"),a<=l)throw new Error("targetLeverage must be above current leverage to remove collateral");let t=j(e,l,100n)*100n,c=t/(a+1n)+1n,i=e-c;if(i<=0n)throw new Error("targetLeverage not reachable by removing collateral");let g$1=t/c;if(g$1<=l)throw new Error("targetLeverage not reachable by removing collateral");if(t%c!==0n&&t/g$1>=e)throw new Error("targetLeverage not reachable by removing collateral");return {...C({collateral:r.collateral,leverage:r.leverage,removeAmount:g.fromRaw(i)}),requestedAmount:g.fromRaw(i)}}function C(r){let e=g.toRaw(r.collateral),l=k.toRaw(r.leverage),a=g.toRaw(r.removeAmount);if(h(e,"collateral"),h(l,"leverage"),h(a,"removeAmount"),a>=e)throw new Error("removeAmount must be below collateral");let m=j(e,l,100n),t=e-a,c=m*b,i=t*10000n,g$1=c/i,p=a;if(g$1<=0n)throw new Error("newLeverage must be positive");if(c%i!==0n){if(t=m*100n/g$1,t>=e)throw new Error("removeAmount cannot produce valid collateral");p=e-t;}return {newLeverage:k.fromRaw(g$1),newCollateral:g.fromRaw(t),effectiveAmount:g.fromRaw(p)}}export{C as leverageAfterRemoveCollateral,w as leverageAfterTopUp,ae as removeCollateralToReachLeverage,te as topUpToReachLeverage};

package/dist/position-BnhSFyGe.d.cts

@@ -0,0 +1,56 @@
+/** Raw protocol inputs for current percent-profit calculation. */
+type PercentProfitInput = {
+    openPriceRaw: bigint;
+    markPriceRaw: bigint;
+    buy: boolean;
+    leverageRaw: bigint | number;
+    initialLeverageRaw: bigint | number;
+};
+/** Raw protocol inputs for mark-value calculation. */
+type MarkValueInput = {
+    collateralRaw: bigint;
+    percentProfitRaw: bigint;
+    fundingFeeRaw: bigint;
+    liquidationMarginRaw: bigint;
+};
+/** Raw protocol inputs for liquidation-margin calculation. */
+type LiquidationMarginInput = {
+    collateralRaw: bigint;
+    leverageRaw: bigint | number;
+    maxLeverageRaw: bigint | number;
+    liqMarginThresholdP: bigint | number;
+};
+/** Raw protocol inputs for liquidation-price calculation. */
+type LiquidationPriceInput = LiquidationMarginInput & {
+    openPriceRaw: bigint;
+    buy: boolean;
+    fundingFeeRaw: bigint;
+};
+/** Raw protocol inputs for unrealized PnL calculation. */
+type UnrealizedPnlInput = {
+    collateralRaw: bigint;
+    markValueRaw: bigint;
+};
+/** Raw protocol inputs for unrealized PnL percentage calculation. */
+type UnrealizedPnlPercentInput = {
+    collateralRaw: bigint;
+    markValueRaw: bigint;
+};
+/** Computes current percent profit in P6 percent scale, capped at protocol max gain. */
+declare function currentPercentProfit(input: PercentProfitInput): bigint;
+/** Computes mark value after percent profit, funding fee, and liquidation-margin floor. */
+declare function markValueFromPercentProfit(input: MarkValueInput): bigint;
+/** Computes DomfiPairInfos.getTradeLiquidationMargin with Solidity integer rounding. */
+declare function liquidationMarginRaw(input: LiquidationMarginInput): bigint;
+/** Computes DomfiPairInfos.getTradeLiquidationPricePure with Solidity integer rounding. */
+declare function liquidationPriceRaw(input: LiquidationPriceInput): bigint;
+/** Computes raw unrealized PnL from mark value and collateral. */
+declare function unrealizedPnlFromMarkValue(input: UnrealizedPnlInput): bigint;
+/**
+ * Net unrealized PnL as a signed percent of collateral in P6 scale (1% == 1_000_000), floored
+ * at -100%. Because markValueFromPercentProfit already nets funding (and floors to zero at the
+ * liquidation margin), this percent likewise reflects funding and bottoms out at a total loss.
+ */
+declare function unrealizedPnlPercentFromMarkValue(input: UnrealizedPnlPercentInput): bigint;
+
+export { type LiquidationMarginInput as L, type MarkValueInput as M, type PercentProfitInput as P, type UnrealizedPnlInput as U, type LiquidationPriceInput as a, liquidationPriceRaw as b, type UnrealizedPnlPercentInput as c, currentPercentProfit as d, unrealizedPnlPercentFromMarkValue as e, liquidationMarginRaw as l, markValueFromPercentProfit as m, unrealizedPnlFromMarkValue as u };

package/dist/position-BnhSFyGe.d.ts

@@ -0,0 +1,56 @@
+/** Raw protocol inputs for current percent-profit calculation. */
+type PercentProfitInput = {
+    openPriceRaw: bigint;
+    markPriceRaw: bigint;
+    buy: boolean;
+    leverageRaw: bigint | number;
+    initialLeverageRaw: bigint | number;
+};
+/** Raw protocol inputs for mark-value calculation. */
+type MarkValueInput = {
+    collateralRaw: bigint;
+    percentProfitRaw: bigint;
+    fundingFeeRaw: bigint;
+    liquidationMarginRaw: bigint;
+};
+/** Raw protocol inputs for liquidation-margin calculation. */
+type LiquidationMarginInput = {
+    collateralRaw: bigint;
+    leverageRaw: bigint | number;
+    maxLeverageRaw: bigint | number;
+    liqMarginThresholdP: bigint | number;
+};
+/** Raw protocol inputs for liquidation-price calculation. */
+type LiquidationPriceInput = LiquidationMarginInput & {
+    openPriceRaw: bigint;
+    buy: boolean;
+    fundingFeeRaw: bigint;
+};
+/** Raw protocol inputs for unrealized PnL calculation. */
+type UnrealizedPnlInput = {
+    collateralRaw: bigint;
+    markValueRaw: bigint;
+};
+/** Raw protocol inputs for unrealized PnL percentage calculation. */
+type UnrealizedPnlPercentInput = {
+    collateralRaw: bigint;
+    markValueRaw: bigint;
+};
+/** Computes current percent profit in P6 percent scale, capped at protocol max gain. */
+declare function currentPercentProfit(input: PercentProfitInput): bigint;
+/** Computes mark value after percent profit, funding fee, and liquidation-margin floor. */
+declare function markValueFromPercentProfit(input: MarkValueInput): bigint;
+/** Computes DomfiPairInfos.getTradeLiquidationMargin with Solidity integer rounding. */
+declare function liquidationMarginRaw(input: LiquidationMarginInput): bigint;
+/** Computes DomfiPairInfos.getTradeLiquidationPricePure with Solidity integer rounding. */
+declare function liquidationPriceRaw(input: LiquidationPriceInput): bigint;
+/** Computes raw unrealized PnL from mark value and collateral. */
+declare function unrealizedPnlFromMarkValue(input: UnrealizedPnlInput): bigint;
+/**
+ * Net unrealized PnL as a signed percent of collateral in P6 scale (1% == 1_000_000), floored
+ * at -100%. Because markValueFromPercentProfit already nets funding (and floors to zero at the
+ * liquidation margin), this percent likewise reflects funding and bottoms out at a total loss.
+ */
+declare function unrealizedPnlPercentFromMarkValue(input: UnrealizedPnlPercentInput): bigint;
+
+export { type LiquidationMarginInput as L, type MarkValueInput as M, type PercentProfitInput as P, type UnrealizedPnlInput as U, type LiquidationPriceInput as a, liquidationPriceRaw as b, type UnrealizedPnlPercentInput as c, currentPercentProfit as d, unrealizedPnlPercentFromMarkValue as e, liquidationMarginRaw as l, markValueFromPercentProfit as m, unrealizedPnlFromMarkValue as u };