@panoptic-eng/sdk 1.0.69 → 1.0.71

package/dist/{v2-Bo1vZXvR.js → v2-BJtBYpJa.js}

@@ -1,8 +1,8 @@
-import { getAccountCollateral, getNetLiquidationValue, panopticQueryAbi$1 as panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-DurYJ0ht.js";
-import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, MulticallResultMissingError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, applyMintBufferPerToken, availableToBorrow, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePositionBalance, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPoolMetadata, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, isPanopticErrorType, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, riskEngineMulticall, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./rates-B-eRYOTS.js";
-import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, WAD, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionGamma, calculatePositionValue, priceToTick, sqrtPriceX96ToTick, tickLimits, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick } from "./greeks-DNPP24KL.js";
-import { addLegToTokenId, buildBatchDispatchArgs, buildProtectedSettlePlan, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getCurrentPositionSizes, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateDispatch, simulateOpenPosition, simulateWithTokenFlow } from "./writes-D53wWDT-.js";
-import { feesFromFeeGrowthDelta, getLpPositionFunding, getMaxLpPositionSize, getPriceHistory, preparePositionGamma, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router } from "./router-ChMhfTqT.js";
+import { UniswapV3PoolAbi, getAccountCollateral, getNetLiquidationValue, panopticQueryAbi$1 as panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-HM0KEH12.js";
+import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, MulticallResultMissingError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, applyMintBufferPerToken, availableToBorrow, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePositionBalance, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPoolMetadata, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, isPanopticErrorType, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, riskEngineMulticall, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./rates-DlqTkuXt.js";
+import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, WAD, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionGamma, calculatePositionValue, getLegLiquidityRange, priceToTick, sqrtPriceX96ToTick, tickLimits, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick } from "./greeks-DNPP24KL.js";
+import { addLegToTokenId, buildBatchDispatchArgs, buildProtectedSettlePlan, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getCurrentPositionSizes, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateDispatch, simulateOpenPosition, simulateWithTokenFlow } from "./writes-DBu2ltcP.js";
+import { feesFromFeeGrowthDelta, getLpPositionFunding, getMaxLpPositionSize, getPriceHistory, preparePositionGamma, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router } from "./router-DDJ3OnDA.js";
 import { ContractFunctionExecutionError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, hexToString, isAddress, isAddressEqual, isHex, keccak256, parseAbi, parseEventLogs, trim, zeroAddress } from "viem";
 import { multicall } from "viem/actions";
 import Decimal from "decimal.js";
@@ -672,7 +672,7 @@ function maximumAmountIn(estimatedAmountIn, slippageBps) {
 	if (slippageBps < 0n) throw new PanopticError("slippageBps must be non-negative");
 	return (estimatedAmountIn * (BPS_DENOMINATOR$2 + slippageBps) + BPS_DENOMINATOR$2 - 1n) / BPS_DENOMINATOR$2;
 }
