@panoptic-eng/sdk 1.0.49 → 1.0.50

package/dist/{v2-DshssxX4.js → v2-zF6b01PI.js}

@@ -1,9 +1,11 @@
-import { StateViewAbi, getAccountCollateral, panopticQueryAbi$1 as panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-mySi_YMF.js";
-import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePositionBalance, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./rates-CDLIUGDz.js";
-import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, WAD, calculatePositionDelta, calculatePositionGamma, calculatePositionValue, priceToTick, sqrtPriceX96ToTick, tickLimits, tickToPriceDecimalScaled, tickToSqrtPriceX96 } from "./greeks-9aTE-DwO.js";
-import { addLegToTokenId, buildBatchDispatchArgs, buildUniqueCredit, buildUniqueLoan, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateOpenPosition, simulateWithTokenFlow } from "./writes-2reV_omF.js";
+import { StateViewAbi, getAccountCollateral, panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-BJaJSUjF.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$1, parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./rates-COAJpKRd.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-CNi1-cnp.js";
+import { addLegToTokenId, buildBatchDispatchArgs, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateOpenPosition, simulateWithTokenFlow } from "./writes-D1zN0v9x.js";
+import { getLpPositionFunding, getMaxLpPositionSize } from "./router-BSS7HKd2.js";
 import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, keccak256, toHex, zeroAddress } from "viem";
 import { multicall } from "viem/actions";
+import Decimal from "decimal.js";
 
 //#region src/panoptic/v2/clients/blocksByTimestamp.ts
 /**
@@ -162,1480 +164,1880 @@ async function multicallRead(params) {
 }
 
 //#endregion
-//#region src/panoptic/v2/utils/factory.ts
+//#region src/panoptic/v2/utils/priceConvert.ts
+const Q128$3 = 1n << 128n;
 /**
-* Decode a base64-encoded Panoptic NFT token URI into metadata.
-*
-* @param tokenURI - The base64-encoded data URI string
-* @returns Parsed NFT metadata object, or undefined if input is invalid
+* A non-positive price has no meaningful conversion, and `convert1to0` would
+* divide by zero — surface that as a typed SDK error rather than a RangeError
+* thrown from inside the arithmetic.
 */
-function decodePanopticTokenURI(tokenURI) {
-	if (tokenURI === void 0 || tokenURI === "") return void 0;
-	const parts = tokenURI.split("data:application/json;base64,");
-	if (parts.length < 2 || parts[1] === "") return void 0;
-	try {
-		const decoded = atob(parts[1]);
-		return JSON.parse(decoded);
-	} catch {
-		return void 0;
+function assertPositivePrice(sqrtPriceX96) {
+	if (sqrtPriceX96 <= 0n) throw new PanopticError(`sqrtPriceX96 must be positive, got ${sqrtPriceX96}`);
+}
+/** Convert a token0 amount to its token1-equivalent at the given sqrtPriceX96. */
+function convert0to1$2(amount, sqrtPriceX96) {
+	assertPositivePrice(sqrtPriceX96);
+	if (sqrtPriceX96 < Q128$3) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * sp2Hi >> 128n;
+}
+/** Convert a token1 amount to its token0-equivalent at the given sqrtPriceX96. */
+function convert1to0$2(amount, sqrtPriceX96) {
+	assertPositivePrice(sqrtPriceX96);
+	if (sqrtPriceX96 < Q128$3) {
+		const denom = sqrtPriceX96 * sqrtPriceX96;
+		return amount * (1n << 192n) / denom;
 	}
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * (1n << 128n) / sp2Hi;
 }
-
-//#endregion
-//#region src/panoptic/v2/utils/interpolateBlocks.ts
 /**
-* Generate evenly-spaced block numbers between start and end (pure math, no RPC).
-*
-* @param startBlock - First block in the range
-* @param endBlock - Last block in the range
-* @param points - Number of evenly-spaced data points to generate
-* @returns Array of interpolated block numbers
-*
-* @throws {InvalidHistoryRangeError} if startBlock > endBlock or points < 0
+* Convert an amount denominated in `fromTokenIndex` into the other token's
+* terms, so the two sides of a pool flow can be compared on one scale.
 */
-function interpolateBlocks(startBlock, endBlock, points) {
-	if (!Number.isFinite(points) || !Number.isSafeInteger(points)) throw new InvalidHistoryRangeError(`points must be a finite safe integer, got ${points}`);
-	if (points < 0) throw new InvalidHistoryRangeError(`points must be >= 0, got ${points}`);
-	if (startBlock > endBlock) throw new InvalidHistoryRangeError(`startBlock (${startBlock}) must be <= endBlock (${endBlock})`);
-	if (points === 0) return [];
-	if (points === 1) return [endBlock];
-	const range = endBlock - startBlock;
-	return Array.from({ length: points }, (_, i) => startBlock + range * BigInt(i) / BigInt(points - 1));
+function convertToTokenIndex(amount, fromTokenIndex, toTokenIndex, sqrtPriceX96) {
+	if (fromTokenIndex === toTokenIndex) return amount;
+	return fromTokenIndex === 0n ? convert0to1$2(amount, sqrtPriceX96) : convert1to0$2(amount, sqrtPriceX96);
 }
 
 //#endregion
-//#region src/panoptic/v2/sfpmSwap/calldata.ts
+//#region src/panoptic/v2/reads/margin.ts
+const FP96$1 = 1n << 96n;
+const Q128$2 = 1n << 128n;
+/** Cap for a usage ratio with no collateral behind it. */
+const MAX_USAGE_BPS = 1000000n;
+const bigintMax = (a, b) => a > b ? a : b;
+const bigintMin = (a, b) => a < b ? a : b;
 /**
-* Encode the `multicall([mint, burn])` for a swap plan.
+* Convert a token0 amount to its token1-equivalent at the given sqrtPriceX96.
 *
-* The order is always `[mint, burn]` — the ERC1155 must be minted before it is
-* burned. Which call carries the inverted (swap) limits is decided in the plan.
+* Matches the on-chain `PanopticMath.convert0to1` truncation, with an
+* overflow-safe branch when `sqrtPriceX96^2` would not fit in uint256.
 */
-function buildSfpmSwapCalldata(plan) {
-	const mintData = encodeFunctionData({
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "mintTokenizedPosition",
-		args: [
-			plan.poolKey,
-			plan.tokenId,
-			plan.positionSize,
-			plan.mintTickLimits[0],
-			plan.mintTickLimits[1]
-		]
-	});
-	const burnData = encodeFunctionData({
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "burnTokenizedPosition",
-		args: [
-			plan.poolKey,
-			plan.tokenId,
-			plan.positionSize,
-			plan.burnTickLimits[0],
-			plan.burnTickLimits[1]
-		]
-	});
-	const multicallData = encodeFunctionData({
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "multicall",
-		args: [[mintData, burnData]]
-	});
-	return {
-		multicallData,
-		mintData,
-		burnData
-	};
+function convert0to1$1(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128$2) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * sp2Hi >> 128n;
 }
-
-//#endregion
-//#region src/panoptic/v2/sfpmSwap/init.ts
 /**
-* Resolve the `uint64` SFPM poolId for a Uniswap v3 pool, initializing it if needed.
-*
-* `initializeAMMPool` is permissionless and idempotent and **returns the poolId**
-* whether or not the pool was already registered, so a `simulateContract` call is
-* enough to learn the id without sending a transaction. Always resolve the id this
-* way rather than encoding it offline — the SFPM can collision-increment ids.
+* Convert a token1 amount to its token0-equivalent at the given sqrtPriceX96.
 */
-async function fetchSfpmV3PoolId(params) {
-	const { client, sfpmAddress, token0, token1, fee } = params;
-	const vegoid = params.vegoid ?? Number(DEFAULT_VEGOID);
-	const { result } = await client.simulateContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "initializeAMMPool",
-		args: [
-			token0,
-			token1,
-			fee,
-			vegoid
-		]
-	});
-	return BigInt(result);
+function convert1to0$1(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128$2) {
+		const denom = sqrtPriceX96 * sqrtPriceX96;
+		return amount * (1n << 192n) / denom;
+	}
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * (1n << 128n) / sp2Hi;
 }
 /**
-* Ensure a Uniswap v3 pool is registered on the SFPM, sending `initializeAMMPool`
-* only if it is not already registered. Returns the resolved poolId.
+* Get margin buffer and distance-to-liquidation for an account.
 *
-* When `expectedPool` is given, the resolved id is checked to map back to it via
-* `getUniswapV3PoolFromId` — guards against a wrong token/fee triple.
+* Reads, all pinned to the same block:
+* - `getCurrentTick` (sequencing dependency for sqrtPrice conversion)
+* - `getFullPositionsData(account, true, tokenIds)` → collateralRequirements
+* - `CollateralTracker.assetsOf(account)` on both trackers → gross collateral
+* - `PanopticQuery.getLiquidationPrices(...)` → liquidation boundaries
+*
+* @param params - The parameters
+* @returns Margin buffer with liquidation distance and block metadata
 */
-async function ensureSfpmV3PoolInitialized(params) {
-	const { client, wallet, sfpmAddress, token0, token1, fee, expectedPool } = params;
-	const vegoid = params.vegoid ?? Number(DEFAULT_VEGOID);
-	const poolId = await fetchSfpmV3PoolId({
+async function getMarginBuffer(params) {
+	const { client, poolAddress, account, tokenIds, queryAddress, blockNumber, mintBuffer } = params;
+	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	let collateralToken0;
+	let collateralToken1;
+	if (params.collateralAddresses) {
+		collateralToken0 = params.collateralAddresses.collateralToken0;
+		collateralToken1 = params.collateralAddresses.collateralToken1;
+	} else {
+		const addrs = await client.multicall({
+			contracts: [{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken0"
+			}, {
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "collateralToken1"
+			}],
+			blockNumber: targetBlockNumber,
+			allowFailure: false
+		});
+		collateralToken0 = addrs[0];
+		collateralToken1 = addrs[1];
+	}
+	const plan = prepareMarginBufferRead({
+		poolAddress,
+		account,
+		tokenIds,
+		queryAddress,
+		mintBuffer,
+		collateralAddresses: {
+			collateralToken0,
+			collateralToken1
+		}
+	});
+	const { _meta, results } = await readBlockAndAggregate({
 		client,
-		sfpmAddress,
-		token0,
-		token1,
-		fee,
-		vegoid
+		calls: plan.contracts.map((contract) => ({
+			target: contract.address,
+			callData: encodeFunctionData({
+				abi: contract.abi,
+				functionName: contract.functionName,
+				args: contract.args
+			})
+		})),
+		blockNumber: targetBlockNumber
 	});
-	const registered = await client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "getUniswapV3PoolFromId",
-		args: [poolId]
+	const decodedResults = results.map((result, index) => {
+		const contract = plan.contracts[index];
+		if (!contract) return {
+			status: "failure",
+			error: new MulticallResultMissingError("margin read contract", index)
+		};
+		if (!result.success) return {
+			status: "failure",
+			error: new PanopticError(`Margin read ${index} failed`)
+		};
+		return {
+			status: "success",
+			result: decodeFunctionResult({
+				abi: contract.abi,
+				functionName: contract.functionName,
+				data: result.returnData
+			})
+		};
 	});
-	let initialized = false;
-	let resolved = registered;
-	if (getAddress(registered) === zeroAddress) {
-		const account = wallet.account;
-		if (account === void 0) throw new PanopticError("wallet client has no account");
-		const hash = await wallet.writeContract({
-			account,
-			chain: wallet.chain ?? null,
-			address: sfpmAddress,
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: "initializeAMMPool",
-			args: [
-				token0,
-				token1,
-				fee,
-				vegoid
-			]
-		});
-		await client.waitForTransactionReceipt({ hash });
-		initialized = true;
-		resolved = await client.readContract({
-			address: sfpmAddress,
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: "getUniswapV3PoolFromId",
-			args: [poolId]
-		});
-	}
-	if (expectedPool !== void 0 && getAddress(resolved) !== getAddress(expectedPool)) throw new WrongUniswapPoolError(new PanopticError(`SFPM poolId ${poolId} resolves to ${resolved}, expected ${expectedPool}`));
-	return {
-		poolId,
-		initialized
-	};
+	return plan.decode(decodedResults, _meta);
 }
-
-//#endregion
-//#region src/panoptic/v2/sfpmSwap/plan.ts
-/** Wide, non-inverted band for the paired (non-swapping) call — never triggers a swap. */
-const WIDE_LIMITS = [Number(MIN_TICK) + 1, Number(MAX_TICK) - 1];
-/**
-* Convert a slippage tolerance in bps to a conservative Uniswap tick distance.
-*
-* Ticks are 1.0001^tick, so each tick ≈ 1 bps. This walks up powers of 1.0001
-* until the cumulative price move covers `slippageBps`, matching the hedger-bot's
-* dispatch-path helper so both swap paths agree on band width.
-*/
-function slippageBpsToTickDistance(slippageBps) {
-	if (slippageBps < 0n || slippageBps > 1000n) throw new PanopticError(`slippage bps ${slippageBps} out of bounds (0..1000)`);
-	if (slippageBps === 0n) return 0n;
-	let numerator = 1n;
-	let denominator = 1n;
-	let ticks = 0n;
-	while (numerator * 10000n < denominator * (10000n + slippageBps)) {
-		numerator *= 10001n;
-		denominator *= 10000n;
-		ticks += 1n;
-	}
-	return ticks;
+function requireMulticallResult(results, index, label) {
+	const result = results[index];
+	if (result === void 0) throw new MulticallResultMissingError(label, index);
+	if (result.status === "failure") throw result.error;
+	return result.result;
 }
-/**
-* Build the swap plan.
-*
-* Mechanism (verified in the Phase 0 fork test):
-* - A single-leg **loan** tokenId (width=0, isLong=false, `asset == tokenType`) moves
-*   exactly `positionSize` of the `tokenType` token when its call carries inverted
-*   tick limits (`low > high`); the paired call uses a wide band and moves nothing.
-* - `exactIn`: swap on the **mint**; `tokenType` = the **input** token index.
-* - `exactOut`: swap on the **burn** (isLong flips → exact-output); `tokenType` = the
-*   **output** token index.
-*
-* The inverted band is centered on `currentTick` at ±`slippageBpsToTickDistance`,
-* which the SFPM re-sorts and enforces as an open interval on the post-swap tick.
-*/
-function buildSfpmSwapPlan(params) {
-	const { sfpmAddress, poolAddress, poolId, kind, zeroForOne, amount, currentTick, slippageBps } = params;
-	if (amount <= 0n) throw new PanopticError(`swap amount must be positive (got ${amount})`);
-	const distance = slippageBpsToTickDistance(slippageBps);
-	if (distance < 1n) throw new PanopticError(`slippageBps ${slippageBps} yields a zero-width tick band; use a larger tolerance`);
-	const tokenType = kind === "exactIn" ? zeroForOne ? 0n : 1n : zeroForOne ? 1n : 0n;
-	const tokenId = createTokenIdBuilder(poolId).addLoan({
-		asset: tokenType,
-		tokenType,
-		strike: 0n
-	}).build();
-	const d = Number(distance);
-	const low = Math.min(Number(MAX_TICK), currentTick + d);
-	const high = Math.max(Number(MIN_TICK), currentTick - d);
-	if (low <= high) throw new PanopticError(`slippageBps ${slippageBps} at tick ${currentTick} yields a non-inverted band after clamping`);
-	const invertedLimits = [low, high];
-	const swapOn = kind === "exactIn" ? "mint" : "burn";
+function requireBigIntResult(results, index, label) {
+	const result = requireMulticallResult(results, index, label);
+	if (typeof result !== "bigint" && typeof result !== "number") throw new PanopticError(`${label} returned an invalid value`);
+	return BigInt(result);
+}
+function prepareMarginBufferRead({ poolAddress, account, tokenIds, queryAddress, collateralAddresses, mintBuffer }) {
+	const hasPositions = tokenIds.length > 0;
+	const contracts = [
+		{
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "getCurrentTick"
+		},
+		{
+			address: collateralAddresses.collateralToken0,
+			abi: collateralTrackerV2Abi,
+			functionName: "assetsOf",
+			args: [account]
+		},
+		{
+			address: collateralAddresses.collateralToken1,
+			abi: collateralTrackerV2Abi,
+			functionName: "assetsOf",
+			args: [account]
+		}
+	];
+	const positionDataIndex = hasPositions ? contracts.length : null;
+	if (positionDataIndex !== null) contracts.push({
+		address: poolAddress,
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			true,
+			tokenIds
+		]
+	});
+	const liqPricesIndex = hasPositions ? contracts.length : null;
+	if (liqPricesIndex !== null) contracts.push({
+		address: queryAddress,
+		abi: panopticQueryAbi,
+		functionName: "getLiquidationPrices",
+		args: [
+			poolAddress,
+			account,
+			tokenIds
+		]
+	});
+	const checkCollateralIndex = hasPositions ? contracts.length : null;
+	if (checkCollateralIndex !== null) contracts.push({
+		address: queryAddress,
+		abi: panopticQueryAbi,
+		functionName: "checkCollateral",
+		args: [
+			poolAddress,
+			account,
+			tokenIds
+		]
+	});
 	return {
-		sfpmAddress,
-		poolAddress,
-		poolKey: encodeAbiParameters([{ type: "address" }], [poolAddress]),
-		tokenId,
-		positionSize: amount,
-		mintTickLimits: swapOn === "mint" ? invertedLimits : WIDE_LIMITS,
-		burnTickLimits: swapOn === "burn" ? invertedLimits : WIDE_LIMITS,
-		swapOn,
-		kind
+		contracts,
+		decode: (results, _meta) => decodeMarginBufferResults({
+			results,
+			_meta,
+			positionDataIndex,
+			liqPricesIndex,
+			checkCollateralIndex,
+			mintBuffer
+		})
+	};
+}
+function decodeMarginBufferResults({ results, _meta, positionDataIndex, liqPricesIndex, checkCollateralIndex, mintBuffer }) {
+	const currentTick = requireBigIntResult(results, 0, "PanopticPool.getCurrentTick");
+	const assets0 = requireBigIntResult(results, 1, "CollateralTracker.assetsOf token0");
+	const assets1 = requireBigIntResult(results, 2, "CollateralTracker.assetsOf token1");
+	const positionDataResult = positionDataIndex === null ? null : requireMulticallResult(results, positionDataIndex, "PanopticPool.getFullPositionsData");
+	const liqPricesResult = liqPricesIndex === null ? null : requireMulticallResult(results, liqPricesIndex, "PanopticQuery.getLiquidationPrices");
+	const checkCollateralResult = checkCollateralIndex === null ? null : requireMulticallResult(results, checkCollateralIndex, "PanopticQuery.checkCollateral");
+	let usageBps0 = null;
+	let usageBps1 = null;
+	let crossMarginUsageBps = null;
+	let mintableMarginBinding = null;
+	if (checkCollateralResult) {
+		const [balances0, requireds0, balances1, requireds1] = checkCollateralResult;
+		const ratio = (required, balance) => {
+			if (required === void 0 || balance === void 0) return null;
+			if (balance === 0n) return required > 0n ? MAX_USAGE_BPS : 0n;
+			return required * 10000n / balance;
+		};
+		usageBps0 = ratio(requireds0[0], balances0[0]);
+		usageBps1 = ratio(requireds1[0], balances1[0]);
+		if (usageBps0 !== null || usageBps1 !== null) crossMarginUsageBps = usageBps0 === null ? usageBps1 : usageBps1 === null ? usageBps0 : bigintMax(usageBps0, usageBps1);
+		const mintable = (balance, required) => balance === void 0 || required === void 0 ? null : mintableAfterBuffer(balance, required, mintBuffer);
+		const mintable0 = mintable(balances0[0], requireds0[0]);
+		const mintable1 = mintable(balances1[0], requireds1[0]);
+		if (mintable0 !== null || mintable1 !== null) mintableMarginBinding = mintable0 === null ? mintable1 : mintable1 === null ? mintable0 : bigintMin(mintable0, mintable1);
+	}
+	let required0Native = 0n;
+	let required1Native = 0n;
+	if (positionDataResult) {
+		const collateralRequirements = positionDataResult[3];
+		for (const packed of collateralRequirements) {
+			const decoded = decodeLeftRightUnsigned(packed);
+			required0Native += decoded.right;
+			required1Native += decoded.left;
+		}
+	}
+	const sqrtPriceX96 = tickToSqrtPriceX96(currentTick);
+	const denominatedInToken = sqrtPriceX96 < FP96$1 ? 0 : 1;
+	const currentMargin0 = assets0 + convert1to0$1(assets1, sqrtPriceX96);
+	const requiredMargin0 = required0Native + convert1to0$1(required1Native, sqrtPriceX96);
+	const currentMargin1 = assets1 + convert0to1$1(assets0, sqrtPriceX96);
+	const requiredMargin1 = required1Native + convert0to1$1(required0Native, sqrtPriceX96);
+	const buffer0 = currentMargin0 - requiredMargin0;
+	const buffer1 = currentMargin1 - requiredMargin1;
+	const bufferPercent0 = requiredMargin0 === 0n ? null : buffer0 * 10000n / requiredMargin0;
+	const bufferPercent1 = requiredMargin1 === 0n ? null : buffer1 * 10000n / requiredMargin1;
+	let lowerLiquidationTick = null;
+	let upperLiquidationTick = null;
+	let liquidationDistance = null;
+	if (liqPricesResult) {
+		const liqPriceDown = BigInt(liqPricesResult[0]);
+		const liqPriceUp = BigInt(liqPricesResult[1]);
+		lowerLiquidationTick = liqPriceDown === NO_LOWER_LIQUIDATION_TICK ? null : liqPriceDown;
+		upperLiquidationTick = liqPriceUp === NO_UPPER_LIQUIDATION_TICK ? null : liqPriceUp;
+		if (lowerLiquidationTick !== null && upperLiquidationTick !== null) {
+			const distLower = currentTick - lowerLiquidationTick;
+			const distUpper = upperLiquidationTick - currentTick;
+			liquidationDistance = distLower < distUpper ? distLower : distUpper;
+		} else if (lowerLiquidationTick !== null) liquidationDistance = currentTick - lowerLiquidationTick;
+		else if (upperLiquidationTick !== null) liquidationDistance = upperLiquidationTick - currentTick;
+	}
+	return {
+		buffer0,
+		buffer1,
+		bufferPercent0,
+		bufferPercent1,
+		currentMargin0,
+		currentMargin1,
+		requiredMargin0,
+		requiredMargin1,
+		denominatedInToken,
+		liquidationDistance,
+		lowerLiquidationTick,
+		upperLiquidationTick,
+		crossMarginUsageBps,
+		usageBps0,
+		usageBps1,
+		mintableMarginBinding,
+		currentTick,
+		_meta
 	};
 }
 
 //#endregion
-//#region src/panoptic/v2/sfpmSwap/quote.ts
-const UINT128 = 1n << 128n;
-const INT128_MAX = (1n << 127n) - 1n;
-/** Extract the two signed 128-bit slots from a packed `LeftRightSigned` int256. */
-function unpackLeftRightSigned(packed) {
-	const u = packed < 0n ? packed + (1n << 256n) : packed;
-	const toInt128 = (half) => half > INT128_MAX ? half - UINT128 : half;
+//#region src/panoptic/v2/reads/lpFunding.ts
+/** Recheck full LP backing against fresh pool and account state before signing. */
+async function readLpFundingSnapshot(params) {
+	const { client, poolAddress, account, existingPositionIds, queryAddress, quoteTokenIndex } = params;
+	const metadata = await getPoolMetadata({
+		client,
+		poolAddress
+	});
+	if (metadata.isV4 && !params.stateViewAddress) throw new PanopticError("Missing V4 StateView for LP funding check");
+	const priceContract = metadata.isV4 && params.stateViewAddress ? {
+		address: params.stateViewAddress,
+		abi: stateViewAbi,
+		functionName: "getSlot0",
+		args: [metadata.underlyingPoolId]
+	} : {
+		address: metadata.underlyingPoolId,
+		abi: uniswapV3PoolAbi,
+		functionName: "slot0"
+	};
+	const marginRead = prepareMarginBufferRead({
+		poolAddress,
+		account,
+		tokenIds: existingPositionIds,
+		queryAddress,
+		collateralAddresses: {
+			collateralToken0: metadata.collateralToken0Address,
+			collateralToken1: metadata.collateralToken1Address
+		}
+	});
+	const { results, _meta } = await multicallRead({
+		client,
+		contracts: [priceContract, ...marginRead.contracts],
+		blockNumber: params.blockNumber
+	});
+	const priceResult = results[0];
+	if (!priceResult) throw new PanopticError("Missing pool price result for LP funding check");
+	if (priceResult.status === "failure") throw priceResult.error;
+	const slot0 = priceResult.result;
+	const margin = marginRead.decode(results.slice(1), _meta);
+	const valuationSqrtPriceX96 = tickToSqrtPriceX96(margin.currentTick);
+	const fundingParams = {
+		tokenId: params.tokenId,
+		positionSize: params.positionSize,
+		tickSpacing: metadata.tickSpacing,
+		sqrtPriceX96: slot0[0],
+		valuationSqrtPriceX96,
+		quoteTokenIndex
+	};
+	const funding = getLpPositionFunding(fundingParams);
+	const available = margin.mintableMarginBinding ?? (margin.denominatedInToken === 0 ? margin.currentMargin0 : margin.currentMargin1);
+	const availableInQuote = convertToTokenIndex(available, BigInt(margin.denominatedInToken), BigInt(quoteTokenIndex), valuationSqrtPriceX96);
 	return {
-		right: toInt128(u & UINT128 - 1n),
-		left: toInt128(u >> 128n & UINT128 - 1n)
+		funding,
+		fundingParams,
+		availableInQuote,
+		blockNumber: _meta.blockNumber,
+		currentTick: margin.currentTick,
+		_meta
 	};
 }
-/** Wrap an unknown thrown value as a PanopticError, decoding Panoptic reverts when possible. */
-function toPanopticError(err) {
-	if (err instanceof PanopticError) return err;
-	const parsed = parsePanopticError(err);
-	if (parsed) return parsed.error;
-	return new PanopticError(err instanceof Error ? err.message : "SFPM swap simulation failed", err instanceof Error ? err : void 0);
+/** Recheck the same funding policy used by executable LP sizing before signing. */
+async function assertLpPositionFunded(params) {
+	const { funding, availableInQuote } = await readLpFundingSnapshot(params);
+	if (availableInQuote < funding.totalInQuote) throw new PanopticError("Insufficient collateral for the full LP principal and 5% funding buffer. Refresh the position and deposit collateral or reduce its size.");
+	return funding;
 }
+
+//#endregion
+//#region src/panoptic/v2/simulations/simulateDispatch.ts
 /**
-* Quote a swap by simulating `SFPM.multicall([mint, burn])` and decoding the swap
-* call's `totalMoved` return. Authoritative — captures the width-0 loan-leg wei
-* rounding a raw QuoterV2 quote would miss.
+* Simulate a raw dispatch operation.
+*
+* Uses PanopticPool.multicall with getAssetsOf-dispatch-getAssetsOf pattern
+* to measure exact collateral asset movements.
+*
+* @param params - Simulation parameters
+* @returns Simulation result with dispatch data or error
 */
-async function quoteSfpmSwap(params) {
-	const { client, plan, account, stateOverride, blockNumber } = params;
-	const { mintData, burnData } = buildSfpmSwapCalldata(plan);
-	const _meta = await getBlockMeta({
+async function simulateDispatch(params) {
+	const { client, poolAddress, account, positionIdList, finalPositionIdList, positionSizes, tickAndSpreadLimits, usePremiaAsCollateral = false, builderCode = 0n, blockNumber, existingPositionIdList, measurePremia = false } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const metaPromise = getBlockMeta({
 		client,
-		blockNumber
+		blockNumber: targetBlockNumber
 	});
 	try {
-		const { result } = await client.simulateContract({
-			account,
-			address: plan.sfpmAddress,
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: "multicall",
-			args: [[mintData, burnData]],
-			blockNumber,
-			stateOverride
-		});
-		const swapIndex = plan.swapOn === "mint" ? 0 : 1;
-		const decoded = decodeFunctionResult({
-			abi: semiFungiblePositionManagerV3Abi,
-			functionName: plan.swapOn === "mint" ? "mintTokenizedPosition" : "burnTokenizedPosition",
-			data: result[swapIndex]
+		const callData = encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "dispatch",
+			args: [
+				positionIdList,
+				finalPositionIdList,
+				positionSizes,
+				tickAndSpreadLimits.map((t) => [
+					Number(t[0]),
+					Number(t[1]),
+					Number(t[2])
+				]),
+				usePremiaAsCollateral,
+				builderCode
+			]
 		});
-		const finalTick = Number(decoded[2]);
-		const { right, left } = unpackLeftRightSigned(decoded[1]);
-		const inSlot = [right, left].find((s) => s > 0n);
-		const outSlot = [right, left].find((s) => s < 0n);
-		if (inSlot === void 0 || outSlot === void 0) return {
-			success: false,
-			error: new PanopticError(`SFPM swap simulation moved no tokens (totalMoved=${decoded[1]})`),
-			_meta
+		const preFullPositionsCallData = existingPositionIdList !== void 0 ? encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				account,
+				false,
+				existingPositionIdList
+			]
+		}) : void 0;
+		const prePremiaCallData = measurePremia && existingPositionIdList !== void 0 ? encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				account,
+				true,
+				existingPositionIdList
+			]
+		}) : void 0;
+		const postFullPositionsCallData = encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				account,
+				false,
+				finalPositionIdList
+			]
+		});
+		const postPremiaCallData = measurePremia ? encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getFullPositionsData",
+			args: [
+				account,
+				true,
+				finalPositionIdList
+			]
+		}) : void 0;
+		const flowResult = await simulateWithTokenFlow({
+			client,
+			poolAddress,
+			user: account,
+			callData: params.settleSequence?.targets.length ? encodeFunctionData({
+				abi: panopticPoolV2Abi,
+				functionName: "multicall",
+				args: [[...buildSettleSequenceCalls(params.settleSequence), callData]]
+			}) : callData,
+			blockNumber: targetBlockNumber,
+			preCallData: preFullPositionsCallData ? [preFullPositionsCallData, ...prePremiaCallData ? [prePremiaCallData] : []] : void 0,
+			postCallData: [postFullPositionsCallData, ...postPremiaCallData ? [postPremiaCallData] : []]
+		});
+		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Token flow simulation failed");
+		const tokenFlow = flowResult.tokenFlow;
+		const preSnapshot = existingPositionIdList ?? [];
+		const positionsCreated = finalPositionIdList.filter((id) => !preSnapshot.includes(id));
+		const positionsClosed = preSnapshot.filter((id) => !finalPositionIdList.includes(id));
+		const decodeFullPositions = (data$1) => {
+			if (!data$1) return null;
+			try {
+				const decoded = decodeFunctionResult({
+					abi: panopticPoolV2Abi,
+					functionName: "getFullPositionsData",
+					data: data$1
+				});
+				const shortPremium = decodeLeftRightUnsigned(decoded[0]);
+				const longPremium = decodeLeftRightUnsigned(decoded[1]);
+				const reqs = decoded[3];
+				let collateralRequirements0 = 0n;
+				let collateralRequirements1 = 0n;
+				for (const packed of reqs) {
+					const r = decodeLeftRightUnsigned(packed);
+					collateralRequirements0 += r.right;
+					collateralRequirements1 += r.left;
+				}
+				return {
+					collateralRequirements0,
+					collateralRequirements1,
+					netPremia0: shortPremium.right - longPremium.right,
+					netPremia1: shortPremium.left - longPremium.left
+				};
+			} catch {
+				return null;
+			}
+		};
+		const prePositions = decodeFullPositions(flowResult.preCallResults?.[0]);
+		const postPositions = decodeFullPositions(flowResult.postCallResults?.[0]);
+		const prePremia = decodeFullPositions(flowResult.preCallResults?.[1]);
+		const postPremia = decodeFullPositions(flowResult.postCallResults?.[1]);
+		const _meta = await metaPromise;
+		const data = {
+			netAmount0: tokenFlow.delta0,
+			netAmount1: tokenFlow.delta1,
+			premiaReceived0: prePremia !== null && postPremia !== null ? prePremia.netPremia0 - postPremia.netPremia0 : null,
+			premiaReceived1: prePremia !== null && postPremia !== null ? prePremia.netPremia1 - postPremia.netPremia1 : null,
+			positionsCreated,
+			positionsClosed,
+			postCollateral0: tokenFlow.balanceAfter0,
+			postCollateral1: tokenFlow.balanceAfter1,
+			preMarginExcess0: prePositions === null ? null : tokenFlow.balanceBefore0 - prePositions.collateralRequirements0,
+			preMarginExcess1: prePositions === null ? null : tokenFlow.balanceBefore1 - prePositions.collateralRequirements1,
+			postMarginExcess0: postPositions === null ? null : tokenFlow.balanceAfter0 - postPositions.collateralRequirements0,
+			postMarginExcess1: postPositions === null ? null : tokenFlow.balanceAfter1 - postPositions.collateralRequirements1
 		};
 		return {
 			success: true,
-			data: {
-				amountIn: inSlot,
-				amountOut: -outSlot,
-				finalTick
-			},
-			gasEstimate: 0n,
+			data,
+			gasEstimate: flowResult.gasEstimate,
+			tokenFlow,
 			_meta
 		};
-	} catch (err) {
+	} catch (error) {
+		const _meta = await metaPromise;
 		return {
 			success: false,
-			error: toPanopticError(err),
+			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Simulation failed", error instanceof Error ? error : void 0),
 			_meta
 		};
 	}
 }
 
 //#endregion
