@panoptic-eng/sdk 1.0.26 → 1.0.28

package/dist/greeks-GysWXct-.js

@@ -0,0 +1,1072 @@
+//#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;
+/**
+* Zero collateral object for guest mode.
+* Returns safe defaults when no wallet is connected.
+*/
+const ZERO_COLLATERAL = {
+	token0: {
+		assets: 0n,
+		shares: 0n,
+		availableAssets: 0n,
+		lockedAssets: 0n
+	},
+	token1: {
+		assets: 0n,
+		shares: 0n,
+		availableAssets: 0n,
+		lockedAssets: 0n
+	}
+};
+/**
+* Zero valuation object for guest mode.
+* Returns safe defaults when no wallet is connected.
+*/
+const ZERO_VALUATION = {
+	netLiquidationValue0: 0n,
+	netLiquidationValue1: 0n,
+	maintenanceMargin0: 0n,
+	maintenanceMargin1: 0n,
+	marginExcess0: 0n,
+	marginExcess1: 0n
+};
+/**
+* Storage schema version for the SDK.
+* Increment when storage format changes (triggers migration or clear).
+*/
+const SCHEMA_VERSION = 1;
+/**
+* Storage key prefix for all SDK data.
+*/
+const STORAGE_PREFIX = "panoptic-v2-sdk";
+/**
+* Maximum number of chunks that can be tracked per pool.
+* Exceeding this limit throws ChunkLimitError.
+*/
+const MAX_TRACKED_CHUNKS = 1e3;
+/**
+* Default reorg depth for chain reorganization handling.
+* On reorg detection, rollback this many blocks and re-sync.
+*/
+const REORG_DEPTH = 128n;
+/**
+* Oracle epoch duration in seconds (64 seconds per epoch).
+*/
+const ORACLE_EPOCH_SECONDS = 64n;
+/**
+* Minimum tick value for Uniswap v3/v4 pools.
+*/
+const MIN_TICK = -887272n;
+/**
+* Maximum tick value for Uniswap v3/v4 pools.
+*/
+const MAX_TICK = 887272n;
+/**
+* Basis points denominator (100% = 10000 bps).
+*/
+const BPS_DENOMINATOR = 10000n;
+/**
+* Utilization denominator (100% = 10000).
+*/
+const UTILIZATION_DENOMINATOR = 10000n;
+
+//#endregion
+//#region src/panoptic/v2/formatters/tick.ts
+const Q192$1 = 1n << 192n;
+const RAW_PRICE_PRECISION = 40n;
+function pow10(exponent) {
+	if (exponent < 0n) throw new RangeError("Exponent must be non-negative");
+	return 10n ** exponent;
+}
+function absBigint(value) {
+	return value < 0n ? -value : value;
+}
+function trimTrailingZeros(value) {
+	const dotIndex = value.indexOf(".");
+	if (dotIndex === -1) return value;
+	let end = value.length;
+	while (end > dotIndex && value[end - 1] === "0") end -= 1;
+	if (end === dotIndex + 1) end = dotIndex;
+	return value.slice(0, end);
+}
+function formatRatio(numerator, denominator, precision) {
+	if (precision < 0n) throw new RangeError("Precision must be non-negative");
+	const sign = numerator < 0n ? "-" : "";
+	const absNumerator = numerator < 0n ? -numerator : numerator;
+	const scale = pow10(precision);
+	const scaled = (absNumerator * scale + denominator / 2n) / denominator;
+	const integerPart = scaled / scale;
+	const fractionalPart = scaled % scale;
+	if (precision === 0n) return `${sign}${integerPart}`;
+	return `${sign}${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
+}
+function parseDecimalToFraction(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) throw new Error("Price must be a number");
+	const isNegative = trimmed.startsWith("-");
+	const unsigned = isNegative || trimmed.startsWith("+") ? trimmed.slice(1) : trimmed;
+	const [basePart, exponentPart] = unsigned.toLowerCase().split("e");
+	const [integerStr, fractionalStr = ""] = basePart.split(".");
+	if (integerStr === "" && fractionalStr === "") throw new Error("Price must be a number");
+	const integerDigits = integerStr === "" ? "0" : integerStr;
+	const digits = `${integerDigits}${fractionalStr}`;
+	let numerator = BigInt(digits === "" ? "0" : digits);
+	let denominator = pow10(BigInt(fractionalStr.length));
+	if (exponentPart !== void 0 && exponentPart !== "") {
+		const exponent = BigInt(exponentPart);
+		if (exponent > 0n) numerator *= pow10(exponent);
+		else if (exponent < 0n) denominator *= pow10(-exponent);
+	}
+	if (isNegative) numerator = -numerator;
+	return {
+		numerator,
+		denominator
+	};
+}
+function compareRatios(leftNumerator, leftDenominator, rightNumerator, rightDenominator) {
+	const left = leftNumerator * rightDenominator;
+	const right = rightNumerator * leftDenominator;
+	if (left === right) return 0;
+	return left < right ? -1 : 1;
+}
+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);
+function getPriceRatioFromSqrtPriceX96(sqrtPriceX96) {
+	return {
+		numerator: sqrtPriceX96 * sqrtPriceX96,
+		denominator: Q192$1
+	};
+}
+function getRawPriceRatio(tick) {
+	return getPriceRatioFromSqrtPriceX96(tickToSqrtPriceX96(tick));
+}
+function adjustRatioForDecimals(numerator, denominator, decimals0, decimals1) {
+	const diff = decimals0 - decimals1;
+	if (diff === 0n) return {
+		numerator,
+		denominator
+	};
+	if (diff > 0n) return {
+		numerator: numerator * pow10(diff),
+		denominator
+	};
+	return {
+		numerator,
+		denominator: denominator * pow10(-diff)
+	};
+}
+/**
+* Convert a tick to a raw price string (no decimal adjustment).
+* Uses the formula: price = 1.0001^tick
+*
+* This returns the raw price ratio, not adjusted for token decimals.
+* A fixed internal precision is used and trailing zeros are trimmed.
+*
+* @param tick - The tick value
+* @returns Price string
+*
+* @example
+* ```typescript
+* tickToPrice(0n)       // "1"
+* tickToPrice(1000n)    // "1.105..." (approximately)
+* tickToPrice(-1000n)   // "0.904..." (approximately)
+* tickToPrice(200000n)  // Very large number
+* ```
+*/
+function tickToPrice(tick) {
+	const { numerator, denominator } = getRawPriceRatio(tick);
+	const price = formatRatio(numerator, denominator, RAW_PRICE_PRECISION);
+	return trimTrailingZeros(price);
+}
+/**
+* Convert a tick to a human-readable price with decimal scaling.
+* Uses the formula: price = 1.0001^tick * 10^(decimals0-decimals1)
+*
+* This adjusts for the different decimals of the two tokens in the pair.
+*
+* @param tick - The tick value
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Formatted price string
+*
+* @example
+* ```typescript
+* // WETH/USDC pool (18 decimals / 6 decimals)
+* // At tick ~200000, price is roughly $2000 per ETH
+* tickToPriceDecimalScaled(200000n, 18n, 6n, 2n) // "2000.00" (approximately)
+*
+* // For token1/token0 price, swap the decimals
+* tickToPriceDecimalScaled(200000n, 6n, 18n, 6n) // "0.000500" (approximately)
+* ```
+*/
+function tickToPriceDecimalScaled(tick, decimals0, decimals1, precision) {
+	const rawRatio = getRawPriceRatio(tick);
+	const { numerator, denominator } = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
+	return formatRatio(numerator, denominator, precision);
+}
+/**
+* Convert a sqrtPriceX96 to a human-readable price with decimal scaling.
+*
+* Uses the formula: price = (sqrtPriceX96^2 / 2^192) * 10^(decimals0-decimals1)
+*
+* @param sqrtPriceX96 - The sqrt price in Q64.96 format
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Formatted price string
+*
+* @example
+* ```typescript
+* sqrtPriceX96ToPriceDecimalScaled(2n ** 96n, 18n, 18n, 2n) // "1.00"
+* ```
+*/
+function sqrtPriceX96ToPriceDecimalScaled(sqrtPriceX96, decimals0, decimals1, precision) {
+	const rawRatio = getPriceRatioFromSqrtPriceX96(sqrtPriceX96);
+	const { numerator, denominator } = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
+	return formatRatio(numerator, denominator, precision);
+}
+/**
+* Convert a price to a tick value.
+*
+* @param price - The price string
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @returns The tick value (rounded to nearest integer)
+*
+* @example
+* ```typescript
+* // WETH/USDC: What tick for $2000 per ETH?
+* priceToTick("2000", 18n, 6n) // ~200000n
+*
+* // Inverse: What tick for 0.0005 ETH per USDC?
+* priceToTick("0.0005", 6n, 18n) // ~200000n
+* ```
+*/
+function priceToTick(price, decimals0, decimals1) {
+	const parsed = parseDecimalToFraction(price);
+	if (parsed.numerator <= 0n) throw new Error("Price must be positive");
+	let targetNumerator = parsed.numerator;
+	let targetDenominator = parsed.denominator;
+	const diff = decimals0 - decimals1;
+	if (diff > 0n) targetDenominator *= pow10(diff);
+	else if (diff < 0n) targetNumerator *= pow10(-diff);
+	let low = MIN_TICK;
+	let high = MAX_TICK;
+	while (low <= high) {
+		const mid = (low + high) / 2n;
+		const { numerator, denominator } = getRawPriceRatio(mid);
+		const cmp = compareRatios(numerator, denominator, targetNumerator, targetDenominator);
+		if (cmp === 0) return mid;
+		if (cmp < 0) low = mid + 1n;
+		else high = mid - 1n;
+	}
+	const floorTick = high;
+	const ceilTick = low;
+	if (floorTick < MIN_TICK) return MIN_TICK;
+	if (ceilTick > MAX_TICK) return MAX_TICK;
+	const floorRatio = getRawPriceRatio(floorTick);
+	const ceilRatio = getRawPriceRatio(ceilTick);
+	const floorDiffNumerator = absBigint(targetNumerator * floorRatio.denominator - floorRatio.numerator * targetDenominator);
+	const ceilDiffNumerator = absBigint(targetNumerator * ceilRatio.denominator - ceilRatio.numerator * targetDenominator);
+	const floorDiffDenominator = targetDenominator * floorRatio.denominator;
+	const ceilDiffDenominator = targetDenominator * ceilRatio.denominator;
+	return floorDiffNumerator * ceilDiffDenominator <= ceilDiffNumerator * floorDiffDenominator ? floorTick : ceilTick;
+}
+/**
+* Convert a sqrtPriceX96 value to the nearest tick.
+*
+* @param sqrtPriceX96 - The sqrt price in Q64.96 format
+* @returns The tick value (rounded to nearest integer)
+*
+* @example
+* ```typescript
+* const tick = sqrtPriceX96ToTick(2n ** 96n) // 0n
+* ```
+*/
+function sqrtPriceX96ToTick(sqrtPriceX96) {
+	if (sqrtPriceX96 <= 0n) throw new Error("Sqrt price must be positive");
+	if (sqrtPriceX96 < MIN_SQRT_PRICE_X96 || sqrtPriceX96 > MAX_SQRT_PRICE_X96) throw new RangeError("Sqrt price out of bounds");
+	let low = MIN_TICK;
+	let high = MAX_TICK;
+	while (low <= high) {
+		const mid = (low + high) / 2n;
+		const midSqrt = tickToSqrtPriceX96(mid);
+		if (midSqrt === sqrtPriceX96) return mid;
+		if (midSqrt < sqrtPriceX96) low = mid + 1n;
+		else high = mid - 1n;
+	}
+	const floorTick = high;
+	const ceilTick = low;
+	if (floorTick < MIN_TICK) return MIN_TICK;
+	if (ceilTick > MAX_TICK) return MAX_TICK;
+	const floorSqrt = tickToSqrtPriceX96(floorTick);
+	const ceilSqrt = tickToSqrtPriceX96(ceilTick);
+	const floorDiff = absBigint(sqrtPriceX96 - floorSqrt);
+	const ceilDiff = absBigint(ceilSqrt - sqrtPriceX96);
+	return floorDiff <= ceilDiff ? floorTick : ceilTick;
+}
+/**
+* Format a tick value for display.
+*
+* @param tick - The tick value
+* @returns Formatted tick string
+*
+* @example
+* ```typescript
+* formatTick(200000n)  // "200000"
+* formatTick(-50000n)  // "-50000"
+* ```
+*/
+function formatTick(tick) {
+	return tick.toString();
+}
+/**
+* Get the price at a specific tick, returning both token0/token1 and token1/token0 prices.
+*
+* @param tick - The tick value
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Object with both price directions
+*
+* @example
+* ```typescript
+* const prices = getPricesAtTick(200000n, 18n, 6n, 2n)
+* // prices.token0PerToken1 = "0.00" (very small)
+* // prices.token1PerToken0 = "2000.00" (USDC per ETH)
+* ```
+*/
+function getPricesAtTick(tick, decimals0, decimals1, precision) {
+	const rawRatio = getRawPriceRatio(tick);
+	const adjustedRatio = adjustRatioForDecimals(rawRatio.numerator, rawRatio.denominator, decimals0, decimals1);
+	return {
+		token0PerToken1: formatRatio(adjustedRatio.denominator, adjustedRatio.numerator, precision),
+		token1PerToken0: formatRatio(adjustedRatio.numerator, adjustedRatio.denominator, precision)
+	};
+}
+/**
+* Format a tick range for display.
+*
+* @param tickLower - Lower tick
+* @param tickUpper - Upper tick
+* @returns Formatted tick range string
+*
+* @example
+* ```typescript
+* formatTickRange(-50000n, 200000n) // "-50000 - 200000"
+* ```
+*/
+function formatTickRange(tickLower, tickUpper) {
+	return `${tickLower} - ${tickUpper}`;
+}
+/**
+* Format a price range for display.
+*
+* @param tickLower - Lower tick
+* @param tickUpper - Upper tick
+* @param decimals0 - Decimals of token0
+* @param decimals1 - Decimals of token1
+* @param precision - Number of decimal places to display
+* @returns Formatted price range string
+*
+* @example
+* ```typescript
+* formatPriceRange(0n, 0n, 18n, 18n, 2n) // "1.00 - 1.00"
+* ```
+*/
+function formatPriceRange(tickLower, tickUpper, decimals0, decimals1, precision) {
+	const lower = tickToPriceDecimalScaled(tickLower, decimals0, decimals1, precision);
+	const upper = tickToPriceDecimalScaled(tickUpper, decimals0, decimals1, precision);
+	return `${lower} - ${upper}`;
+}
+/**
+* Calculate the tick spacing for a given fee tier.
+*
+* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
+* @returns Tick spacing
+*
+* @example
+* ```typescript
+* getTickSpacing(100n)  // 1n (0.01% fee tier)
+* getTickSpacing(500n)  // 10n (0.05% fee tier)
+* getTickSpacing(3000n) // 60n (0.30% fee tier)
+* getTickSpacing(10000n) // 200n (1.00% fee tier)
+* ```
+*/
+function getTickSpacing(feeBps) {
+	switch (feeBps) {
+		case 100n: return 1n;
+		case 500n: return 10n;
+		case 3000n: return 60n;
+		case 10000n: return 200n;
+		default: {
+			const spacing = feeBps / 50n;
+			return spacing > 1n ? spacing : 1n;
+		}
+	}
+}
+/**
+* Round a tick to the nearest valid tick for a given tick spacing.
+*
+* @param tick - The tick to round
+* @param tickSpacing - The tick spacing
+* @returns Rounded tick
+*
+* @example
+* ```typescript
+* roundToTickSpacing(12345n, 10n) // 12340n
+* roundToTickSpacing(12345n, 60n) // 12360n
+* roundToTickSpacing(-12345n, 10n) // -12350n
+* ```
+*/
+function roundToTickSpacing(tick, tickSpacing) {
+	const remainder = tick % tickSpacing;
+	if (remainder === 0n) return tick;
+	if (tick >= 0n) return remainder >= tickSpacing / 2n ? tick + (tickSpacing - remainder) : tick - remainder;
+	const absRemainder = -remainder;
+	return absRemainder >= tickSpacing / 2n ? tick - (tickSpacing - absRemainder) : tick + absRemainder;
+}
+/**
+* Compute slippage-bounded tick limits around the current tick.
+*
+* 1 tick ≈ 1 basis point (0.01 %) of price change, so a `toleranceBps`
+* of 500 allows roughly 5 % price movement.  The result is clamped to
+* the protocol's `[MIN_TICK, MAX_TICK]` range.
+*
+* Useful for setting `tickLimitLow` / `tickLimitHigh` on `openPosition`
+* and `closePosition` to protect against MEV sandwiches and volatile
+* tick moves.
+*
+* @param currentTick - The current pool tick (must be within [MIN_TICK, MAX_TICK]).
+* @param toleranceBps - Slippage tolerance in basis points (≈ ticks). Must be non-negative.
+* @returns Clamped `{ low, high }` tick limits.
+* @throws {RangeError} If `toleranceBps` is negative or `currentTick` is out of bounds.
+*
+* @example
+* ```typescript
+* const { low, high } = tickLimits(200_000n, 500n)
+* // low  = 199_500n
+* // high = 200_500n
+*
+* await openPosition({ ..., tickLimitLow: low, tickLimitHigh: high })
+* ```
+*/
+function tickLimits(currentTick, toleranceBps) {
+	if (toleranceBps < 0n) throw new RangeError(`toleranceBps must be non-negative, got ${toleranceBps}`);
+	if (currentTick < MIN_TICK || currentTick > MAX_TICK) throw new RangeError(`currentTick ${currentTick} is out of bounds [${MIN_TICK}, ${MAX_TICK}]`);
+	const rawLow = currentTick - toleranceBps;
+	const rawHigh = currentTick + toleranceBps;
+	const low = rawLow < MIN_TICK ? MIN_TICK : rawLow;
+	const high = rawHigh > MAX_TICK ? MAX_TICK : rawHigh;
+	if (low > high) throw new RangeError(`Computed tick limits are inverted: low ${low} > high ${high} (currentTick=${currentTick}, toleranceBps=${toleranceBps})`);
+	return {
+		low,
+		high
+	};
+}
+
+//#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 { BPS_DENOMINATOR, MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, ORACLE_EPOCH_SECONDS, REORG_DEPTH, SCHEMA_VERSION, STORAGE_PREFIX, UTILIZATION_DENOMINATOR, WAD, ZERO_COLLATERAL, ZERO_VALUATION, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, formatPriceRange, formatTick, formatTickRange, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLoanEffectiveDelta, getPricesAtTick, getTickSpacing, isCall, isDefinedRisk, priceToTick, roundToTickSpacing, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick };
+//# sourceMappingURL=greeks-GysWXct-.js.map