@panoptic-eng/sdk 1.0.69 → 1.0.71

package/dist/panoptic/v2/index.js

@@ -94,7 +94,7 @@ const UTILIZATION_DENOMINATOR = 10000n;
 
 //#endregion
 //#region src/panoptic/v2/formatters/tick.ts
-const Q192$7 = 1n << 192n;
+const Q192$8 = 1n << 192n;
 const RAW_PRICE_PRECISION = 40n;
 function pow10$2(exponent) {
 	if (exponent < 0n) throw new RangeError("Exponent must be non-negative");
@@ -184,7 +184,7 @@ const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
 function getPriceRatioFromSqrtPriceX96(sqrtPriceX96) {
 	return {
 		numerator: sqrtPriceX96 * sqrtPriceX96,
-		denominator: Q192$7
+		denominator: Q192$8
 	};
 }
 function getRawPriceRatio(tick) {
@@ -10068,7 +10068,7 @@ function hasLoanOrCredit(tokenId) {
 const POOL_ID_MASK$4 = (1n << 64n) - 1n;
 const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
 const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
-const Q192$6 = 1n << 192n;
+const Q192$7 = 1n << 192n;
 /**
 * Floor integer square root for bigints (Newton's method). Mirrors the isqrt
 * used in reads/collateralEstimate.ts (buildNeutralLeg).
@@ -10115,7 +10115,7 @@ function computeTinyCreditSignedStrike(positionSize, tickSpacing) {
 	const maxSafe = MAX_TICK - tickSpacing - 1n;
 	let signedStrike;
 	try {
-		const sqrtKrawX96 = isqrt$1(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$6 / positionSize);
+		const sqrtKrawX96 = isqrt$1(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$7 / positionSize);
 		signedStrike = sqrtPriceX96ToTick(sqrtKrawX96);
 	} catch {
 		signedStrike = minSafe;
@@ -10987,7 +10987,7 @@ function formatGwei(wei, precision) {
 //#region src/panoptic/v2/tokenId/generateOverlapping.ts
 const MAX_UINT64$2 = (1n << 64n) - 1n;
 const MAX_UINT128$4 = (1n << 128n) - 1n;
-const Q192$5 = 1n << 192n;
+const Q192$6 = 1n << 192n;
 const MAX_TOKEN_DECIMALS = 255n;
 const MAX_DECIMAL_EXPONENT = 512n;
 function invalid$1(message) {
@@ -11033,7 +11033,7 @@ function quotePriceAtTick(tick, asset, assetDecimals, quoteDecimals) {
 	const orientedTick = asset === 0n ? tick : -tick;
 	const sqrtPriceX96 = tickToSqrtPriceX96(orientedTick);
 	let numerator = sqrtPriceX96 * sqrtPriceX96;
-	let denominator = Q192$5;
+	let denominator = Q192$6;
 	const decimalDifference = assetDecimals - quoteDecimals;
 	if (decimalDifference > 0n) numerator *= pow10$1(decimalDifference);
 	else if (decimalDifference < 0n) denominator *= pow10$1(-decimalDifference);
@@ -11053,7 +11053,7 @@ function isPriceGridStrike(strike, params, spacing, tickSpacing) {
 	}
 	return false;
 }
-function ceilDiv$5(value, divisor) {
+function ceilDiv$6(value, divisor) {
 	const quotient = value / divisor;
 	const remainder = value % divisor;
 	return remainder > 0n ? quotient + 1n : quotient;
@@ -11086,7 +11086,7 @@ function resolveLegs(legs) {
 function getCandidateStrikes(params, spacing, tickSpacing, halfWidth) {
 	const lower = MIN_TICK + halfWidth > params.currentTick - halfWidth + 1n ? MIN_TICK + halfWidth : params.currentTick - halfWidth + 1n;
 	const upper = MAX_TICK - halfWidth < params.currentTick + halfWidth - 1n ? MAX_TICK - halfWidth : params.currentTick + halfWidth - 1n;
-	const firstStrike = ceilDiv$5(lower, tickSpacing) * tickSpacing;
+	const firstStrike = ceilDiv$6(lower, tickSpacing) * tickSpacing;
 	const lastStrike = floorDiv$1(upper, tickSpacing) * tickSpacing;
 	const strikes = [];
 	for (let strike = firstStrike; strike <= lastStrike; strike += tickSpacing) if (isPriceGridStrike(strike, params, spacing, tickSpacing)) strikes.push(strike);
@@ -11308,10 +11308,41 @@ function splitTokenIdByTimescale(tokenId, positionSize, targetTimescale) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/tokenId/validate.ts
+/**
+* Validate a TokenId's structure using the rules of TokenId.validate.
+* This does not check pool registration, available liquidity, or account collateral.
+*/
+function getTokenIdValidationError(tokenId) {
+	if (tokenId < 0n || tokenId >= 1n << 256n) return "Token ID must fit in uint256.";
+	const legs = [];
+	for (let index = 0n; index < TOKEN_ID_BITS.MAX_LEGS; index++) {
+		const leg = decodeLeg(tokenId, index);
+		if (leg.optionRatio === 0n) {
+			const offset = TOKEN_ID_BITS.POOL_ID_SIZE + index * TOKEN_ID_BITS.LEG_SIZE;
+			if (tokenId >> offset !== 0n) return "Position contains empty or non-contiguous legs.";
+			break;
+		}
+		legs.push(leg);
+	}
+	if (legs.length === 0) return "Position must contain at least one leg.";
+	const chunks = new Set();
+	for (const leg of legs) {
+		const chunk = `${leg.strike}:${leg.width}:${leg.tokenType}`;
+		if (chunks.has(chunk)) return "Position contains duplicate legs sharing the same liquidity chunk.";
+		chunks.add(chunk);
+		if (leg.strike <= -887272n || leg.strike >= 887272n) return "Position strike must be inside the pool tick bounds.";
+		const partner = legs[Number(leg.riskPartner)];
+		if (!partner || partner.riskPartner !== leg.index) return "Position risk partners must reference existing legs and be mutual.";
+	}
+	return null;
+}
+
 //#endregion
 //#region src/uniswap/lpDeposit.ts
-const Q96$5 = 1n << 96n;
-const ceilDiv$4 = (n, d) => (n + d - 1n) / d;
+const Q96$6 = 1n << 96n;
+const ceilDiv$5 = (n, d) => (n + d - 1n) / d;
 /** Principal and separately identified funding headroom, in native token units. */
 function getLpDepositBreakdown(ranges, sqrtPriceX96) {
 	if (sqrtPriceX96 <= 0n) throw new Error("Invalid pool price");
@@ -11322,12 +11353,12 @@ function getLpDepositBreakdown(ranges, sqrtPriceX96) {
 		const lower = tickToSqrtPriceX96(BigInt(tickLower));
 		const upper = tickToSqrtPriceX96(BigInt(tickUpper));
 		const price = sqrtPriceX96 < lower ? lower : sqrtPriceX96 > upper ? upper : sqrtPriceX96;
-		amount0 += ceilDiv$4(liquidity * Q96$5 * (upper - price), upper * price);
-		amount1 += ceilDiv$4(liquidity * (price - lower), Q96$5);
+		amount0 += ceilDiv$5(liquidity * Q96$6 * (upper - price), upper * price);
+		amount1 += ceilDiv$5(liquidity * (price - lower), Q96$6);
 	}
 	const buffer = {
-		amount0: ceilDiv$4(amount0 * 5n, 100n),
-		amount1: ceilDiv$4(amount1 * 5n, 100n)
+		amount0: ceilDiv$5(amount0 * 5n, 100n),
+		amount1: ceilDiv$5(amount1 * 5n, 100n)
 	};
 	return {
 		principal: {
@@ -11351,7 +11382,7 @@ function getUnhedgedLpRanges({ tokenId, positionSize, tickSpacing }) {
 		const lower = tickToSqrtPriceX96(tickLower);
 		const upper = tickToSqrtPriceX96(tickUpper);
 		const amount = positionSize * leg.optionRatio;
-		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96$5) / (upper - lower) : amount * Q96$5 / (upper - lower);
+		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96$6) / (upper - lower) : amount * Q96$6 / (upper - lower);
 		return liquidity <= 0n ? [] : [{
 			tickLower: Number(tickLower),
 			tickUpper: Number(tickUpper),
@@ -11372,7 +11403,7 @@ function getLpPositionFunding(params) {
 	});
 	const breakdown = getLpDepositBreakdown(ranges, sqrtPriceX96);
 	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
-	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv$4(amount1 * Q96$5 * Q96$5, priceSquared) : amount1 + ceilDiv$4(amount0 * priceSquared, Q96$5 * Q96$5);
+	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv$5(amount1 * Q96$6 * Q96$6, priceSquared) : amount1 + ceilDiv$5(amount0 * priceSquared, Q96$6 * Q96$6);
 	const principalInQuote = value(breakdown.principal);
 	const totalInQuote = value(breakdown.total);
 	return {
@@ -11394,7 +11425,7 @@ function getMaxLpPositionSize(params) {
 			...params,
 			positionSize: mid
 		});
-		const minimum = params.minimumRequirement ? ceilDiv$4(params.minimumRequirement.requiredInQuote * mid, params.minimumRequirement.referenceSize) : 0n;
+		const minimum = params.minimumRequirement ? ceilDiv$5(params.minimumRequirement.requiredInQuote * mid, params.minimumRequirement.referenceSize) : 0n;
 		if (funding.totalInQuote <= params.availableInQuote && minimum <= params.availableInQuote) low = mid;
 		else high = mid - 1n;
 	}
@@ -12854,7 +12885,7 @@ async function submitWriteRequest(params) {
 * Exported so callers can display the constant; prefer {@link applyMintBuffer}
 * over multiplying by it directly, which is how the rounding bug reappears.
 */
-const MINT_BUFFER = 10666667n;
+const MINT_BUFFER = 10750000n;
 /** `RiskEngine.DECIMALS` — the denominator {@link MINT_BUFFER} is taken over. */
 const MINT_BUFFER_DENOMINATOR = 10000000n;
 /** The compiled-in default, matching the deployed RiskEngine. */
@@ -14585,8 +14616,8 @@ async function assertLpPositionFunded(params) {
 
 //#endregion
 //#region src/uniswap/lpGreeks.ts
-const Q96$4 = 1n << 96n;
-const Q192$4 = 1n << 192n;
+const Q96$5 = 1n << 96n;
+const Q192$5 = 1n << 192n;
 /**
 * Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
 * at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
@@ -14596,8 +14627,8 @@ const Q192$4 = 1n << 192n;
 function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liquidity) {
 	const [sqrtA, sqrtB] = sqrtRatioAX96 <= sqrtRatioBX96 ? [sqrtRatioAX96, sqrtRatioBX96] : [sqrtRatioBX96, sqrtRatioAX96];
 	const sqrtC = sqrtPriceX96 < sqrtA ? sqrtA : sqrtPriceX96 > sqrtB ? sqrtB : sqrtPriceX96;
-	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$4 / (sqrtC * sqrtB) : 0n;
-	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$4 : 0n;
+	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$5 / (sqrtC * sqrtB) : 0n;
+	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$5 : 0n;
 	return {
 		amount0,
 		amount1
@@ -14606,7 +14637,7 @@ function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liqu
 
 //#endregion
 //#region src/panoptic/v2/greeks/legLiquidity.ts
-const Q96$3 = 1n << 96n;
+const Q96$4 = 1n << 96n;
 function divCeil(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
 }
@@ -14619,7 +14650,7 @@ function getLegLiquidityRange(leg, positionSize, tickSpacing) {
 	const sqrtLower = tickToSqrtPriceX96(lowerTick);
 	const sqrtUpper = tickToSqrtPriceX96(upperTick);
 	const amount = positionSize * leg.optionRatio;
-	const liquidity = leg.asset === 0n ? amount * (sqrtLower * sqrtUpper / Q96$3) / (sqrtUpper - sqrtLower) : amount * Q96$3 / (sqrtUpper - sqrtLower);
+	const liquidity = leg.asset === 0n ? amount * (sqrtLower * sqrtUpper / Q96$4) / (sqrtUpper - sqrtLower) : amount * Q96$4 / (sqrtUpper - sqrtLower);
 	return {
 		lowerTick,
 		upperTick,
@@ -14642,7 +14673,7 @@ function getLegTokenInventory(leg, currentTick, positionSize, tickSpacing, token
 		if (tokenIndex === 0n) {
 			const scaled = (liquidity << 96n) * span;
 			movedAmount = leg.isLong ? scaled / sqrtUpper / sqrtLower : divCeil(divCeil(scaled, sqrtUpper), sqrtLower);
-		} else movedAmount = leg.isLong ? liquidity * span / Q96$3 : divCeil(liquidity * span, Q96$3);
+		} else movedAmount = leg.isLong ? liquidity * span / Q96$4 : divCeil(liquidity * span, Q96$4);
 	}
 	const net = heldAmount - movedAmount;
 	return leg.isLong ? -net : net;
@@ -14651,8 +14682,8 @@ function getLegTokenInventory(leg, currentTick, positionSize, tickSpacing, token
 //#endregion
 //#region src/panoptic/v2/greeks/index.ts
 /** Fixed-point scale constants for sqrtPriceX96 arithmetic */
-const Q96$2 = 1n << 96n;
-const Q192$3 = 1n << 192n;
+const Q96$3 = 1n << 96n;
+const Q192$4 = 1n << 192n;
 /**
 * Convert tick to quote-denominated tick based on asset direction.
 *
@@ -14706,7 +14737,7 @@ function computeWidth0Notional(leg, m) {
 	const signedStrike = leg.asset === 0n ? leg.strike : -leg.strike;
 	const sqrtKraw = tickToSqrtPriceX96(signedStrike);
 	const KrawX192 = sqrtKraw * sqrtKraw;
-	return divTrunc(m * KrawX192, Q192$3);
+	return divTrunc(m * KrawX192, Q192$4);
 }
 /**
 * Calculate value for a width=0 (loan/credit) leg.
@@ -14726,7 +14757,7 @@ function getLegValueWidth0(leg, m, qCurrentTick, qStrikeTick, qMintTick, isAsset
 		const sqrtPm = tickToSqrtPriceX96(qMintTick);
 		const PX192 = sqrtP * sqrtP;
 		const PmX192 = sqrtPm * sqrtPm;
-		return divTrunc(-notional * (PX192 - PmX192), Q192$3);
+		return divTrunc(-notional * (PX192 - PmX192), Q192$4);
 	} else return 0n;
 }
 /**
@@ -14755,7 +14786,7 @@ function getLegNetValueWidth0(leg, m, qCurrentTick, qMintTick, isAssetToken0, sw
 	const sqrtPm = tickToSqrtPriceX96(qMintTick);
 	const PX192 = sqrtP * sqrtP;
 	const PmX192 = sqrtPm * sqrtPm;
-	if (borrowsAsset) return divTrunc(-notional * (PX192 - PmX192), Q192$3);
+	if (borrowsAsset) return divTrunc(-notional * (PX192 - PmX192), Q192$4);
 	return divTrunc(notional * PX192, PmX192) - notional;
 }
 /**
@@ -14777,7 +14808,7 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 			const sqrtPm$2 = tickToSqrtPriceX96(qMintTick);
 			const KX192 = sqrtK$1 * sqrtK$1;
 			const PmX192 = sqrtPm$2 * sqrtPm$2;
-			return divTrunc(m * (KX192 - PmX192), Q192$3);
+			return divTrunc(m * (KX192 - PmX192), Q192$4);
 		} else if (qMintTick > qStrikeTick + halfWidthTick) return 0n;
 		const sqrtKR = tickToSqrtPriceX96(qStrikeTick + halfWidthTick);
 		const sqrtPm$1 = tickToSqrtPriceX96(qMintTick);
@@ -14785,7 +14816,7 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 		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$3);
+		return divTrunc(m * diffSqX192$1, rX192$1 - Q192$4);
 	}
 	if (qMintTick < qStrikeTick - halfWidthTick) return 0n;
 	else if (qMintTick > qStrikeTick + halfWidthTick) {
@@ -14799,10 +14830,10 @@ function computeOptionItm(m, qStrikeTick, qMintTick, halfWidthTick, isPut) {
 	const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 	const sqrtPm = tickToSqrtPriceX96(qMintTick);
 	const rX192 = sqrtR * sqrtR;
-	const sqrtKPmX96 = divTrunc(sqrtK * Q96$2, sqrtPm);
+	const sqrtKPmX96 = divTrunc(sqrtK * Q96$3, sqrtPm);
 	const diff = sqrtR - sqrtKPmX96;
 	const diffSqX192 = diff * diff;
-	return divTrunc(m * diffSqX192, rX192 - Q192$3);
+	return divTrunc(m * diffSqX192, rX192 - Q192$4);
 }
 /**
 * Check if leg is a call option (vs put).
@@ -14858,11 +14889,11 @@ function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing,
 	if (qCurrentTick < qStrikeTick - halfWidthTick) {
 		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
 		const PX192 = sqrtP * sqrtP;
-		v = divTrunc(m * PX192, Q192$3);
+		v = divTrunc(m * PX192, Q192$4);
 	} else if (qCurrentTick > qStrikeTick + halfWidthTick) {
 		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 		const KX192 = sqrtK * sqrtK;
-		v = divTrunc(m * KX192, Q192$3);
+		v = divTrunc(m * KX192, Q192$4);
 	} else {
 		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
 		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
@@ -14871,8 +14902,8 @@ function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing,
 		const PX192 = sqrtP * sqrtP;
 		const KX192 = sqrtK * sqrtK;
 		const rX192 = sqrtR * sqrtR;
-		const numerator = m * (2n * sqrtPKR * Q96$2 - PX192 - KX192);
-		const denominator = rX192 - Q192$3;
+		const numerator = m * (2n * sqrtPKR * Q96$3 - PX192 - KX192);
+		const denominator = rX192 - Q192$4;
 		v = divTrunc(numerator, denominator);
 	}
 	const debt = -m;
@@ -14881,19 +14912,19 @@ function getLegValue(leg, currentTick, mintTick, positionSize, poolTickSpacing,
 	if (isPut) {
 		const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 		const KX192 = sqrtK * sqrtK;
-		const debtK = divTrunc(debt * KX192, Q192$3);
+		const debtK = divTrunc(debt * KX192, Q192$4);
 		return debtK + v + itm;
 	} else {
 		const sqrtP = tickToSqrtPriceX96(qCurrentTick);
 		const PX192 = sqrtP * sqrtP;
-		const debtP = divTrunc(debt * PX192, Q192$3);
+		const debtP = divTrunc(debt * PX192, Q192$4);
 		if (definedRisk) {
 			const sqrtPm = tickToSqrtPriceX96(qMintTick);
 			const PmX192 = sqrtPm * sqrtPm;
-			const itmPm = divTrunc(itm * PmX192, Q192$3);
+			const itmPm = divTrunc(itm * PmX192, Q192$4);
 			return debtP + v + itmPm;
 		} else {
-			const itmP = divTrunc(itm * PX192, Q192$3);
+			const itmP = divTrunc(itm * PX192, Q192$4);
 			return debtP + v + itmP;
 		}
 	}
@@ -14929,7 +14960,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 		const signedStrike = leg.asset === 0n ? leg.strike : -leg.strike;
 		const sqrtKraw = tickToSqrtPriceX96(signedStrike);
 		const KrawX192 = sqrtKraw * sqrtKraw;
-		const notional = divTrunc(m * KrawX192, Q192$3);
+		const notional = divTrunc(m * KrawX192, Q192$4);
 		return -notional;
 	}
 	if (halfWidthTick === 0n) {
@@ -14958,8 +14989,8 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 		const sqrtKR = tickToSqrtPriceX96(qStrikeTick + halfWidthTick);
 		const sqrtR = tickToSqrtPriceX96(halfWidthTick);
 		const rX192 = sqrtR * sqrtR;
-		const numerator = m * (sqrtKR - sqrtP) * Q192$3;
-		const denominator = sqrtP * (rX192 - Q192$3);
+		const numerator = m * (sqrtKR - sqrtP) * Q192$4;
+		const denominator = sqrtP * (rX192 - Q192$4);
 		vDelta = divTrunc(numerator, denominator);
 	}
 	const isPut = !isCall(leg.tokenType, isAssetToken0);
@@ -14979,10 +15010,10 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 			const sqrtK = tickToSqrtPriceX96(qStrikeTick);
 			const sqrtPm = tickToSqrtPriceX96(qMintTick);
 			const rX192 = sqrtR * sqrtR;
-			const sqrtKPmX96 = sqrtK * Q96$2 / sqrtPm;
+			const sqrtKPmX96 = sqrtK * Q96$3 / sqrtPm;
 			const diff = sqrtR - sqrtKPmX96;
 			const diffSqX192 = diff * diff;
-			return divTrunc(m * diffSqX192, rX192 - Q192$3);
+			return divTrunc(m * diffSqX192, rX192 - Q192$4);
 		}
 	})();
 	return definedRisk ? debtDelta + vDelta : debtDelta + vDelta + itmDelta;
@@ -14991,7 +15022,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 function toVaultFrameAtTick(delta, fromAsset, vaultAssetIndex, currentTick, flipSignOnAssetInversion = false) {
 	if (fromAsset === vaultAssetIndex) return delta;
 	const sqrtPriceX96 = tickToSqrtPriceX96(currentTick);
-	const converted = vaultAssetIndex === 0n ? delta * Q192$3 / (sqrtPriceX96 * sqrtPriceX96) : delta * sqrtPriceX96 * sqrtPriceX96 / Q192$3;
+	const converted = vaultAssetIndex === 0n ? delta * Q192$4 / (sqrtPriceX96 * sqrtPriceX96) : delta * sqrtPriceX96 * sqrtPriceX96 / Q192$4;
 	return flipSignOnAssetInversion ? -converted : converted;
 }
 /**
@@ -15040,8 +15071,8 @@ function getLegGamma(leg, currentTick, positionSize, poolTickSpacing, assetIndex
 	const sqrtKPR = tickToSqrtPriceX96(qStrikeTick + qCurrentTick + halfWidthTick);
 	const sqrtR = tickToSqrtPriceX96(halfWidthTick);
 	const rX192 = sqrtR * sqrtR;
-	const numerator = m * sqrtKPR * Q96$2;
-	const denominator = 2n * (rX192 - Q192$3);
+	const numerator = m * sqrtKPR * Q96$3;
+	const denominator = 2n * (rX192 - Q192$4);
 	return divTrunc(numerator, denominator);
 }
 /**
@@ -17672,7 +17703,7 @@ function maximumAmountIn(estimatedAmountIn, slippageBps) {
 	if (slippageBps < 0n) throw new PanopticError("slippageBps must be non-negative");
 	return (estimatedAmountIn * (BPS_DENOMINATOR$5 + slippageBps) + BPS_DENOMINATOR$5 - 1n) / BPS_DENOMINATOR$5;
 }
-function ceilDiv$3(numerator, denominator) {
+function ceilDiv$4(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
 }
 function getInputAmount(tokenFlow, tokenInIndex) {
@@ -17777,7 +17808,7 @@ async function quoteTokenShortfallRecovery(params) {
 			const estimatedAmountIn = getInputAmount(swapSimulation.tokenFlow, tokenInIndex);
 			const estimatedAmountOut = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 			if (estimatedAmountOut < requiredOutput) {
-				creditInput = estimatedAmountOut > 0n ? ceilDiv$3(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
+				creditInput = estimatedAmountOut > 0n ? ceilDiv$4(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
 				continue;
 			}
 			const recoveredDispatch = buildPrefixedExactInputRecoveryDispatch({
@@ -17832,7 +17863,7 @@ async function quoteTokenShortfallRecovery(params) {
 			};
 			const residual = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 			requiredOutput += residual > 0n ? residual : requiredOutput;
-			creditInput = ceilDiv$3(creditInput * requiredOutput, estimatedAmountOut) + 1n;
+			creditInput = ceilDiv$4(creditInput * requiredOutput, estimatedAmountOut) + 1n;
 		}
 		return {
 			available: false,
@@ -17887,7 +17918,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const maxAmountIn = maximumAmountIn(estimatedAmountIn, params.slippageBps);
 		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 		if (swapOutput < amountOut) {
-			creditOutSize = swapOutput > 0n ? ceilDiv$3(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+			creditOutSize = swapOutput > 0n ? ceilDiv$4(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 			continue;
 		}
 		const recoverySimulation = await simulateDispatch({
@@ -17942,7 +17973,7 @@ async function quoteTokenShortfallRecovery(params) {
 		if (decodedShortfall >= shortfallError.assetsRequested - shortfallError.assetBalance) return quotePrefixedExactInput(amountOut);
 		const additionalAmountOut = decodedShortfall > 0n ? decodedShortfall : amountOut;
 		amountOut += additionalAmountOut;
-		creditOutSize = swapOutput > 0n ? ceilDiv$3(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+		creditOutSize = swapOutput > 0n ? ceilDiv$4(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 	}
 	return quotePrefixedExactInput(shortfallError.assetsRequested - shortfallError.assetBalance);
 }
@@ -20864,7 +20895,7 @@ async function getItmAmounts(params) {
 * high-decimal amount can't masquerade as real flow.
 */
 const FLOW_NEUTRAL_DUST_THRESHOLD = 1000n;
-const Q192$2 = 1n << 192n;
+const Q192$3 = 1n << 192n;
 const POOL_ID_MASK$2 = (1n << 64n) - 1n;
 /**
 * Floor integer square root for bigints (Newton's method). Exact for all
@@ -20900,7 +20931,7 @@ function buildNeutralLeg(tokenIndex, signedAmount, positionSize) {
 	const absAmount = signedAmount < 0n ? -signedAmount : signedAmount;
 	const legAsset = tokenIndex === 0n ? 1n : 0n;
 	const legIsLong = signedAmount < 0n;
-	const sqrtKrawX96 = isqrt(absAmount * Q192$2 / positionSize);
+	const sqrtKrawX96 = isqrt(absAmount * Q192$3 / positionSize);
 	let signedTick;
 	try {
 		signedTick = sqrtPriceX96ToTick(sqrtKrawX96);
@@ -21158,7 +21189,7 @@ async function createFlowNeutralTokenId(params) {
 	const sqrtPX96 = tickToSqrtPriceX96(tickBefore);
 	const valueAbs = (index, amount) => {
 		const abs$1 = amount < 0n ? -amount : amount;
-		return index === 0n ? abs$1 * sqrtPX96 * sqrtPX96 / Q192$2 : abs$1;
+		return index === 0n ? abs$1 * sqrtPX96 * sqrtPX96 / Q192$3 : abs$1;
 	};
 	const flowFor = (index) => index === 0n ? credit.creditAmount0 : credit.creditAmount1;
 	if (queryAddress !== void 0) {
@@ -22131,7 +22162,7 @@ async function getPoolLiquidities(params) {
 
 //#endregion
 //#region src/panoptic/v2/reads/accountGreeks.ts
-const Q192$1 = 1n << 192n;
+const Q192$2 = 1n << 192n;
 /**
 * Calculate account-level greeks using stored position data.
 *
@@ -22252,8 +22283,8 @@ async function getAccountGreeks(params) {
 		const assetBal = isAssetToken0 ? collateral.token0.assets : collateral.token1.assets;
 		const otherBal = isAssetToken0 ? collateral.token1.assets : collateral.token0.assets;
 		const sqrtPriceX96 = tickToSqrtPriceX96(BigInt(currentTick));
-		if (isAssetToken0) collateralValue = assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 + otherBal;
-		else collateralValue = assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96) + otherBal;
+		if (isAssetToken0) collateralValue = assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$2 + otherBal;
+		else collateralValue = assetBal * Q192$2 / (sqrtPriceX96 * sqrtPriceX96) + otherBal;
 		collateralDelta = assetBal;
 	}
 	return {
@@ -22293,7 +22324,7 @@ function calculateAccountGreeksPure(params) {
 		const totalDelta$1 = [];
 		for (let i = 0; i < n; i++) {
 			const sqrtPriceX96 = tickToSqrtPriceX96(atTicks[i]);
-			const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 : assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96);
+			const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$2 : assetBal * Q192$2 / (sqrtPriceX96 * sqrtPriceX96);
 			totalValue$1.push(assetValueInNumeraire + otherBal);
 			totalDelta$1.push(assetBal);
 		}
@@ -22343,7 +22374,7 @@ function calculateAccountGreeksPure(params) {
 	}
 	for (let i = 0; i < n; i++) {
 		const sqrtPriceX96 = tickToSqrtPriceX96(atTicks[i]);
-		const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 : assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96);
+		const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$2 : assetBal * Q192$2 / (sqrtPriceX96 * sqrtPriceX96);
 		totalValue[i] += assetValueInNumeraire + otherBal;
 		totalDelta[i] += assetBal;
 	}
@@ -24758,10 +24789,10 @@ async function processClosedPositions(client, queryAddress, positions) {
 //#endregion
 //#region src/panoptic/v2/reads/hedgeCapacity.ts
 const SCALE$1 = 10000000n;
-const FEE_SCALE = 10000n;
-const Q192 = 1n << 192n;
+const FEE_SCALE$1 = 10000n;
+const Q192$1 = 1n << 192n;
 const MASK128$1 = (1n << 128n) - 1n;
-const ceilDiv$2 = (value, divisor) => (value + divisor - 1n) / divisor;
+const ceilDiv$3 = (value, divisor) => (value + divisor - 1n) / divisor;
 function accountHedgeDelta({ positionIds, balances, collateralDelta, tick, tickSpacing, assetIndex }) {
 	return positionIds.reduce((sum$1, id, index) => {
 		const balance = balances[index];
@@ -24781,8 +24812,8 @@ function accountHedgeDelta({ positionIds, balances, collateralDelta, tick, tickS
 function buildCapacityHedge({ delta, assetIndex, tick, tickSpacing, poolId, notionalFee, swapFee }) {
 	const borrowToken = delta >= 0n ? assetIndex : assetIndex === 0n ? 1n : 0n;
 	const receiveToken = borrowToken === 0n ? 1n : 0n;
-	const amount = delta >= 0n ? delta : ceilDiv$2((toVaultFrameAtTick(-delta, assetIndex, borrowToken, tick) + 1n) * 1000000n * FEE_SCALE, (1000000n - swapFee) * (FEE_SCALE - notionalFee));
-	const commission = ceilDiv$2(amount * notionalFee, FEE_SCALE);
+	const amount = delta >= 0n ? delta : ceilDiv$3((toVaultFrameAtTick(-delta, assetIndex, borrowToken, tick) + 1n) * 1000000n * FEE_SCALE$1, (1000000n - swapFee) * (FEE_SCALE$1 - notionalFee));
+	const commission = ceilDiv$3(amount * notionalFee, FEE_SCALE$1);
 	const proceeds = toVaultFrameAtTick((amount - commission) * (1000000n - swapFee) / 1000000n, borrowToken, receiveToken, tick);
 	const tokenId = addLegToTokenId(poolId, {
 		index: 0n,
@@ -24814,7 +24845,7 @@ function hedgeMargin({ tokenData, balanceChanges, crossRatios, tick, buffer }) {
 	const surplus1 = balances[1] > required1 ? (balances[1] - required1) * crossRatios[1] / SCALE$1 : 0n;
 	const sqrt = tickToSqrtPriceX96(tick);
 	const price = sqrt * sqrt;
-	const pairs = sqrt < 1n << 96n ? [[balances[0] + surplus1 * Q192 / price, required0], [balances[1] * Q192 / price + surplus0, ceilDiv$2(required1 * Q192, price)]] : [[balances[0] * price / Q192 + surplus1, ceilDiv$2(required0 * price, Q192)], [balances[1] + surplus0 * price / Q192, required1]];
+	const pairs = sqrt < 1n << 96n ? [[balances[0] + surplus1 * Q192$1 / price, required0], [balances[1] * Q192$1 / price + surplus0, ceilDiv$3(required1 * Q192$1, price)]] : [[balances[0] * price / Q192$1 + surplus1, ceilDiv$3(required0 * price, Q192$1)], [balances[1] + surplus0 * price / Q192$1, required1]];
 	const headroom = pairs.map(([balance, required]) => balance - required);
 	return {
 		solvent: balances.every((balance) => balance >= 0n) && headroom.every((value) => value >= 0n),
@@ -25027,7 +25058,7 @@ async function getHedgeLimits({ client, poolAddress, account, positionIds, asset
 		if (hedge.amount > 0n && BigInt(legCount) >= maxLegs) return unavailable("leg-limit");
 		const totalAssets = hedge.borrowToken === 0n ? total0 : total1;
 		if (hedge.amount > 0n && (hedge.amount > MAX_SIZE || hedge.amount > borrowCapacity[Number(hedge.borrowToken)] || totalAssets === 0n)) return unavailable("capacity");
-		const projectedUtilization = currentUtilizations.map((util, i) => hedge.amount > 0n && BigInt(i) === hedge.borrowToken ? ceilDiv$2(util * totalAssets + hedge.amount * 10000n, totalAssets) : util);
+		const projectedUtilization = currentUtilizations.map((util, i) => hedge.amount > 0n && BigInt(i) === hedge.borrowToken ? ceilDiv$3(util * totalAssets + hedge.amount * 10000n, totalAssets) : util);
 		if (hedge.amount > 0n && projectedUtilization.some((util) => util > 10000n)) return unavailable("capacity");
 		const global = projectedUtilization.map((util, i) => util > globalUtilizations[i] ? util : globalUtilizations[i]);
 		const syntheticBalance = hedge.amount | projectedUtilization[0] << 128n | projectedUtilization[1] << 144n;
@@ -25119,6 +25150,90 @@ async function getHedgeLimits({ client, poolAddress, account, positionIds, asset
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/positionMintFunding.ts
+const Q96$2 = 1n << 96n;
+const Q192 = 1n << 192n;
+const BPS = 10000n;
+const FEE_SCALE = 1000000n;
+const max = (a, b) => a > b ? a : b;
+const ceilDiv$2 = (n, d) => n > 0n ? (n + d - 1n) / d : n / d;
+/**
+* Estimate deposit-independent mint funding, including settlement and commission.
+* Swaps use spot conversion with fees and slippage allowance; execution still needs a live quote.
+* Received tokens cover post-mint margin but cannot fund the other tracker's upfront payment.
+* Each requiredValue is the starting balance when funding entirely in that token.
+*/
+function getPositionMintFunding(params) {
+	const { tokenId, positionSize, sqrtPriceX96, valuationSqrtPriceX96, swapAtMint, commissionRate, swapFee, slippageBps, required0, required1 } = params;
+	if (positionSize < 0n || sqrtPriceX96 <= 0n || valuationSqrtPriceX96 <= 0n || commissionRate < 0n || swapFee < 0n || swapFee >= FEE_SCALE || slippageBps < 0n || slippageBps >= BPS || required0 < 0n || required1 < 0n) throw new RangeError("Invalid mint funding inputs");
+	const { legs, tickSpacing } = decodeTokenId(tokenId);
+	const firstLeg = legs[0];
+	if (!firstLeg || tickSpacing <= 0n) throw new RangeError("Invalid position");
+	let paid0 = 0n;
+	let paid1 = 0n;
+	let itm0 = 0n;
+	let itm1 = 0n;
+	let notional0 = 0n;
+	let notional1 = 0n;
+	for (const leg of legs) {
+		const { sqrtLower, sqrtUpper, liquidity } = getLegLiquidityRange(leg.width === 0n ? {
+			...leg,
+			width: 2n
+		} : leg, positionSize, tickSpacing);
+		const round = !leg.isLong || leg.width === 0n ? ceilDiv$2 : (n, d) => n / d;
+		const moved0 = round((liquidity << 96n) * (sqrtUpper - sqrtLower), sqrtUpper * sqrtLower);
+		const moved1 = round(liquidity * (sqrtUpper - sqrtLower), Q96$2);
+		const sign = leg.isLong ? -1n : 1n;
+		let amm0 = 0n;
+		let amm1 = 0n;
+		if (leg.width > 0n) {
+			const price = max(sqrtLower, sqrtPriceX96 < sqrtUpper ? sqrtPriceX96 : sqrtUpper);
+			amm0 = sign * round((liquidity << 96n) * (sqrtUpper - price), sqrtUpper * price);
+			amm1 = sign * round(liquidity * (price - sqrtLower), Q96$2);
+			itm0 += leg.tokenType === 1n ? amm0 : 0n;
+			itm1 += leg.tokenType === 0n ? amm1 : 0n;
+		} else {
+			itm0 -= leg.tokenType === 0n ? sign * moved0 : 0n;
+			itm1 -= leg.tokenType === 1n ? sign * moved1 : 0n;
+		}
+		paid0 += amm0 - (leg.tokenType === 0n ? sign * moved0 : 0n);
+		paid1 += amm1 - (leg.tokenType === 1n ? sign * moved1 : 0n);
+		notional0 += leg.tokenType === 0n ? moved0 : 0n;
+		notional1 += leg.tokenType === 1n ? moved1 : 0n;
+	}
+	if (swapAtMint && (itm0 !== 0n || itm1 !== 0n)) {
+		const swapToken0 = itm0 !== 0n && (itm1 === 0n || firstLeg.asset === 0n);
+		const priceSquared$1 = sqrtPriceX96 * sqrtPriceX96;
+		const itm = swapToken0 ? itm0 : itm1;
+		const numerator = swapToken0 ? priceSquared$1 : Q192;
+		const denominator = swapToken0 ? Q192 : priceSquared$1;
+		const retained$1 = (FEE_SCALE - swapFee) * (BPS - slippageBps);
+		const scale$1 = FEE_SCALE * BPS;
+		const payment = itm > 0n ? ceilDiv$2(itm * numerator * scale$1, denominator * retained$1) : itm * numerator * retained$1 / (denominator * scale$1);
+		paid0 += swapToken0 ? -itm : payment;
+		paid1 += swapToken0 ? payment : -itm;
+	}
+	paid0 += ceilDiv$2(notional0 * commissionRate, BPS);
+	paid1 += ceilDiv$2(notional1 * commissionRate, BPS);
+	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
+	const inToken0 = (amount0, amount1) => amount0 + ceilDiv$2(amount1 * Q192, priceSquared);
+	const inToken1 = (amount0, amount1) => amount1 + ceilDiv$2(amount0 * priceSquared, Q192);
+	const retained = (FEE_SCALE - swapFee) * (BPS - slippageBps);
+	const scale = FEE_SCALE * BPS;
+	const spotSquared = sqrtPriceX96 * sqrtPriceX96;
+	const upfront0 = max(paid0, 0n) + ceilDiv$2(max(paid1, 0n) * Q192 * scale, spotSquared * retained);
+	const upfront1 = max(paid1, 0n) + ceilDiv$2(max(paid0, 0n) * spotSquared * scale, Q192 * retained);
+	const requiredValue0 = upfront0 + max(0n, inToken0(required0 - max(-paid0, 0n), required1 - max(-paid1, 0n)));
+	const requiredValue1 = upfront1 + max(0n, inToken1(required0 - max(-paid0, 0n), required1 - max(-paid1, 0n)));
+	return {
+		paid0,
+		paid1,
+		requiredValue0,
+		requiredValue1
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/sync/getSyncStatus.ts
 /**
@@ -31040,7 +31155,7 @@ const DEFAULT_INTERVAL_MS = 12000n;
 /**
 * Default maximum block range per poll.
 */
-const DEFAULT_MAX_BLOCK_RANGE = 1000n;
+const DEFAULT_MAX_BLOCK_RANGE$1 = 1000n;
 /**
 * Create an HTTP polling-based event fetcher.
 *
@@ -31077,7 +31192,7 @@ const DEFAULT_MAX_BLOCK_RANGE = 1000n;
 * ```
 */
 function createEventPoller(params) {
-	const { client, poolAddress, collateralTracker0, collateralTracker1, riskEngineAddress, sfpmAddress, poolManagerAddress, eventTypes, onLogs, onError, intervalMs = DEFAULT_INTERVAL_MS, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE, fromBlock } = params;
+	const { client, poolAddress, collateralTracker0, collateralTracker1, riskEngineAddress, sfpmAddress, poolManagerAddress, eventTypes, onLogs, onError, intervalMs = DEFAULT_INTERVAL_MS, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE$1, fromBlock } = params;
 	let isRunning = false;
 	let lastPolledBlock = fromBlock ?? 0n;
 	let pollTimeout = null;
@@ -31265,6 +31380,1355 @@ function createEventPoller(params) {
 	};
 }
 
+//#endregion
+//#region src/abis/UniswapV3Pool.ts
+const UniswapV3PoolAbi = [
+	{
+		inputs: [],
+		stateMutability: "payable",
+		type: "constructor"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			}
+		],
+		name: "Burn",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount0",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount1",
+				type: "uint128"
+			}
+		],
+		name: "Collect",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount0",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount1",
+				type: "uint128"
+			}
+		],
+		name: "CollectProtocol",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "paid0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "paid1",
+				type: "uint256"
+			}
+		],
+		name: "Flash",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [{
+			indexed: false,
+			internalType: "uint16",
+			name: "observationCardinalityNextOld",
+			type: "uint16"
+		}, {
+			indexed: false,
+			internalType: "uint16",
+			name: "observationCardinalityNextNew",
+			type: "uint16"
+		}],
+		name: "IncreaseObservationCardinalityNext",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [{
+			indexed: false,
+			internalType: "uint160",
+			name: "sqrtPriceX96",
+			type: "uint160"
+		}, {
+			indexed: false,
+			internalType: "int24",
+			name: "tick",
+			type: "int24"
+		}],
+		name: "Initialize",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				indexed: true,
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			}
+		],
+		name: "Mint",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol0Old",
+				type: "uint8"
+			},
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol1Old",
+				type: "uint8"
+			},
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol0New",
+				type: "uint8"
+			},
+			{
+				indexed: false,
+				internalType: "uint8",
+				name: "feeProtocol1New",
+				type: "uint8"
+			}
+		],
+		name: "SetFeeProtocol",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "int256",
+				name: "amount0",
+				type: "int256"
+			},
+			{
+				indexed: false,
+				internalType: "int256",
+				name: "amount1",
+				type: "int256"
+			},
+			{
+				indexed: false,
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				indexed: false,
+				internalType: "uint128",
+				name: "liquidity",
+				type: "uint128"
+			},
+			{
+				indexed: false,
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			}
+		],
+		name: "Swap",
+		type: "event"
+	},
+	{
+		inputs: [
+			{
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			}
+		],
+		name: "burn",
+		outputs: [{
+			internalType: "uint256",
+			name: "amount0",
+			type: "uint256"
+		}, {
+			internalType: "uint256",
+			name: "amount1",
+			type: "uint256"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				internalType: "uint128",
+				name: "amount0Requested",
+				type: "uint128"
+			},
+			{
+				internalType: "uint128",
+				name: "amount1Requested",
+				type: "uint128"
+			}
+		],
+		name: "collect",
+		outputs: [{
+			internalType: "uint128",
+			name: "amount0",
+			type: "uint128"
+		}, {
+			internalType: "uint128",
+			name: "amount1",
+			type: "uint128"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "uint128",
+				name: "amount0Requested",
+				type: "uint128"
+			},
+			{
+				internalType: "uint128",
+				name: "amount1Requested",
+				type: "uint128"
+			}
+		],
+		name: "collectProtocol",
+		outputs: [{
+			internalType: "uint128",
+			name: "amount0",
+			type: "uint128"
+		}, {
+			internalType: "uint128",
+			name: "amount1",
+			type: "uint128"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "factory",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "fee",
+		outputs: [{
+			internalType: "uint24",
+			name: "",
+			type: "uint24"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal0X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "feeGrowthGlobal1X128",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "flash",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint16",
+			name: "observationCardinalityNext",
+			type: "uint16"
+		}],
+		name: "increaseObservationCardinalityNext",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint160",
+			name: "sqrtPriceX96",
+			type: "uint160"
+		}],
+		name: "initialize",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "liquidity",
+		outputs: [{
+			internalType: "uint128",
+			name: "",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "maxLiquidityPerTick",
+		outputs: [{
+			internalType: "uint128",
+			name: "",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "int24",
+				name: "tickLower",
+				type: "int24"
+			},
+			{
+				internalType: "int24",
+				name: "tickUpper",
+				type: "int24"
+			},
+			{
+				internalType: "uint128",
+				name: "amount",
+				type: "uint128"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "mint",
+		outputs: [{
+			internalType: "uint256",
+			name: "amount0",
+			type: "uint256"
+		}, {
+			internalType: "uint256",
+			name: "amount1",
+			type: "uint256"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		name: "observations",
+		outputs: [
+			{
+				internalType: "uint32",
+				name: "blockTimestamp",
+				type: "uint32"
+			},
+			{
+				internalType: "int56",
+				name: "tickCumulative",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityCumulativeX128",
+				type: "uint160"
+			},
+			{
+				internalType: "bool",
+				name: "initialized",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint32[]",
+			name: "secondsAgos",
+			type: "uint32[]"
+		}],
+		name: "observe",
+		outputs: [{
+			internalType: "int56[]",
+			name: "tickCumulatives",
+			type: "int56[]"
+		}, {
+			internalType: "uint160[]",
+			name: "secondsPerLiquidityCumulativeX128s",
+			type: "uint160[]"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes32",
+			name: "",
+			type: "bytes32"
+		}],
+		name: "positions",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidity",
+				type: "uint128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthInside0LastX128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthInside1LastX128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint128",
+				name: "tokensOwed0",
+				type: "uint128"
+			},
+			{
+				internalType: "uint128",
+				name: "tokensOwed1",
+				type: "uint128"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "protocolFees",
+		outputs: [{
+			internalType: "uint128",
+			name: "token0",
+			type: "uint128"
+		}, {
+			internalType: "uint128",
+			name: "token1",
+			type: "uint128"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint8",
+			name: "feeProtocol0",
+			type: "uint8"
+		}, {
+			internalType: "uint8",
+			name: "feeProtocol1",
+			type: "uint8"
+		}],
+		name: "setFeeProtocol",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "slot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint16",
+				name: "observationIndex",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinality",
+				type: "uint16"
+			},
+			{
+				internalType: "uint16",
+				name: "observationCardinalityNext",
+				type: "uint16"
+			},
+			{
+				internalType: "uint8",
+				name: "feeProtocol",
+				type: "uint8"
+			},
+			{
+				internalType: "bool",
+				name: "unlocked",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int24",
+			name: "tickLower",
+			type: "int24"
+		}, {
+			internalType: "int24",
+			name: "tickUpper",
+			type: "int24"
+		}],
+		name: "snapshotCumulativesInside",
+		outputs: [
+			{
+				internalType: "int56",
+				name: "tickCumulativeInside",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityInsideX128",
+				type: "uint160"
+			},
+			{
+				internalType: "uint32",
+				name: "secondsInside",
+				type: "uint32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "recipient",
+				type: "address"
+			},
+			{
+				internalType: "bool",
+				name: "zeroForOne",
+				type: "bool"
+			},
+			{
+				internalType: "int256",
+				name: "amountSpecified",
+				type: "int256"
+			},
+			{
+				internalType: "uint160",
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "swap",
+		outputs: [{
+			internalType: "int256",
+			name: "amount0",
+			type: "int256"
+		}, {
+			internalType: "int256",
+			name: "amount1",
+			type: "int256"
+		}],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int16",
+			name: "",
+			type: "int16"
+		}],
+		name: "tickBitmap",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "tickSpacing",
+		outputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "int24",
+			name: "",
+			type: "int24"
+		}],
+		name: "ticks",
+		outputs: [
+			{
+				internalType: "uint128",
+				name: "liquidityGross",
+				type: "uint128"
+			},
+			{
+				internalType: "int128",
+				name: "liquidityNet",
+				type: "int128"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside0X128",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "feeGrowthOutside1X128",
+				type: "uint256"
+			},
+			{
+				internalType: "int56",
+				name: "tickCumulativeOutside",
+				type: "int56"
+			},
+			{
+				internalType: "uint160",
+				name: "secondsPerLiquidityOutsideX128",
+				type: "uint160"
+			},
+			{
+				internalType: "uint32",
+				name: "secondsOutside",
+				type: "uint32"
+			},
+			{
+				internalType: "bool",
+				name: "initialized",
+				type: "bool"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token0",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "token1",
+		outputs: [{
+			internalType: "address",
+			name: "",
+			type: "address"
+		}],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+
+//#endregion
+//#region src/panoptic/v2/events/poolSwapStream.ts
+const DEFAULT_POLL_INTERVAL_MS$1 = 3e3;
+const FAILURE_WINDOW_MS = 3e4;
+const FAILURES_BEFORE_POLL = 3;
+const STREAM_RETRY_MIN_MS = 15e3;
+const STREAM_RETRY_MAX_MS = 3e5;
+const RESYNC_JITTER_MS = 2e3;
+const EVENT_SOURCE_CLOSED = 2;
+function parseRecord(data) {
+	const value = JSON.parse(data);
+	if (typeof value !== "object" || value === null) throw new Error("Malformed stream frame");
+	return value;
+}
+function bigintField(record, field) {
+	const value = record[field];
+	if (typeof value !== "string") throw new Error(`Stream frame is missing ${field}`);
+	return BigInt(value);
+}
+function numberField(record, field) {
+	const value = record[field];
+	if (typeof value !== "number") throw new Error(`Stream frame is missing ${field}`);
+	return value;
+}
+function parseStreamedKey(data) {
+	const record = parseRecord(data);
+	return {
+		blockNumber: bigintField(record, "blockNumber"),
+		logIndex: numberField(record, "logIndex")
+	};
+}
+function parseStreamedSwap(data) {
+	const record = parseRecord(data);
+	const transactionHash = record.transactionHash;
+	if (typeof transactionHash !== "string") throw new Error("Stream frame is missing transactionHash");
+	return {
+		...parseStreamedKey(data),
+		timestamp: bigintField(record, "timestamp"),
+		transactionHash,
+		tick: numberField(record, "tick"),
+		amount0: bigintField(record, "amount0"),
+		amount1: bigintField(record, "amount1"),
+		sqrtPriceX96: bigintField(record, "sqrtPriceX96"),
+		liquidity: bigintField(record, "liquidity")
+	};
+}
+function parseHead(data) {
+	return bigintField(parseRecord(data ?? ""), "head");
+}
+function defaultEventSource() {
+	const EventSourceCtor = globalThis.EventSource;
+	return EventSourceCtor && ((url) => new EventSourceCtor(url));
+}
+function toError$1(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+/**
+* Stream a pool's swaps from the relay at `streamUrl`.
+*
+* Every `ready`/`resync` frame carries the relay's head; swaps from the cursor up
+* to that head are fetched over HTTP so nothing is lost across reconnects. A
+* stream that closes, or errors three times in 30 s, is replaced by HTTP polling
+* and retried with backoff; one that closes before ever opening is not retried.
+*/
+function streamPoolSwaps(params) {
+	const { client, pool, fromBlock, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS$1, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE, streamUrl, onSwaps, onError, onRemoved, onTransport, eventSource = defaultEventSource() } = params;
+	let running = true;
+	let cursor = fromBlock === void 0 ? void 0 : fromBlock - 1n;
+	let transport = "off";
+	let failures = [];
+	let source;
+	let poller;
+	let retryTimer;
+	let retryDelayMs = STREAM_RETRY_MIN_MS;
+	let catchUpTimer;
+	let catchUpTarget;
+	let catchingUp = false;
+	let everOpened = false;
+	const setTransport = (next) => {
+		if (next === transport) return;
+		transport = next;
+		onTransport?.(next);
+	};
+	const advance = (block) => {
+		if (block !== void 0 && (cursor === void 0 || block > cursor)) cursor = block;
+	};
+	const report = (error) => {
+		if (running) onError?.(toError$1(error));
+	};
+	const catchUpPending = () => catchingUp || catchUpTarget !== void 0;
+	const runCatchUp = async () => {
+		catchingUp = true;
+		while (running && catchUpTarget !== void 0) {
+			const head = catchUpTarget;
+			catchUpTarget = void 0;
+			if (cursor === void 0) {
+				cursor = head;
+				continue;
+			}
+			try {
+				const { swaps } = await fetchPoolSwaps(client, pool, cursor + 1n, head, maxBlockRange);
+				if (!running) break;
+				const first = swaps[0];
+				const last = swaps[swaps.length - 1];
+				if (first && last) onSwaps(swaps, {
+					fromBlock: first.blockNumber,
+					toBlock: last.blockNumber
+				});
+				advance(head);
+			} catch (error) {
+				report(error);
+				if (catchUpTarget === void 0 || catchUpTarget < head) catchUpTarget = head;
+				catchingUp = false;
+				catchUpTimer = setTimeout(() => void runCatchUp(), pollIntervalMs);
+				return;
+			}
+		}
+		catchingUp = false;
+	};
+	const catchUp = (head, delayMs = 0) => {
+		if (catchUpTarget === void 0 || head > catchUpTarget) catchUpTarget = head;
+		if (catchingUp) return;
+		if (catchUpTimer !== void 0) clearTimeout(catchUpTimer);
+		catchUpTimer = setTimeout(() => {
+			catchUpTimer = void 0;
+			runCatchUp();
+		}, delayMs);
+	};
+	const startPolling = () => {
+		if (poller) return;
+		poller = watchPoolSwaps({
+			client,
+			pool,
+			fromBlock: cursor === void 0 ? void 0 : cursor + 1n,
+			pollIntervalMs,
+			maxBlockRange,
+			onSwaps,
+			onError
+		});
+		setTransport("poll");
+	};
+	const stopPolling = () => {
+		if (!poller) return;
+		advance(poller.lastScannedBlock());
+		poller.stop();
+		poller = void 0;
+	};
+	const closeStream = () => {
+		source?.close();
+		source = void 0;
+	};
+	const scheduleStreamRetry = () => {
+		retryTimer = setTimeout(() => {
+			retryTimer = void 0;
+			if (running) openStream();
+		}, retryDelayMs);
+		retryDelayMs = Math.min(retryDelayMs * 2, STREAM_RETRY_MAX_MS);
+	};
+	const openStream = () => {
+		if (!eventSource) {
+			startPolling();
+			return;
+		}
+		const es = eventSource(streamUrl);
+		source = es;
+		failures = [];
+		let opened = false;
+		const listen = (type, handle) => es.addEventListener(type, (event) => {
+			if (!running || source !== es) return;
+			try {
+				handle(event.data);
+			} catch (error) {
+				report(error);
+			}
+		});
+		listen("open", () => {
+			opened = true;
+			everOpened = true;
+			failures = [];
+			retryDelayMs = STREAM_RETRY_MIN_MS;
+		});
+		listen("ready", (data) => {
+			const head = parseHead(data);
+			stopPolling();
+			setTransport("stream");
+			catchUp(head);
+		});
+		listen("resync", (data) => {
+			catchUp(parseHead(data), Math.random() * RESYNC_JITTER_MS);
+		});
+		listen("swap", (data) => {
+			const swap = parseStreamedSwap(data ?? "");
+			onSwaps([swap], {
+				fromBlock: swap.blockNumber,
+				toBlock: swap.blockNumber
+			});
+			if (!catchUpPending()) advance(swap.blockNumber);
+		});
+		listen("removed", (data) => {
+			onRemoved?.(parseStreamedKey(data ?? ""));
+		});
+		listen("error", () => {
+			const now = Date.now();
+			failures = failures.filter((at) => now - at < FAILURE_WINDOW_MS);
+			failures.push(now);
+			const closed = es.readyState === EVENT_SOURCE_CLOSED;
+			if (!closed && failures.length < FAILURES_BEFORE_POLL) return;
+			closeStream();
+			startPolling();
+			if (closed && !opened && !everOpened) return;
+			scheduleStreamRetry();
+		});
+	};
+	openStream();
+	return {
+		stop() {
+			running = false;
+			closeStream();
+			stopPolling();
+			if (retryTimer !== void 0) clearTimeout(retryTimer);
+			if (catchUpTimer !== void 0) clearTimeout(catchUpTimer);
+			setTransport("off");
+		},
+		lastScannedBlock: () => cursor,
+		transport: () => transport
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/events/poolSwaps.ts
+const DEFAULT_POLL_INTERVAL_MS = 3e3;
+const DEFAULT_MAX_BLOCK_RANGE = 2000n;
+const SHARED_BUFFER_LIMIT = 4096;
+/**
+* Parse a decoded v3 `UniswapV3Pool.Swap` or v4 `PoolManager.Swap` log.
+*/
+function parseSwapLog(log, timestamp) {
+	if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) throw new Error("Cannot parse a pending Swap log");
+	const args = log.args;
+	return {
+		blockNumber: log.blockNumber,
+		logIndex: log.logIndex,
+		timestamp,
+		transactionHash: log.transactionHash,
+		tick: Number(args.tick),
+		amount0: args.amount0,
+		amount1: args.amount1,
+		sqrtPriceX96: args.sqrtPriceX96,
+		liquidity: args.liquidity
+	};
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+async function fetchSwapLogs(client, pool, fromBlock, toBlock) {
+	if (pool.version === "v3") return client.getContractEvents({
+		address: pool.poolAddress,
+		abi: UniswapV3PoolAbi,
+		eventName: "Swap",
+		fromBlock,
+		toBlock
+	});
+	return client.getContractEvents({
+		address: pool.poolManager,
+		abi: poolManagerAbi,
+		eventName: "Swap",
+		args: { id: pool.poolId },
+		fromBlock,
+		toBlock
+	});
+}
+async function fetchSwaps(client, pool, fromBlock, toBlock) {
+	const logs = await fetchSwapLogs(client, pool, fromBlock, toBlock);
+	if (logs.length === 0) return [];
+	const blockNumbers = [...new Set(logs.flatMap((log) => log.blockNumber === null ? [] : [log.blockNumber]))];
+	const blocks = await Promise.all(blockNumbers.map((blockNumber) => client.getBlock({ blockNumber })));
+	const timestamps = new Map(blocks.map((block, i) => [blockNumbers[i], block.timestamp]));
+	return logs.map((log) => parseSwapLog(log, timestamps.get(log.blockNumber ?? -1n) ?? 0n)).sort((a, b) => a.blockNumber === b.blockNumber ? a.logIndex - b.logIndex : a.blockNumber < b.blockNumber ? -1 : 1);
+}
+/**
+* Fetch a pool's swaps in `[fromBlock, toBlock]` (default: the current head), in
+* chain order. Returns no swaps when `fromBlock > toBlock`.
+*/
+async function fetchPoolSwaps(client, pool, fromBlock, toBlock, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE) {
+	const end = toBlock ?? await client.getBlockNumber();
+	const swaps = [];
+	for (let from = fromBlock; from <= end; from += maxBlockRange) {
+		const to = from + maxBlockRange - 1n < end ? from + maxBlockRange - 1n : end;
+		swaps.push(...await fetchSwaps(client, pool, from, to));
+	}
+	return {
+		swaps,
+		toBlock: end
+	};
+}
+/**
+* Poll a single pool's `Swap` logs with `eth_getLogs`, timestamped by block.
+*
+* Works over plain HTTP (no filters or websockets). A chunk that fails is retried on
+* the next tick; errors never stop the loop.
+*/
+function watchPoolSwaps(params) {
+	const { client, pool, fromBlock, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, maxBlockRange = DEFAULT_MAX_BLOCK_RANGE, onSwaps, onError } = params;
+	let running = true;
+	let lastScanned;
+	let timer;
+	const poll = async () => {
+		try {
+			const head = await client.getBlockNumber();
+			let from = lastScanned !== void 0 ? lastScanned + 1n : fromBlock ?? head;
+			while (running && from <= head) {
+				const to = from + maxBlockRange - 1n < head ? from + maxBlockRange - 1n : head;
+				const swaps = await fetchSwaps(client, pool, from, to);
+				if (!running) return;
+				if (swaps.length > 0) onSwaps(swaps, {
+					fromBlock: from,
+					toBlock: to
+				});
+				lastScanned = to;
+				from = to + 1n;
+			}
+		} catch (error) {
+			if (running) onError?.(toError(error));
+		}
+		if (running) timer = setTimeout(() => void poll(), pollIntervalMs);
+	};
+	poll();
+	return {
+		stop() {
+			running = false;
+			if (timer !== void 0) clearTimeout(timer);
+		},
+		lastScannedBlock: () => lastScanned
+	};
+}
+const sharedWatchers = new Map();
+function swapKey(key) {
+	return `${key.blockNumber}:${key.logIndex}`;
+}
+/**
+* Ref-counted pool swap feed: subscribers with the same `key` share one watcher
+* (relay stream when `streamUrl` is set, else HTTP polling), duplicates are
+* dropped, late subscribers first receive the swaps already seen, and the watcher
+* stops when the last subscriber unsubscribes.
+*/
+function subscribePoolSwaps(params) {
+	const { key, streamUrl, onSwaps, onError, onRemoved, onTransport,...watchParams } = params;
+	const listener = {
+		onSwaps,
+		onError,
+		onRemoved,
+		onTransport
+	};
+	const existing = sharedWatchers.get(key);
+	if (existing) {
+		existing.listeners.add(listener);
+		const buffered = [...existing.buffer.values()];
+		const first = buffered[0];
+		const last = buffered[buffered.length - 1];
+		if (first && last) onSwaps(buffered, {
+			fromBlock: first.blockNumber,
+			toBlock: last.blockNumber
+		});
+		onTransport?.(existing.transport);
+	} else {
+		const listeners = new Set([listener]);
+		const buffer = new Map();
+		const entry = {
+			watcher: {
+				stop: () => void 0,
+				lastScannedBlock: () => void 0
+			},
+			listeners,
+			buffer,
+			transport: "off"
+		};
+		const setTransport = (transport) => {
+			entry.transport = transport;
+			for (const l of listeners) l.onTransport?.(transport);
+		};
+		const callbacks = {
+			onSwaps: (swaps, range) => {
+				const fresh = swaps.filter((swap) => !buffer.has(swapKey(swap)));
+				if (fresh.length === 0) return;
+				for (const swap of fresh) buffer.set(swapKey(swap), swap);
+				for (const k of buffer.keys()) {
+					if (buffer.size <= SHARED_BUFFER_LIMIT) break;
+					buffer.delete(k);
+				}
+				for (const l of listeners) l.onSwaps(fresh, range);
+			},
+			onError: (error) => {
+				for (const l of listeners) l.onError?.(error);
+			}
+		};
+		sharedWatchers.set(key, entry);
+		if (streamUrl !== void 0) entry.watcher = streamPoolSwaps({
+			...watchParams,
+			...callbacks,
+			streamUrl,
+			onRemoved: (removed) => {
+				buffer.delete(swapKey(removed));
+				for (const l of listeners) l.onRemoved?.(removed);
+			},
+			onTransport: setTransport
+		});
+		else {
+			entry.watcher = watchPoolSwaps({
+				...watchParams,
+				...callbacks
+			});
+			setTransport("poll");
+		}
+	}
+	return () => {
+		const entry = sharedWatchers.get(key);
+		if (!entry) return;
+		entry.listeners.delete(listener);
+		if (entry.listeners.size === 0) {
+			entry.watcher.stop();
+			sharedWatchers.delete(key);
+		}
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/strike/ladder.ts
 /** Target number of rungs across a leg's full range (lower tick → upper tick). */
@@ -32742,7 +34206,7 @@ function calculatePositionVolatilityMetrics({ observations, netPremium, baseFees
 	for (const point of points) if (!point.price.isFinite() || point.price.lte(0) || !point.gamma.isFinite() || point.rangeGammas.some((gamma) => !gamma.isFinite())) throw new RangeError("Invalid price or gamma observation");
 	const quantum = new Precision(10).pow(-quoteDecimals);
 	const gammas = points.flatMap((point) => [point.gamma, ...point.rangeGammas]);
-	const peak = gammas.reduce((max, gamma) => Precision.max(max, gamma.abs()), new Precision(0));
+	const peak = gammas.reduce((max$1, gamma) => Precision.max(max$1, gamma.abs()), new Precision(0));
 	const tolerance = Precision.max(quantum, peak.mul("1e-12"));
 	const positive = gammas.some((gamma) => gamma.gt(tolerance));
 	const negative = gammas.some((gamma) => gamma.lt(tolerance.neg()));
@@ -33213,5 +34677,5 @@ async function getPositionVolatilityHistory({ client, poolAddress, account, toke
 }
 
 //#endregion
-export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MARKET_INDICATOR_PERIODS, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, STRIKE_LADDER_TARGET_STRIKES, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, VARIANCE_RATIO_LAG, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculateMarketIndicator, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculatePositionValues, calculatePositionVolatilityMetrics, calculateResyncBlock, calculateSpreadWad, calculateVarianceProfile, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralCurveTicks, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, emptyLiquidateParams, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCloseZapSwap, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feeGrowthInsideX128, feesFromFeeGrowthDelta, fetchPoolId, fetchSfpmV3PoolId, fetchUniswapFeeData, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosePositionTransferEstimate, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralCurve, getCollateralCurveInputs, getCollateralData, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, getGuardianUnlockState, getHedgeLimits, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getNotEnoughTokensError, getOpenPositionIds, getOpenPositionPreview, getOracleRiskParameters, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionDeltaMetrics, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositionValueCurve, getPositionVolatilityHistory, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getSimpleLoanTokenIndex, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, ladderStrikeSequence, liquidate, liquidateAndWait, loadCheckpoint, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, netLiquidationValueInQuote, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, positionValueKey, positionValueTicks, prepareIndicatorCandles, prepareLiquidityGamma, preparePositionGamma, preparePositionValue, preparePositionValueCurve, previewBorrow, previewDeposit, previewMint, previewRedeem, previewRepay, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, quoteV3ExactIn, ratePerSecWadToAprPct, realizedBeta, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateBatchDispatch, simulateClosePosition, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, valuePositionAccrual, verifyBlockContinuity, watchEvents, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
+export { AccountInsolventError, AlreadyInitializedError, BORROW_INDEX_BITS, BPS_DENOMINATOR, BPS_SCALE, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MARKET_INDICATOR_PERIODS, MAX_TICK, MAX_TRACKED_CHUNKS, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MIN_TICK, MaxRetriesExceededError, MissingPositionIdsError, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, ORACLE_EPOCH_SECONDS, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, RATE_AT_TARGET_BITS, REORG_DEPTH, REQUIRED_BASE_ERROR_SENTINEL, ReentrancyError, RpcError, RpcResponseError, SCHEMA_VERSION, SECONDS_PER_YEAR, STANDARD_TICK_WIDTHS, STORAGE_PREFIX, STRIKE_LADDER_TARGET_STRIKES, SafeModeError, StaleDataError, StaleOracleError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UNREALIZED_INTEREST_BITS, UTILIZATION_DENOMINATOR, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, VARIANCE_RATIO_LAG, WAD, WrongPoolIdError, WrongUniswapPoolError, ZERO_COLLATERAL, ZERO_VALUATION, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, addPendingPosition, addTrackedChunks, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, apportion, approve, approveAndWait, approvePool, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, borrow, borrowAndWait, buildBatchDispatchArgs, buildCreditSwapCall, buildCreditWrappedDispatch, buildOpenPositionCalldata, buildProtectedSettleDispatch, buildProtectedSettlePlan, buildSettleSequenceCalls, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, buildUniqueCredit, buildUniqueLoan, buildUniqueWidthZeroLeg, calculateAccountGreeksPure, calculateMarketIndicator, calculatePortfolioDelta, calculatePortfolioGamma, calculatePortfolioGreeks, calculatePortfolioValue, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionDeltaWithSwap, calculatePositionGamma, calculatePositionGreeks, calculatePositionValue, calculatePositionValues, calculatePositionVolatilityMetrics, calculateResyncBlock, calculateSpreadWad, calculateVarianceProfile, cancelTransaction, checkApproval, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearCheckpoint, clearPendingPositions, clearTrackedChunks, clearTrackedPositions, clearTradeHistory, closePosition, closePositionAndWait, collateralCurveTicks, collateralRuleKindFor, collateralTrackerV2Abi, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, countLegs, createEventPoller, createEventSubscription, createFileStorage, createFlowNeutralTokenId, createMemoryStorage, createNonceManager, createPoolFormatters, createTokenIdBuilder, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePanopticTokenURI, decodePoolId, decodeTickSpacing, decodeTokenId, decodeVegoid, deployNewPool, deployNewPoolAndWait, deposit, depositAndWait, deriveSupplyRatePerSecWad, deriveUniqueTokenId, detectReorg, diagnoseOracleSafeMode, dispatch, dispatchAndWait, emptyLiquidateParams, encodeLeg, encodePoolId, encodePoolKeyBytes, encodeV3PoolKeyBytes, encodeV4PoolId, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCloseZapSwap, estimateCollateralBreakdown, estimateCollateralRequired, executeBatchDispatch, executeBatchDispatchAndWait, executeSettleSequence, executeSettleSequenceAndWait, failPendingPosition, feeGrowthInsideX128, feesFromFeeGrowthDelta, fetchPoolId, fetchPoolSwaps, fetchSfpmV3PoolId, fetchUniswapFeeData, forceExercise, forceExerciseAndWait, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatPoolIdHex, formatPriceRange, formatRateWad, formatRatioPercent, formatTick, formatTickRange, formatTimestamp, formatTimestampLocale, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWad, formatWadPercent, formatWadSigned, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountCollateral, getAccountGreeks, getAccountHistory, getAccountPremia, getAccountSummaryBasic, getAccountSummaryRisk, getAssetIndex, getBlockMeta, getChainDeployment, getChunkLiquidities, getChunkSpreads, getClosePositionTransferEstimate, getClosedPositions, getClosedPositionsKey, getCollateralAddresses, getCollateralCurve, getCollateralCurveInputs, getCollateralData, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getCurrentRates, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, getGuardianUnlockState, getHedgeLimits, getInterestState, getIrmCurrent, getIrmCurve, getItmAmounts, getLegDelta, getLegDeltaInVaultFrame, getLegGamma, getLegNetValueWidth0, getLegValue, getLiquidationPrices, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNetLiquidationValue, getNetLiquidationValues, getNotEnoughTokensError, getOpenPositionIds, getOpenPositionPreview, getOracleRiskParameters, getOracleState, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPortfolioValue, getPosition, getPositionChunkData, getPositionDeltaMetrics, getPositionEnrichmentData, getPositionGreeks, getPositionMetaKey, getPositionMintFunding, getPositionValueCurve, getPositionVolatilityHistory, getPositions, getPositionsKey, getPositionsWithPremia, getPriceHistory, getPricesAtTick, getRealizedPnL, getRequiredCreditForITM, getRiskParameters, getSafeMode, getSchemaVersionKey, getSimpleLoanTokenIndex, getStreamiaHistory, getSyncCheckpointKey, getSyncStatus, getTickSpacing, getTokenIdValidationError, getTokenListId, getTrackedChunks, getTrackedChunksKey, getTrackedPositionIds, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, getUtilization, hasLoanOrCredit, hasLongLeg, interpolateBlocks, isCall, isCredit, isCreditLeg, isDefinedRisk, isGasError, isInputListFailError, isLiquidatable, isLoan, isLoanLeg, isNonceError, isPanopticErrorType, isPositionTracked, isRetryableRpcError, isShortOnly, isSpread, isSupportedChain, isolateGroupTokenId, jsonSerializer, ladderStrikeSequence, liquidate, liquidateAndWait, loadCheckpoint, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, mint, mintAndWait, mintableAfterBuffer, multicallRead, netLiquidationValueInQuote, openPosition, openPositionAndWait, optimizeTokenIdRiskPartners, oracleEpochAt, orderListForSettle, packMarketState, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parseBps, parseCollateralLog, parsePanopticError, parsePoolLog, parseStreamedKey, parseStreamedSwap, parseSwapLog, parseTokenAmount, parseTokenListId, parseWad, planDeriveStrategy, pokeOracle, pokeOracleAndWait, positionValueKey, positionValueTicks, prepareIndicatorCandles, prepareLiquidityGamma, preparePositionGamma, preparePositionValue, preparePositionValueCurve, previewBorrow, previewDeposit, previewMint, previewRedeem, previewRepay, previewUnwrap, previewWithdraw, previewWrap, priceToTick, publicBroadcaster, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, quoteV3ExactIn, ratePerSecWadToAprPct, realizedBeta, reconstructFromEvents, recoverSnapshot, recoverSnapshotFromTx, redeem, redeemAndWait, removeTrackedChunks, repay, repayAndWait, requireChainDeployment, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveTokenIndex, resolveUniswapV4PoolKey, riskEngineAbi, rollPosition, rollPositionAndWait, roundToTickSpacing, saveCheckpoint, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, selectDispatchForAccount, settleAccumulatedPremia, settleAccumulatedPremiaAndWait, settlePremiumFrom, settlePremiumFromAndWait, simulateBatchDispatch, simulateClosePosition, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateOpenPosition, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithTokenFlow, simulateWithdraw, slippageBpsToTickDistance, smartRepay, smartRepayAndWait, speedUpTransaction, splitTokenIdByTimescale, sqrtPriceX96ToPriceDecimalScaled, sqrtPriceX96ToTick, streamPoolSwaps, subscribePoolSwaps, supply, supplyAndWait, swapExactIn, swapExactInAndWait, swapExactOut, swapExactOutAndWait, syncPositions, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick, truncateAddress, unsupply, unsupplyAndWait, unwrapWeth, unwrapWethAndWait, unwrapXstock, unwrapXstockAndWait, utilizationBpsToWad, utilizationPctToWad, validateBatch, validateBuilderCode, validatePoolId, valuePositionAccrual, verifyBlockContinuity, watchEvents, watchPoolSwaps, wethWrapAbi, withdraw, withdrawAndWait, withdrawWithPositions, withdrawWithPositionsAndWait, wrapEth, wrapEthAndWait, wrapXstock, wrapXstockAndWait, xstockWrapperAbi };
 //# sourceMappingURL=index.js.map