-//#region src/panoptic/v2/reads/sfpm.ts
+//#region src/panoptic/v2/simulations/creditWrap.ts
 /**
-* Resolve an SFPM poolId to its corresponding Uniswap V3 pool address.
+* Wrap a dispatch with a temporary credit leg that is opened and closed in the
+* same transaction, netting to a swap.
 *
-* Calls `SemiFungiblePositionManagerV3.getUniswapV3PoolFromId(poolId)`.
+* `swapAtMint` is not a calldata flag — it is the ORDER of the tick-limit pair:
+* descending `[high, low]` turns the swap on, ascending `[low, high]` leaves it
+* off. Exactly one of the two legs carries it, and which one is what makes the
+* swap exact-in vs exact-out.
 */
-async function getUniswapV3PoolFromId(params) {
-	const { client, sfpmAddress, poolId } = params;
-	return client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "getUniswapV3PoolFromId",
-		args: [poolId]
-	});
+function buildCreditWrappedDispatch(params) {
+	const { dispatch, creditTokenId, creditPositionSize, direction, placement } = params;
+	const low = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitLow : params.tickLimitHigh;
+	const high = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitHigh : params.tickLimitLow;
+	const swapping = [
+		high,
+		low,
+		0n
+	];
+	const notSwapping = [
+		low,
+		high,
+		0n
+	];
+	const mintLimits = direction === "exact-out" ? swapping : notSwapping;
+	const burnLimits = direction === "exact-out" ? notSwapping : swapping;
+	const positionIdList = placement === "straddle" ? [
+		creditTokenId,
+		...dispatch.positionIdList,
+		creditTokenId
+	] : placement === "prepend" ? [
+		creditTokenId,
+		creditTokenId,
+		...dispatch.positionIdList
+	] : [
+		...dispatch.positionIdList,
+		creditTokenId,
+		creditTokenId
+	];
+	const positionSizes = placement === "straddle" ? [
+		creditPositionSize,
+		...dispatch.positionSizes,
+		0n
+	] : placement === "prepend" ? [
+		creditPositionSize,
+		0n,
+		...dispatch.positionSizes
+	] : [
+		...dispatch.positionSizes,
+		creditPositionSize,
+		0n
+	];
+	const tickAndSpreadLimits = placement === "straddle" ? [
+		mintLimits,
+		...dispatch.tickAndSpreadLimits,
+		burnLimits
+	] : placement === "prepend" ? [
+		mintLimits,
+		burnLimits,
+		...dispatch.tickAndSpreadLimits
+	] : [
+		...dispatch.tickAndSpreadLimits,
+		mintLimits,
+		burnLimits
+	];
+	const wrapped = {
+		positionIdList,
+		finalPositionIdList: [...dispatch.finalPositionIdList],
+		positionSizes,
+		tickAndSpreadLimits,
+		usePremiaAsCollateral: dispatch.usePremiaAsCollateral,
+		builderCode: dispatch.builderCode
+	};
+	return wrapped;
 }
+
+//#endregion
+//#region src/panoptic/v2/simulations/tokenShortfallRecovery.ts
+const BPS_DENOMINATOR$2 = 10000n;
+const MAX_RECOVERY_QUOTE_ATTEMPTS = 8;
 /**
-* Resolve an SFPM poolId to its corresponding Uniswap V4 pool key.
+* Wrap a dispatch with a temporary credit leg that sources the shortfall.
 *
-* Calls `SemiFungiblePositionManagerV4.getUniswapV4PoolKeyFromId(poolId)`.
+* Exact-output construction: mint the credit with `swapAtMint=true` (paying a
+* swapped amount of the token the account has), run the user's operations, then
+* burn it with `swapAtMint=false` to receive exactly the missing token.
+*
+* A credit rather than a loan so the recovery is never capped by the shortfall
+* token's utilization — the case that fails today on a >94% utilized tracker.
 */