-function ceilDiv$2(numerator, denominator) {
+function ceilDiv$3(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
 }
 function getInputAmount(tokenFlow, tokenInIndex) {
@@ -777,7 +777,7 @@ async function quoteTokenShortfallRecovery(params) {
 			const estimatedAmountIn = getInputAmount(swapSimulation.tokenFlow, tokenInIndex);
 			const estimatedAmountOut = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 			if (estimatedAmountOut < requiredOutput) {
-				creditInput = estimatedAmountOut > 0n ? ceilDiv$2(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
+				creditInput = estimatedAmountOut > 0n ? ceilDiv$3(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
 				continue;
 			}
 			const recoveredDispatch = buildPrefixedExactInputRecoveryDispatch({
@@ -832,7 +832,7 @@ async function quoteTokenShortfallRecovery(params) {
 			};
 			const residual = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 			requiredOutput += residual > 0n ? residual : requiredOutput;
-			creditInput = ceilDiv$2(creditInput * requiredOutput, estimatedAmountOut) + 1n;
+			creditInput = ceilDiv$3(creditInput * requiredOutput, estimatedAmountOut) + 1n;
 		}
 		return {
 			available: false,
@@ -887,7 +887,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const maxAmountIn = maximumAmountIn(estimatedAmountIn, params.slippageBps);
 		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 		if (swapOutput < amountOut) {
-			creditOutSize = swapOutput > 0n ? ceilDiv$2(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+			creditOutSize = swapOutput > 0n ? ceilDiv$3(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 			continue;
 		}
 		const recoverySimulation = await simulateDispatch({
@@ -942,7 +942,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$2(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+		creditOutSize = swapOutput > 0n ? ceilDiv$3(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 	}
 	return quotePrefixedExactInput(shortfallError.assetsRequested - shortfallError.assetBalance);
 }
@@ -2250,7 +2250,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$1 = (1n << 64n) - 1n;
 /**
 * Floor integer square root for bigints (Newton's method). Exact for all
@@ -2286,7 +2286,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);
@@ -2544,7 +2544,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) {
@@ -3517,7 +3517,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.
 *
@@ -3638,8 +3638,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 {
@@ -3679,7 +3679,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);
 		}
@@ -3729,7 +3729,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;
 	}
@@ -5323,10 +5323,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$1 = (value, divisor) => (value + divisor - 1n) / divisor;
+const ceilDiv$2 = (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];
@@ -5346,8 +5346,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$1((toVaultFrameAtTick(-delta, assetIndex, borrowToken, tick) + 1n) * 1000000n * FEE_SCALE, (1000000n - swapFee) * (FEE_SCALE - notionalFee));
-	const commission = ceilDiv$1(amount * notionalFee, FEE_SCALE);
+	const amount = delta >= 0n ? delta : ceilDiv$2((toVaultFrameAtTick(-delta, assetIndex, borrowToken, tick) + 1n) * 1000000n * FEE_SCALE$1, (1000000n - swapFee) * (FEE_SCALE$1 - notionalFee));
+	const commission = ceilDiv$2(amount * notionalFee, FEE_SCALE$1);
 	const proceeds = toVaultFrameAtTick((amount - commission) * (1000000n - swapFee) / 1000000n, borrowToken, receiveToken, tick);
 	const tokenId = addLegToTokenId(poolId, {
 		index: 0n,
@@ -5379,7 +5379,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$1(required1 * Q192, price)]] : [[balances[0] * price / Q192 + surplus1, ceilDiv$1(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$2(required1 * Q192$1, price)]] : [[balances[0] * price / Q192$1 + surplus1, ceilDiv$2(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),
@@ -5592,7 +5592,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$1(util * totalAssets + hedge.amount * 10000n, totalAssets) : util);
+		const projectedUtilization = currentUtilizations.map((util, i) => hedge.amount > 0n && BigInt(i) === hedge.borrowToken ? ceilDiv$2(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;
@@ -5684,6 +5684,90 @@ async function getHedgeLimits({ client, poolAddress, account, positionIds, asset
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/positionMintFunding.ts
+const Q96 = 1n << 96n;
+const Q192 = 1n << 192n;
+const BPS = 10000n;
+const FEE_SCALE = 1000000n;
+const max = (a, b) => a > b ? a : b;
+const ceilDiv$1 = (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$1 : (n, d) => n / d;
+		const moved0 = round((liquidity << 96n) * (sqrtUpper - sqrtLower), sqrtUpper * sqrtLower);
+		const moved1 = round(liquidity * (sqrtUpper - sqrtLower), Q96);
+		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);
+			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$1(itm * numerator * scale$1, denominator * retained$1) : itm * numerator * retained$1 / (denominator * scale$1);
+		paid0 += swapToken0 ? -itm : payment;
+		paid1 += swapToken0 ? payment : -itm;
+	}
+	paid0 += ceilDiv$1(notional0 * commissionRate, BPS);
+	paid1 += ceilDiv$1(notional1 * commissionRate, BPS);
+	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
+	const inToken0 = (amount0, amount1) => amount0 + ceilDiv$1(amount1 * Q192, priceSquared);
+	const inToken1 = (amount0, amount1) => amount1 + ceilDiv$1(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$1(max(paid1, 0n) * Q192 * scale, spotSquared * retained);
+	const upfront1 = max(paid1, 0n) + ceilDiv$1(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
 /**
@@ -8645,7 +8729,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.
 *
@@ -8682,7 +8766,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;
@@ -8870,6 +8954,431 @@ function createEventPoller(params) {
 	};
 }
 
+//#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). */
@@ -10233,4 +10742,4 @@ async function getPositionVolatilityHistory({ client, poolAddress, account, toke
 }
 
 //#endregion
-export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, MARKET_INDICATOR_PERIODS, REQUIRED_BASE_ERROR_SENTINEL, STRIKE_LADDER_TARGET_STRIKES, VARIANCE_RATIO_LAG, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateMarketIndicator, calculateSpreadWad, calculateVarianceProfile, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralCurveTicks, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, emptyLiquidateParams, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCloseZapSwap, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feeGrowthInsideX128, fetchSfpmV3PoolId, fetchUniswapFeeData, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getChunkLiquidities, getChunkSpreads, getClosePositionTransferEstimate, getClosedPositions, getCollateralCurve, getCollateralCurveInputs, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getHedgeLimits, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolCollateralAddresses, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionValueCurve, getPositionVolatilityHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, minePoolAddressLocalAsync, multicallRead, netLiquidationValueInQuote, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, positionValueKey, positionValueTicks, prepareIndicatorCandles, preparePositionValueCurve, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, realizedBeta, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, simulateBatchDispatch, simulateClosePosition, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, watchEvents };
+export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, MARKET_INDICATOR_PERIODS, REQUIRED_BASE_ERROR_SENTINEL, STRIKE_LADDER_TARGET_STRIKES, VARIANCE_RATIO_LAG, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateMarketIndicator, calculateSpreadWad, calculateVarianceProfile, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralCurveTicks, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, emptyLiquidateParams, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCloseZapSwap, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feeGrowthInsideX128, fetchPoolSwaps, fetchSfpmV3PoolId, fetchUniswapFeeData, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getChunkLiquidities, getChunkSpreads, getClosePositionTransferEstimate, getClosedPositions, getCollateralCurve, getCollateralCurveInputs, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getHedgeLimits, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolCollateralAddresses, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionMintFunding, getPositionValueCurve, getPositionVolatilityHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, minePoolAddressLocalAsync, multicallRead, netLiquidationValueInQuote, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, parseStreamedKey, parseStreamedSwap, parseSwapLog, positionValueKey, positionValueTicks, prepareIndicatorCandles, preparePositionValueCurve, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, realizedBeta, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, simulateBatchDispatch, simulateClosePosition, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, streamPoolSwaps, subscribePoolSwaps, watchEvents, watchPoolSwaps };