@panoptic-eng/sdk 1.0.38 → 1.0.40

package/dist/panoptic/v2/greeks/index.js

@@ -1,3 +1,621 @@
-import { calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLoanEffectiveDelta, isCall, isDefinedRisk, toVaultFrameAtTick } from "../../../greeks-GysWXct-.js";
+//#region src/panoptic/v2/utils/constants.ts
+/**
+* Constants for the Panoptic v2 SDK.
+* @module v2/utils/constants
+*/
+/**
+* WAD constant (10^18) used for fixed-point arithmetic.
+* Commonly used for spread calculations and other WAD-scaled values.
+*/
+const WAD = 10n ** 18n;
+/**
+* Minimum tick value for Uniswap v3/v4 pools.
+*/
+const MIN_TICK = -887272n;
+/**
+* Maximum tick value for Uniswap v3/v4 pools.
+*/
+const MAX_TICK = 887272n;
 
-export { calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLoanEffectiveDelta, isCall, isDefinedRisk, toVaultFrameAtTick };
+//#endregion
+//#region src/panoptic/v2/formatters/tick.ts
+const Q192$1 = 1n << 192n;
+function tickToSqrtPriceX96(tick) {
+	if (tick < MIN_TICK || tick > MAX_TICK) throw new RangeError("Tick out of bounds");
+	const absTick = tick < 0n ? -tick : tick;
+	let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
+	if ((absTick & 0x2n) !== 0n) ratio = ratio * 0xfff97272373d413259a46990580e213an >> 128n;
+	if ((absTick & 0x4n) !== 0n) ratio = ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn >> 128n;
+	if ((absTick & 0x8n) !== 0n) ratio = ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n >> 128n;
+	if ((absTick & 0x10n) !== 0n) ratio = ratio * 0xffcb9843d60f6159c9db58835c926644n >> 128n;
+	if ((absTick & 0x20n) !== 0n) ratio = ratio * 0xff973b41fa98c081472e6896dfb254c0n >> 128n;
+	if ((absTick & 0x40n) !== 0n) ratio = ratio * 0xff2ea16466c96a3843ec78b326b52861n >> 128n;
+	if ((absTick & 0x80n) !== 0n) ratio = ratio * 0xfe5dee046a99a2a811c461f1969c3053n >> 128n;
+	if ((absTick & 0x100n) !== 0n) ratio = ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n >> 128n;
+	if ((absTick & 0x200n) !== 0n) ratio = ratio * 0xf987a7253ac413176f2b074cf7815e54n >> 128n;
+	if ((absTick & 0x400n) !== 0n) ratio = ratio * 0xf3392b0822b70005940c7a398e4b70f3n >> 128n;
+	if ((absTick & 0x800n) !== 0n) ratio = ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n >> 128n;
+	if ((absTick & 0x1000n) !== 0n) ratio = ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n >> 128n;
+	if ((absTick & 0x2000n) !== 0n) ratio = ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n >> 128n;
+	if ((absTick & 0x4000n) !== 0n) ratio = ratio * 0x70d869a156d2a1b890bb3df62baf32f7n >> 128n;
+	if ((absTick & 0x8000n) !== 0n) ratio = ratio * 0x31be135f97d08fd981231505542fcfa6n >> 128n;
+	if ((absTick & 0x10000n) !== 0n) ratio = ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n >> 128n;
+	if ((absTick & 0x20000n) !== 0n) ratio = ratio * 0x5d6af8dedb81196699c329225ee604n >> 128n;
+	if ((absTick & 0x40000n) !== 0n) ratio = ratio * 0x2216e584f5fa1ea926041bedfe98n >> 128n;
+	if ((absTick & 0x80000n) !== 0n) ratio = ratio * 0x48a170391f7dc42444e8fa2n >> 128n;
+	if (tick > 0n) ratio = ((1n << 256n) - 1n) / ratio;
+	const remainderMask = (1n << 32n) - 1n;
+	const sqrtPriceX96 = (ratio >> 32n) + ((ratio & remainderMask) === 0n ? 0n : 1n);
+	return sqrtPriceX96;
+}
+const MIN_SQRT_PRICE_X96 = tickToSqrtPriceX96(MIN_TICK);
+const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
+
+//#endregion
+//#region src/panoptic/v2/greeks/index.ts
+/** Fixed-point scale constants for sqrtPriceX96 arithmetic */
+const Q96 = 1n << 96n;
+const Q192 = 1n << 192n;
+/**
+* Convert tick to quote-denominated tick based on asset direction.
+*
+* When isAssetToken0 = true (asset is token0, numeraire is token1):
+* - Tick already encodes price as token1/token0 (numeraire per asset)
+* - Return tick unchanged
+*
+* When isAssetToken0 = false (asset is token1, numeraire is token0):
+* - Tick encodes price as token1/token0, but we need token0/token1 (numeraire per asset)
+* - Invert by negating: 1/price = 1.0001^(-tick)
+*/
+function quoteTick(tick, isAssetToken0) {
+	return isAssetToken0 ? tick : -tick;
+}
+/**
+* Divide with truncation toward zero (matches Solidity division behavior).
+*
+* JavaScript bigint division uses floor (toward negative infinity), but Solidity
+* truncates toward zero. For on-chain fidelity, we must match Solidity.
+*
+* Example:
+* - Solidity: -7 / 2 = -3 (truncate toward zero)
+* - JS bigint: -7n / 2n = -4n (floor toward -∞)
+* - This function: divTrunc(-7n, 2n) = -3n ✓
+*/
+function divTrunc(numerator, denominator) {
+	if (denominator === 0n) return 0n;
+	const quotient = numerator / denominator;
+	const remainder = numerator % denominator;
+	if (numerator < 0n !== denominator < 0n && remainder !== 0n) return quotient + 1n;
+	return quotient;
+}
+/** Resolve isAssetToken0: optional assetIndex overrides leg.asset */
+function resolveAssetDirection(leg, assetIndex) {
+	return assetIndex !== void 0 ? assetIndex === 0n : leg.asset === 0n;
+}
+/**
+* Compute the tokenType-denominated notional of a width=0 (loan/credit) leg.
+*
+* When leg.asset !== leg.tokenType, positionSize is in leg.asset units and
+* the borrowed notional is encoded via leg.strike: notional_tokenType_raw =
+* positionSize_raw × 1.0001^strike (a raw-to-raw ratio, unquoted by pool direction).
+* When leg.asset === leg.tokenType, m is already the notional (old convention).
+*
+* `m > 0` for loans (isLong=false), `m < 0` for credits (isLong=true), so the
+* returned notional is signed the same way.
+*/
+function computeWidth0Notional(leg, m) {
+	const scaleByStrike = leg.asset !== leg.tokenType;
+	if (!scaleByStrike) return m;
+	const signedStrike = leg.asset === 0n ? leg.strike : -leg.strike;
+	const sqrtKraw = tickToSqrtPriceX96(signedStrike);
+	const KrawX192 = sqrtKraw * sqrtKraw;
+	return divTrunc(m * KrawX192, Q192);
+}
+/**
+* Calculate value for a width=0 (loan/credit) leg.
+* Width=0 means the range is a single tick (the strike), so there's no meaningful
+* "in range" — we use the below/above formulas which avoid division by (r-1)=0.
+*
+* This is the DEBT-ONLY value (the borrowed/lent obligation), used by delta/greeks
+* aggregation where the held-collateral side lives in a separate wallet/CT term. For
+* a standalone payoff chart that must reflect the net user-experienced payoff (which
+* depends on Zap vs Cover-at-mint), use `getLegNetValueWidth0`.
+*/
+function getLegValueWidth0(leg, m, qCurrentTick, qStrikeTick, qMintTick, isAssetToken0, _definedRisk) {
+	const borrowsAsset = isCall(leg.tokenType, isAssetToken0);
+	const notional = computeWidth0Notional(leg, m);
+	if (borrowsAsset) {
+		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
+		const sqrtPm = tickToSqrtPriceX96(qMintTick);
+		const PX192 = sqrtP * sqrtP;
+		const PmX192 = sqrtPm * sqrtPm;
+		return divTrunc(-notional * (PX192 - PmX192), Q192);
+	} else return 0n;
+}
+/**
+* Calculate the NET (user-experienced) payoff value for a width=0 (loan/credit) leg.
+*
+* Unlike `getLegValueWidth0` (debt-only), this includes the collateral/holding side and
+* therefore depends on how the position was opened:
+*
+* - **Cover at mint** (`swapAtMint = false`): the collateral is sourced in the SAME token as
+*   the debt/credit, so the holding side exactly offsets it → net PnL is FLAT (0 everywhere,
+*   mint-relative), regardless of which token the leg is denominated in.
+* - **Zap** (`swapAtMint = true`): the collateral is sourced in the OTHER token, leaving a
+*   ±1-delta line in the asset (ETH), anchored to 0 at the mint price:
+*     - USDC loan  → zap to ETH:   +1 (long ETH)
+*     - ETH  loan  → zap to USDC:  −1 (short ETH)
+*     - USDC credit ← zap from ETH: −1 (short ETH)
+*     - ETH  credit ← zap from USDC: +1 (long ETH)
+*
+* @returns Net leg value in numeraire token smallest units (mint-relative PnL).
+*/
+function getLegNetValueWidth0(leg, m, qCurrentTick, qMintTick, isAssetToken0, swapAtMint, itmOffsetNotional = 0n) {
+	if (!swapAtMint) return 0n;
+	const borrowsAsset = isCall(leg.tokenType, isAssetToken0);
+	const notional = computeWidth0Notional(leg, m) + itmOffsetNotional;
+	const sqrtP = tickToSqrtPriceX96(qCurrentTick);
+	const sqrtPm = tickToSqrtPriceX96(qMintTick);
+	const PX192 = sqrtP * sqrtP;
+	const PmX192 = sqrtPm * sqrtPm;
+	if (borrowsAsset) return divTrunc(-notional * (PX192 - PmX192), Q192);
+	return divTrunc(notional * PX192, PmX192) - notional;
+}
+/**
+* Compute the mint-time ITM (in-the-money) adjustment for an option leg.
+*
+* This is the `itm` baseline used by {@link getLegValue}: the amount by which the
+* position was already ITM at mint, expressed in the leg's natural units:
+* - Puts: numeraire units (added directly to the put's `debt*K + v` value).
+* - Calls: asset-ratio units (the call value multiplies it by price: `itm*P`/`itm*Pm`).
+*
+* Extracted so callers (e.g. {@link calculatePositionValue}) can build a per-side ITM
+* notional pool to net width=0 credit/loan legs against — an ITM-neutralizing credit
+* was sized to offset exactly this amount, so it should not add a spurious swap line.
+*/
+function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
+	if (isPut) {
+		if (qMintTick < qStrikeTick - halfWidthTick) {
+			const sqrtK$1 = tickToSqrtPriceX96(qStrikeTick);
+			const sqrtPm$2 = tickToSqrtPriceX96(qMintTick);
+			const KX192 = sqrtK$1 * sqrtK$1;
+			const PmX192 = sqrtPm$2 * sqrtPm$2;
+			return divTrunc(m * (KX192 - PmX192), Q192);
+		} else if (qMintTick > qStrikeTick + halfWidthTick) return 0n;
+		const sqrtKR = tickToSqrtPriceX96(qStrikeTick + halfWidthTick);
+		const sqrtPm$1 = tickToSqrtPriceX96(qMintTick);
+		const sqrtR$1 = tickToSqrtPriceX96(halfWidthTick);
+		const rX192$1 = sqrtR$1 * sqrtR$1;
+		const diff$1 = sqrtKR - sqrtPm$1;
+		const diffSqX192$1 = diff$1 * diff$1;
+		return divTrunc(m * diffSqX192$1, rX192$1 - Q192);
+	}
+	if (qMintTick < qStrikeTick - halfWidthTick) return 0n;
+	else if (qMintTick > qStrikeTick + halfWidthTick) {
+		const sqrtK$1 = tickToSqrtPriceX96(qStrikeTick);
+		const sqrtPm$1 = tickToSqrtPriceX96(qMintTick);
+		const KX192 = sqrtK$1 * sqrtK$1;
+		const PmX192 = sqrtPm$1 * sqrtPm$1;
+		return divTrunc(m * (PmX192 - KX192), PmX192);
+	}
+	const sqrtR = tickToSqrtPriceX96(halfWidthTick);
+	const sqrtK = tickToSqrtPriceX96(qStrikeTick);
+	const sqrtPm = tickToSqrtPriceX96(qMintTick);
+	const rX192 = sqrtR * sqrtR;
+	const sqrtKPmX96 = divTrunc(sqrtK * Q96, sqrtPm);
+	const diff = sqrtR - sqrtKPmX96;
+	const diffSqX192 = diff * diff;
+	return divTrunc(m * diffSqX192, rX192 - Q192);
+}
+/**
+* Check if leg is a call option (vs put).
+*
+* A call is when the leg moves the asset token:
+* - If asset is token0: call when tokenType=0
+* - If asset is token1: call when tokenType=1
+*/
+function isCall(tokenType, isAssetToken0) {
+	return isAssetToken0 ? tokenType === 0n : tokenType === 1n;
+}
+/**
+* Check if position has defined risk (is a spread).
+*
+* A position is defined risk if it has 2+ legs of the same tokenType
+* with both long and short exposure.
+*/
+function isDefinedRisk(legs) {
+	if (legs.length < 2) return false;
+	for (const tt of [0n, 1n]) {
+		const group = legs.filter((l) => l.tokenType === tt);
+		if (group.length >= 2 && group.some((l) => l.isLong) && group.some((l) => !l.isLong)) return true;
+	}
+	return false;
+}
+/**
+* Calculate the value of a single leg.
+*
+* Value represents the current P&L of the position in numeraire token units.
+* Combines base value (from Panoptic's piecewise formula), debt, and ITM adjustment.
+*
+* Uses sqrtPriceX96 for all calculations to maintain precision and on-chain fidelity.
+*
+* @param leg - The leg to calculate
+* @param currentTick - Current pool tick
+* @param mintTick - Tick at position mint
+* @param positionSize - Position size in asset token smallest units
+* @param poolTickSpacing - Pool tick spacing
+* @param definedRisk - Whether position is defined risk
+* @param assetIndex - Optional override for leg.asset (0n = token0 is asset, 1n = token1)
+* @returns Leg value in numeraire token smallest units
+*/
+function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing, definedRisk, assetIndex, swapAtMint) {
+	const isAssetToken0 = resolveAssetDirection(leg, assetIndex);
+	const qCurrentTick = quoteTick(currentTick, isAssetToken0);
+	const qMintTick = quoteTick(mintTick, isAssetToken0);
+	const qStrikeTick = quoteTick(leg.strike, isAssetToken0);
+	const halfWidthTick = leg.width * poolTickSpacing / 2n;
+	const m = leg.isLong ? -(positionSize * leg.optionRatio) : positionSize * leg.optionRatio;
+	if (leg.width === 0n && swapAtMint !== void 0) return getLegNetValueWidth0(leg, m, qCurrentTick, qMintTick, isAssetToken0, swapAtMint);
+	if (halfWidthTick === 0n) return getLegValueWidth0(leg, m, qCurrentTick, qStrikeTick, qMintTick, isAssetToken0, definedRisk);
+	let v;
+	if (qCurrentTick < qStrikeTick - halfWidthTick) {
+		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
+		const PX192 = sqrtP * sqrtP;
+		v = divTrunc(m * PX192, Q192);
+	} else if (qCurrentTick > qStrikeTick + halfWidthTick) {
+		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
+		const KX192 = sqrtK * sqrtK;
+		v = divTrunc(m * KX192, Q192);
+	} else {
+		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
+		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
+		const sqrtPKR = tickToSqrtPriceX96(qCurrentTick + qStrikeTick + halfWidthTick);
+		const sqrtR = tickToSqrtPriceX96(halfWidthTick);
+		const PX192 = sqrtP * sqrtP;
+		const KX192 = sqrtK * sqrtK;
+		const rX192 = sqrtR * sqrtR;
+		const numerator = m * (2n * sqrtPKR * Q96 - PX192 - KX192);
+		const denominator = rX192 - Q192;
+		v = divTrunc(numerator, denominator);
+	}
+	const debt = -m;
+	const isPut = !isCall(leg.tokenType, isAssetToken0);
+	const itm = computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut);
+	if (isPut) {
+		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
+		const KX192 = sqrtK * sqrtK;
+		const debtK = divTrunc(debt * KX192, Q192);
+		return debtK + v + itm;
+	} else {
+		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
+		const PX192 = sqrtP * sqrtP;
+		const debtP = divTrunc(debt * PX192, Q192);
+		if (definedRisk) {
+			const sqrtPm = tickToSqrtPriceX96(qMintTick);
+			const PmX192 = sqrtPm * sqrtPm;
+			const itmPm = divTrunc(itm * PmX192, Q192);
+			return debtP + v + itmPm;
+		} else {
+			const itmP = divTrunc(itm * PX192, Q192);
+			return debtP + v + itmP;
+		}
+	}
+}
+/**
+* Calculate the delta of a single leg.
+*
+* Delta is the rate of change of position value with respect to price.
+* For puts: delta = vDelta
+* For calls: delta = debtDelta + vDelta + itmDelta (if not defined risk)
+*
+* Uses sqrtPriceX96 for all price calculations to maintain precision.
+*
+* @param leg - The leg to calculate
+* @param currentTick - Current pool tick
+* @param positionSize - Position size in asset token smallest units
+* @param poolTickSpacing - Pool tick spacing
+* @param mintTick - Tick at mint (optional, for ITM adjustment)
+* @param definedRisk - Whether position is defined risk
+* @param assetIndex - Optional override for leg.asset (0n = token0 is asset, 1n = token1)
+* @returns Leg delta in asset token smallest units
+*/
+function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick, definedRisk, assetIndex) {
+	const isAssetToken0 = resolveAssetDirection(leg, assetIndex);
+	const qCurrentTick = quoteTick(currentTick, isAssetToken0);
+	const qStrikeTick = quoteTick(leg.strike, isAssetToken0);
+	const halfWidthTick = leg.width * poolTickSpacing / 2n;
+	const m = leg.isLong ? -(positionSize * leg.optionRatio) : positionSize * leg.optionRatio;
+	if (leg.width === 0n) {
+		const borrowsAsset = isAssetToken0 ? leg.tokenType === 0n : leg.tokenType === 1n;
+		if (!borrowsAsset) return 0n;
+		if (leg.asset === leg.tokenType) return -m;
+		const signedStrike = leg.asset === 0n ? leg.strike : -leg.strike;
+		const sqrtKraw = tickToSqrtPriceX96(signedStrike);
+		const KrawX192 = sqrtKraw * sqrtKraw;
+		const notional = divTrunc(m * KrawX192, Q192);
+		return -notional;
+	}
+	if (halfWidthTick === 0n) {
+		const vDelta$1 = qCurrentTick <= qStrikeTick ? m : 0n;
+		const isPut$1 = !isCall(leg.tokenType, isAssetToken0);
+		if (isPut$1) return vDelta$1;
+		const debtDelta$1 = -m;
+		let itmDelta$1 = 0n;
+		if (mintTick !== void 0 && !definedRisk) {
+			const qMintTick = quoteTick(mintTick, isAssetToken0);
+			if (qMintTick > qStrikeTick) {
+				const sqrtPm = tickToSqrtPriceX96(qMintTick);
+				const sqrtK = tickToSqrtPriceX96(qStrikeTick);
+				const PmX192 = sqrtPm * sqrtPm;
+				const KX192 = sqrtK * sqrtK;
+				itmDelta$1 = divTrunc((PmX192 - KX192) * m, PmX192);
+			}
+		}
+		return definedRisk ? debtDelta$1 + vDelta$1 : debtDelta$1 + vDelta$1 + itmDelta$1;
+	}
+	let vDelta;
+	if (qCurrentTick < qStrikeTick - halfWidthTick) vDelta = m;
+	else if (qCurrentTick > qStrikeTick + halfWidthTick) vDelta = 0n;
+	else {
+		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
+		const sqrtKR = tickToSqrtPriceX96(qStrikeTick + halfWidthTick);
+		const sqrtR = tickToSqrtPriceX96(halfWidthTick);
+		const rX192 = sqrtR * sqrtR;
+		const numerator = m * (sqrtKR - sqrtP) * Q192;
+		const denominator = sqrtP * (rX192 - Q192);
+		vDelta = divTrunc(numerator, denominator);
+	}
+	const isPut = !isCall(leg.tokenType, isAssetToken0);
+	if (isPut) return vDelta;
+	const debtDelta = -m;
+	const itmDelta = mintTick === void 0 ? 0n : (() => {
+		const qMintTick = quoteTick(mintTick, isAssetToken0);
+		if (qMintTick < qStrikeTick - halfWidthTick) return 0n;
+		else if (qMintTick > qStrikeTick + halfWidthTick) {
+			const sqrtPm = tickToSqrtPriceX96(qMintTick);
+			const sqrtK = tickToSqrtPriceX96(qStrikeTick);
+			const PmX192 = sqrtPm * sqrtPm;
+			const KX192 = sqrtK * sqrtK;
+			return divTrunc((PmX192 - KX192) * m, PmX192);
+		} else {
+			const sqrtR = tickToSqrtPriceX96(halfWidthTick);
+			const sqrtK = tickToSqrtPriceX96(qStrikeTick);
+			const sqrtPm = tickToSqrtPriceX96(qMintTick);
+			const rX192 = sqrtR * sqrtR;
+			const sqrtKPmX96 = sqrtK * Q96 / sqrtPm;
+			const diff = sqrtR - sqrtKPmX96;
+			const diffSqX192 = diff * diff;
+			return divTrunc(m * diffSqX192, rX192 - Q192);
+		}
+	})();
+	return definedRisk ? debtDelta + vDelta : debtDelta + vDelta + itmDelta;
+}
+/** Convert a delta between token frames at the current pool tick. */
+function toVaultFrameAtTick(delta, fromAsset, vaultAssetIndex, currentTick, flipSignOnAssetInversion = false) {
+	if (fromAsset === vaultAssetIndex) return delta;
+	const sqrtPriceX96 = tickToSqrtPriceX96(currentTick);
+	const converted = vaultAssetIndex === 0n ? delta * Q192 / (sqrtPriceX96 * sqrtPriceX96) : delta * sqrtPriceX96 * sqrtPriceX96 / Q192;
+	return flipSignOnAssetInversion ? -converted : converted;
+}
+/**
+* Calculate one leg's wallet-aware delta in the vault asset frame.
+*
+* Width-zero loans and credits must be evaluated directly in the vault frame.
+* Option legs remain in their natural leg frame until converted at the mark tick.
+*/
+function getLegDeltaInVaultFrame(leg, currentTick, positionSize, poolTickSpacing, mintTick, definedRisk, vaultAssetIndex) {
+	if (leg.width === 0n) return getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick, definedRisk, vaultAssetIndex);
+	const legDelta = getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick, definedRisk);
+	return toVaultFrameAtTick(legDelta, leg.asset, vaultAssetIndex, currentTick, true);
+}
+/**
+* Calculate the gamma (dollar gamma) of a single leg.
+*
+* Formula: gamma = (m * sqrt(K * P * r)) / (2 * (r - 1))
+* where:
+* - m = positionSize * optionRatio (with sign based on long/short)
+* - K = strike price (numeraire/asset)
+* - P = current price (numeraire/asset)
+* - r = 1.0001^(width*tickSpacing/2) ≈ 1 (dimensionless ratio)
+*
+* Uses sqrtPriceX96 arithmetic:
+* - sqrt(K*P*r) = tickToSqrtPriceX96(strikeₜ + currentₜ + widthₜ/2)
+* - Keeps X96/X192 precision until final division
+*
+* @param leg - The leg to calculate
+* @param currentTick - Current pool tick
+* @param positionSize - Position size in asset token smallest units
+* @param poolTickSpacing - Pool tick spacing
+* @param assetIndex - Optional override for leg.asset (0n = token0 is asset, 1n = token1)
+* @returns Leg gamma in numeraire token smallest units
+*/
+function getLegGamma(leg, currentTick, positionSize, poolTickSpacing, assetIndex) {
+	const isAssetToken0 = resolveAssetDirection(leg, assetIndex);
+	const qCurrentTick = quoteTick(currentTick, isAssetToken0);
+	const qStrikeTick = quoteTick(leg.strike, isAssetToken0);
+	const halfWidthTick = leg.width * poolTickSpacing / 2n;
+	if (leg.width === 0n) return 0n;
+	if (halfWidthTick === 0n) return 0n;
+	if (qCurrentTick < qStrikeTick - halfWidthTick || qCurrentTick > qStrikeTick + halfWidthTick) return 0n;
+	const m = leg.isLong ? positionSize * leg.optionRatio : -(positionSize * leg.optionRatio);
+	const sqrtKPR = tickToSqrtPriceX96(qStrikeTick + qCurrentTick + halfWidthTick);
+	const sqrtR = tickToSqrtPriceX96(halfWidthTick);
+	const rX192 = sqrtR * sqrtR;
+	const numerator = m * sqrtKPR * Q96;
+	const denominator = 2n * (rX192 - Q192);
+	return divTrunc(numerator, denominator);
+}
+/**
+* Calculate total value across all legs.
+*/
+function calculatePositionValue(input) {
+	const { legs, currentTick, mintTick, positionSize, poolTickSpacing, assetIndex, swapAtMint } = input;
+	const definedRisk = isDefinedRisk(legs);
+	if (swapAtMint === void 0) return legs.reduce((sum$1, leg) => sum$1 + getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing, definedRisk, assetIndex, swapAtMint), 0n);
+	let numeraireItmPool = 0n;
+	let assetItmPool = 0n;
+	for (const leg of legs) {
+		const halfWidthTick = leg.width * poolTickSpacing / 2n;
+		if (leg.width === 0n || halfWidthTick === 0n) continue;
+		const isAssetToken0 = resolveAssetDirection(leg, assetIndex);
+		const qStrikeTick = quoteTick(leg.strike, isAssetToken0);
+		const qMintTick = quoteTick(mintTick, isAssetToken0);
+		const m = leg.isLong ? -(positionSize * leg.optionRatio) : positionSize * leg.optionRatio;
+		const isPut = !isCall(leg.tokenType, isAssetToken0);
+		const itm = computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut);
+		if (isPut) numeraireItmPool += itm;
+		else assetItmPool += itm;
+	}
+	let sum = 0n;
+	for (const leg of legs) if (leg.width === 0n) {
+		const isAssetToken0 = resolveAssetDirection(leg, assetIndex);
+		const borrowsAsset = isCall(leg.tokenType, isAssetToken0);
+		const offset = borrowsAsset ? assetItmPool : numeraireItmPool;
+		if (borrowsAsset) assetItmPool = 0n;
+		else numeraireItmPool = 0n;
+		const qCurrentTick = quoteTick(currentTick, isAssetToken0);
+		const qMintTick = quoteTick(mintTick, isAssetToken0);
+		const m = leg.isLong ? -(positionSize * leg.optionRatio) : positionSize * leg.optionRatio;
+		sum += getLegNetValueWidth0(leg, m, qCurrentTick, qMintTick, isAssetToken0, swapAtMint, offset);
+	} else sum += getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing, definedRisk, assetIndex, swapAtMint);
+	return sum;
+}
+/**
+* Calculate total delta across all legs.
+*/
+function calculatePositionDelta(input) {
+	const { legs, currentTick, mintTick, positionSize, poolTickSpacing, assetIndex } = input;
+	const definedRisk = isDefinedRisk(legs);
+	return legs.reduce((sum, leg) => sum + getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick, definedRisk, assetIndex), 0n);
+}
+/**
+* Calculate debt-only position delta in a single target asset frame.
+*
+* Option legs are first valued in their natural `leg.asset` frame, then
+* converted into `assetIndex` using the current pool price. Width-zero legs
+* are evaluated directly in the target frame.
+*
+* Width=0 loan/credit legs include only their debt obligation. The held-token
+* side must be added separately from account collateral balances, preventing a
+* zap from being counted once in the position and again in collateral.
+*/
+function calculatePositionDeltaDebtOnly(input) {
+	const { legs, currentTick, mintTick, positionSize, poolTickSpacing, assetIndex } = input;
+	const definedRisk = isDefinedRisk(legs);
+	return legs.reduce((sum, leg) => sum + getLegDeltaInVaultFrame(leg, currentTick, positionSize, poolTickSpacing, mintTick, definedRisk, assetIndex), 0n);
+}
+/**
+* Calculate total gamma across all legs.
+*/
+function calculatePositionGamma(input) {
+	const { legs, currentTick, positionSize, poolTickSpacing, assetIndex } = input;
+	return legs.reduce((sum, leg) => sum + getLegGamma(leg, currentTick, positionSize, poolTickSpacing, assetIndex), 0n);
+}
+/**
+* Calculate all greeks for a position.
+*/
+function calculatePositionGreeks(input) {
+	return {
+		value: calculatePositionValue(input),
+		delta: calculatePositionDelta(input),
+		gamma: calculatePositionGamma(input)
+	};
+}
+/**
+* Aggregate value across multiple independent positions.
+*
+* Each entry is valued with its OWN `positionSize`, `mintTick`, and legs, then
+* summed. Do NOT collapse multiple positions into one synthetic `PositionGreeksInput`
+* with a shared `positionSize` — `m = positionSize * optionRatio` is per-position, so a
+* shared size double-counts (and integer `optionRatio` cannot encode fractional shares).
+*
+* @param positions - One `PositionGreeksInput` per open position
+* @returns Total value in numeraire token smallest units
+*/
+function calculatePortfolioValue(positions) {
+	return positions.reduce((sum, input) => sum + calculatePositionValue(input), 0n);
+}
+/**
+* Aggregate delta across multiple independent positions.
+*
+* See {@link calculatePortfolioValue} for why each position must keep its own
+* `positionSize` rather than being merged into one synthetic position.
+*
+* @param positions - One `PositionGreeksInput` per open position
+* @returns Total delta in asset token smallest units
+*/
+function calculatePortfolioDelta(positions) {
+	return positions.reduce((sum, input) => sum + calculatePositionDelta(input), 0n);
+}
+/**
+* Aggregate gamma across multiple independent positions.
+*
+* See {@link calculatePortfolioValue} for why each position must keep its own
+* `positionSize` rather than being merged into one synthetic position.
+*
+* @param positions - One `PositionGreeksInput` per open position
+* @returns Total gamma in numeraire token smallest units
+*/
+function calculatePortfolioGamma(positions) {
+	return positions.reduce((sum, input) => sum + calculatePositionGamma(input), 0n);
+}
+/**
+* Calculate all greeks aggregated across multiple independent positions.
+*/
+function calculatePortfolioGreeks(positions) {
+	return {
+		value: calculatePortfolioValue(positions),
+		delta: calculatePortfolioDelta(positions),
+		gamma: calculatePortfolioGamma(positions)
+	};
+}
+/**
+* Calculate the effective delta of a loan leg accounting for swapAtMint.
+*
+* A loan borrows one token and (optionally) swaps it for the other at mint.
+* The net delta depends on whether the swap occurred:
+*
+* | Scenario              | Result                                          |
+* |-----------------------|-------------------------------------------------|
+* | No swap               | 0n (hold what you owe, net zero)                |
+* | Swap + borrows asset  | -m (hold numeraire, owe asset → short exposure) |
+* | Swap + borrows numer. | +m (hold asset, owe numeraire → long exposure)  |
+*
+* Only meaningful for legs with `width === 0n`. For options, use `getLegDelta`.
+*
+* @param leg - The loan leg
+* @param positionSize - Position size in asset token smallest units
+* @param swapAtMint - Whether the borrowed tokens were swapped at mint
+* @param assetIndex - Optional override for leg.asset (0n = token0 is asset)
+* @returns Effective delta in asset token smallest units
+*/
+function getLoanEffectiveDelta(leg, positionSize, swapAtMint, assetIndex) {
+	if (!swapAtMint) return 0n;
+	const isAssetToken0 = resolveAssetDirection(leg, assetIndex);
+	const m = leg.isLong ? -(positionSize * leg.optionRatio) : positionSize * leg.optionRatio;
+	const borrowsAsset = isAssetToken0 ? leg.tokenType === 0n : leg.tokenType === 1n;
+	return borrowsAsset ? -m : m;
+}
+/**
+* Calculate total delta for a position, using swap-aware delta for loan legs.
+*
+* For legs with `width === 0n` (loans/credits), uses `getLoanEffectiveDelta`
+* which accounts for the swapAtMint flag. For option legs (`width > 0n`),
+* uses the standard `getLegDelta`.
+*
+* @param input - Position greeks input plus swapAtMint flag
+* @returns Total delta in asset token smallest units
+*/
+function calculatePositionDeltaWithSwap(input) {
+	const { legs, currentTick, mintTick, positionSize, poolTickSpacing, assetIndex, swapAtMint } = input;
+	const optionLegs = legs.filter((l) => l.width !== 0n);
+	const definedRisk = isDefinedRisk(optionLegs);
+	return legs.reduce((sum, leg) => {
+		if (leg.width === 0n) return sum + getLoanEffectiveDelta(leg, positionSize, swapAtMint, assetIndex);
+		return sum + getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick, definedRisk, assetIndex);
+	}, 0n);
+}
+
+//#endregion
+export { calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLoanEffectiveDelta, isCall, isDefinedRisk, toVaultFrameAtTick };
+//# sourceMappingURL=index.js.map