-async function getUniswapV4PoolKeyFromId(params) {
-	const { client, sfpmAddress, poolId } = params;
-	const raw = await client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV4Abi,
-		functionName: "getUniswapV4PoolKeyFromId",
-		args: [poolId]
+function buildTokenShortfallRecoveryDispatch(params) {
+	return buildCreditWrappedDispatch({
+		...params,
+		direction: "exact-out",
+		placement: "straddle"
 	});
-	return {
-		currency0: raw.currency0,
-		currency1: raw.currency1,
-		fee: BigInt(raw.fee),
-		tickSpacing: BigInt(raw.tickSpacing),
-		hooks: raw.hooks
-	};
 }
-/**
-* Get the enforced tick limits for a pool from the SFPM.
-*
-* @param params - The parameters
-* @returns The min and max enforced ticks
-*/
-async function getEnforcedTickLimits(params) {
-	const { client, sfpmAddress, poolId } = params;
-	const [minTick, maxTick] = await client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV4Abi,
-		functionName: "getEnforcedTickLimits",
-		args: [poolId]
+function buildPrefixedExactInputRecoveryDispatch(params) {
+	return buildCreditWrappedDispatch({
+		...params,
+		direction: "exact-in",
+		placement: "prepend"
 	});
-	return {
-		minEnforcedTick: minTick,
-		maxEnforcedTick: maxTick
-	};
 }
 /**
-* Fetch liquidity breakdown for a batch of chunks via SFPM.getAccountLiquidity().
+* Extract a fully-decoded `NotEnoughTokens` revert from an arbitrary error.
 *
-* Uses multicall for efficiency. Returns one result per input chunk,
-* along with block metadata for freshness tracking.
+* Returns `null` when the error is something else, or when only the 4-byte
+* selector could be matched (the parser's fallback path constructs the error
+* with undefined args, which is not actionable).
 */
-async function getChunkLiquidities(params) {
-	const { client, sfpmAddress, poolKeyBytes, chunks } = params;
-	if (chunks.length > MAX_TRACKED_CHUNKS) throw new ChunkLimitError(BigInt(chunks.length), 0n);
-	const _meta = params._meta ?? await getBlockMeta({ client });
-	if (chunks.length === 0) return {
-		results: [],
-		_meta
+function getNotEnoughTokensError(error) {
+	const visited = new Set();
+	let current = error;
+	while (current !== void 0 && current !== null && !visited.has(current)) {
+		visited.add(current);
+		const parsed = current instanceof NotEnoughTokensError ? current : parsePanopticError(current)?.error;
+		const candidate = parsed instanceof NotEnoughTokensError ? parsed : null;
+		if (candidate !== null) {
+			const args = candidate;
+			if (args.tokenAddress !== void 0 && args.assetsRequested !== void 0 && args.assetBalance !== void 0) return candidate;
+		}
+		current = current instanceof Error && "cause" in current ? current.cause : void 0;
+	}
+	return null;
+}
+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) {
+	return (numerator + denominator - 1n) / denominator;
+}
+function getInputAmount(tokenFlow, tokenInIndex) {
+	const delta = tokenInIndex === 0n ? tokenFlow.delta0 : tokenFlow.delta1;
+	return delta < 0n ? -delta : delta;
+}
+function getOutputAmount(tokenFlow, tokenOutIndex) {
+	const delta = tokenOutIndex === 0n ? tokenFlow.delta0 : tokenFlow.delta1;
+	return delta > 0n ? delta : 0n;
+}
+async function quoteTokenShortfallRecovery(params) {
+	const shortfallError = getNotEnoughTokensError(params.error);
+	if (shortfallError === null) return {
+		available: false,
+		reason: "not-token-shortfall"
 	};
-	const multicallResults = await client.multicall({
-		contracts: chunks.map((chunk) => ({
-			address: sfpmAddress,
-			abi: semiFungiblePositionManagerV4Abi,
-			functionName: "getAccountLiquidity",
-			args: [
-				poolKeyBytes,
-				chunk.owner,
-				chunk.tokenType,
-				Number(chunk.tickLower),
-				Number(chunk.tickUpper)
-			]
-		})),
-		allowFailure: true
+	let amountOut = shortfallError.assetsRequested - shortfallError.assetBalance;
+	if (amountOut <= 0n) return {
+		available: false,
+		reason: "invalid-shortfall",
+		detail: `requested=${shortfallError.assetsRequested} <= balance=${shortfallError.assetBalance}`
+	};
+	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR$2) return {
+		available: false,
+		reason: "invalid-slippage",
+		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR$2}]`
+	};
+	const targetBlockNumber = params.blockNumber ?? await params.client.getBlockNumber();
+	const pool = await getPool({
+		client: params.client,
+		poolAddress: params.poolAddress,
+		chainId: params.chainId,
+		blockNumber: targetBlockNumber
 	});
-	const results = multicallResults.map((result) => {
-		if (result.status === "failure") return {
-			netLiquidity: 0n,
-			removedLiquidity: 0n,
-			totalLiquidity: 0n,
-			shortLiquidity: 0n,
-			longLiquidity: 0n
-		};
-		const packed = result.result;
-		const netLiquidity = packed & (1n << 128n) - 1n;
-		const removedLiquidity = packed >> 128n;
-		const totalLiquidity = netLiquidity + removedLiquidity;
+	const defaultTickLimits = tickLimits(pool.currentTick, params.slippageBps);
+	const tickLimitLow = params.tickLimitLow ?? defaultTickLimits.low;
+	const tickLimitHigh = params.tickLimitHigh ?? defaultTickLimits.high;
+	if (tickLimitLow >= tickLimitHigh) return {
+		available: false,
+		reason: "invalid-tick-limits",
+		detail: `tickLimitLow=${tickLimitLow} >= tickLimitHigh=${tickLimitHigh}`
+	};
+	const token0 = pool.collateralTracker0.token;
+	const token1 = pool.collateralTracker1.token;
+	const shortfallTokenIndex = (error) => {
+		const address = error.tokenAddress.toLowerCase();
+		if (address === token0.toLowerCase() || address === pool.collateralTracker0.address.toLowerCase()) return 0n;
+		if (address === token1.toLowerCase() || address === pool.collateralTracker1.address.toLowerCase()) return 1n;
+		return null;
+	};
+	const tokenOutIndex = shortfallTokenIndex(shortfallError);
+	if (tokenOutIndex === null) return {
+		available: false,
+		reason: "unsupported-token",
+		detail: `${shortfallError.tokenAddress} is neither collateral token of ${params.poolAddress}`
+	};
+	const tokenInIndex = tokenOutIndex === 0n ? 1n : 0n;
+	const tokenOut = tokenOutIndex === 0n ? token0 : token1;
+	const tokenIn = tokenInIndex === 0n ? token0 : token1;
+	const collisionIds = Array.from(new Set([
+		...params.existingPositionIds,
+		...params.dispatch.positionIdList,
+		...params.dispatch.finalPositionIdList
+	]));
+	const quotePrefixedExactInput = async (initialRequiredOutput) => {
+		let requiredOutput = initialRequiredOutput;
+		const spotInput = convertToTokenIndex(requiredOutput, tokenOutIndex, tokenInIndex, pool.sqrtPriceX96);
+		let creditInput = maximumAmountIn(spotInput > 0n ? spotInput : 1n, params.slippageBps);
+		for (let attempt = 0; attempt < MAX_RECOVERY_QUOTE_ATTEMPTS; attempt++) {
+			const credit = buildUniqueCredit(pool.poolId, tokenInIndex, tokenInIndex, pool.currentTick, pool.tickSpacing, collisionIds, creditInput);
+			const wrapArgs = {
+				creditTokenId: credit.tokenId,
+				creditPositionSize: credit.adjustedSize,
+				tickLimitLow,
+				tickLimitHigh
+			};
+			const swapDispatch = buildPrefixedExactInputRecoveryDispatch({
+				...wrapArgs,
+				dispatch: {
+					positionIdList: [],
+					finalPositionIdList: [...params.existingPositionIds],
+					positionSizes: [],
+					tickAndSpreadLimits: [],
+					usePremiaAsCollateral: false,
+					builderCode: 0n
+				}
+			});
+			const swapSimulation = await simulateDispatch({
+				client: params.client,
+				poolAddress: params.poolAddress,
+				account: params.account,
+				existingPositionIdList: params.existingPositionIds,
+				...swapDispatch,
+				blockNumber: targetBlockNumber
+			});
+			if (!swapSimulation.success || swapSimulation.tokenFlow === void 0) return {
+				available: false,
+				reason: "swap-unavailable",
+				detail: swapSimulation.success ? "prefixed swap simulation returned no token flow" : `prefixed swap simulation reverted: ${swapSimulation.error.message}`,
+				error: swapSimulation.success ? void 0 : swapSimulation.error
+			};
+			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;
+				continue;
+			}
+			const recoveredDispatch = buildPrefixedExactInputRecoveryDispatch({
+				...wrapArgs,
+				dispatch: params.dispatch
+			});
+			const recoverySimulation = await simulateDispatch({
+				client: params.client,
+				poolAddress: params.poolAddress,
+				account: params.account,
+				existingPositionIdList: params.existingPositionIds,
+				...recoveredDispatch,
+				settleSequence: params.settleSequence,
+				measurePremia: true,
+				blockNumber: targetBlockNumber
+			});
+			if (recoverySimulation.success && recoverySimulation.tokenFlow !== void 0) return {
+				available: true,
+				quote: {
+					tokenIn,
+					tokenOut,
+					direction: "exact-in",
+					amountOut: requiredOutput,
+					estimatedAmountOut,
+					estimatedAmountIn,
+					maximumAmountIn: estimatedAmountIn,
+					slippageBps: params.slippageBps,
+					netTokenInChange: tokenInIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
+					netTokenOutChange: tokenOutIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
+					creditTokenId: credit.tokenId,
+					dispatch: recoveredDispatch,
+					simulation: {
+						...recoverySimulation,
+						tokenFlow: recoverySimulation.tokenFlow
+					},
+					tokenFlow: recoverySimulation.tokenFlow,
+					_meta: recoverySimulation._meta
+				}
+			};
+			if (recoverySimulation.success) return {
+				available: false,
+				reason: "recovery-unavailable",
+				detail: "prefixed recovery simulation returned no token flow",
+				error: new PanopticError("Recovery simulation did not return token flow")
+			};
+			const remainingShortfall = getNotEnoughTokensError(recoverySimulation.error);
+			if (remainingShortfall === null || shortfallTokenIndex(remainingShortfall) !== tokenOutIndex) return {
+				available: false,
+				reason: "recovery-unavailable",
+				detail: `prefixed recovery reverted with a non-output shortfall: ${recoverySimulation.error.message}`,
+				error: recoverySimulation.error
+			};
+			const residual = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
+			requiredOutput += residual > 0n ? residual : requiredOutput;
+			creditInput = ceilDiv$2(creditInput * requiredOutput, estimatedAmountOut) + 1n;
+		}
 		return {
-			netLiquidity,
-			removedLiquidity,
-			totalLiquidity,
-			shortLiquidity: totalLiquidity,
-			longLiquidity: removedLiquidity
+			available: false,
+			reason: "recovery-unavailable",
+			detail: `prefixed recovery remained short after ${MAX_RECOVERY_QUOTE_ATTEMPTS} attempts`,
+			error: new PanopticError("Could not size the prefixed recovery swap")
 		};
-	});
-	return {
-		results,
-		_meta
 	};
+	let creditOutSize = amountOut;
+	for (let attempt = 0; attempt < MAX_RECOVERY_QUOTE_ATTEMPTS; attempt++) {
+		const credit = buildUniqueCredit(pool.poolId, tokenOutIndex, tokenOutIndex, pool.currentTick, pool.tickSpacing, collisionIds, creditOutSize);
+		const recoveredDispatch = buildTokenShortfallRecoveryDispatch({
+			dispatch: params.dispatch,
+			creditTokenId: credit.tokenId,
+			creditPositionSize: credit.adjustedSize,
+			tickLimitLow,
+			tickLimitHigh
+		});
+		const swapDispatch = buildTokenShortfallRecoveryDispatch({
+			dispatch: {
+				positionIdList: [],
+				finalPositionIdList: [...params.existingPositionIds],
+				positionSizes: [],
+				tickAndSpreadLimits: [],
+				usePremiaAsCollateral: false,
+				builderCode: 0n
+			},
+			creditTokenId: credit.tokenId,
+			creditPositionSize: credit.adjustedSize,
+			tickLimitLow,
+			tickLimitHigh
+		});
+		const swapSimulation = await simulateDispatch({
+			client: params.client,
+			poolAddress: params.poolAddress,
+			account: params.account,
+			existingPositionIdList: params.existingPositionIds,
+			...swapDispatch,
+			blockNumber: targetBlockNumber
+		});
+		if (!swapSimulation.success || swapSimulation.tokenFlow === void 0) {
+			const bootstrapShortfall = swapSimulation.success ? null : getNotEnoughTokensError(swapSimulation.error);
+			if (bootstrapShortfall !== null && shortfallTokenIndex(bootstrapShortfall) === tokenOutIndex) return quotePrefixedExactInput(amountOut);
+			return {
+				available: false,
+				reason: "swap-unavailable",
+				detail: swapSimulation.success ? "swap-only simulation returned no token flow" : `swap-only simulation reverted: ${swapSimulation.error.message}`,
+				error: swapSimulation.success ? void 0 : swapSimulation.error
+			};
+		}
+		const estimatedAmountIn = getInputAmount(swapSimulation.tokenFlow, tokenInIndex);
+		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;
+			continue;
+		}
+		const recoverySimulation = await simulateDispatch({
+			client: params.client,
+			poolAddress: params.poolAddress,
+			account: params.account,
+			existingPositionIdList: params.existingPositionIds,
+			...recoveredDispatch,
+			settleSequence: params.settleSequence,
+			measurePremia: true,
+			blockNumber: targetBlockNumber
+		});
+		if (recoverySimulation.success) {
+			if (recoverySimulation.tokenFlow !== void 0) return {
+				available: true,
+				quote: {
+					tokenIn,
+					tokenOut,
+					direction: "exact-out",
+					amountOut,
+					estimatedAmountOut: swapOutput,
+					estimatedAmountIn,
+					maximumAmountIn: maxAmountIn,
+					slippageBps: params.slippageBps,
+					netTokenInChange: tokenInIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
+					netTokenOutChange: tokenOutIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
+					creditTokenId: credit.tokenId,
+					dispatch: recoveredDispatch,
+					simulation: {
+						...recoverySimulation,
+						tokenFlow: recoverySimulation.tokenFlow
+					},
+					tokenFlow: recoverySimulation.tokenFlow,
+					_meta: recoverySimulation._meta
+				}
+			};
+			return {
+				available: false,
+				reason: "recovery-unavailable",
+				detail: "wrapped dispatch simulation returned no token flow",
+				error: new PanopticError("Recovery simulation did not return token flow")
+			};
+		}
+		const remainingShortfall = getNotEnoughTokensError(recoverySimulation.error);
+		if (remainingShortfall === null || shortfallTokenIndex(remainingShortfall) !== tokenOutIndex) return {
+			available: false,
+			reason: "recovery-unavailable",
+			detail: `wrapped dispatch reverted with a non-shortfall error: ${recoverySimulation.error.message}`,
+			error: recoverySimulation.error
+		};
+		const decodedShortfall = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
+		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;
+	}
+	return quotePrefixedExactInput(shortfallError.assetsRequested - shortfallError.assetBalance);
 }
 
 //#endregion
-//#region src/panoptic/v2/reads/factory.ts
-/**
-* Get the token URI from a PanopticFactory NFT.
+//#region src/panoptic/v2/reads/lpMaxSize.ts
+/** Largest verified LP mint within 0.1% of the funding bound, at one block.
+* Never returns an untested size. Transport errors abort instead of shrinking MAX.
 */
-async function getFactoryTokenURI(params) {
-	const { client, factoryAddress, version, tokenId } = params;
-	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
-	return client.readContract({
-		address: factoryAddress,
-		abi,
-		functionName: "tokenURI",
-		args: [tokenId]
+async function getExecutableLpMaxSize(params) {
+	const snapshot = await readLpFundingSnapshot({
+		...params,
+		positionSize: 0n
 	});
-}
-/**
-* Get the owner of a PanopticFactory NFT.
-*/
-async function getFactoryOwnerOf(params) {
-	const { client, factoryAddress, version, tokenId } = params;
-	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
-	return client.readContract({
-		address: factoryAddress,
-		abi,
-		functionName: "ownerOf",
-		args: [tokenId]
+	const upper = getMaxLpPositionSize({
+		...snapshot.fundingParams,
+		availableInQuote: snapshot.availableInQuote
 	});
+	const limits = tickLimits(
+		// Funding valuation is derived from the account's current tick.
+		// Read the bounds from that same snapshot, not an independently cached oracle.
+		snapshot.currentTick,
+		params.slippageBps
+);
+	const executable = async (size) => {
+		const intent = {
+			positionIdList: [params.tokenId],
+			finalPositionIdList: [...params.existingPositionIds, params.tokenId],
+			positionSizes: [size],
+			tickAndSpreadLimits: [[
+				limits.low,
+				limits.high,
+				0n
+			]],
+			usePremiaAsCollateral: false,
+			builderCode: 0n
+		};
+		const simulation = await simulateDispatch({
+			...params,
+			...intent,
+			existingPositionIdList: params.existingPositionIds,
+			blockNumber: snapshot.blockNumber
+		});
+		if (simulation.success) return true;
+		const parsedSimulationError = parsePanopticError(simulation.error);
+		if (parsedSimulationError && isPanopticErrorType(parsedSimulationError.error, NotEnoughTokensError) && getNotEnoughTokensError(simulation.error) !== null) {
+			const recovery = await quoteTokenShortfallRecovery({
+				...params,
+				dispatch: intent,
+				error: simulation.error,
+				blockNumber: snapshot.blockNumber
+			});
+			if (recovery.available) return true;
+			if (recovery.error) {
+				const parsedRecoveryError = parsePanopticError(recovery.error);
+				if (!parsedRecoveryError) throw recovery.error;
+			}
+			return false;
+		}
+		if (!parsedSimulationError) throw simulation.error;
+		return false;
+	};
+	if (upper === 0n || await executable(upper)) return {
+		maxSize: upper,
+		...snapshot
+	};
+	let low = 0n;
+	let high = upper;
+	const tolerance = upper / 1000n > 0n ? upper / 1000n : 1n;
+	while (high - low > tolerance) {
+		const mid = (low + high) / 2n;
+		if (await executable(mid)) low = mid;
+		else high = mid;
+	}
+	return {
+		maxSize: low,
+		...snapshot
+	};
 }
+
+//#endregion
+//#region src/panoptic/v2/utils/factory.ts
 /**
-* Construct NFT metadata for a pool via the factory contract.
+* Decode a base64-encoded Panoptic NFT token URI into metadata.
+*
+* @param tokenURI - The base64-encoded data URI string
+* @returns Parsed NFT metadata object, or undefined if input is invalid
 */
-async function getFactoryConstructMetadata(params) {
-	const { client, factoryAddress, version, panopticPoolAddress, symbol0, symbol1, fee } = params;
-	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
-	return client.readContract({
-		address: factoryAddress,
-		abi,
-		functionName: "constructMetadata",
-		args: [
-			panopticPoolAddress,
-			symbol0,
-			symbol1,
-			fee
-		]
-	});
+function decodePanopticTokenURI(tokenURI) {
+	if (tokenURI === void 0 || tokenURI === "") return void 0;
+	const parts = tokenURI.split("data:application/json;base64,");
+	if (parts.length < 2 || parts[1] === "") return void 0;
+	try {
+		const decoded = atob(parts[1]);
+		return JSON.parse(decoded);
+	} catch {
+		return void 0;
+	}
 }
+
+//#endregion
+//#region src/panoptic/v2/utils/interpolateBlocks.ts
 /**
-* Get the PanopticPool address for a given pool and risk engine.
+* Generate evenly-spaced block numbers between start and end (pure math, no RPC).
+*
+* @param startBlock - First block in the range
+* @param endBlock - Last block in the range
+* @param points - Number of evenly-spaced data points to generate
+* @returns Array of interpolated block numbers
+*
+* @throws {InvalidHistoryRangeError} if startBlock > endBlock or points < 0
 */
-async function getPanopticPoolAddress(params) {
-	const { client, factoryAddress, riskEngine } = params;
-	if (params.version === "v3") return client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV3Abi,
-		functionName: "getPanopticPool",
-		args: [params.univ3pool, riskEngine]
-	});
-	return client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV4Abi,
-		functionName: "getPanopticPool",
-		args: [{
-			currency0: params.poolKey.currency0,
-			currency1: params.poolKey.currency1,
-			fee: Number(params.poolKey.fee),
-			tickSpacing: Number(params.poolKey.tickSpacing),
-			hooks: params.poolKey.hooks
-		}, riskEngine]
-	});
+function interpolateBlocks(startBlock, endBlock, points) {
+	if (!Number.isFinite(points) || !Number.isSafeInteger(points)) throw new InvalidHistoryRangeError(`points must be a finite safe integer, got ${points}`);
+	if (points < 0) throw new InvalidHistoryRangeError(`points must be >= 0, got ${points}`);
+	if (startBlock > endBlock) throw new InvalidHistoryRangeError(`startBlock (${startBlock}) must be <= endBlock (${endBlock})`);
+	if (points === 0) return [];
+	if (points === 1) return [endBlock];
+	const range = endBlock - startBlock;
+	return Array.from({ length: points }, (_, i) => startBlock + range * BigInt(i) / BigInt(points - 1));
 }
+
+//#endregion
+//#region src/panoptic/v2/sfpmSwap/calldata.ts
 /**
-* Mine for an optimal pool address salt with high rarity.
+* Encode the `multicall([mint, burn])` for a swap plan.
+*
+* The order is always `[mint, burn]` — the ERC1155 must be minted before it is
+* burned. Which call carries the inverted (swap) limits is decided in the plan.
 */
-async function minePoolAddress(params) {
-	const { client, factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
-	let result;
-	if (params.version === "v3") result = await client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV3Abi,
-		functionName: "minePoolAddress",
+function buildSfpmSwapCalldata(plan) {
+	const mintData = encodeFunctionData({
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "mintTokenizedPosition",
 		args: [
-			deployerAddress,
-			params.v3Pool,
-			riskEngine,
-			salt,
-			loops,
-			minTargetRarity
+			plan.poolKey,
+			plan.tokenId,
+			plan.positionSize,
+			plan.mintTickLimits[0],
+			plan.mintTickLimits[1]
 		]
 	});
-	else result = await client.readContract({
-		address: factoryAddress,
-		abi: panopticFactoryV4Abi,
-		functionName: "minePoolAddress",
+	const burnData = encodeFunctionData({
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "burnTokenizedPosition",
 		args: [
-			deployerAddress,
-			{
-				currency0: params.poolKey.currency0,
-				currency1: params.poolKey.currency1,
-				fee: Number(params.poolKey.fee),
-				tickSpacing: Number(params.poolKey.tickSpacing),
-				hooks: params.poolKey.hooks
-			},
-			riskEngine,
-			salt,
-			loops,
-			minTargetRarity
+			plan.poolKey,
+			plan.tokenId,
+			plan.positionSize,
+			plan.burnTickLimits[0],
+			plan.burnTickLimits[1]
 		]
 	});
+	const multicallData = encodeFunctionData({
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "multicall",
+		args: [[mintData, burnData]]
+	});
 	return {
-		bestSalt: BigInt(result[0]),
-		highestRarity: result[1]
+		multicallData,
+		mintData,
+		burnData
 	};
 }
+
+//#endregion
+//#region src/panoptic/v2/sfpmSwap/init.ts
 /**
-* Simulate a pool deployment to get the predicted pool address.
+* Resolve the `uint64` SFPM poolId for a Uniswap v3 pool, initializing it if needed.
 *
-* Uses `simulateContract` on `deployNewPool` — the return value is the new pool address
-* without actually executing the transaction.
+* `initializeAMMPool` is permissionless and idempotent and **returns the poolId**
+* whether or not the pool was already registered, so a `simulateContract` call is
+* enough to learn the id without sending a transaction. Always resolve the id this
+* way rather than encoding it offline — the SFPM can collision-increment ids.
 */
-async function simulateDeployNewPool(params) {
-	const { client, factoryAddress, account, riskEngine, salt } = params;
-	if (params.version === "v3") {
-		const { result: result$1 } = await client.simulateContract({
-			address: factoryAddress,
-			abi: panopticFactoryV3Abi,
-			functionName: "deployNewPool",
-			args: [
-				params.token0,
-				params.token1,
-				Number(params.fee),
-				riskEngine,
-				salt
-			],
-			account
-		});
-		return result$1;
-	}
+async function fetchSfpmV3PoolId(params) {
+	const { client, sfpmAddress, token0, token1, fee } = params;
+	const vegoid = params.vegoid ?? Number(DEFAULT_VEGOID);
 	const { result } = await client.simulateContract({
-		address: factoryAddress,
-		abi: panopticFactoryV4Abi,
-		functionName: "deployNewPool",
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "initializeAMMPool",
 		args: [
-			{
-				currency0: params.poolKey.currency0,
-				currency1: params.poolKey.currency1,
-				fee: Number(params.poolKey.fee),
-				tickSpacing: Number(params.poolKey.tickSpacing),
-				hooks: params.poolKey.hooks
-			},
-			riskEngine,
-			salt
-		],
-		account
+			token0,
+			token1,
+			fee,
+			vegoid
+		]
 	});
-	return result;
+	return BigInt(result);
 }
 /**
-* Resolve an SFPM poolId to its PanopticPool address.
+* Ensure a Uniswap v3 pool is registered on the SFPM, sending `initializeAMMPool`
+* only if it is not already registered. Returns the resolved poolId.
 *
-* Chains two on-chain lookups:
-* 1. SFPM: poolId → Uniswap pool address (V3) or pool key (V4)
-* 2. Factory: Uniswap pool + riskEngine → PanopticPool address
+* When `expectedPool` is given, the resolved id is checked to map back to it via
+* `getUniswapV3PoolFromId` — guards against a wrong token/fee triple.
 */
-async function getPanopticPoolFromPoolId(params) {
-	const { client, sfpmAddress, factoryAddress, riskEngine, poolId, version } = params;
-	if (version === "v3") {
-		const univ3pool = await getUniswapV3PoolFromId({
-			client,
-			sfpmAddress,
-			poolId
-		});
-		return getPanopticPoolAddress({
-			version: "v3",
-			client,
-			factoryAddress,
-			univ3pool,
-			riskEngine
-		});
-	}
-	const poolKey = await getUniswapV4PoolKeyFromId({
+async function ensureSfpmV3PoolInitialized(params) {
+	const { client, wallet, sfpmAddress, token0, token1, fee, expectedPool } = params;
+	const vegoid = params.vegoid ?? Number(DEFAULT_VEGOID);
+	const poolId = await fetchSfpmV3PoolId({
 		client,
 		sfpmAddress,
-		poolId
+		token0,
+		token1,
+		fee,
+		vegoid
 	});
-	return getPanopticPoolAddress({
-		version: "v4",
-		client,
-		factoryAddress,
-		poolKey,
-		riskEngine
+	const registered = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "getUniswapV3PoolFromId",
+		args: [poolId]
 	});
-}
-/**
-* Resolve an SFPM poolId to its PanopticPool address without knowing the version.
-*
-* Tries both V3 and V4 lookups in parallel. The factory returns `address(0)` for
-* non-existent pools, so the non-zero result identifies the correct version.
-*
-* At least one of `v3` or `v4` must be provided.
-*
-* @throws {PanopticValidationError} If no version config is provided or neither resolves.
-*/
-async function resolvePanopticPoolFromPoolId(params) {
-	const { client, poolId, riskEngine, v3, v4 } = params;
-	if (!v3 && !v4) throw new Error("At least one of v3 or v4 must be provided");
-	const isNotFoundError = (err) => {
-		if (typeof err === "object" && err !== null && "name" in err) {
-			const name = err.name;
-			return name === "ContractFunctionExecutionError" || name === "ContractFunctionRevertedError";
-		}
-		return false;
-	};
-	const results = await Promise.all([v3 ? getPanopticPoolFromPoolId({
-		version: "v3",
-		client,
-		sfpmAddress: v3.sfpmAddress,
-		factoryAddress: v3.factoryAddress,
-		riskEngine,
-		poolId
-	}).catch((err) => {
-		if (isNotFoundError(err)) return zeroAddress;
-		throw err;
-	}) : Promise.resolve(zeroAddress), v4 ? getPanopticPoolFromPoolId({
-		version: "v4",
-		client,
-		sfpmAddress: v4.sfpmAddress,
-		factoryAddress: v4.factoryAddress,
-		riskEngine,
-		poolId
-	}).catch((err) => {
-		if (isNotFoundError(err)) return zeroAddress;
-		throw err;
-	}) : Promise.resolve(zeroAddress)]);
-	const [v3Result, v4Result] = results;
-	if (v3Result !== zeroAddress) return {
-		panopticPoolAddress: v3Result,
-		version: "v3"
-	};
-	if (v4Result !== zeroAddress) return {
-		panopticPoolAddress: v4Result,
-		version: "v4"
+	let initialized = false;
+	let resolved = registered;
+	if (getAddress(registered) === zeroAddress) {
+		const account = wallet.account;
+		if (account === void 0) throw new PanopticError("wallet client has no account");
+		const hash = await wallet.writeContract({
+			account,
+			chain: wallet.chain ?? null,
+			address: sfpmAddress,
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: "initializeAMMPool",
+			args: [
+				token0,
+				token1,
+				fee,
+				vegoid
+			]
+		});
+		await client.waitForTransactionReceipt({ hash });
+		initialized = true;
+		resolved = await client.readContract({
+			address: sfpmAddress,
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: "getUniswapV3PoolFromId",
+			args: [poolId]
+		});
+	}
+	if (expectedPool !== void 0 && getAddress(resolved) !== getAddress(expectedPool)) throw new WrongUniswapPoolError(new PanopticError(`SFPM poolId ${poolId} resolves to ${resolved}, expected ${expectedPool}`));
+	return {
+		poolId,
+		initialized
 	};
-	throw new Error(`No PanopticPool found for poolId ${poolId}`);
 }
 
 //#endregion
-//#region src/panoptic/v2/reads/minePoolAddressLocal.ts
+//#region src/panoptic/v2/sfpmSwap/plan.ts
+/** Wide, non-inverted band for the paired (non-swapping) call — never triggers a swap. */
+const WIDE_LIMITS = [Number(MIN_TICK) + 1, Number(MAX_TICK) - 1];
 /**
-* keccak256 of the CREATE3 proxy initcode used by ClonesWithImmutableArgs.
-* Source: packages/panoptic-v2-core/lib/clones-with-immutable-args/src/ClonesWithImmutableArgs.sol
+* Convert a slippage tolerance in bps to a conservative Uniswap tick distance.
+*
+* Ticks are 1.0001^tick, so each tick ≈ 1 bps. This walks up powers of 1.0001
+* until the cumulative price move covers `slippageBps`, matching the hedger-bot's
+* dispatch-path helper so both swap paths agree on band width.
 */
-const CREATE3_PROXY_BYTECODE_HASH = "0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f";
-const MASK_80 = (1n << 80n) - 1n;
-const MASK_40 = (1n << 40n) - 1n;
-const MASK_96 = (1n << 96n) - 1n;
-/** Encode a BigInt as a big-endian fixed-length byte array. */
-function bigintToBytes(value, byteLength) {
-	const bytes = new Uint8Array(byteLength);
-	let v = value;
-	for (let i = byteLength - 1; i >= 0; i--) {
-		bytes[i] = Number(v & 0xffn);
-		v >>= 8n;
+function slippageBpsToTickDistance(slippageBps) {
+	if (slippageBps < 0n || slippageBps > 1000n) throw new PanopticError(`slippage bps ${slippageBps} out of bounds (0..1000)`);
+	if (slippageBps === 0n) return 0n;
+	let numerator = 1n;
+	let denominator = 1n;
+	let ticks = 0n;
+	while (numerator * 10000n < denominator * (10000n + slippageBps)) {
+		numerator *= 10001n;
+		denominator *= 10000n;
+		ticks += 1n;
 	}
-	return bytes;
+	return ticks;
 }
-/** Parse a 0x-prefixed address into 20 bytes. */
-function addressToBytes(addr) {
-	const hex = addr.slice(2).padStart(40, "0");
-	const bytes = new Uint8Array(20);
-	for (let i = 0; i < 20; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-	return bytes;
+/**
+* Build the swap plan.
+*
+* Mechanism (verified in the Phase 0 fork test):
+* - A single-leg **loan** tokenId (width=0, isLong=false, `asset == tokenType`) moves
+*   exactly `positionSize` of the `tokenType` token when its call carries inverted
+*   tick limits (`low > high`); the paired call uses a wide band and moves nothing.
+* - `exactIn`: swap on the **mint**; `tokenType` = the **input** token index.
+* - `exactOut`: swap on the **burn** (isLong flips → exact-output); `tokenType` = the
+*   **output** token index.
+*
+* The inverted band is centered on `currentTick` at ±`slippageBpsToTickDistance`,
+* which the SFPM re-sorts and enforces as an open interval on the post-swap tick.
+*/
+function buildSfpmSwapPlan(params) {
+	const { sfpmAddress, poolAddress, poolId, kind, zeroForOne, amount, currentTick, slippageBps } = params;
+	if (amount <= 0n) throw new PanopticError(`swap amount must be positive (got ${amount})`);
+	const distance = slippageBpsToTickDistance(slippageBps);
+	if (distance < 1n) throw new PanopticError(`slippageBps ${slippageBps} yields a zero-width tick band; use a larger tolerance`);
+	const tokenType = kind === "exactIn" ? zeroForOne ? 0n : 1n : zeroForOne ? 1n : 0n;
+	const tokenId = createTokenIdBuilder(poolId).addLoan({
+		asset: tokenType,
+		tokenType,
+		strike: 0n
+	}).build();
+	const d = Number(distance);
+	const low = Math.min(Number(MAX_TICK), currentTick + d);
+	const high = Math.max(Number(MIN_TICK), currentTick - d);
+	if (low <= high) throw new PanopticError(`slippageBps ${slippageBps} at tick ${currentTick} yields a non-inverted band after clamping`);
+	const invertedLimits = [low, high];
+	const swapOn = kind === "exactIn" ? "mint" : "burn";
+	return {
+		sfpmAddress,
+		poolAddress,
+		poolKey: encodeAbiParameters([{ type: "address" }], [poolAddress]),
+		tokenId,
+		positionSize: amount,
+		mintTickLimits: swapOn === "mint" ? invertedLimits : WIDE_LIMITS,
+		burnTickLimits: swapOn === "burn" ? invertedLimits : WIDE_LIMITS,
+		swapOn,
+		kind
+	};
 }
-/** Parse a 0x-prefixed 32-byte hex string into bytes. */
-function hex32ToBytes(hex) {
-	const h = hex.slice(2).padStart(64, "0");
-	const bytes = new Uint8Array(32);
-	for (let i = 0; i < 32; i++) bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
-	return bytes;
+
+//#endregion
+//#region src/panoptic/v2/sfpmSwap/quote.ts
+const UINT128 = 1n << 128n;
+const INT128_MAX = (1n << 127n) - 1n;
+/** Extract the two signed 128-bit slots from a packed `LeftRightSigned` int256. */
+function unpackLeftRightSigned(packed) {
+	const u = packed < 0n ? packed + (1n << 256n) : packed;
+	const toInt128 = (half) => half > INT128_MAX ? half - UINT128 : half;
+	return {
+		right: toInt128(u & UINT128 - 1n),
+		left: toInt128(u >> 128n & UINT128 - 1n)
+	};
 }
-/**
-* Compute the CREATE3 deployed address for a given factory and packed salt.
-*
-* Mirrors `ClonesWithImmutableArgs.addressOfClone3(salt)` (with `address(this)` = factory):
-*   proxy    = CREATE2(factory, salt, PROXY_BYTECODE_HASH)
-*   deployed = CREATE1(proxy, nonce=1)
-*
-* Returns the deployed address as a uint160 BigInt.
-*/
-function addressOfClone3(factory, salt) {
-	const saltBytes = bigintToBytes(salt, 32);
-	const create2Input = new Uint8Array(85);
-	create2Input[0] = 255;
-	create2Input.set(addressToBytes(factory), 1);
-	create2Input.set(saltBytes, 21);
-	create2Input.set(hex32ToBytes(CREATE3_PROXY_BYTECODE_HASH), 53);
-	const proxyHash = keccak256(create2Input, "bytes");
-	const proxyAddress = proxyHash.slice(12);
-	const create1Input = new Uint8Array(23);
-	create1Input[0] = 214;
-	create1Input[1] = 148;
-	create1Input.set(proxyAddress, 2);
-	create1Input[22] = 1;
-	const deployedHash = keccak256(create1Input, "bytes");
-	let addr = 0n;
-	for (let i = 12; i < 32; i++) addr = addr << 8n | BigInt(deployedHash[i]);
-	return addr;
+/** Wrap an unknown thrown value as a PanopticError, decoding Panoptic reverts when possible. */
+function toPanopticError(err) {
+	if (err instanceof PanopticError) return err;
+	const parsed = parsePanopticError(err);
+	if (parsed) return parsed.error;
+	return new PanopticError(err instanceof Error ? err.message : "SFPM swap simulation failed", err instanceof Error ? err : void 0);
 }
 /**
-* Count leading hex-zero characters in a 160-bit address value.
-*
-* Mirrors `PanopticMath.numberOfLeadingHexZeros(addr)`.
-* Returns 40 for the zero address.
+* Quote a swap by simulating `SFPM.multicall([mint, burn])` and decoding the swap
+* call's `totalMoved` return. Authoritative — captures the width-0 loan-leg wei
+* rounding a raw QuoterV2 quote would miss.
 */
-function numberOfLeadingHexZeros(addrInt) {
-	if (addrInt === 0n) return 40;
-	let x = addrInt;
-	let r = 0;
-	if (x >= 0x100000000000000000000000000000000n) {
-		x >>= 128n;
-		r += 32;
-	}
-	if (x >= 0x10000000000000000n) {
-		x >>= 64n;
-		r += 16;
-	}
-	if (x >= 0x100000000n) {
-		x >>= 32n;
-		r += 8;
-	}
-	if (x >= 0x10000n) {
-		x >>= 16n;
-		r += 4;
-	}
-	if (x >= 0x100n) {
-		x >>= 8n;
-		r += 2;
+async function quoteSfpmSwap(params) {
+	const { client, plan, account, stateOverride, blockNumber } = params;
+	const { mintData, burnData } = buildSfpmSwapCalldata(plan);
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber
+	});
+	try {
+		const { result } = await client.simulateContract({
+			account,
+			address: plan.sfpmAddress,
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: "multicall",
+			args: [[mintData, burnData]],
+			blockNumber,
+			stateOverride
+		});
+		const swapIndex = plan.swapOn === "mint" ? 0 : 1;
+		const decoded = decodeFunctionResult({
+			abi: semiFungiblePositionManagerV3Abi,
+			functionName: plan.swapOn === "mint" ? "mintTokenizedPosition" : "burnTokenizedPosition",
+			data: result[swapIndex]
+		});
+		const finalTick = Number(decoded[2]);
+		const { right, left } = unpackLeftRightSigned(decoded[1]);
+		const inSlot = [right, left].find((s) => s > 0n);
+		const outSlot = [right, left].find((s) => s < 0n);
+		if (inSlot === void 0 || outSlot === void 0) return {
+			success: false,
+			error: new PanopticError(`SFPM swap simulation moved no tokens (totalMoved=${decoded[1]})`),
+			_meta
+		};
+		return {
+			success: true,
+			data: {
+				amountIn: inSlot,
+				amountOut: -outSlot,
+				finalTick
+			},
+			gasEstimate: 0n,
+			_meta
+		};
+	} catch (err) {
+		return {
+			success: false,
+			error: toPanopticError(err),
+			_meta
+		};
 	}
-	if (x >= 0x10n) r += 1;
-	return 39 - r;
-}
-/**
-* Construct the bytes32 CREATE3 salt for PanopticFactoryV3.
-*
-* Mirrors:
-*   bytes32(abi.encodePacked(
-*     uint80(uint160(deployerAddress) >> 80),  // bits [159:80]  of deployer  → 10 bytes
-*     uint40(uint160(v3Pool) >> 120),           // bits [159:120] of v3Pool    →  5 bytes
-*     uint40(uint160(riskEngine) >> 120),       // bits [159:120] of riskEngine→  5 bytes
-*     salt                                      // uint96                      → 12 bytes
-*   ))
-*/
-function computeSaltPrefixV3(deployerAddress, v3Pool, riskEngine) {
-	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
-	const pool40 = BigInt(v3Pool) >> 120n & MASK_40;
-	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
-	return deployer80 << 176n | pool40 << 136n | risk40 << 96n;
 }
+
+//#endregion
+//#region src/panoptic/v2/reads/sfpm.ts
 /**
-* Compute the Uniswap V4 PoolId for a PoolKey.
+* Resolve an SFPM poolId to its corresponding Uniswap V3 pool address.
 *
-* Mirrors `PoolId.toId(key)` = keccak256 of the ABI-encoded PoolKey struct
-* (5 fields × 32 bytes = 160 bytes).
+* Calls `SemiFungiblePositionManagerV3.getUniswapV3PoolFromId(poolId)`.
 */
-function computePoolIdV4(poolKey) {
-	const fee = Number(poolKey.fee);
-	if (!Number.isInteger(fee) || fee < 0 || fee >= 2 ** 24) throw new PanopticValidationError(`fee out of uint24 range: ${fee}`);
-	const tickSpacing = Number(poolKey.tickSpacing);
-	if (!Number.isInteger(tickSpacing) || tickSpacing < -(2 ** 23) || tickSpacing > 2 ** 23 - 1) throw new PanopticValidationError(`tickSpacing out of int24 range: ${tickSpacing}`);
-	const encoded = encodeAbiParameters([
-		{ type: "address" },
-		{ type: "address" },
-		{ type: "uint24" },
-		{ type: "int24" },
-		{ type: "address" }
-	], [
-		poolKey.currency0,
-		poolKey.currency1,
-		Number(poolKey.fee),
-		Number(poolKey.tickSpacing),
-		poolKey.hooks
-	]);
-	return BigInt(keccak256(encoded));
+async function getUniswapV3PoolFromId(params) {
+	const { client, sfpmAddress, poolId } = params;
+	return client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "getUniswapV3PoolFromId",
+		args: [poolId]
+	});
 }
 /**
-* Construct the bytes32 CREATE3 salt for PanopticFactoryV4.
+* Resolve an SFPM poolId to its corresponding Uniswap V4 pool key.
 *
-* Mirrors:
-*   bytes32(abi.encodePacked(
-*     uint80(uint160(deployerAddress) >> 80),
-*     uint40(uint256(PoolId.unwrap(key.toId())) >> 120),  // bits [159:120] of poolId
-*     uint40(uint160(riskEngine) >> 120),
-*     salt
-*   ))
+* Calls `SemiFungiblePositionManagerV4.getUniswapV4PoolKeyFromId(poolId)`.
 */
-function computeSaltPrefixV4(deployerAddress, poolKey, riskEngine) {
-	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
-	const poolId40 = computePoolIdV4(poolKey) >> 120n & MASK_40;
-	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
-	return deployer80 << 176n | poolId40 << 136n | risk40 << 96n;
+async function getUniswapV4PoolKeyFromId(params) {
+	const { client, sfpmAddress, poolId } = params;
+	const raw = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV4Abi,
+		functionName: "getUniswapV4PoolKeyFromId",
+		args: [poolId]
+	});
+	return {
+		currency0: raw.currency0,
+		currency1: raw.currency1,
+		fee: BigInt(raw.fee),
+		tickSpacing: BigInt(raw.tickSpacing),
+		hooks: raw.hooks
+	};
 }
-/** Number of iterations per chunk before yielding back to the event loop. */
-const CHUNK_SIZE = 5000n;
 /**
-* Async version of {@link minePoolAddressLocal} that yields to the event loop
-* between chunks of iterations, preventing the browser UI from freezing.
+* Get the enforced tick limits for a pool from the SFPM.
 *
-* @param params - Mining parameters (versioned: 'v3' or 'v4'). No `client` required.
-* @returns The best salt found and its rarity (number of leading hex zeros).
+* @param params - The parameters
+* @returns The min and max enforced ticks
 */
-async function minePoolAddressLocalAsync(params) {
-	const { factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
-	let bestSalt = salt;
-	let highestRarity = 0n;
-	const maxSalt = salt + loops;
-	const saltPrefix = params.version === "v3" ? computeSaltPrefixV3(deployerAddress, params.v3Pool, riskEngine) : computeSaltPrefixV4(deployerAddress, params.poolKey, riskEngine);
-	let currentSalt = salt;
-	while (currentSalt < maxSalt) {
-		const chunkEnd = currentSalt + CHUNK_SIZE < maxSalt ? currentSalt + CHUNK_SIZE : maxSalt;
-		let done = false;
-		for (; currentSalt < chunkEnd; currentSalt++) {
-			const newSalt = saltPrefix | currentSalt & MASK_96;
-			const addrInt = addressOfClone3(factoryAddress, newSalt);
-			const rarity = BigInt(numberOfLeadingHexZeros(addrInt));
-			if (rarity > highestRarity) {
-				highestRarity = rarity;
-				bestSalt = currentSalt;
-			}
-			if (rarity >= minTargetRarity) {
-				highestRarity = rarity;
-				bestSalt = currentSalt;
-				done = true;
-				break;
-			}
-		}
-		if (done) break;
-		await new Promise((resolve) => setTimeout(resolve, 0));
-	}
+async function getEnforcedTickLimits(params) {
+	const { client, sfpmAddress, poolId } = params;
+	const [minTick, maxTick] = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV4Abi,
+		functionName: "getEnforcedTickLimits",
+		args: [poolId]
+	});
 	return {
-		bestSalt,
-		highestRarity
+		minEnforcedTick: minTick,
+		maxEnforcedTick: maxTick
+	};
+}
+/**
+* Fetch liquidity breakdown for a batch of chunks via SFPM.getAccountLiquidity().
+*
+* Uses multicall for efficiency. Returns one result per input chunk,
+* along with block metadata for freshness tracking.
+*/
+async function getChunkLiquidities(params) {
+	const { client, sfpmAddress, poolKeyBytes, chunks } = params;
+	if (chunks.length > MAX_TRACKED_CHUNKS) throw new ChunkLimitError(BigInt(chunks.length), 0n);
+	const _meta = params._meta ?? await getBlockMeta({ client });
+	if (chunks.length === 0) return {
+		results: [],
+		_meta
+	};
+	const multicallResults = await client.multicall({
+		contracts: chunks.map((chunk) => ({
+			address: sfpmAddress,
+			abi: semiFungiblePositionManagerV4Abi,
+			functionName: "getAccountLiquidity",
+			args: [
+				poolKeyBytes,
+				chunk.owner,
+				chunk.tokenType,
+				Number(chunk.tickLower),
+				Number(chunk.tickUpper)
+			]
+		})),
+		allowFailure: true
+	});
+	const results = multicallResults.map((result) => {
+		if (result.status === "failure") return {
+			netLiquidity: 0n,
+			removedLiquidity: 0n,
+			totalLiquidity: 0n,
+			shortLiquidity: 0n,
+			longLiquidity: 0n
+		};
+		const packed = result.result;
+		const netLiquidity = packed & (1n << 128n) - 1n;
+		const removedLiquidity = packed >> 128n;
+		const totalLiquidity = netLiquidity + removedLiquidity;
+		return {
+			netLiquidity,
+			removedLiquidity,
+			totalLiquidity,
+			shortLiquidity: totalLiquidity,
+			longLiquidity: removedLiquidity
+		};
+	});
+	return {
+		results,
+		_meta
 	};
 }
 
 //#endregion
-//#region src/panoptic/v2/utils/priceConvert.ts
-const Q128$3 = 1n << 128n;
+//#region src/panoptic/v2/reads/factory.ts
 /**
-* A non-positive price has no meaningful conversion, and `convert1to0` would
-* divide by zero — surface that as a typed SDK error rather than a RangeError
-* thrown from inside the arithmetic.
+* Get the token URI from a PanopticFactory NFT.
 */
-function assertPositivePrice(sqrtPriceX96) {
-	if (sqrtPriceX96 <= 0n) throw new PanopticError(`sqrtPriceX96 must be positive, got ${sqrtPriceX96}`);
+async function getFactoryTokenURI(params) {
+	const { client, factoryAddress, version, tokenId } = params;
+	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
+	return client.readContract({
+		address: factoryAddress,
+		abi,
+		functionName: "tokenURI",
+		args: [tokenId]
+	});
 }
-/** Convert a token0 amount to its token1-equivalent at the given sqrtPriceX96. */
-function convert0to1$2(amount, sqrtPriceX96) {
-	assertPositivePrice(sqrtPriceX96);
-	if (sqrtPriceX96 < Q128$3) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
-	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
-	return amount * sp2Hi >> 128n;
+/**
+* Get the owner of a PanopticFactory NFT.
+*/
+async function getFactoryOwnerOf(params) {
+	const { client, factoryAddress, version, tokenId } = params;
+	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
+	return client.readContract({
+		address: factoryAddress,
+		abi,
+		functionName: "ownerOf",
+		args: [tokenId]
+	});
 }
-/** Convert a token1 amount to its token0-equivalent at the given sqrtPriceX96. */
-function convert1to0$2(amount, sqrtPriceX96) {
-	assertPositivePrice(sqrtPriceX96);
-	if (sqrtPriceX96 < Q128$3) {
-		const denom = sqrtPriceX96 * sqrtPriceX96;
-		return amount * (1n << 192n) / denom;
-	}
-	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
-	return amount * (1n << 128n) / sp2Hi;
+/**
+* Construct NFT metadata for a pool via the factory contract.
+*/
+async function getFactoryConstructMetadata(params) {
+	const { client, factoryAddress, version, panopticPoolAddress, symbol0, symbol1, fee } = params;
+	const abi = version === "v3" ? panopticFactoryV3Abi : panopticFactoryV4Abi;
+	return client.readContract({
+		address: factoryAddress,
+		abi,
+		functionName: "constructMetadata",
+		args: [
+			panopticPoolAddress,
+			symbol0,
+			symbol1,
+			fee
+		]
+	});
 }
 /**
-* Convert an amount denominated in `fromTokenIndex` into the other token's
-* terms, so the two sides of a pool flow can be compared on one scale.
+* Get the PanopticPool address for a given pool and risk engine.
 */
-function convertToTokenIndex(amount, fromTokenIndex, toTokenIndex, sqrtPriceX96) {
-	if (fromTokenIndex === toTokenIndex) return amount;
-	return fromTokenIndex === 0n ? convert0to1$2(amount, sqrtPriceX96) : convert1to0$2(amount, sqrtPriceX96);
+async function getPanopticPoolAddress(params) {
+	const { client, factoryAddress, riskEngine } = params;
+	if (params.version === "v3") return client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV3Abi,
+		functionName: "getPanopticPool",
+		args: [params.univ3pool, riskEngine]
+	});
+	return client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV4Abi,
+		functionName: "getPanopticPool",
+		args: [{
+			currency0: params.poolKey.currency0,
+			currency1: params.poolKey.currency1,
+			fee: Number(params.poolKey.fee),
+			tickSpacing: Number(params.poolKey.tickSpacing),
+			hooks: params.poolKey.hooks
+		}, riskEngine]
+	});
 }
-
-//#endregion
-//#region src/panoptic/v2/simulations/creditWrap.ts
 /**
-* Wrap a dispatch with a temporary credit leg that is opened and closed in the
-* same transaction, netting to a swap.
-*
-* `swapAtMint` is not a calldata flag — it is the ORDER of the tick-limit pair:
-* descending `[high, low]` turns the swap on, ascending `[low, high]` leaves it
-* off. Exactly one of the two legs carries it, and which one is what makes the
-* swap exact-in vs exact-out.
+* Mine for an optimal pool address salt with high rarity.
 */
-function buildCreditWrappedDispatch(params) {
-	const { dispatch, creditTokenId, creditPositionSize, direction, placement } = params;
-	const low = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitLow : params.tickLimitHigh;
-	const high = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitHigh : params.tickLimitLow;
-	const swapping = [
-		high,
-		low,
-		0n
-	];
-	const notSwapping = [
-		low,
-		high,
-		0n
-	];
-	const mintLimits = direction === "exact-out" ? swapping : notSwapping;
-	const burnLimits = direction === "exact-out" ? notSwapping : swapping;
-	const positionIdList = placement === "straddle" ? [
-		creditTokenId,
-		...dispatch.positionIdList,
-		creditTokenId
-	] : placement === "prepend" ? [
-		creditTokenId,
-		creditTokenId,
-		...dispatch.positionIdList
-	] : [
-		...dispatch.positionIdList,
-		creditTokenId,
-		creditTokenId
-	];
-	const positionSizes = placement === "straddle" ? [
-		creditPositionSize,
-		...dispatch.positionSizes,
-		0n
-	] : placement === "prepend" ? [
-		creditPositionSize,
-		0n,
-		...dispatch.positionSizes
-	] : [
-		...dispatch.positionSizes,
-		creditPositionSize,
-		0n
-	];
-	const tickAndSpreadLimits = placement === "straddle" ? [
-		mintLimits,
-		...dispatch.tickAndSpreadLimits,
-		burnLimits
-	] : placement === "prepend" ? [
-		mintLimits,
-		burnLimits,
-		...dispatch.tickAndSpreadLimits
-	] : [
-		...dispatch.tickAndSpreadLimits,
-		mintLimits,
-		burnLimits
-	];
-	const wrapped = {
-		positionIdList,
-		finalPositionIdList: [...dispatch.finalPositionIdList],
-		positionSizes,
-		tickAndSpreadLimits,
-		usePremiaAsCollateral: dispatch.usePremiaAsCollateral,
-		builderCode: dispatch.builderCode
+async function minePoolAddress(params) {
+	const { client, factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
+	let result;
+	if (params.version === "v3") result = await client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV3Abi,
+		functionName: "minePoolAddress",
+		args: [
+			deployerAddress,
+			params.v3Pool,
+			riskEngine,
+			salt,
+			loops,
+			minTargetRarity
+		]
+	});
+	else result = await client.readContract({
+		address: factoryAddress,
+		abi: panopticFactoryV4Abi,
+		functionName: "minePoolAddress",
+		args: [
+			deployerAddress,
+			{
+				currency0: params.poolKey.currency0,
+				currency1: params.poolKey.currency1,
+				fee: Number(params.poolKey.fee),
+				tickSpacing: Number(params.poolKey.tickSpacing),
+				hooks: params.poolKey.hooks
+			},
+			riskEngine,
+			salt,
+			loops,
+			minTargetRarity
+		]
+	});
+	return {
+		bestSalt: BigInt(result[0]),
+		highestRarity: result[1]
 	};
-	return wrapped;
 }
-
-//#endregion
-//#region src/panoptic/v2/simulations/simulateDispatch.ts
 /**
-* Simulate a raw dispatch operation.
-*
-* Uses PanopticPool.multicall with getAssetsOf-dispatch-getAssetsOf pattern
-* to measure exact collateral asset movements.
+* Simulate a pool deployment to get the predicted pool address.
 *
-* @param params - Simulation parameters
-* @returns Simulation result with dispatch data or error
+* Uses `simulateContract` on `deployNewPool` — the return value is the new pool address
+* without actually executing the transaction.
 */
-async function simulateDispatch(params) {
-	const { client, poolAddress, account, positionIdList, finalPositionIdList, positionSizes, tickAndSpreadLimits, usePremiaAsCollateral = false, builderCode = 0n, blockNumber, existingPositionIdList, measurePremia = false } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
-	try {
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatch",
+async function simulateDeployNewPool(params) {
+	const { client, factoryAddress, account, riskEngine, salt } = params;
+	if (params.version === "v3") {
+		const { result: result$1 } = await client.simulateContract({
+			address: factoryAddress,
+			abi: panopticFactoryV3Abi,
+			functionName: "deployNewPool",
 			args: [
-				positionIdList,
-				finalPositionIdList,
-				positionSizes,
-				tickAndSpreadLimits.map((t) => [
-					Number(t[0]),
-					Number(t[1]),
-					Number(t[2])
-				]),
-				usePremiaAsCollateral,
-				builderCode
-			]
+				params.token0,
+				params.token1,
+				Number(params.fee),
+				riskEngine,
+				salt
+			],
+			account
 		});
-		const preFullPositionsCallData = existingPositionIdList !== void 0 ? encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				false,
-				existingPositionIdList
-			]
-		}) : void 0;
-		const prePremiaCallData = measurePremia && existingPositionIdList !== void 0 ? encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				true,
-				existingPositionIdList
-			]
-		}) : void 0;
-		const postFullPositionsCallData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				false,
-				finalPositionIdList
-			]
+		return result$1;
+	}
+	const { result } = await client.simulateContract({
+		address: factoryAddress,
+		abi: panopticFactoryV4Abi,
+		functionName: "deployNewPool",
+		args: [
+			{
+				currency0: params.poolKey.currency0,
+				currency1: params.poolKey.currency1,
+				fee: Number(params.poolKey.fee),
+				tickSpacing: Number(params.poolKey.tickSpacing),
+				hooks: params.poolKey.hooks
+			},
+			riskEngine,
+			salt
+		],
+		account
+	});
+	return result;
+}
+/**
+* Resolve an SFPM poolId to its PanopticPool address.
+*
+* Chains two on-chain lookups:
+* 1. SFPM: poolId → Uniswap pool address (V3) or pool key (V4)
+* 2. Factory: Uniswap pool + riskEngine → PanopticPool address
+*/
+async function getPanopticPoolFromPoolId(params) {
+	const { client, sfpmAddress, factoryAddress, riskEngine, poolId, version } = params;
+	if (version === "v3") {
+		const univ3pool = await getUniswapV3PoolFromId({
+			client,
+			sfpmAddress,
+			poolId
 		});
-		const postPremiaCallData = measurePremia ? encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				true,
-				finalPositionIdList
-			]
-		}) : void 0;
-		const flowResult = await simulateWithTokenFlow({
+		return getPanopticPoolAddress({
+			version: "v3",
 			client,
-			poolAddress,
-			user: account,
-			callData,
-			blockNumber: targetBlockNumber,
-			preCallData: preFullPositionsCallData ? [preFullPositionsCallData, ...prePremiaCallData ? [prePremiaCallData] : []] : void 0,
-			postCallData: [postFullPositionsCallData, ...postPremiaCallData ? [postPremiaCallData] : []]
+			factoryAddress,
+			univ3pool,
+			riskEngine
 		});
-		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Token flow simulation failed");
-		const tokenFlow = flowResult.tokenFlow;
-		const preSnapshot = existingPositionIdList ?? [];
-		const positionsCreated = finalPositionIdList.filter((id) => !preSnapshot.includes(id));
-		const positionsClosed = preSnapshot.filter((id) => !finalPositionIdList.includes(id));
-		const decodeFullPositions = (data$1) => {
-			if (!data$1) return null;
-			try {
-				const decoded = decodeFunctionResult({
-					abi: panopticPoolV2Abi,
-					functionName: "getFullPositionsData",
-					data: data$1
-				});
-				const shortPremium = decodeLeftRightUnsigned(decoded[0]);
-				const longPremium = decodeLeftRightUnsigned(decoded[1]);
-				const reqs = decoded[3];
-				let collateralRequirements0 = 0n;
-				let collateralRequirements1 = 0n;
-				for (const packed of reqs) {
-					const r = decodeLeftRightUnsigned(packed);
-					collateralRequirements0 += r.right;
-					collateralRequirements1 += r.left;
-				}
-				return {
-					collateralRequirements0,
-					collateralRequirements1,
-					netPremia0: shortPremium.right - longPremium.right,
-					netPremia1: shortPremium.left - longPremium.left
-				};
-			} catch {
-				return null;
-			}
-		};
-		const prePositions = decodeFullPositions(flowResult.preCallResults?.[0]);
-		const postPositions = decodeFullPositions(flowResult.postCallResults?.[0]);
-		const prePremia = decodeFullPositions(flowResult.preCallResults?.[1]);
-		const postPremia = decodeFullPositions(flowResult.postCallResults?.[1]);
-		const _meta = await metaPromise;
-		const data = {
-			netAmount0: tokenFlow.delta0,
-			netAmount1: tokenFlow.delta1,
-			premiaReceived0: prePremia !== null && postPremia !== null ? prePremia.netPremia0 - postPremia.netPremia0 : null,
-			premiaReceived1: prePremia !== null && postPremia !== null ? prePremia.netPremia1 - postPremia.netPremia1 : null,
-			positionsCreated,
-			positionsClosed,
-			postCollateral0: tokenFlow.balanceAfter0,
-			postCollateral1: tokenFlow.balanceAfter1,
-			preMarginExcess0: prePositions === null ? null : tokenFlow.balanceBefore0 - prePositions.collateralRequirements0,
-			preMarginExcess1: prePositions === null ? null : tokenFlow.balanceBefore1 - prePositions.collateralRequirements1,
-			postMarginExcess0: postPositions === null ? null : tokenFlow.balanceAfter0 - postPositions.collateralRequirements0,
-			postMarginExcess1: postPositions === null ? null : tokenFlow.balanceAfter1 - postPositions.collateralRequirements1
-		};
-		return {
-			success: true,
-			data,
-			gasEstimate: flowResult.gasEstimate,
-			tokenFlow,
-			_meta
-		};
-	} catch (error) {
-		const _meta = await metaPromise;
-		return {
-			success: false,
-			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Simulation failed", error instanceof Error ? error : void 0),
-			_meta
-		};
 	}
+	const poolKey = await getUniswapV4PoolKeyFromId({
+		client,
+		sfpmAddress,
+		poolId
+	});
+	return getPanopticPoolAddress({
+		version: "v4",
+		client,
+		factoryAddress,
+		poolKey,
+		riskEngine
+	});
+}
+/**
+* Resolve an SFPM poolId to its PanopticPool address without knowing the version.
+*
+* Tries both V3 and V4 lookups in parallel. The factory returns `address(0)` for
+* non-existent pools, so the non-zero result identifies the correct version.
+*
+* At least one of `v3` or `v4` must be provided.
+*
+* @throws {PanopticValidationError} If no version config is provided or neither resolves.
+*/
+async function resolvePanopticPoolFromPoolId(params) {
+	const { client, poolId, riskEngine, v3, v4 } = params;
+	if (!v3 && !v4) throw new Error("At least one of v3 or v4 must be provided");
+	const isNotFoundError = (err) => {
+		if (typeof err === "object" && err !== null && "name" in err) {
+			const name = err.name;
+			return name === "ContractFunctionExecutionError" || name === "ContractFunctionRevertedError";
+		}
+		return false;
+	};
+	const results = await Promise.all([v3 ? getPanopticPoolFromPoolId({
+		version: "v3",
+		client,
+		sfpmAddress: v3.sfpmAddress,
+		factoryAddress: v3.factoryAddress,
+		riskEngine,
+		poolId
+	}).catch((err) => {
+		if (isNotFoundError(err)) return zeroAddress;
+		throw err;
+	}) : Promise.resolve(zeroAddress), v4 ? getPanopticPoolFromPoolId({
+		version: "v4",
+		client,
+		sfpmAddress: v4.sfpmAddress,
+		factoryAddress: v4.factoryAddress,
+		riskEngine,
+		poolId
+	}).catch((err) => {
+		if (isNotFoundError(err)) return zeroAddress;
+		throw err;
+	}) : Promise.resolve(zeroAddress)]);
+	const [v3Result, v4Result] = results;
+	if (v3Result !== zeroAddress) return {
+		panopticPoolAddress: v3Result,
+		version: "v3"
+	};
+	if (v4Result !== zeroAddress) return {
+		panopticPoolAddress: v4Result,
+		version: "v4"
+	};
+	throw new Error(`No PanopticPool found for poolId ${poolId}`);
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/tokenShortfallRecovery.ts
-const BPS_DENOMINATOR$2 = 10000n;
-const MAX_RECOVERY_QUOTE_ATTEMPTS = 8;
+//#region src/panoptic/v2/reads/minePoolAddressLocal.ts
 /**
-* Wrap a dispatch with a temporary credit leg that sources the shortfall.
+* keccak256 of the CREATE3 proxy initcode used by ClonesWithImmutableArgs.
+* Source: packages/panoptic-v2-core/lib/clones-with-immutable-args/src/ClonesWithImmutableArgs.sol
+*/
+const CREATE3_PROXY_BYTECODE_HASH = "0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f";
+const MASK_80 = (1n << 80n) - 1n;
+const MASK_40 = (1n << 40n) - 1n;
+const MASK_96 = (1n << 96n) - 1n;
+/** Encode a BigInt as a big-endian fixed-length byte array. */
+function bigintToBytes(value, byteLength) {
+	const bytes = new Uint8Array(byteLength);
+	let v = value;
+	for (let i = byteLength - 1; i >= 0; i--) {
+		bytes[i] = Number(v & 0xffn);
+		v >>= 8n;
+	}
+	return bytes;
+}
+/** Parse a 0x-prefixed address into 20 bytes. */
+function addressToBytes(addr) {
+	const hex = addr.slice(2).padStart(40, "0");
+	const bytes = new Uint8Array(20);
+	for (let i = 0; i < 20; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/** Parse a 0x-prefixed 32-byte hex string into bytes. */
+function hex32ToBytes(hex) {
+	const h = hex.slice(2).padStart(64, "0");
+	const bytes = new Uint8Array(32);
+	for (let i = 0; i < 32; i++) bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/**
+* Compute the CREATE3 deployed address for a given factory and packed salt.
 *
-* Exact-output construction: mint the credit with `swapAtMint=true` (paying a
-* swapped amount of the token the account has), run the user's operations, then
-* burn it with `swapAtMint=false` to receive exactly the missing token.
+* Mirrors `ClonesWithImmutableArgs.addressOfClone3(salt)` (with `address(this)` = factory):
+*   proxy    = CREATE2(factory, salt, PROXY_BYTECODE_HASH)
+*   deployed = CREATE1(proxy, nonce=1)
 *
-* A credit rather than a loan so the recovery is never capped by the shortfall
-* token's utilization — the case that fails today on a >94% utilized tracker.
+* Returns the deployed address as a uint160 BigInt.
 */
-function buildTokenShortfallRecoveryDispatch(params) {
-	return buildCreditWrappedDispatch({
-		...params,
-		direction: "exact-out",
-		placement: "straddle"
-	});
-}
-function buildPrefixedExactInputRecoveryDispatch(params) {
-	return buildCreditWrappedDispatch({
-		...params,
-		direction: "exact-in",
-		placement: "prepend"
-	});
+function addressOfClone3(factory, salt) {
+	const saltBytes = bigintToBytes(salt, 32);
+	const create2Input = new Uint8Array(85);
+	create2Input[0] = 255;
+	create2Input.set(addressToBytes(factory), 1);
+	create2Input.set(saltBytes, 21);
+	create2Input.set(hex32ToBytes(CREATE3_PROXY_BYTECODE_HASH), 53);
+	const proxyHash = keccak256(create2Input, "bytes");
+	const proxyAddress = proxyHash.slice(12);
+	const create1Input = new Uint8Array(23);
+	create1Input[0] = 214;
+	create1Input[1] = 148;
+	create1Input.set(proxyAddress, 2);
+	create1Input[22] = 1;
+	const deployedHash = keccak256(create1Input, "bytes");
+	let addr = 0n;
+	for (let i = 12; i < 32; i++) addr = addr << 8n | BigInt(deployedHash[i]);
+	return addr;
 }
 /**
-* Extract a fully-decoded `NotEnoughTokens` revert from an arbitrary error.
+* Count leading hex-zero characters in a 160-bit address value.
 *
-* Returns `null` when the error is something else, or when only the 4-byte
-* selector could be matched (the parser's fallback path constructs the error
-* with undefined args, which is not actionable).
+* Mirrors `PanopticMath.numberOfLeadingHexZeros(addr)`.
+* Returns 40 for the zero address.
 */
-function getNotEnoughTokensError(error) {
-	const visited = new Set();
-	let current = error;
-	while (current !== void 0 && current !== null && !visited.has(current)) {
-		visited.add(current);
-		const parsed = current instanceof NotEnoughTokensError ? current : parsePanopticError(current)?.error;
-		const candidate = parsed instanceof NotEnoughTokensError ? parsed : null;
-		if (candidate !== null) {
-			const args = candidate;
-			if (args.tokenAddress !== void 0 && args.assetsRequested !== void 0 && args.assetBalance !== void 0) return candidate;
-		}
-		current = current instanceof Error && "cause" in current ? current.cause : void 0;
+function numberOfLeadingHexZeros(addrInt) {
+	if (addrInt === 0n) return 40;
+	let x = addrInt;
+	let r = 0;
+	if (x >= 0x100000000000000000000000000000000n) {
+		x >>= 128n;
+		r += 32;
 	}
-	return null;
-}
-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$1(numerator, denominator) {
-	return (numerator + denominator - 1n) / denominator;
-}
-function getInputAmount(tokenFlow, tokenInIndex) {
-	const delta = tokenInIndex === 0n ? tokenFlow.delta0 : tokenFlow.delta1;
-	return delta < 0n ? -delta : delta;
-}
-function getBalanceBefore(tokenFlow, tokenIndex) {
-	return tokenIndex === 0n ? tokenFlow.balanceBefore0 : tokenFlow.balanceBefore1;
-}
-function getOutputAmount(tokenFlow, tokenOutIndex) {
-	const delta = tokenOutIndex === 0n ? tokenFlow.delta0 : tokenFlow.delta1;
-	return delta > 0n ? delta : 0n;
+	if (x >= 0x10000000000000000n) {
+		x >>= 64n;
+		r += 16;
+	}
+	if (x >= 0x100000000n) {
+		x >>= 32n;
+		r += 8;
+	}
+	if (x >= 0x10000n) {
+		x >>= 16n;
+		r += 4;
+	}
+	if (x >= 0x100n) {
+		x >>= 8n;
+		r += 2;
+	}
+	if (x >= 0x10n) r += 1;
+	return 39 - r;
 }
-async function quoteTokenShortfallRecovery(params) {
-	const shortfallError = getNotEnoughTokensError(params.error);
-	if (shortfallError === null) return {
-		available: false,
-		reason: "not-token-shortfall"
-	};
-	let amountOut = shortfallError.assetsRequested - shortfallError.assetBalance;
-	if (amountOut <= 0n) return {
-		available: false,
-		reason: "invalid-shortfall",
-		detail: `requested=${shortfallError.assetsRequested} <= balance=${shortfallError.assetBalance}`
-	};
-	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR$2) return {
-		available: false,
-		reason: "invalid-slippage",
-		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR$2}]`
-	};
-	const targetBlockNumber = params.blockNumber ?? await params.client.getBlockNumber();
-	const pool = await getPool({
-		client: params.client,
-		poolAddress: params.poolAddress,
-		chainId: params.chainId,
-		blockNumber: targetBlockNumber
-	});
-	const defaultTickLimits = tickLimits(pool.currentTick, params.slippageBps);
-	const tickLimitLow = params.tickLimitLow ?? defaultTickLimits.low;
-	const tickLimitHigh = params.tickLimitHigh ?? defaultTickLimits.high;
-	if (tickLimitLow >= tickLimitHigh) return {
-		available: false,
-		reason: "invalid-tick-limits",
-		detail: `tickLimitLow=${tickLimitLow} >= tickLimitHigh=${tickLimitHigh}`
-	};
-	const token0 = pool.collateralTracker0.token;
-	const token1 = pool.collateralTracker1.token;
-	const shortfallTokenIndex = (error) => {
-		const address = error.tokenAddress.toLowerCase();
-		if (address === token0.toLowerCase() || address === pool.collateralTracker0.address.toLowerCase()) return 0n;
-		if (address === token1.toLowerCase() || address === pool.collateralTracker1.address.toLowerCase()) return 1n;
-		return null;
-	};
-	const tokenOutIndex = shortfallTokenIndex(shortfallError);
-	if (tokenOutIndex === null) return {
-		available: false,
-		reason: "unsupported-token",
-		detail: `${shortfallError.tokenAddress} is neither collateral token of ${params.poolAddress}`
-	};
-	const tokenInIndex = tokenOutIndex === 0n ? 1n : 0n;
-	const tokenOut = tokenOutIndex === 0n ? token0 : token1;
-	const tokenIn = tokenInIndex === 0n ? token0 : token1;
-	const collisionIds = Array.from(new Set([
-		...params.existingPositionIds,
-		...params.dispatch.positionIdList,
-		...params.dispatch.finalPositionIdList
-	]));
-	const quotePrefixedExactInput = async (initialRequiredOutput) => {
-		let requiredOutput = initialRequiredOutput;
-		const spotInput = convertToTokenIndex(requiredOutput, tokenOutIndex, tokenInIndex, pool.sqrtPriceX96);
-		let creditInput = maximumAmountIn(spotInput > 0n ? spotInput : 1n, params.slippageBps);
-		for (let attempt = 0; attempt < MAX_RECOVERY_QUOTE_ATTEMPTS; attempt++) {
-			const credit = buildUniqueCredit(pool.poolId, tokenInIndex, tokenInIndex, pool.currentTick, pool.tickSpacing, collisionIds, creditInput);
-			const wrapArgs = {
-				creditTokenId: credit.tokenId,
-				creditPositionSize: credit.adjustedSize,
-				tickLimitLow,
-				tickLimitHigh
-			};
-			const swapDispatch = buildPrefixedExactInputRecoveryDispatch({
-				...wrapArgs,
-				dispatch: {
-					positionIdList: [],
-					finalPositionIdList: [...params.existingPositionIds],
-					positionSizes: [],
-					tickAndSpreadLimits: [],
-					usePremiaAsCollateral: false,
-					builderCode: 0n
-				}
-			});
-			const swapSimulation = await simulateDispatch({
-				client: params.client,
-				poolAddress: params.poolAddress,
-				account: params.account,
-				existingPositionIdList: params.existingPositionIds,
-				...swapDispatch,
-				blockNumber: targetBlockNumber
-			});
-			if (!swapSimulation.success || swapSimulation.tokenFlow === void 0) return {
-				available: false,
-				reason: "swap-unavailable",
-				detail: swapSimulation.success ? "prefixed swap simulation returned no token flow" : `prefixed swap simulation reverted: ${swapSimulation.error.message}`,
-				error: swapSimulation.success ? void 0 : swapSimulation.error
-			};
-			const estimatedAmountIn = getInputAmount(swapSimulation.tokenFlow, tokenInIndex);
-			const estimatedAmountOut = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
-			const sourceBalance = getBalanceBefore(swapSimulation.tokenFlow, tokenInIndex);
-			if (sourceBalance < estimatedAmountIn) return {
-				available: false,
-				reason: "swap-unavailable",
-				detail: `source balance ${sourceBalance} < exact input cost ${estimatedAmountIn}`,
-				error: new PanopticError("Insufficient source collateral for the recovery swap")
-			};
-			if (estimatedAmountOut < requiredOutput) {
-				creditInput = estimatedAmountOut > 0n ? ceilDiv$1(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
-				continue;
+/**
+* Construct the bytes32 CREATE3 salt for PanopticFactoryV3.
+*
+* Mirrors:
+*   bytes32(abi.encodePacked(
+*     uint80(uint160(deployerAddress) >> 80),  // bits [159:80]  of deployer  → 10 bytes
+*     uint40(uint160(v3Pool) >> 120),           // bits [159:120] of v3Pool    →  5 bytes
+*     uint40(uint160(riskEngine) >> 120),       // bits [159:120] of riskEngine→  5 bytes
+*     salt                                      // uint96                      → 12 bytes
+*   ))
+*/
+function computeSaltPrefixV3(deployerAddress, v3Pool, riskEngine) {
+	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
+	const pool40 = BigInt(v3Pool) >> 120n & MASK_40;
+	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
+	return deployer80 << 176n | pool40 << 136n | risk40 << 96n;
+}
+/**
+* Compute the Uniswap V4 PoolId for a PoolKey.
+*
+* Mirrors `PoolId.toId(key)` = keccak256 of the ABI-encoded PoolKey struct
+* (5 fields × 32 bytes = 160 bytes).
+*/
+function computePoolIdV4(poolKey) {
+	const fee = Number(poolKey.fee);
+	if (!Number.isInteger(fee) || fee < 0 || fee >= 2 ** 24) throw new PanopticValidationError(`fee out of uint24 range: ${fee}`);
+	const tickSpacing = Number(poolKey.tickSpacing);
+	if (!Number.isInteger(tickSpacing) || tickSpacing < -(2 ** 23) || tickSpacing > 2 ** 23 - 1) throw new PanopticValidationError(`tickSpacing out of int24 range: ${tickSpacing}`);
+	const encoded = encodeAbiParameters([
+		{ type: "address" },
+		{ type: "address" },
+		{ type: "uint24" },
+		{ type: "int24" },
+		{ type: "address" }
+	], [
+		poolKey.currency0,
+		poolKey.currency1,
+		Number(poolKey.fee),
+		Number(poolKey.tickSpacing),
+		poolKey.hooks
+	]);
+	return BigInt(keccak256(encoded));
+}
+/**
+* Construct the bytes32 CREATE3 salt for PanopticFactoryV4.
+*
+* Mirrors:
+*   bytes32(abi.encodePacked(
+*     uint80(uint160(deployerAddress) >> 80),
+*     uint40(uint256(PoolId.unwrap(key.toId())) >> 120),  // bits [159:120] of poolId
+*     uint40(uint160(riskEngine) >> 120),
+*     salt
+*   ))
+*/
+function computeSaltPrefixV4(deployerAddress, poolKey, riskEngine) {
+	const deployer80 = BigInt(deployerAddress) >> 80n & MASK_80;
+	const poolId40 = computePoolIdV4(poolKey) >> 120n & MASK_40;
+	const risk40 = BigInt(riskEngine) >> 120n & MASK_40;
+	return deployer80 << 176n | poolId40 << 136n | risk40 << 96n;
+}
+/** Number of iterations per chunk before yielding back to the event loop. */
+const CHUNK_SIZE = 5000n;
+/**
+* Async version of {@link minePoolAddressLocal} that yields to the event loop
+* between chunks of iterations, preventing the browser UI from freezing.
+*
+* @param params - Mining parameters (versioned: 'v3' or 'v4'). No `client` required.
+* @returns The best salt found and its rarity (number of leading hex zeros).
+*/
+async function minePoolAddressLocalAsync(params) {
+	const { factoryAddress, deployerAddress, riskEngine, salt, loops, minTargetRarity } = params;
+	let bestSalt = salt;
+	let highestRarity = 0n;
+	const maxSalt = salt + loops;
+	const saltPrefix = params.version === "v3" ? computeSaltPrefixV3(deployerAddress, params.v3Pool, riskEngine) : computeSaltPrefixV4(deployerAddress, params.poolKey, riskEngine);
+	let currentSalt = salt;
+	while (currentSalt < maxSalt) {
+		const chunkEnd = currentSalt + CHUNK_SIZE < maxSalt ? currentSalt + CHUNK_SIZE : maxSalt;
+		let done = false;
+		for (; currentSalt < chunkEnd; currentSalt++) {
+			const newSalt = saltPrefix | currentSalt & MASK_96;
+			const addrInt = addressOfClone3(factoryAddress, newSalt);
+			const rarity = BigInt(numberOfLeadingHexZeros(addrInt));
+			if (rarity > highestRarity) {
+				highestRarity = rarity;
+				bestSalt = currentSalt;
+			}
+			if (rarity >= minTargetRarity) {
+				highestRarity = rarity;
+				bestSalt = currentSalt;
+				done = true;
+				break;
 			}
-			const recoveredDispatch = buildPrefixedExactInputRecoveryDispatch({
-				...wrapArgs,
-				dispatch: params.dispatch
-			});
-			const recoverySimulation = await simulateDispatch({
-				client: params.client,
-				poolAddress: params.poolAddress,
-				account: params.account,
-				existingPositionIdList: params.existingPositionIds,
-				...recoveredDispatch,
-				measurePremia: true,
-				blockNumber: targetBlockNumber
-			});
-			if (recoverySimulation.success && recoverySimulation.tokenFlow !== void 0) return {
-				available: true,
-				quote: {
-					tokenIn,
-					tokenOut,
-					direction: "exact-in",
-					amountOut: requiredOutput,
-					estimatedAmountOut,
-					estimatedAmountIn,
-					maximumAmountIn: estimatedAmountIn,
-					slippageBps: params.slippageBps,
-					netTokenInChange: tokenInIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
-					netTokenOutChange: tokenOutIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
-					creditTokenId: credit.tokenId,
-					dispatch: recoveredDispatch,
-					simulation: {
-						...recoverySimulation,
-						tokenFlow: recoverySimulation.tokenFlow
-					},
-					tokenFlow: recoverySimulation.tokenFlow,
-					_meta: recoverySimulation._meta
-				}
-			};
-			if (recoverySimulation.success) return {
-				available: false,
-				reason: "recovery-unavailable",
-				detail: "prefixed recovery simulation returned no token flow",
-				error: new PanopticError("Recovery simulation did not return token flow")
-			};
-			const remainingShortfall = getNotEnoughTokensError(recoverySimulation.error);
-			if (remainingShortfall === null || shortfallTokenIndex(remainingShortfall) !== tokenOutIndex) return {
-				available: false,
-				reason: "recovery-unavailable",
-				detail: `prefixed recovery reverted with a non-output shortfall: ${recoverySimulation.error.message}`,
-				error: recoverySimulation.error
-			};
-			const residual = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
-			requiredOutput += residual > 0n ? residual : requiredOutput;
-			creditInput = ceilDiv$1(creditInput * requiredOutput, estimatedAmountOut) + 1n;
-		}
-		return {
-			available: false,
-			reason: "recovery-unavailable",
-			detail: `prefixed recovery remained short after ${MAX_RECOVERY_QUOTE_ATTEMPTS} attempts`,
-			error: new PanopticError("Could not size the prefixed recovery swap")
-		};
-	};
-	let creditOutSize = amountOut;
-	for (let attempt = 0; attempt < MAX_RECOVERY_QUOTE_ATTEMPTS; attempt++) {
-		const credit = buildUniqueCredit(pool.poolId, tokenOutIndex, tokenOutIndex, pool.currentTick, pool.tickSpacing, collisionIds, creditOutSize);
-		const recoveredDispatch = buildTokenShortfallRecoveryDispatch({
-			dispatch: params.dispatch,
-			creditTokenId: credit.tokenId,
-			creditPositionSize: credit.adjustedSize,
-			tickLimitLow,
-			tickLimitHigh
-		});
-		const swapDispatch = buildTokenShortfallRecoveryDispatch({
-			dispatch: {
-				positionIdList: [],
-				finalPositionIdList: [...params.existingPositionIds],
-				positionSizes: [],
-				tickAndSpreadLimits: [],
-				usePremiaAsCollateral: false,
-				builderCode: 0n
-			},
-			creditTokenId: credit.tokenId,
-			creditPositionSize: credit.adjustedSize,
-			tickLimitLow,
-			tickLimitHigh
-		});
-		const swapSimulation = await simulateDispatch({
-			client: params.client,
-			poolAddress: params.poolAddress,
-			account: params.account,
-			existingPositionIdList: params.existingPositionIds,
-			...swapDispatch,
-			blockNumber: targetBlockNumber
-		});
-		if (!swapSimulation.success || swapSimulation.tokenFlow === void 0) {
-			const bootstrapShortfall = swapSimulation.success ? null : getNotEnoughTokensError(swapSimulation.error);
-			if (bootstrapShortfall !== null && shortfallTokenIndex(bootstrapShortfall) === tokenOutIndex) return quotePrefixedExactInput(amountOut);
-			return {
-				available: false,
-				reason: "swap-unavailable",
-				detail: swapSimulation.success ? "swap-only simulation returned no token flow" : `swap-only simulation reverted: ${swapSimulation.error.message}`,
-				error: swapSimulation.success ? void 0 : swapSimulation.error
-			};
-		}
-		const estimatedAmountIn = getInputAmount(swapSimulation.tokenFlow, tokenInIndex);
-		const maxAmountIn = maximumAmountIn(estimatedAmountIn, params.slippageBps);
-		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
-		const sourceBalance = getBalanceBefore(swapSimulation.tokenFlow, tokenInIndex);
-		if (swapOutput < amountOut) {
-			creditOutSize = swapOutput > 0n ? ceilDiv$1(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
-			continue;
-		}
-		if (sourceBalance < maxAmountIn) return {
-			available: false,
-			reason: "swap-unavailable",
-			detail: `source balance ${sourceBalance} < maximumAmountIn ${maxAmountIn} (estimated ${estimatedAmountIn}, slippageBps ${params.slippageBps})`,
-			error: new PanopticError("Insufficient source collateral for the recovery swap")
-		};
-		const recoverySimulation = await simulateDispatch({
-			client: params.client,
-			poolAddress: params.poolAddress,
-			account: params.account,
-			existingPositionIdList: params.existingPositionIds,
-			...recoveredDispatch,
-			measurePremia: true,
-			blockNumber: targetBlockNumber
-		});
-		if (recoverySimulation.success) {
-			if (recoverySimulation.tokenFlow !== void 0) return {
-				available: true,
-				quote: {
-					tokenIn,
-					tokenOut,
-					direction: "exact-out",
-					amountOut,
-					estimatedAmountOut: swapOutput,
-					estimatedAmountIn,
-					maximumAmountIn: maxAmountIn,
-					slippageBps: params.slippageBps,
-					netTokenInChange: tokenInIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
-					netTokenOutChange: tokenOutIndex === 0n ? recoverySimulation.tokenFlow.delta0 : recoverySimulation.tokenFlow.delta1,
-					creditTokenId: credit.tokenId,
-					dispatch: recoveredDispatch,
-					simulation: {
-						...recoverySimulation,
-						tokenFlow: recoverySimulation.tokenFlow
-					},
-					tokenFlow: recoverySimulation.tokenFlow,
-					_meta: recoverySimulation._meta
-				}
-			};
-			return {
-				available: false,
-				reason: "recovery-unavailable",
-				detail: "wrapped dispatch simulation returned no token flow",
-				error: new PanopticError("Recovery simulation did not return token flow")
-			};
 		}
-		const remainingShortfall = getNotEnoughTokensError(recoverySimulation.error);
-		if (remainingShortfall === null || shortfallTokenIndex(remainingShortfall) !== tokenOutIndex) return {
-			available: false,
-			reason: "recovery-unavailable",
-			detail: `wrapped dispatch reverted with a non-shortfall error: ${recoverySimulation.error.message}`,
-			error: recoverySimulation.error
-		};
-		const decodedShortfall = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
-		const additionalAmountOut = decodedShortfall > 0n ? decodedShortfall : amountOut;
-		amountOut += additionalAmountOut;
-		creditOutSize = swapOutput > 0n ? ceilDiv$1(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+		if (done) break;
+		await new Promise((resolve) => setTimeout(resolve, 0));
 	}
 	return {
-		available: false,
-		reason: "recovery-unavailable",
-		detail: `still short after ${MAX_RECOVERY_QUOTE_ATTEMPTS} sizing attempts (last target ${amountOut})`,
-		error: new PanopticError("Could not cover recovery swap costs within the quote attempt limit")
+		bestSalt,
+		highestRarity
 	};
 }
 
@@ -1656,7 +2058,7 @@ const MAX_EFFECTIVE_LIQUIDITY_LIMIT = 8388607;
 * returned value must be scaled down to the caller's actual `positionSize`.
 */
 const MAX_UINT64$1 = 2n ** 64n - 1n;
-const FP96$1 = 1n << 96n;
+const FP96 = 1n << 96n;
 /**
 * `getRequiredBase` returns `type(uint128).max` as an error sentinel (invalid
 * tokenId or reverting `getMargin`). Detect it so we don't scale a garbage value.
@@ -1677,7 +2079,11 @@ const REQUIRED_BASE_ERROR_SENTINEL = 2n ** 128n - 1n;
 * @returns Estimated collateral requirements with block metadata
 */
 async function estimateCollateralRequired(params) {
-	const { client, poolAddress, tokenId, positionSize, atTick, queryAddress, blockNumber } = params;
+	return scaleCollateralRequired(await getCollateralRequiredBase(params), params.positionSize);
+}
+/** Account- and size-independent requirement, with its valuation tick and block. */
+async function getCollateralRequiredBase(params) {
+	const { client, poolAddress, tokenId, atTick, queryAddress, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
 	let effectiveTick;
 	if (atTick !== void 0) effectiveTick = atTick;
@@ -1704,8 +2110,17 @@ async function estimateCollateralRequired(params) {
 		client,
 		blockNumber: targetBlockNumber
 	})]);
+	return {
+		requiredBase,
+		effectiveTick,
+		_meta
+	};
+}
+/** Preserve the contract sentinel and integer rounding when scaling a cached base. */
+function scaleCollateralRequired(base, positionSize) {
+	const { requiredBase, effectiveTick, _meta } = base;
 	const scaledRequirement = requiredBase >= REQUIRED_BASE_ERROR_SENTINEL ? requiredBase : requiredBase * positionSize / MAX_UINT64$1;
-	const denominatedInToken0 = tickToSqrtPriceX96(effectiveTick) < FP96$1;
+	const denominatedInToken0 = tickToSqrtPriceX96(effectiveTick) < FP96;
 	return {
 		required0: denominatedInToken0 ? scaledRequirement : 0n,
 		required1: denominatedInToken0 ? 0n : scaledRequirement,
@@ -1722,8 +2137,10 @@ async function estimateCollateralRequired(params) {
 * @returns Maximum position size with bounds and block metadata
 */
 async function getMaxPositionSize(params) {
+	params.signal?.throwIfAborted();
 	const { client, poolAddress, account, tokenId, queryAddress, existingPositionIds, storage, chainId, refine = true, precisionPct = 1, swapAtMint = false, usePremiaAsCollateral = false, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	const targetBlockNumber = blockNumber ?? params.bounds?._meta.blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
+	if (params.bounds && params.bounds._meta.blockNumber !== targetBlockNumber) throw new PanopticError("MAX bounds block does not match the refinement block");
 	let positionIds;
 	if (existingPositionIds !== void 0) positionIds = existingPositionIds;
 	else if (storage && chainId !== void 0) positionIds = await getTrackedPositionIds({
@@ -1733,7 +2150,7 @@ async function getMaxPositionSize(params) {
 		storage
 	});
 	else positionIds = [];
-	const [boundsResult, _meta] = await Promise.all([client.readContract({
+	const [boundsResult, _meta] = await Promise.all([params.bounds ? [params.bounds.maxSizeAtMinUtil, params.bounds.maxSizeAtMaxUtil] : client.readContract({
 		address: queryAddress,
 		abi: panopticQueryAbi,
 		functionName: "getMaxPositionSizeBounds",
@@ -1744,11 +2161,12 @@ async function getMaxPositionSize(params) {
 			tokenId
 		],
 		blockNumber: targetBlockNumber
-	}), params._meta ?? getBlockMeta({
+	}), params.bounds?._meta ?? params._meta ?? getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	})]);
 	const [maxSizeAtMinUtil, maxSizeAtMaxUtil] = boundsResult;
+	params.signal?.throwIfAborted();
 	const precisionDivisor = BigInt(Math.floor(100 / precisionPct));
 	if (!refine || maxSizeAtMinUtil === maxSizeAtMaxUtil || maxSizeAtMinUtil - maxSizeAtMaxUtil <= maxSizeAtMaxUtil / precisionDivisor) return {
 		maxSize: maxSizeAtMaxUtil,
@@ -1766,7 +2184,9 @@ async function getMaxPositionSize(params) {
 		high: maxSizeAtMinUtil * 2n,
 		precisionDivisor,
 		swapAtMint,
-		usePremiaAsCollateral
+		usePremiaAsCollateral,
+		blockNumber: targetBlockNumber,
+		signal: params.signal
 	});
 	return {
 		maxSize,
@@ -1790,9 +2210,11 @@ async function binarySearchMaxSize(params) {
 		existingPositionIds,
 		positionSize,
 		swapAtMint,
-		usePremiaAsCollateral
+		usePremiaAsCollateral,
+		blockNumber: params.blockNumber
 	});
 	while (high - low > 1n && high - low > low / precisionDivisor) {
+		params.signal?.throwIfAborted();
 		const range = high - low;
 		const p1 = low + range / 6n;
 		const p2 = low + range * 2n / 6n;
@@ -1806,6 +2228,7 @@ async function binarySearchMaxSize(params) {
 			trySize(p4),
 			trySize(p5)
 		]);
+		params.signal?.throwIfAborted();
 		if (s5) low = p5;
 		else if (s4) {
 			low = p4;
@@ -1856,7 +2279,8 @@ async function tryDispatchSimulation(params) {
 			abi: panopticPoolV2Abi,
 			functionName: "multicall",
 			args: [[callData]],
-			account
+			account,
+			blockNumber: params.blockNumber
 		});
 		return true;
 	} catch {
@@ -1977,7 +2401,7 @@ async function getItmAmounts(params) {
 * high-decimal amount can't masquerade as real flow.
 */
 const FLOW_NEUTRAL_DUST_THRESHOLD = 1000n;
-const Q192$1 = 1n << 192n;
+const Q192$2 = 1n << 192n;
 const POOL_ID_MASK$1 = (1n << 64n) - 1n;
 /**
 * Floor integer square root for bigints (Newton's method). Exact for all
@@ -2013,7 +2437,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$1 / positionSize);
+	const sqrtKrawX96 = isqrt(absAmount * Q192$2 / positionSize);
 	let signedTick;
 	try {
 		signedTick = sqrtPriceX96ToTick(sqrtKrawX96);
@@ -2271,7 +2695,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$1 : abs$1;
+		return index === 0n ? abs$1 * sqrtPX96 * sqrtPX96 / Q192$2 : abs$1;
 	};
 	const flowFor = (index) => index === 0n ? credit.creditAmount0 : credit.creditAmount1;
 	if (queryAddress !== void 0) {
@@ -2665,7 +3089,7 @@ async function estimateCollateralBreakdown(params) {
 */
 function apportion(groups, isolated, total) {
 	if (groups.length !== isolated.length) throw new PanopticError(`apportion: groups and isolated must have equal lengths (${groups.length} !== ${isolated.length})`);
-	const weightSum = isolated.reduce((sum, value) => sum + (value ?? 0n), 0n);
+	const weightSum = isolated.reduce((sum$1, value) => sum$1 + (value ?? 0n), 0n);
 	if (total === null || total <= 0n || weightSum <= 0n) return groups.map((group, i) => ({
 		...group,
 		isolatedRequired0: isolated[i],
@@ -3166,7 +3590,7 @@ async function getPoolLiquidities(params) {
 
 //#endregion
 //#region src/panoptic/v2/reads/accountGreeks.ts
-const Q192 = 1n << 192n;
+const Q192$1 = 1n << 192n;
 /**
 * Calculate account-level greeks using stored position data.
 *
@@ -3287,8 +3711,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 + otherBal;
-		else collateralValue = assetBal * Q192 / (sqrtPriceX96 * sqrtPriceX96) + otherBal;
+		if (isAssetToken0) collateralValue = assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 + otherBal;
+		else collateralValue = assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96) + otherBal;
 		collateralDelta = assetBal;
 	}
 	return {
@@ -3328,7 +3752,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 : assetBal * Q192 / (sqrtPriceX96 * sqrtPriceX96);
+			const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 : assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96);
 			totalValue$1.push(assetValueInNumeraire + otherBal);
 			totalDelta$1.push(assetBal);
 		}
@@ -3378,7 +3802,7 @@ function calculateAccountGreeksPure(params) {
 	}
 	for (let i = 0; i < n; i++) {
 		const sqrtPriceX96 = tickToSqrtPriceX96(atTicks[i]);
-		const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192 : assetBal * Q192 / (sqrtPriceX96 * sqrtPriceX96);
+		const assetValueInNumeraire = isAssetToken0 ? assetBal * sqrtPriceX96 * sqrtPriceX96 / Q192$1 : assetBal * Q192$1 / (sqrtPriceX96 * sqrtPriceX96);
 		totalValue[i] += assetValueInNumeraire + otherBal;
 		totalDelta[i] += assetBal;
 	}
@@ -3391,250 +3815,6 @@ function calculateAccountGreeksPure(params) {
 	};
 }
 
-//#endregion
-//#region src/panoptic/v2/reads/margin.ts
-const FP96 = 1n << 96n;
-const Q128$2 = 1n << 128n;
-/** Cap for a usage ratio with no collateral behind it. */
-const MAX_USAGE_BPS = 1000000n;
-const bigintMax = (a, b) => a > b ? a : b;
-const bigintMin = (a, b) => a < b ? a : b;
-/**
-* Convert a token0 amount to its token1-equivalent at the given sqrtPriceX96.
-*
-* Matches the on-chain `PanopticMath.convert0to1` truncation, with an
-* overflow-safe branch when `sqrtPriceX96^2` would not fit in uint256.
-*/
-function convert0to1$1(amount, sqrtPriceX96) {
-	if (sqrtPriceX96 < Q128$2) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
-	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
-	return amount * sp2Hi >> 128n;
-}
-/**
-* Convert a token1 amount to its token0-equivalent at the given sqrtPriceX96.
-*/
-function convert1to0$1(amount, sqrtPriceX96) {
-	if (sqrtPriceX96 < Q128$2) {
-		const denom = sqrtPriceX96 * sqrtPriceX96;
-		return amount * (1n << 192n) / denom;
-	}
-	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
-	return amount * (1n << 128n) / sp2Hi;
-}
-/**
-* Get margin buffer and distance-to-liquidation for an account.
-*
-* Reads, all pinned to the same block:
-* - `getCurrentTick` (sequencing dependency for sqrtPrice conversion)
-* - `getFullPositionsData(account, true, tokenIds)` → collateralRequirements
-* - `CollateralTracker.assetsOf(account)` on both trackers → gross collateral
-* - `PanopticQuery.getLiquidationPrices(...)` → liquidation boundaries
-*
-* @param params - The parameters
-* @returns Margin buffer with liquidation distance and block metadata
-*/
-async function getMarginBuffer(params) {
-	const { client, poolAddress, account, tokenIds, queryAddress, blockNumber, mintBuffer } = params;
-	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
-	let collateralToken0;
-	let collateralToken1;
-	if (params.collateralAddresses) {
-		collateralToken0 = params.collateralAddresses.collateralToken0;
-		collateralToken1 = params.collateralAddresses.collateralToken1;
-	} else {
-		const addrs = await client.multicall({
-			contracts: [{
-				address: poolAddress,
-				abi: panopticPoolV2Abi,
-				functionName: "collateralToken0"
-			}, {
-				address: poolAddress,
-				abi: panopticPoolV2Abi,
-				functionName: "collateralToken1"
-			}],
-			blockNumber: targetBlockNumber,
-			allowFailure: false
-		});
-		collateralToken0 = addrs[0];
-		collateralToken1 = addrs[1];
-	}
-	const hasPositions = tokenIds.length > 0;
-	const calls = [
-		{
-			target: poolAddress,
-			callData: encodeFunctionData({
-				abi: panopticPoolV2Abi,
-				functionName: "getCurrentTick"
-			})
-		},
-		{
-			target: collateralToken0,
-			callData: encodeFunctionData({
-				abi: collateralTrackerV2Abi,
-				functionName: "assetsOf",
-				args: [account]
-			})
-		},
-		{
-			target: collateralToken1,
-			callData: encodeFunctionData({
-				abi: collateralTrackerV2Abi,
-				functionName: "assetsOf",
-				args: [account]
-			})
-		}
-	];
-	const positionDataIndex = hasPositions ? calls.length : null;
-	if (positionDataIndex !== null) calls.push({
-		target: poolAddress,
-		callData: encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				true,
-				tokenIds
-			]
-		})
-	});
-	const liqPricesIndex = hasPositions ? calls.length : null;
-	if (liqPricesIndex !== null) calls.push({
-		target: queryAddress,
-		callData: encodeFunctionData({
-			abi: panopticQueryAbi,
-			functionName: "getLiquidationPrices",
-			args: [
-				poolAddress,
-				account,
-				tokenIds
-			]
-		})
-	});
-	const checkCollateralIndex = hasPositions ? calls.length : null;
-	if (checkCollateralIndex !== null) calls.push({
-		target: queryAddress,
-		callData: encodeFunctionData({
-			abi: panopticQueryAbi,
-			functionName: "checkCollateral",
-			args: [
-				poolAddress,
-				account,
-				tokenIds
-			]
-		})
-	});
-	const { _meta, results } = await readBlockAndAggregate({
-		client,
-		calls,
-		blockNumber: targetBlockNumber
-	});
-	const currentTickResult = decodeFunctionResult({
-		abi: panopticPoolV2Abi,
-		functionName: "getCurrentTick",
-		data: requireReturnData(results, 0, "PanopticPool.getCurrentTick")
-	});
-	const currentTick = BigInt(currentTickResult);
-	const assets0 = decodeFunctionResult({
-		abi: collateralTrackerV2Abi,
-		functionName: "assetsOf",
-		data: requireReturnData(results, 1, "CollateralTracker.assetsOf token0")
-	});
-	const assets1 = decodeFunctionResult({
-		abi: collateralTrackerV2Abi,
-		functionName: "assetsOf",
-		data: requireReturnData(results, 2, "CollateralTracker.assetsOf token1")
-	});
-	const positionDataResult = positionDataIndex === null ? null : decodeFunctionResult({
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		data: requireReturnData(results, positionDataIndex, "PanopticPool.getFullPositionsData")
-	});
-	const liqPricesResult = liqPricesIndex === null ? null : decodeFunctionResult({
-		abi: panopticQueryAbi,
-		functionName: "getLiquidationPrices",
-		data: requireReturnData(results, liqPricesIndex, "PanopticQuery.getLiquidationPrices")
-	});
-	const checkCollateralResult = checkCollateralIndex === null ? null : decodeFunctionResult({
-		abi: panopticQueryAbi,
-		functionName: "checkCollateral",
-		data: requireReturnData(results, checkCollateralIndex, "PanopticQuery.checkCollateral")
-	});
-	let usageBps0 = null;
-	let usageBps1 = null;
-	let crossMarginUsageBps = null;
-	let mintableMarginBinding = null;
-	if (checkCollateralResult) {
-		const [balances0, requireds0, balances1, requireds1] = checkCollateralResult;
-		const ratio = (required, balance) => {
-			if (required === void 0 || balance === void 0) return null;
-			if (balance === 0n) return required > 0n ? MAX_USAGE_BPS : 0n;
-			return required * 10000n / balance;
-		};
-		usageBps0 = ratio(requireds0[0], balances0[0]);
-		usageBps1 = ratio(requireds1[0], balances1[0]);
-		if (usageBps0 !== null || usageBps1 !== null) crossMarginUsageBps = usageBps0 === null ? usageBps1 : usageBps1 === null ? usageBps0 : bigintMax(usageBps0, usageBps1);
-		const mintable = (balance, required) => balance === void 0 || required === void 0 ? null : mintableAfterBuffer(balance, required, mintBuffer);
-		const mintable0 = mintable(balances0[0], requireds0[0]);
-		const mintable1 = mintable(balances1[0], requireds1[0]);
-		if (mintable0 !== null || mintable1 !== null) mintableMarginBinding = mintable0 === null ? mintable1 : mintable1 === null ? mintable0 : bigintMin(mintable0, mintable1);
-	}
-	let required0Native = 0n;
-	let required1Native = 0n;
-	if (positionDataResult) {
-		const collateralRequirements = positionDataResult[3];
-		for (const packed of collateralRequirements) {
-			const decoded = decodeLeftRightUnsigned(packed);
-			required0Native += decoded.right;
-			required1Native += decoded.left;
-		}
-	}
-	const sqrtPriceX96 = tickToSqrtPriceX96(currentTick);
-	const denominatedInToken = sqrtPriceX96 < FP96 ? 0 : 1;
-	const currentMargin0 = assets0 + convert1to0$1(assets1, sqrtPriceX96);
-	const requiredMargin0 = required0Native + convert1to0$1(required1Native, sqrtPriceX96);
-	const currentMargin1 = assets1 + convert0to1$1(assets0, sqrtPriceX96);
-	const requiredMargin1 = required1Native + convert0to1$1(required0Native, sqrtPriceX96);
-	const buffer0 = currentMargin0 - requiredMargin0;
-	const buffer1 = currentMargin1 - requiredMargin1;
-	const bufferPercent0 = requiredMargin0 === 0n ? null : buffer0 * 10000n / requiredMargin0;
-	const bufferPercent1 = requiredMargin1 === 0n ? null : buffer1 * 10000n / requiredMargin1;
-	let lowerLiquidationTick = null;
-	let upperLiquidationTick = null;
-	let liquidationDistance = null;
-	if (liqPricesResult) {
-		const liqPriceDown = BigInt(liqPricesResult[0]);
-		const liqPriceUp = BigInt(liqPricesResult[1]);
-		lowerLiquidationTick = liqPriceDown === NO_LOWER_LIQUIDATION_TICK ? null : liqPriceDown;
-		upperLiquidationTick = liqPriceUp === NO_UPPER_LIQUIDATION_TICK ? null : liqPriceUp;
-		if (lowerLiquidationTick !== null && upperLiquidationTick !== null) {
-			const distLower = currentTick - lowerLiquidationTick;
-			const distUpper = upperLiquidationTick - currentTick;
-			liquidationDistance = distLower < distUpper ? distLower : distUpper;
-		} else if (lowerLiquidationTick !== null) liquidationDistance = currentTick - lowerLiquidationTick;
-		else if (upperLiquidationTick !== null) liquidationDistance = upperLiquidationTick - currentTick;
-	}
-	return {
-		buffer0,
-		buffer1,
-		bufferPercent0,
-		bufferPercent1,
-		currentMargin0,
-		currentMargin1,
-		requiredMargin0,
-		requiredMargin1,
-		denominatedInToken,
-		liquidationDistance,
-		lowerLiquidationTick,
-		upperLiquidationTick,
-		crossMarginUsageBps,
-		usageBps0,
-		usageBps1,
-		mintableMarginBinding,
-		currentTick,
-		_meta
-	};
-}
-
 //#endregion
 //#region src/panoptic/v2/reads/hedge.ts
 /**
@@ -3866,10 +4046,30 @@ async function getCollateralTotalAssetsBatch(client, collateralTrackerAddresses,
 		return collateralTrackerAddresses.map(() => 0n);
 	}
 }
-
-//#endregion
-//#region src/panoptic/v2/reads/buyingPower.ts
-const Q128$1 = 1n << 128n;
+
+//#endregion
+//#region src/panoptic/v2/reads/buyingPower.ts
+const Q128$1 = 1n << 128n;
+/** Immutable collateral tracker addresses, suitable for a pool-scoped cache. */
+async function getPoolCollateralAddresses(params) {
+	const [collateralToken0, collateralToken1] = await multicall(params.client, {
+		contracts: [{
+			address: params.poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "collateralToken0"
+		}, {
+			address: params.poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "collateralToken1"
+		}],
+		blockNumber: params.blockNumber,
+		allowFailure: false
+	});
+	return {
+		collateralToken0,
+		collateralToken1
+	};
+}
 function convert0to1(amount, sqrtPriceX96) {
 	if (sqrtPriceX96 < Q128$1) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
 	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
@@ -3906,21 +4106,13 @@ async function getAccountBuyingPower(params) {
 		collateralToken0 = params.collateralAddresses.collateralToken0;
 		collateralToken1 = params.collateralAddresses.collateralToken1;
 	} else {
-		const addrs = await multicall(client, {
-			contracts: [{
-				address: poolAddress,
-				abi: panopticPoolV2Abi,
-				functionName: "collateralToken0"
-			}, {
-				address: poolAddress,
-				abi: panopticPoolV2Abi,
-				functionName: "collateralToken1"
-			}],
-			blockNumber,
-			allowFailure: false
+		const addresses = await getPoolCollateralAddresses({
+			client,
+			poolAddress,
+			blockNumber
 		});
-		collateralToken0 = addrs[0];
-		collateralToken1 = addrs[1];
+		collateralToken0 = addresses.collateralToken0;
+		collateralToken1 = addresses.collateralToken1;
 	}
 	const calls = [
 		{
@@ -4024,14 +4216,16 @@ async function getAccountBuyingPower(params) {
 */
 async function getOpenPositionPreview(params) {
 	const { client, poolAddress, account, existingPositionIds, tokenId, positionSize, queryAddress, tickLimitLow, tickLimitHigh, spreadLimit, swapAtMint, usePremiaAsCollateral, chainId, blockNumber } = params;
-	const [currentBuyingPower, simulation] = await Promise.all([getAccountBuyingPower({
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const [currentBuyingPower, simulation] = await Promise.all([params.buyingPower ?? getAccountBuyingPower({
 		client,
 		poolAddress,
 		account,
 		tokenIds: existingPositionIds,
 		queryAddress,
-		blockNumber
+		blockNumber: targetBlockNumber
 	}), simulateOpenPosition({
+		estimateGas: params.estimateGas,
 		client,
 		poolAddress,
 		account,
@@ -4044,8 +4238,9 @@ async function getOpenPositionPreview(params) {
 		swapAtMint,
 		usePremiaAsCollateral,
 		chainId,
-		blockNumber
+		blockNumber: targetBlockNumber
 	})]);
+	if (currentBuyingPower._meta.blockNumber !== targetBlockNumber) throw new PanopticError("Buying power snapshot block does not match the preview block");
 	let isSolvent = true;
 	let tokenShortfall = null;
 	if (!simulation.success) {
@@ -5329,6 +5524,370 @@ async function processClosedPositions(client, queryAddress, positions) {
 	return entries;
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/hedgeCapacity.ts
+const SCALE$1 = 10000000n;
+const FEE_SCALE = 10000n;
+const Q192 = 1n << 192n;
+const MASK128$1 = (1n << 128n) - 1n;
+const ceilDiv$1 = (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];
+		if (balance === void 0) throw new Error("Missing position balance");
+		const { positionSize, tickAtMint } = decodePositionBalance(balance);
+		return sum$1 + calculatePositionDeltaDebtOnly({
+			legs: decodeTokenId(id).legs,
+			positionSize,
+			mintTick: tickAtMint,
+			currentTick: tick,
+			poolTickSpacing: tickSpacing,
+			assetIndex
+		});
+	}, collateralDelta);
+}
+/** A separate loan leaves existing option legs and their risk partners unchanged. */
+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 proceeds = toVaultFrameAtTick((amount - commission) * (1000000n - swapFee) / 1000000n, borrowToken, receiveToken, tick);
+	const tokenId = addLegToTokenId(poolId, {
+		index: 0n,
+		asset: borrowToken,
+		tokenType: borrowToken,
+		width: 0n,
+		strike: tick / tickSpacing * tickSpacing,
+		optionRatio: 1n,
+		riskPartner: 0n,
+		isLong: 0n
+	});
+	return {
+		tokenId,
+		amount,
+		borrowToken,
+		receiveToken,
+		commission,
+		proceeds
+	};
+}
+/** Both cross-collateral constraints, with conversion and mint-buffer rounding matching RiskEngine. */
+function hedgeMargin({ tokenData, balanceChanges, crossRatios, tick, buffer }) {
+	const balances = tokenData.map((data, i) => (data & MASK128$1) + balanceChanges[i]);
+	const [required0, required1] = applyMintBufferPerToken(tokenData[0] >> 128n, tokenData[1] >> 128n, {
+		numerator: buffer,
+		denominator: SCALE$1
+	});
+	const surplus0 = balances[0] > required0 ? (balances[0] - required0) * crossRatios[0] / SCALE$1 : 0n;
+	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 headroom = pairs.map(([balance, required]) => balance - required);
+	return {
+		solvent: balances.every((balance) => balance >= 0n) && headroom.every((value) => value >= 0n),
+		headroom: headroom[0] < headroom[1] ? headroom[0] : headroom[1],
+		denomination: sqrt < 1n << 96n ? 0n : 1n
+	};
+}
+async function findHedgeBoundary(current, samples, direction, evaluate) {
+	if (!current.affordable) return current.tick;
+	const ordered = samples.filter((point) => direction * (point.tick - current.tick) > 0).sort((a, b) => direction * (a.tick - b.tick));
+	let affordableTick = current.tick;
+	for (const point of ordered) {
+		if (point.affordable) {
+			affordableTick = point.tick;
+			continue;
+		}
+		let failedTick = point.tick;
+		while (Math.abs(failedTick - affordableTick) > 1) {
+			const middle = Math.floor((failedTick + affordableTick) / 2);
+			const result = await evaluate(middle);
+			if (result.affordable) affordableTick = middle;
+			else failedTick = middle;
+		}
+		return failedTick;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/hedgeLimits.ts
+const SCALE = 10000000n;
+const MAX_SIZE = (1n << 127n) - 1n;
+const MASK128 = (1n << 128n) - 1n;
+const RANGE = 12800;
+const STEP = 400;
+const SAMPLE_BATCH_SIZE = 32;
+/** Snapshot estimate; prices, balances and requirements share one block, with spot swaps excluding price impact. */
+async function getHedgeLimits({ client, poolAddress, account, positionIds, assetIndex, blockNumber: requestedBlock }) {
+	if (positionIds.length === 0 || positionIds.length > 26 || new Set(positionIds).size !== positionIds.length) throw new Error("Hedge limits require a complete, nonempty list of open positions");
+	const blockNumber = requestedBlock ?? await client.getBlockNumber();
+	const metadata = await getPoolMetadata({
+		client,
+		poolAddress
+	});
+	const { collateralToken0Address: ct0, collateralToken1Address: ct1, riskEngineAddress: engine } = metadata;
+	if (metadata.fee >= 1000000n) throw new Error("A fixed swap fee is required for this estimate");
+	const [full, currentTick, pool0, pool1, total0, total1, interest0, interest1, buffer, notionalFee, cross0, cross1, maxLegs, accountLegs, supply0, supply1] = await client.multicall({
+		contracts: [
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "getFullPositionsData",
+				args: [
+					account,
+					false,
+					positionIds
+				]
+			},
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "getCurrentTick"
+			},
+			{
+				address: ct0,
+				abi: collateralTrackerV2Abi,
+				functionName: "getPoolData"
+			},
+			{
+				address: ct1,
+				abi: collateralTrackerV2Abi,
+				functionName: "getPoolData"
+			},
+			{
+				address: ct0,
+				abi: collateralTrackerV2Abi,
+				functionName: "totalAssets"
+			},
+			{
+				address: ct1,
+				abi: collateralTrackerV2Abi,
+				functionName: "totalAssets"
+			},
+			{
+				address: ct0,
+				abi: collateralTrackerV2Abi,
+				functionName: "assetsAndInterest",
+				args: [account]
+			},
+			{
+				address: ct1,
+				abi: collateralTrackerV2Abi,
+				functionName: "assetsAndInterest",
+				args: [account]
+			},
+			{
+				address: engine,
+				abi: riskEngineAbi,
+				functionName: "BP_DECREASE_BUFFER"
+			},
+			{
+				address: engine,
+				abi: riskEngineAbi,
+				functionName: "NOTIONAL_FEE"
+			},
+			{
+				address: engine,
+				abi: riskEngineAbi,
+				functionName: "CROSS_BUFFER_0"
+			},
+			{
+				address: engine,
+				abi: riskEngineAbi,
+				functionName: "CROSS_BUFFER_1"
+			},
+			{
+				address: engine,
+				abi: riskEngineAbi,
+				functionName: "MAX_OPEN_LEGS"
+			},
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "numberOfLegs",
+				args: [account]
+			},
+			{
+				address: ct0,
+				abi: collateralTrackerV2Abi,
+				functionName: "totalSupply"
+			},
+			{
+				address: ct1,
+				abi: collateralTrackerV2Abi,
+				functionName: "totalSupply"
+			}
+		],
+		allowFailure: false,
+		blockNumber
+	});
+	const [shortPremium, longPremium, balances] = full;
+	if (balances.length !== positionIds.length || balances.some((value) => (value & MASK128) === 0n)) throw new Error("Position snapshot is incomplete; refresh positions and retry");
+	const decoded = positionIds.map((id) => decodeTokenId(id).legs);
+	const legCount = decoded.reduce((sum$1, legs) => sum$1 + legs.length, 0);
+	if (BigInt(legCount) !== accountLegs) throw new Error("The account position list is incomplete");
+	const borrowCapacity = [availableToBorrow(pool0, supply0), availableToBorrow(pool1, supply1)];
+	const currentUtilizations = [pool0[3], pool1[3]];
+	const globalUtilizations = balances.reduce((result, value) => {
+		const decodedBalance = decodePositionBalance(value);
+		return [result[0] > decodedBalance.poolUtilization0 ? result[0] : decodedBalance.poolUtilization0, result[1] > decodedBalance.poolUtilization1 ? result[1] : decodedBalance.poolUtilization1];
+	}, [0n, 0n]);
+	const [baseCross0, baseCross1] = await client.multicall({
+		contracts: [{
+			address: engine,
+			abi: riskEngineAbi,
+			functionName: "crossBufferRatio",
+			args: [globalUtilizations[0], cross0]
+		}, {
+			address: engine,
+			abi: riskEngineAbi,
+			functionName: "crossBufferRatio",
+			args: [globalUtilizations[1], cross1]
+		}],
+		allowFailure: false,
+		blockNumber
+	});
+	const [assets, interest] = assetIndex === 0n ? interest0 : interest1;
+	const premiumShift = assetIndex * 128n;
+	const collateralDelta = (assets > interest ? assets - interest : 0n) + (shortPremium >> premiumShift & MASK128) - (longPremium >> premiumShift & MASK128);
+	const marginCall = (tick, ids, positionBalances) => ({
+		address: engine,
+		abi: riskEngineAbi,
+		functionName: "getMargin",
+		args: [
+			positionBalances,
+			tick,
+			account,
+			ids,
+			shortPremium,
+			longPremium,
+			ct0,
+			ct1
+		]
+	});
+	const evaluate = async (tick) => {
+		const delta = accountHedgeDelta({
+			positionIds,
+			balances,
+			collateralDelta,
+			tick: BigInt(tick),
+			tickSpacing: metadata.tickSpacing,
+			assetIndex
+		});
+		const hedge = buildCapacityHedge({
+			delta,
+			assetIndex,
+			tick: BigInt(tick),
+			tickSpacing: metadata.tickSpacing,
+			poolId: metadata.poolId,
+			notionalFee: BigInt(notionalFee),
+			swapFee: metadata.fee
+		});
+		const unavailable = (reason) => ({
+			tick,
+			affordable: false,
+			reason,
+			delta,
+			headroom: null
+		});
+		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);
+		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;
+		const hedgedIds = hedge.amount === 0n ? positionIds : [...positionIds, hedge.tokenId];
+		const hedgedBalances = hedge.amount === 0n ? balances : [...balances, syntheticBalance];
+		const [base, after, ratio0, ratio1] = await client.multicall({
+			contracts: [
+				marginCall(tick, positionIds, balances),
+				marginCall(tick, hedgedIds, hedgedBalances),
+				{
+					address: engine,
+					abi: riskEngineAbi,
+					functionName: "crossBufferRatio",
+					args: [global[0], cross0]
+				},
+				{
+					address: engine,
+					abi: riskEngineAbi,
+					functionName: "crossBufferRatio",
+					args: [global[1], cross1]
+				}
+			],
+			allowFailure: false,
+			blockNumber
+		});
+		const before = hedgeMargin({
+			tokenData: [base[0], base[1]],
+			balanceChanges: [0n, 0n],
+			crossRatios: [baseCross0, baseCross1],
+			tick: BigInt(tick),
+			buffer: SCALE
+		});
+		const balanceChanges = hedge.borrowToken === 0n ? [0n, hedge.proceeds] : [hedge.proceeds, 0n];
+		const margin = hedgeMargin({
+			tokenData: [after[0], after[1]],
+			balanceChanges,
+			crossRatios: hedge.amount === 0n ? [baseCross0, baseCross1] : [ratio0, ratio1],
+			tick: BigInt(tick),
+			buffer: hedge.amount === 0n ? SCALE : BigInt(buffer)
+		});
+		return {
+			tick,
+			affordable: before.solvent && margin.solvent,
+			reason: !before.solvent ? "insolvent" : !margin.solvent ? "margin" : "available",
+			delta,
+			headroom: toVaultFrameAtTick(margin.headroom, margin.denomination, assetIndex === 0n ? 1n : 0n, BigInt(tick))
+		};
+	};
+	const current = await evaluate(currentTick);
+	const minTick = Math.max(-887200, currentTick - RANGE);
+	const maxTick = Math.min(887200, currentTick + RANGE);
+	if (!current.affordable) return {
+		current,
+		lowerTick: currentTick,
+		upperTick: currentTick,
+		minTick,
+		maxTick,
+		blockNumber
+	};
+	const ticks = new Set([minTick, maxTick]);
+	for (let tick = minTick; tick <= maxTick; tick += STEP) ticks.add(tick);
+	for (const leg of decoded.flat()) {
+		const halfWidth = leg.width * metadata.tickSpacing / 2n;
+		for (const tick of [
+			leg.strike - halfWidth,
+			leg.strike,
+			leg.strike + halfWidth
+		]) for (const offset of [
+			-1,
+			0,
+			1
+		]) {
+			const value = Number(tick) + offset;
+			if (value >= minTick && value <= maxTick) ticks.add(value);
+		}
+	}
+	ticks.delete(currentTick);
+	const samples = [];
+	const sortedTicks = [...ticks].sort((a, b) => a - b);
+	for (let i = 0; i < sortedTicks.length; i += SAMPLE_BATCH_SIZE) samples.push(...await Promise.all(sortedTicks.slice(i, i + SAMPLE_BATCH_SIZE).map(evaluate)));
+	const [lowerTick, upperTick] = await Promise.all([findHedgeBoundary(current, samples, -1, evaluate), findHedgeBoundary(current, samples, 1, evaluate)]);
+	return {
+		current,
+		lowerTick,
+		upperTick,
+		minTick,
+		maxTick,
+		blockNumber
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/sync/getSyncStatus.ts
 /**
@@ -5879,6 +6438,154 @@ async function cleanupStalePendingPositions(params, currentBlock, maxAgeBlocks =
 	else if (remaining.length !== pending.length) await storage.set(key, jsonSerializer.stringify(remaining));
 }
 
+//#endregion
+//#region src/panoptic/v2/liquidator/index.ts
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+/**
+* A LiquidateParams skeleton with every optional route zeroed: no flash loan,
+* no swaps, no native funding, zero floors. Spread and override.
+*/
+function emptyLiquidateParams(pool, account, positionIdListTo) {
+	return {
+		pool,
+		account,
+		positionIdListTo,
+		usePremiaAsCollateral: 0n,
+		flashToken: ZERO_ADDRESS,
+		flashAmount: 0n,
+		nativeFundingAmount: 0n,
+		preSwapTarget: ZERO_ADDRESS,
+		preSwapCallData: "0x",
+		preSwapTokenIn: ZERO_ADDRESS,
+		preSwapAmountIn: 0n,
+		swapTarget: ZERO_ADDRESS,
+		swapCallData: "0x",
+		swapTokenIn: ZERO_ADDRESS,
+		swapAmountIn: 0n,
+		minDelta0: 0n,
+		minDelta1: 0n
+	};
+}
+/**
+* Reproduce the pool's liquidation gate exactly, pinned to one block.
+*
+* `dispatchFrom` checks solvency at `[spotTick, twapTick, latestTick,
+* currentTick]` — note `twapTick` (riskEngine EMA via `getTWAP()`)
+* deliberately REPLACES the `medianTick` that `getOracleTicks()` returns.
+* Never gate liquidatability on the 3-arg `checkCollateral` overload: it
+* iterates `getOracleTicks()` (which includes medianTick and omits twapTick)
+* and disagrees with the pool at the margin.
+*
+* Two phases, both pinned to the same block: (1) read the oracle ticks and
+* TWAP, (2) `isAccountSolvent` at each of the four gate ticks.
+*/
+async function screenAccountExact(params) {
+	const { client, poolAddress, queryAddress, account, tokenIds } = params;
+	const tickCalls = [{
+		target: poolAddress,
+		callData: encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getOracleTicks"
+		})
+	}, {
+		target: poolAddress,
+		callData: encodeFunctionData({
+			abi: panopticPoolV2Abi,
+			functionName: "getTWAP"
+		})
+	}];
+	const phase1 = await readBlockAndAggregate({
+		client,
+		calls: tickCalls,
+		blockNumber: params.blockNumber
+	});
+	const oracle = decodeFunctionResult({
+		abi: panopticPoolV2Abi,
+		functionName: "getOracleTicks",
+		data: requireReturnData(phase1.results, 0, "PanopticPool.getOracleTicks")
+	});
+	const twapTick = BigInt(decodeFunctionResult({
+		abi: panopticPoolV2Abi,
+		functionName: "getTWAP",
+		data: requireReturnData(phase1.results, 1, "PanopticPool.getTWAP")
+	}));
+	const ticks = {
+		currentTick: BigInt(oracle[0]),
+		spotTick: BigInt(oracle[1]),
+		latestTick: BigInt(oracle[3]),
+		twapTick
+	};
+	const gateTicks = [
+		ticks.spotTick,
+		ticks.twapTick,
+		ticks.latestTick,
+		ticks.currentTick
+	];
+	const solvencyCalls = gateTicks.map((atTick) => ({
+		target: queryAddress,
+		callData: encodeFunctionData({
+			abi: panopticQueryAbi$1,
+			functionName: "isAccountSolvent",
+			args: [
+				poolAddress,
+				account,
+				tokenIds,
+				Number(atTick)
+			]
+		})
+	}));
+	const phase2 = await readBlockAndAggregate({
+		client,
+		calls: solvencyCalls,
+		blockNumber: phase1._meta.blockNumber
+	});
+	if (phase2._meta.blockHash !== phase1._meta.blockHash) throw new PanopticError(`screenAccountExact: block ${phase1._meta.blockNumber} hash changed between phases (${phase1._meta.blockHash} -> ${phase2._meta.blockHash}); reorg mid-screen — retry`);
+	const solventAt = gateTicks.map((_, i) => decodeFunctionResult({
+		abi: panopticQueryAbi$1,
+		functionName: "isAccountSolvent",
+		data: requireReturnData(phase2.results, i, `PanopticQuery.isAccountSolvent[${i}]`)
+	}));
+	return {
+		isLiquidatable: solventAt.every((solvent) => !solvent),
+		solventAt,
+		ticks,
+		_meta: phase2._meta
+	};
+}
+/**
+* Run `PanopticLiquidator.quoteLiquidation` via `eth_call` (it is
+* state-mutating by design and must never be mined).
+*/
+async function quoteLiquidation(params) {
+	const { client, liquidatorAddress, owner, stateOverride, value, blockNumber } = params;
+	const response = await client.call({
+		account: owner,
+		to: liquidatorAddress,
+		data: encodeFunctionData({
+			abi: panopticLiquidatorAbi,
+			functionName: "quoteLiquidation",
+			args: [params.params]
+		}),
+		value,
+		stateOverride,
+		blockNumber
+	});
+	if (response.data === void 0) throw new PanopticError("quoteLiquidation eth_call returned no data");
+	const [bonus0, bonus1, shortfall0, shortfall1, protocolLoss0, protocolLoss1] = decodeFunctionResult({
+		abi: panopticLiquidatorAbi,
+		functionName: "quoteLiquidation",
+		data: response.data
+	});
+	return {
+		bonus0,
+		bonus1,
+		shortfall0,
+		shortfall1,
+		protocolLoss0,
+		protocolLoss1
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/simulations/simulateBatchDispatch.ts
 /**
@@ -6670,9 +7377,6 @@ const DEFAULT_MIN_SWAP_RATIO_BPS = 50n;
 function deltaAt(tokenFlow, index) {
 	return index === 0n ? tokenFlow.delta0 : tokenFlow.delta1;
 }
-function balanceBeforeAt(tokenFlow, index) {
-	return index === 0n ? tokenFlow.balanceBefore0 : tokenFlow.balanceBefore1;
-}
 function abs(value) {
 	return value < 0n ? -value : value;
 }
@@ -6731,7 +7435,8 @@ async function quoteOneTokenFlow(params) {
 	const otherTracker = otherTokenIndex === 0n ? pool.collateralTracker0.address : pool.collateralTracker1.address;
 	const baseSimulation = await simulateDispatch({
 		...simulateArgs,
-		...params.dispatch
+		...params.dispatch,
+		settleSequence: params.settleSequence
 	});
 	let swapAmount;
 	let direction;
@@ -6773,6 +7478,7 @@ async function quoteOneTokenFlow(params) {
 			chainId: params.chainId,
 			existingPositionIds: params.existingPositionIds,
 			dispatch: params.dispatch,
+			settleSequence: params.settleSequence,
 			error: shortfall,
 			slippageBps: params.slippageBps,
 			tickLimitLow: params.tickLimitLow,
@@ -6855,13 +7561,6 @@ async function quoteOneTokenFlow(params) {
 		};
 		estimatedCounterAmount = abs(deltaAt(swapSimulation.tokenFlow, targetTokenIndex));
 		maximumAmountIn$1 = padForSlippage(estimatedCounterAmount, params.slippageBps);
-		const sourceBalance = balanceBeforeAt(swapSimulation.tokenFlow, targetTokenIndex);
-		if (sourceBalance < maximumAmountIn$1) return {
-			available: false,
-			reason: "swap-unavailable",
-			detail: `source balance ${sourceBalance} < maximumAmountIn ${maximumAmountIn$1} (estimated ${estimatedCounterAmount}, slippageBps ${params.slippageBps})`,
-			error: new PanopticError("Insufficient collateral to fund the one-token-out swap")
-		};
 	}
 	const wrappedDispatch = buildCreditWrappedDispatch({
 		...creditWrapArgs,
@@ -6869,7 +7568,8 @@ async function quoteOneTokenFlow(params) {
 	});
 	const wrappedSimulation = await simulateDispatch({
 		...simulateArgs,
-		...wrappedDispatch
+		...wrappedDispatch,
+		settleSequence: params.settleSequence
 	});
 	if (!wrappedSimulation.success || wrappedSimulation.tokenFlow === void 0) return {
 		available: false,
@@ -8891,4 +9591,196 @@ function isGasError(error) {
 }
 
 //#endregion
-export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, REQUIRED_BASE_ERROR_SENTINEL, STRIKE_LADDER_TARGET_STRIKES, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateSpreadWad, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scanChunks, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, watchEvents };
+//#region src/analytics/market-indicators.ts
+const D = Decimal.clone({ precision: 40 });
+const TICK_LOG = new D("1.0001").ln();
+const MARKET_INDICATOR_PERIODS = {
+	atr: 14,
+	efficiency: 10,
+	moments: 96,
+	rsi: 14,
+	"variance-ratio": 96
+};
+const VARIANCE_RATIO_LAG = 4;
+/** Sorts and fills only internal no-swap gaps; never invents leading/trailing history. */
+function prepareIndicatorCandles(candles, interval) {
+	if (interval <= 0n) throw new RangeError("Candle interval must be positive");
+	const sorted = [...candles].sort((a, b) => a.time < b.time ? -1 : a.time > b.time ? 1 : 0);
+	const result = [];
+	for (const candle of sorted) {
+		if (candle.time < 0n || candle.time % interval !== 0n || candle.lowTick < -887272n || candle.highTick > 887272n || candle.lowTick > candle.highTick || candle.openTick < candle.lowTick || candle.openTick > candle.highTick || candle.closeTick < candle.lowTick || candle.closeTick > candle.highTick) throw new RangeError("Invalid candle timestamp or OHLC ticks");
+		const previous = result[result.length - 1];
+		if (previous && previous.time === candle.time) throw new RangeError("Duplicate candle timestamp");
+		if (previous) {
+			if ((candle.time - result[0].time) / interval >= 4096n) throw new RangeError("Indicator history exceeds 4096 candles");
+			for (let time = previous.time + interval; time < candle.time; time += interval) result.push({
+				time,
+				openTick: previous.closeTick,
+				highTick: previous.closeTick,
+				lowTick: previous.closeTick,
+				closeTick: previous.closeTick
+			});
+		}
+		result.push(candle);
+	}
+	return result;
+}
+function sum(values) {
+	return values.reduce((total, value) => total.plus(value), new D(0));
+}
+function tickChanges(candles, isAssetToken0) {
+	return candles.slice(1).map((candle, index) => ({
+		time: candle.time,
+		value: (candle.closeTick - candles[index].closeTick) * (isAssetToken0 ? 1n : -1n)
+	}));
+}
+function wilder(values, period) {
+	let average = new D(0);
+	return values.map((value, index) => {
+		if (index < period) {
+			average = average.plus(value.div(period));
+			return index === period - 1 ? average : null;
+		}
+		average = average.mul(period - 1).plus(value).div(period);
+		return average;
+	});
+}
+function centeredTickChanges(values) {
+	const count = BigInt(values.length);
+	const total = values.reduce((sum$1, value) => sum$1 + value, 0n);
+	const deviations = values.map((value) => count * value - total);
+	const squares = deviations.reduce((sum$1, value) => sum$1 + value ** 2n, 0n);
+	return {
+		count,
+		total,
+		deviations,
+		squares
+	};
+}
+/** Central population moments: skewness and excess kurtosis (normal = 0). */
+function returnMoments(values) {
+	const { count, deviations, squares } = centeredTickChanges(values);
+	if (squares === 0n) return {
+		value: null,
+		secondaryValue: null
+	};
+	const cubes = deviations.reduce((sum$1, value) => sum$1 + value ** 3n, 0n);
+	const fourths = deviations.reduce((sum$1, value) => sum$1 + value ** 4n, 0n);
+	const secondMoment = new D(squares.toString());
+	return {
+		value: new D((cubes * cubes * count).toString()).div(secondMoment.pow(3)).sqrt().mul(cubes < 0n ? -1 : 1),
+		secondaryValue: new D((count * fourths).toString()).div((squares * squares).toString()).minus(3)
+	};
+}
+/** Lo–MacKinlay overlapping, finite-sample-corrected ratio; no significance test. */
+function varianceRatio(values) {
+	const { count, total, squares } = centeredTickChanges(values);
+	if (squares === 0n) return null;
+	const lag = VARIANCE_RATIO_LAG;
+	const q = BigInt(lag);
+	let overlappingSquares = 0n;
+	for (let index = lag; index <= values.length; index++) {
+		const change = values.slice(index - lag, index).reduce((sum$1, value) => sum$1 + value, 0n);
+		overlappingSquares += (count * change - q * total) ** 2n;
+	}
+	const numerator = overlappingSquares * (count - 1n) * count;
+	const denominator = q * (count - q + 1n) * (count - q) * squares;
+	return new D(numerator.toString()).div(denominator.toString());
+}
+/** Prices use quote units per asset; return statistics use equally spaced log closes. */
+function calculateMarketIndicator(indicator, candles, { intervalSeconds, token0Decimals, token1Decimals, isAssetToken0 }) {
+	if (token0Decimals < 0n || token0Decimals > 255n || token1Decimals < 0n || token1Decimals > 255n) throw new RangeError("Token decimals must be between 0 and 255");
+	const prepared = prepareIndicatorCandles(candles, intervalSeconds);
+	const period = MARKET_INDICATOR_PERIODS[indicator];
+	if (indicator === "moments" || indicator === "variance-ratio") {
+		const returns = tickChanges(prepared, isAssetToken0);
+		return returns.map((point, index) => {
+			if (index < period - 1) return {
+				time: point.time,
+				value: null
+			};
+			const window = returns.slice(index - period + 1, index + 1).map((value) => value.value);
+			return {
+				time: point.time,
+				...indicator === "moments" ? returnMoments(window) : { value: varianceRatio(window) }
+			};
+		});
+	}
+	const decimalScale = new D(10).pow((token0Decimals - token1Decimals).toString());
+	const prices = new Map();
+	const price = (tick) => {
+		const cached = prices.get(tick);
+		if (cached) return cached;
+		const direct = new D("1.0001").pow(tick.toString()).mul(decimalScale);
+		const value = isAssetToken0 ? direct : new D(1).div(direct);
+		prices.set(tick, value);
+		return value;
+	};
+	const closes = prepared.map((candle) => price(candle.closeTick));
+	if (indicator === "atr") {
+		const ranges = prepared.map((candle, index) => {
+			const high = price(isAssetToken0 ? candle.highTick : candle.lowTick);
+			const low = price(isAssetToken0 ? candle.lowTick : candle.highTick);
+			const previous = closes[index - 1];
+			return previous ? D.max(high.minus(low), high.minus(previous).abs(), low.minus(previous).abs()) : high.minus(low);
+		});
+		return wilder(ranges, period).map((value, index) => ({
+			time: prepared[index].time,
+			value
+		}));
+	}
+	const changes = closes.slice(1).map((close, index) => close.minus(closes[index]));
+	if (indicator === "rsi") {
+		const gains = wilder(changes.map((value) => D.max(value, 0)), period);
+		const losses = wilder(changes.map((value) => D.max(value.neg(), 0)), period);
+		return gains.map((gain, index) => {
+			const loss = losses[index];
+			const value = gain === null || loss === null ? null : gain.isZero() && loss.isZero() ? new D(50) : loss.isZero() ? new D(100) : new D(100).minus(new D(100).div(new D(1).plus(gain.div(loss))));
+			return {
+				time: prepared[index + 1].time,
+				value
+			};
+		});
+	}
+	return closes.map((close, index) => {
+		if (index < period) return {
+			time: prepared[index].time,
+			value: null
+		};
+		const distance = close.minus(closes[index - period]).abs();
+		const path = sum(changes.slice(index - period, index).map((value) => value.abs()));
+		return {
+			time: prepared[index].time,
+			value: path.isZero() ? new D(0) : distance.div(path)
+		};
+	});
+}
+/** Sample variance of equal-interval log returns, grouped by UTC candle-start hour/day. */
+function calculateVarianceProfile(candles, isAssetToken0, intervalSeconds = 3600n) {
+	if (intervalSeconds <= 0n || intervalSeconds > 86400n || 86400n % intervalSeconds !== 0n) throw new RangeError("Profile candle interval must divide a UTC day");
+	const prepared = prepareIndicatorCandles(candles, intervalSeconds);
+	const returns = tickChanges(prepared, isAssetToken0);
+	const hours = Array.from({ length: 24 }, () => []);
+	const weekdays = Array.from({ length: 7 }, () => []);
+	for (const point of returns) {
+		const hour = Number(point.time / 3600n % 24n);
+		const weekday = Number((point.time / 86400n + 3n) % 7n);
+		hours[hour].push(point.value);
+		weekdays[weekday].push(point.value);
+	}
+	const summarize = (buckets) => buckets.map((values, bucket) => {
+		const { count, squares } = centeredTickChanges(values);
+		return {
+			bucket,
+			count: values.length,
+			variance: count < 2n ? null : new D(squares.toString()).mul(TICK_LOG.pow(2)).div((count * count * (count - 1n)).toString())
+		};
+	});
+	return {
+		hours: summarize(hours),
+		weekdays: summarize(weekdays)
+	};
+}
+
+//#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, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, emptyLiquidateParams, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getChunkLiquidities, getChunkSpreads, getClosedPositions, 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, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, prepareIndicatorCandles, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, watchEvents };