@panoptic-eng/sdk 1.0.47 → 1.0.49

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

@@ -1,7 +1,7 @@
-import { StateViewAbi, formatTokenAmount, getAccountCollateral, panopticQueryAbi$1 as panopticQueryAbi, parseTokenAmount, readBlockAndAggregate, requireReturnData } from "./irm-CvLqxTAo.js";
-import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, LEG_LIMITS, NotEnoughTokensError, PanopticError, PanopticValidationError, STANDARD_TICK_WIDTHS, SafeModeError, StaleDataError, StorageDataNotFoundError, TOKEN_ID_BITS, UnhealthyPoolError, WrongUniswapPoolError, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePosition, decodePositionBalance, decodeTickSpacing, 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 "./getTrackedPositionIds-CwBHzOO2.js";
-import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, WAD, calculatePositionDelta, calculatePositionGamma, calculatePositionValue, priceToTick, roundToTickSpacing, sqrtPriceX96ToTick, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96 } from "./greeks-9aTE-DwO.js";
-import { addLegToTokenId, buildBatchDispatchArgs, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTickSpacing$1, decodeTokenId, getCurrentPositionSizes, getPoolTokensForSimulation, loadCheckpoint, orderListForSettle, resolveTokenIndex, simulateOpenPosition, simulateWithTokenFlow } from "./writes-BZW7UA4N.js";
+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 { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, keccak256, toHex, zeroAddress } from "viem";
 import { multicall } from "viem/actions";
 
@@ -204,1671 +204,665 @@ function interpolateBlocks(startBlock, endBlock, points) {
 }
 
 //#endregion
-//#region src/panoptic/v2/tokenId/deriveUniqueTokenId.ts
-const POOL_ID_MASK$3 = (1n << 64n) - 1n;
-const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
-const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
-const Q192$3 = 1n << 192n;
+//#region src/panoptic/v2/sfpmSwap/calldata.ts
 /**
-* Floor integer square root for bigints (Newton's method). Mirrors the isqrt
-* used in reads/collateralEstimate.ts (buildNeutralLeg).
+* 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.
 */
-function isqrt$1(value) {
-	if (value < 0n) throw new PanopticError("isqrt of negative number");
-	if (value < 2n) return value;
-	let x = value;
-	let y = x + 1n >> 1n;
-	while (y < x) {
-		x = y;
-		y = x + value / x >> 1n;
-	}
-	return x;
-}
-const DEFAULT_TICK_SPACING = 200n;
-/**
-* Target notional (in wei of the tokenType-side asset) for the appended
-* tiny credit leg. Chosen at 10 wei — small enough to be economically
-* meaningless against any real position size, large enough to safely
-* clear rounding on the SFPM's width-2 internal chunk math without any
-* risk of underflowing to zero (which would revert ChunkHasZeroLiquidity).
-*/
-const TINY_CREDIT_TARGET_NOTIONAL_WEI = 10n;
-/**
-* Pick a signedStrike for the appended width=0 credit leg such that:
-*   1. positionSize · 1.0001^signedStrike ≈ TINY_CREDIT_TARGET_NOTIONAL_WEI
-*      (~10 wei — economically meaningless but comfortably above any
-*      SFPM width-2 chunk rounding);
-*   2. the leg's tick range (SFPM internally treats width=0 as width=2, so
-*      the range is `strike ± tickSpacing`) stays strictly inside
-*      `[MIN_POOL_TICK, MAX_POOL_TICK]` — otherwise the getSqrtRatioAtTick
-*      call reverts with `InvalidTick`.
-*
-* Closed form: `1.0001^signedStrike = target/positionSize`, so
-* `sqrtKrawX96 = isqrt(target · 2^192 / positionSize)` and
-* `signedStrike = sqrtPriceX96ToTick(sqrtKrawX96)`. If the notional-optimal
-* strike falls outside the safe range, we clamp inward. Clamping raises the
-* notional but keeps it << position size for any reasonable strike.
-*/
-function computeTinyCreditSignedStrike(positionSize, tickSpacing) {
-	if (positionSize <= 0n) throw new PanopticError("computeTinyCreditSignedStrike: positionSize must be > 0");
-	const minSafe = MIN_TICK + tickSpacing + 1n;
-	const maxSafe = MAX_TICK - tickSpacing - 1n;
-	let signedStrike;
-	try {
-		const sqrtKrawX96 = isqrt$1(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$3 / positionSize);
-		signedStrike = sqrtPriceX96ToTick(sqrtKrawX96);
-	} catch {
-		signedStrike = minSafe;
-	}
-	if (signedStrike < minSafe) return minSafe;
-	if (signedStrike > maxSafe) return maxSafe;
-	return signedStrike;
-}
-/**
-* Assemble the tiny credit leg struct, picking a strike that avoids
-* colliding with any existing width=0 credit leg on the same (asset,
-* tokenType) pair.
-*
-* The encoded strike stored in the tokenId is
-* `asset === 0 ? signedStrike : -signedStrike` (mirrors
-* {@link buildNeutralLeg} in reads/collateralEstimate.ts).
-*/
-function pickUniqueTinyCreditLeg(baseTokenId, legIndex, positionSize, tickSpacing) {
-	const asset = 1n;
-	const tokenType = 0n;
-	const existingLegs = decodeAllLegs(baseTokenId);
-	const maxSafe = MAX_TICK - tickSpacing - 1n;
-	let signedStrike = computeTinyCreditSignedStrike(positionSize, tickSpacing);
-	while (signedStrike <= maxSafe) {
-		const candidate = asset === 0n ? signedStrike : -signedStrike;
-		let collides = false;
-		for (const leg of existingLegs) if (leg.width === 0n && leg.isLong && leg.asset === asset && leg.tokenType === tokenType && leg.strike === candidate) {
-			collides = true;
-			break;
-		}
-		if (!collides) break;
-		signedStrike += 1n;
-	}
-	if (signedStrike > maxSafe) throw new PanopticError("deriveUniqueTokenId: exhausted strike space picking a unique tiny credit leg");
-	const encodedStrike = asset === 0n ? signedStrike : -signedStrike;
-	return {
-		index: legIndex,
-		asset,
-		tokenType,
-		optionRatio: 1n,
-		isLong: 1n,
-		riskPartner: legIndex,
-		strike: encodedStrike,
-		width: 0n
-	};
-}
-function appendTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing) {
-	const newLeg = pickUniqueTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing);
-	return addLegToTokenId(baseTokenId, newLeg);
-}
-function scaleRatios(baseTokenId, targetPositionSize) {
-	const legs = decodeAllLegs(baseTokenId);
-	const maxRatio = legs.reduce((m, leg) => leg.optionRatio > m ? leg.optionRatio : m, 0n);
-	const N = MAX_OPTION_RATIO / maxRatio;
-	if (N < 2n) throw new PanopticError("deriveUniqueTokenId: cannot derive a unique tokenId — all 4 leg slots used and optionRatios already near the 127 ceiling");
-	const newPositionSize = (targetPositionSize + N - 1n) / N;
-	const poolId = baseTokenId & POOL_ID_MASK$3;
-	let out = poolId;
-	for (const leg of legs) out = addLegToTokenId(out, {
-		index: leg.index,
-		asset: leg.asset,
-		tokenType: leg.tokenType,
-		optionRatio: leg.optionRatio * N,
-		isLong: leg.isLong ? 1n : 0n,
-		riskPartner: leg.riskPartner,
-		strike: leg.strike,
-		width: leg.width
+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 {
-		newTokenId: out,
-		newPositionSize,
-		effectivePositionSize: newPositionSize * N,
-		strategy: "ratio-scale"
+		multicallData,
+		mintData,
+		burnData
 	};
 }
-/**
-* Derive a tokenId unique from `baseTokenId` for a partial reduction.
-*
-* Prefers a tiny-credit-leg extension (arbitrary new size). Falls back to
-* optionRatio scaling only when the base tokenId already occupies all 4 leg
-* slots.
-*/
-function deriveUniqueTokenId(params) {
-	const { baseTokenId, targetPositionSize, tickSpacing = DEFAULT_TICK_SPACING } = params;
-	if (targetPositionSize <= 0n) throw new PanopticError("deriveUniqueTokenId: targetPositionSize must be > 0");
-	const legCount = countLegs(baseTokenId);
-	if (legCount === 0n) throw new PanopticError("deriveUniqueTokenId: baseTokenId has no legs");
-	if (legCount < MAX_LEGS) {
-		const newTokenId = appendTinyCreditLeg(baseTokenId, legCount, targetPositionSize, tickSpacing);
-		return {
-			newTokenId,
-			newPositionSize: targetPositionSize,
-			effectivePositionSize: targetPositionSize,
-			strategy: "tiny-credit"
-		};
-	}
-	return scaleRatios(baseTokenId, targetPositionSize);
-}
-/**
-* Re-export decoded leg count so callers can gate UI on the strategy that
-* would be chosen (e.g. show a divisibility hint on ratio-scale positions).
-*/
-function planDeriveStrategy(baseTokenId) {
-	return countLegs(baseTokenId) < MAX_LEGS ? "tiny-credit" : "ratio-scale";
-}
 
 //#endregion
-//#region src/panoptic/v2/formatters/percentage.ts
-/**
-* Percentage and ratio formatters.
-*
-* All formatters require explicit precision - no hidden defaults.
-*
-* @module v2/formatters/percentage
-*/
-const TEN$2 = 10n;
-function formatRatio$2(numerator, denominator, precision) {
-	if (precision < 0n) throw new RangeError("Precision must be non-negative");
-	if (denominator === 0n) return "0";
-	const isNegative = numerator < 0n !== denominator < 0n;
-	const absNumerator = numerator < 0n ? -numerator : numerator;
-	const absDenominator = denominator < 0n ? -denominator : denominator;
-	const scale = TEN$2 ** precision;
-	const scaled = (absNumerator * scale + absDenominator / 2n) / absDenominator;
-	const integerPart = scaled / scale;
-	const fractionalPart = scaled % scale;
-	const sign = isNegative ? "-" : "";
-	if (precision === 0n) return `${sign}${integerPart}`;
-	return `${sign}${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
-}
-/**
-* Format basis points as a percentage string.
-* 100 bps = 1%
-*
-* @param bps - Basis points value
-* @param precision - Number of decimal places to display
-* @returns Formatted percentage string
-*
-* @example
-* ```typescript
-* formatBps(50n, 2n)   // "0.50%"
-* formatBps(50n, 1n)   // "0.5%"
-* formatBps(100n, 2n)  // "1.00%"
-* formatBps(1500n, 2n) // "15.00%"
-* formatBps(-50n, 2n)  // "-0.50%"
-* ```
-*/
-function formatBps(bps, precision) {
-	const isNegative = bps < 0n;
-	const absBps = isNegative ? -bps : bps;
-	const scaleFactor = 10n ** precision;
-	const scaled = absBps * scaleFactor / 100n;
-	const integerPart = scaled / scaleFactor;
-	const fractionalPart = scaled % scaleFactor;
-	const fractionalStr = fractionalPart.toString().padStart(Number(precision), "0");
-	const sign = isNegative ? "-" : "";
-	return precision > 0n ? `${sign}${integerPart}.${fractionalStr}%` : `${sign}${integerPart}%`;
-}
-/**
-* Format utilization as a percentage string.
-* Utilization is stored as 0n-10000n, where 10000n = 100%.
-*
-* @param util - Utilization value (0-10000)
-* @param precision - Number of decimal places to display
-* @returns Formatted percentage string
-*
-* @example
-* ```typescript
-* formatUtilization(7500n, 2n)  // "75.00%"
-* formatUtilization(7500n, 0n)  // "75%"
-* formatUtilization(10000n, 2n) // "100.00%"
-* formatUtilization(123n, 2n)   // "1.23%"
-* ```
-*/
-function formatUtilization(util, precision) {
-	return formatBps(util, precision);
-}
-/**
-* Parse a percentage string to basis points.
-*
-* @param percent - Percentage string (e.g., "1.5%" or "1.5")
-* @returns Basis points value
-*
-* @example
-* ```typescript
-* parseBps("1.5%")  // 150n
-* parseBps("1.5")   // 150n
-* parseBps("100%")  // 10000n
-* parseBps("0.5%")  // 50n
-* ```
-*/
-function parseBps(percent) {
-	const cleaned = percent.trim().replace(/%$/, "");
-	const isNegative = cleaned.startsWith("-");
-	const absValue = isNegative ? cleaned.slice(1) : cleaned;
-	const [integerStr, fractionalStr = ""] = absValue.split(".");
-	const paddedFractional = fractionalStr.padEnd(2, "0").slice(0, 2);
-	const integerPart = BigInt(integerStr || "0") * 100n;
-	const fractionalPart = BigInt(paddedFractional || "0");
-	const result = integerPart + fractionalPart;
-	return isNegative ? -result : result;
-}
+//#region src/panoptic/v2/sfpmSwap/init.ts
 /**
-* Format a ratio as a percentage string.
-*
-* @param numerator - Numerator of the ratio
-* @param denominator - Denominator of the ratio
-* @param precision - Number of decimal places to display
-* @returns Formatted percentage string
+* Resolve the `uint64` SFPM poolId for a Uniswap v3 pool, initializing it if needed.
 *
-* @example
-* ```typescript
-* formatRatioPercent(1n, 4n, 1n)  // "25.0%"
-* formatRatioPercent(3n, 4n, 2n)  // "75.00%"
-* ```
+* `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.
 */
-function formatRatioPercent(numerator, denominator, precision) {
-	const scaledNumerator = numerator * 100n;
-	return `${formatRatio$2(scaledNumerator, denominator, precision)}%`;
+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);
 }
-
-//#endregion
-//#region src/panoptic/v2/formatters/poolFormatters.ts
 /**
-* Create pool-bound formatters that capture token decimals.
-*
-* Use this factory when working with a single pool to avoid passing
-* decimals at every call site.
-*
-* @param config - Pool configuration with token decimals
-* @returns Pool-bound formatter functions
-*
-* @example
-* ```typescript
-* // Get pool data
-* const pool = await getPool({ client, poolAddress })
-*
-* // Create formatters bound to this pool
-* const fmt = createPoolFormatters({
-*   decimals0: pool.token0Decimals,
-*   decimals1: pool.token1Decimals,
-* })
-*
-* // Now use without passing decimals each time
-* const priceStr = fmt.tickToPriceScaled(position.currentTick, 4n)
-* const amount0Str = fmt.formatAmount0(collateral.assets, 4n)
-* const amount1Str = fmt.formatAmount1(premia.token1, 2n)
+* Ensure a Uniswap v3 pool is registered on the SFPM, sending `initializeAMMPool`
+* only if it is not already registered. Returns the resolved poolId.
 *
-* // Parse user input
-* const rawAmount0 = fmt.parseAmount0("1.5")
-* const rawAmount1 = fmt.parseAmount1("3000")
-* ```
+* When `expectedPool` is given, the resolved id is checked to map back to it via
+* `getUniswapV3PoolFromId` — guards against a wrong token/fee triple.
 */
-function createPoolFormatters(config) {
-	const { decimals0, decimals1 } = config;
+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,
+		token0,
+		token1,
+		fee,
+		vegoid
+	});
+	const registered = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "getUniswapV3PoolFromId",
+		args: [poolId]
+	});
+	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 {
-		decimals0,
-		decimals1,
-		tickToPrice(tick) {
-			return tickToPrice(tick);
-		},
-		tickToPriceScaled(tick, precision) {
-			return tickToPriceDecimalScaled(tick, decimals0, decimals1, precision);
-		},
-		tickToInversePriceScaled(tick, precision) {
-			return tickToPriceDecimalScaled(tick, decimals1, decimals0, precision);
-		},
-		priceToTick(price) {
-			return priceToTick(price, decimals0, decimals1);
-		},
-		formatAmount0(amount, precision) {
-			return formatTokenAmount(amount, decimals0, precision);
-		},
-		formatAmount1(amount, precision) {
-			return formatTokenAmount(amount, decimals1, precision);
-		},
-		parseAmount0(amount) {
-			return parseTokenAmount(amount, decimals0);
-		},
-		parseAmount1(amount) {
-			return parseTokenAmount(amount, decimals1);
-		}
+		poolId,
+		initialized
 	};
 }
 
 //#endregion
-//#region src/panoptic/v2/formatters/tokenList.ts
-const TEN$1 = 10n;
-function formatRatio$1(numerator, denominator, precision) {
-	if (precision < 0n) throw new RangeError("Precision must be non-negative");
-	const scale = TEN$1 ** precision;
-	const scaled = (numerator * scale + denominator / 2n) / denominator;
-	const integerPart = scaled / scale;
-	const fractionalPart = scaled % scale;
-	if (precision === 0n) return integerPart.toString();
-	return `${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
-}
+//#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];
 /**
-* Generate a token list ID for external token list integration.
-*
-* Token lists use a standardized format: `chainId:address`
-* This is compatible with most token list standards.
-*
-* @param chainId - The chain ID
-* @param address - The token address
-* @returns Token list ID string
-*
-* @example
-* ```typescript
-* getTokenListId(1n, '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2')
-* // "1:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+* Convert a slippage tolerance in bps to a conservative Uniswap tick distance.
 *
-* getTokenListId(11155111n, '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14')
-* // "11155111:0xfff9976782d46cc05630d1f6ebab18b2324d6b14"
-* ```
+* 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 getTokenListId(chainId, address) {
-	return `${chainId}:${address.toLowerCase()}`;
+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;
 }
 /**
-* Parse a token list ID back to chain ID and address.
+* Build the swap plan.
 *
-* @param tokenListId - The token list ID string
-* @returns Object with chainId and address
+* 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.
 *
-* @example
-* ```typescript
-* parseTokenListId("1:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")
-* // { chainId: 1n, address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2" }
-* ```
+* 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 parseTokenListId(tokenListId) {
-	const [chainIdStr, address] = tokenListId.split(":");
-	if (!chainIdStr || !address) throw new Error(`Invalid token list ID: ${tokenListId}`);
+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 {
-		chainId: BigInt(chainIdStr),
-		address
+		sfpmAddress,
+		poolAddress,
+		poolKey: encodeAbiParameters([{ type: "address" }], [poolAddress]),
+		tokenId,
+		positionSize: amount,
+		mintTickLimits: swapOn === "mint" ? invertedLimits : WIDE_LIMITS,
+		burnTickLimits: swapOn === "burn" ? invertedLimits : WIDE_LIMITS,
+		swapOn,
+		kind
 	};
 }
-/**
-* Generate a pool ID string for display purposes.
-*
-* @param token0Symbol - Symbol of token0
-* @param token1Symbol - Symbol of token1
-* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
-* @returns Pool ID string
-*
-* @example
-* ```typescript
-* getPoolDisplayId('WETH', 'USDC', 500n)
-* // "WETH/USDC 0.05%"
-*
-* getPoolDisplayId('WBTC', 'ETH', 3000n)
-* // "WBTC/ETH 0.30%"
-* ```
-*/
-function getPoolDisplayId(token0Symbol, token1Symbol, feeBps) {
-	return `${token0Symbol}/${token1Symbol} ${formatFeeTier(feeBps)}`;
+
+//#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)
+	};
+}
+/** 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);
 }
 /**
-* Format a fee tier for display.
-*
-* @param feeBps - Fee in basis points (e.g., 500n for 0.05%)
-* @returns Fee tier string
-*
-* @example
-* ```typescript
-* formatFeeTier(500n)   // "0.05%"
-* formatFeeTier(3000n)  // "0.30%"
-* formatFeeTier(10000n) // "1.0%"
-* ```
+* 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 formatFeeTier(feeBps) {
-	const precision = feeBps < 10000n ? 2n : 1n;
-	const feeStr = formatRatio$1(feeBps, 10000n, precision);
-	return `${feeStr}%`;
+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
+		};
+	}
 }
 
 //#endregion
-//#region src/panoptic/v2/formatters/display.ts
-const TEN = 10n;
-function formatRatio(numerator, denominator, precision) {
-	if (precision < 0n) throw new RangeError("Precision must be non-negative");
-	const scale = TEN ** precision;
-	const scaled = (numerator * scale + denominator / 2n) / denominator;
-	const integerPart = scaled / scale;
-	const fractionalPart = scaled % scale;
-	if (precision === 0n) return integerPart.toString();
-	return `${integerPart}.${fractionalPart.toString().padStart(Number(precision), "0")}`;
-}
+//#region src/panoptic/v2/reads/sfpm.ts
 /**
-* Truncate an address for display.
-*
-* @param address - Full address
-* @param chars - Characters to show on each side (default: 4)
-* @returns Truncated address like "0x1234...5678"
-*
-* @example
-* ```typescript
-* truncateAddress('0x1234567890abcdef1234567890abcdef12345678')
-* // "0x1234...5678"
+* Resolve an SFPM poolId to its corresponding Uniswap V3 pool address.
 *
-* truncateAddress('0x1234567890abcdef1234567890abcdef12345678', 6)
-* // "0x123456...345678"
-* ```
+* Calls `SemiFungiblePositionManagerV3.getUniswapV3PoolFromId(poolId)`.
 */
-function truncateAddress(address, chars = 4) {
-	const charsBig = BigInt(chars);
-	const minLength = charsBig * 2n + 4n;
-	if (BigInt(address.length) <= minLength) return address;
-	return `${address.slice(0, Number(charsBig + 2n))}...${address.slice(-Number(charsBig))}`;
+async function getUniswapV3PoolFromId(params) {
+	const { client, sfpmAddress, poolId } = params;
+	return client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV3Abi,
+		functionName: "getUniswapV3PoolFromId",
+		args: [poolId]
+	});
 }
 /**
-* Format a Unix timestamp as an ISO date string (YYYY-MM-DD).
-*
-* @param timestamp - Unix timestamp in seconds
-* @returns ISO date string
+* Resolve an SFPM poolId to its corresponding Uniswap V4 pool key.
 *
-* @example
-* ```typescript
-* formatTimestamp(1700000000n)  // "2023-11-14"
-* ```
+* Calls `SemiFungiblePositionManagerV4.getUniswapV4PoolKeyFromId(poolId)`.
 */
-function formatTimestamp(timestamp) {
-	const ms = timestamp * 1000n;
-	return new Date(Number(ms)).toISOString().split("T")[0];
+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
+	};
 }
 /**
-* Format a Unix timestamp as an ISO datetime string.
-*
-* @param timestamp - Unix timestamp in seconds
-* @returns ISO datetime string
+* Get the enforced tick limits for a pool from the SFPM.
 *
-* @example
-* ```typescript
-* formatDatetime(1700000000n)  // "2023-11-14T22:13:20.000Z"
-* ```
+* @param params - The parameters
+* @returns The min and max enforced ticks
 */
-function formatDatetime(timestamp) {
-	const ms = timestamp * 1000n;
-	return new Date(Number(ms)).toISOString();
+async function getEnforcedTickLimits(params) {
+	const { client, sfpmAddress, poolId } = params;
+	const [minTick, maxTick] = await client.readContract({
+		address: sfpmAddress,
+		abi: semiFungiblePositionManagerV4Abi,
+		functionName: "getEnforcedTickLimits",
+		args: [poolId]
+	});
+	return {
+		minEnforcedTick: minTick,
+		maxEnforcedTick: maxTick
+	};
 }
 /**
-* Format a Unix timestamp as a locale-aware date string.
-*
-* @param timestamp - Unix timestamp in seconds
-* @param locale - Locale string (default: system locale)
-* @param options - Intl.DateTimeFormat options
-* @returns Formatted date string
-*
-* @example
-* ```typescript
-* formatTimestampLocale(1700000000n)
-* // "11/14/2023" (US locale)
+* Fetch liquidity breakdown for a batch of chunks via SFPM.getAccountLiquidity().
 *
-* formatTimestampLocale(1700000000n, 'de-DE')
-* // "14.11.2023" (German locale)
-* ```
+* Uses multicall for efficiency. Returns one result per input chunk,
+* along with block metadata for freshness tracking.
 */
-function formatTimestampLocale(timestamp, locale, options) {
-	const ms = timestamp * 1000n;
-	return new Date(Number(ms)).toLocaleDateString(locale, options);
+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/reads/factory.ts
 /**
-* Format a duration in milliseconds as a human-readable string.
-*
-* @param ms - Duration in milliseconds
-* @returns Formatted duration string
-*
-* @example
-* ```typescript
-* formatDuration(1500n)   // "1.5s"
-* formatDuration(150n)    // "150ms"
-* formatDuration(90000n)  // "1m 30s"
-* formatDuration(3661000n) // "1h 1m"
-* ```
+* Get the token URI from a PanopticFactory NFT.
 */
-function formatDuration(ms) {
-	const isNegative = ms < 0n;
-	const absMs = isNegative ? -ms : ms;
-	const sign = isNegative ? "-" : "";
-	if (absMs < 1000n) return `${sign}${absMs}ms`;
-	if (absMs < 60000n) {
-		const tenthsTotal = (absMs + 50n) / 100n;
-		const seconds = tenthsTotal / 10n;
-		const tenths = tenthsTotal % 10n;
-		return `${sign}${seconds}.${tenths}s`;
-	}
-	if (absMs < 3600000n) {
-		const minutes$1 = absMs / 60000n;
-		const seconds = (absMs % 60000n + 500n) / 1000n;
-		return seconds > 0n ? `${sign}${minutes$1}m ${seconds}s` : `${sign}${minutes$1}m`;
-	}
-	const hours = absMs / 3600000n;
-	const minutes = (absMs % 3600000n + 30000n) / 60000n;
-	return minutes > 0n ? `${sign}${hours}h ${minutes}m` : `${sign}${hours}h`;
+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]
+	});
 }
 /**
-* Format a duration in seconds as a human-readable string.
-*
-* @param seconds - Duration in seconds
-* @returns Formatted duration string
+* Get the owner of a PanopticFactory NFT.
 */
-function formatDurationSeconds(seconds) {
-	return formatDuration(seconds * 1000n);
+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]
+	});
 }
 /**
-* Format a block number for display.
-*
-* @param blockNumber - The block number
-* @returns Formatted block number with commas
-*
-* @example
-* ```typescript
-* formatBlockNumber(18000000n)  // "18,000,000"
-* ```
+* Construct NFT metadata for a pool via the factory contract.
 */
-function formatBlockNumber(blockNumber) {
-	return blockNumber.toLocaleString();
+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
+		]
+	});
 }
 /**
-* Format a gas amount for display.
-*
-* @param gas - Gas units
-* @returns Formatted gas string
+* Get the PanopticPool address for a given pool and risk engine.
 */
-function formatGas(gas) {
-	return gas.toLocaleString();
-}
-/**
-* Format a transaction hash for display (truncated).
-*
-* @param hash - Full transaction hash
-* @param chars - Characters to show on each side (default: 6)
-* @returns Truncated hash like "0x123456...abcdef"
-*
-* @example
-* ```typescript
-* formatTxHash('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef')
-* // "0x123456...abcdef"
-* ```
-*/
-function formatTxHash(hash, chars = 6) {
-	const charsBig = BigInt(chars);
-	const minLength = charsBig * 2n + 4n;
-	if (BigInt(hash.length) <= minLength) return hash;
-	return `${hash.slice(0, Number(charsBig + 2n))}...${hash.slice(-Number(charsBig))}`;
-}
-function formatHex(value) {
-	return `0x${value.toString(16)}`;
+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]
+	});
 }
 /**
-* Format a TokenId as a hex string.
-*
-* @param tokenId - TokenId value
-* @returns Hex string representation
+* Mine for an optimal pool address salt with high rarity.
 */
-function formatTokenIdHex(tokenId) {
-	return formatHex(tokenId);
+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]
+	};
 }
 /**
-* Format a PoolId as a hex string.
+* Simulate a pool deployment to get the predicted pool address.
 *
-* @param poolId - PoolId value
-* @returns Hex string representation
+* Uses `simulateContract` on `deployNewPool` — the return value is the new pool address
+* without actually executing the transaction.
 */
-function formatPoolIdHex(poolId) {
-	return formatHex(poolId);
+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;
+	}
+	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;
 }
 /**
-* Format a TokenId as a shortened hex string.
+* Resolve an SFPM poolId to its PanopticPool address.
 *
-* @param tokenId - TokenId value
-* @param chars - Characters to show on each side (default: 4)
-* @returns Truncated hex string like "0x1234...abcd"
+* Chains two on-chain lookups:
+* 1. SFPM: poolId → Uniswap pool address (V3) or pool key (V4)
+* 2. Factory: Uniswap pool + riskEngine → PanopticPool address
 */
-function formatTokenIdShort(tokenId, chars = 4) {
-	const hex = formatHex(tokenId);
-	const charsBig = BigInt(chars);
-	const minLength = charsBig * 2n + 4n;
-	if (BigInt(hex.length) <= minLength) return hex;
-	return `${hex.slice(0, Number(charsBig + 2n))}...${hex.slice(-Number(charsBig))}`;
+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({
+		client,
+		sfpmAddress,
+		poolId
+	});
+	return getPanopticPoolAddress({
+		version: "v4",
+		client,
+		factoryAddress,
+		poolKey,
+		riskEngine
+	});
 }
 /**
-* Format a large number with K/M/B suffixes.
-*
-* @param value - The numeric value
-* @param precision - Number of decimal places (default: 1n)
-* @returns Formatted string with suffix
+* Resolve an SFPM poolId to its PanopticPool address without knowing the version.
 *
-* @example
-* ```typescript
-* formatCompact(1234n)        // "1.2K"
-* formatCompact(1234567n)     // "1.2M"
-* formatCompact(1234567890n)  // "1.2B"
-* formatCompact(999n)         // "999"
-* ```
-*/
-function formatCompact(value, precision = 1n) {
-	const isNegative = value < 0n;
-	const absValue = isNegative ? -value : value;
-	let formatted;
-	if (absValue < 1000n) formatted = absValue.toString();
-	else if (absValue < 1000000n) formatted = `${formatRatio(absValue, 1000n, precision)}K`;
-	else if (absValue < 1000000000n) formatted = `${formatRatio(absValue, 1000000n, precision)}M`;
-	else formatted = `${formatRatio(absValue, 1000000000n, precision)}B`;
-	return isNegative ? `-${formatted}` : formatted;
-}
-/**
-* Format a wei amount as a display string.
+* 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.
 *
-* @param wei - Amount in wei
-* @returns Formatted string with unit
-*/
-function formatWei(wei) {
-	return `${wei} wei`;
-}
-/**
-* Format a wei amount as gwei.
+* At least one of `v3` or `v4` must be provided.
 *
-* @param wei - Amount in wei
-* @param precision - Number of decimal places to display
-* @returns Formatted string with unit
+* @throws {PanopticValidationError} If no version config is provided or neither resolves.
 */
-function formatGwei(wei, precision) {
-	return `${formatTokenAmount(wei, 9n, precision)} gwei`;
-}
-
-//#endregion
-//#region src/panoptic/v2/tokenId/generateOverlapping.ts
-const MAX_UINT64$2 = (1n << 64n) - 1n;
-const MAX_UINT128$3 = (1n << 128n) - 1n;
-const Q192$2 = 1n << 192n;
-const MAX_TOKEN_DECIMALS = 255n;
-const MAX_DECIMAL_EXPONENT = 512n;
-function invalid$1(message) {
-	throw new PanopticValidationError(`generateOverlappingTokenIds: ${message}`);
-}
-function pow10(exponent) {
-	return 10n ** exponent;
-}
-function parsePriceSpacing(value, quoteDecimals) {
-	const match = /^\+?(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:e([+-]?\d+))?$/i.exec(value.trim());
-	if (match === null) invalid$1("strikePriceSpacing must be a positive decimal string");
-	const integerPart = match[1] ?? "0";
-	const fractionalPart = match[2] ?? match[3] ?? "";
-	const exponent = BigInt(match[4] ?? "0");
-	if (exponent < -MAX_DECIMAL_EXPONENT || exponent > MAX_DECIMAL_EXPONENT) invalid$1("strikePriceSpacing exponent is too large");
-	let units = BigInt(`${integerPart}${fractionalPart}`);
-	let scale = BigInt(fractionalPart.length) - exponent;
-	if (scale < 0n) {
-		units *= pow10(-scale);
-		scale = 0n;
-	}
-	while (scale > 0n && units % 10n === 0n) {
-		units /= 10n;
-		scale -= 1n;
-	}
-	if (units <= 0n) invalid$1("strikePriceSpacing must be positive");
-	if (scale > quoteDecimals) invalid$1("strikePriceSpacing exceeds the quote token decimal precision");
-	return {
-		units,
-		scale,
-		denominator: pow10(scale)
+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;
 	};
-}
-function formatGridPrice(multiple, spacing) {
-	const scaledPrice = multiple * spacing.units;
-	if (spacing.scale === 0n) return scaledPrice.toString();
-	const scale = Number(spacing.scale);
-	const digits = scaledPrice.toString().padStart(scale + 1, "0");
-	const decimalIndex = digits.length - scale;
-	return `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
-}
-function quotePriceAtTick(tick, asset, assetDecimals, quoteDecimals) {
-	const orientedTick = asset === 0n ? tick : -tick;
-	const sqrtPriceX96 = tickToSqrtPriceX96(orientedTick);
-	let numerator = sqrtPriceX96 * sqrtPriceX96;
-	let denominator = Q192$2;
-	const decimalDifference = assetDecimals - quoteDecimals;
-	if (decimalDifference > 0n) numerator *= pow10(decimalDifference);
-	else if (decimalDifference < 0n) denominator *= pow10(-decimalDifference);
-	return {
-		numerator,
-		denominator
+	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"
 	};
-}
-function isPriceGridStrike(strike, params, spacing, tickSpacing) {
-	const price = quotePriceAtTick(strike, params.asset, params.assetDecimals, params.quoteDecimals);
-	const floorMultiple = price.numerator * spacing.denominator / (price.denominator * spacing.units);
-	for (const multiple of [floorMultiple, floorMultiple + 1n]) {
-		if (multiple <= 0n) continue;
-		const orientedTick = priceToTick(formatGridPrice(multiple, spacing), params.assetDecimals, params.quoteDecimals);
-		const poolTick = params.asset === 0n ? orientedTick : -orientedTick;
-		if (roundToTickSpacing(poolTick, tickSpacing) === strike) return true;
-	}
-	return false;
-}
-function ceilDiv$1(value, divisor) {
-	const quotient = value / divisor;
-	const remainder = value % divisor;
-	return remainder > 0n ? quotient + 1n : quotient;
-}
-function floorDiv(value, divisor) {
-	const quotient = value / divisor;
-	const remainder = value % divisor;
-	return remainder < 0n ? quotient - 1n : quotient;
-}
-function resolveLegs(legs) {
-	if (legs.length === 0 || legs.length > Number(TOKEN_ID_BITS.MAX_LEGS)) invalid$1("legs must contain between 1 and 4 entries");
-	const resolved = legs.map((leg, index) => {
-		if (leg.optionType !== "call" && leg.optionType !== "put") invalid$1(`leg ${index} has an invalid optionType`);
-		if (typeof leg.isLong !== "boolean") invalid$1(`leg ${index} has an invalid isLong value`);
-		if (leg.optionRatio < 1n || leg.optionRatio > LEG_LIMITS.MAX_RATIO) invalid$1(`leg ${index} optionRatio must be between 1 and ${LEG_LIMITS.MAX_RATIO}`);
-		const riskPartner = leg.riskPartner ?? BigInt(index);
-		if (riskPartner < 0n || riskPartner >= BigInt(legs.length)) invalid$1(`leg ${index} references an inactive risk partner`);
-		return {
-			...leg,
-			riskPartner
-		};
-	});
-	for (const [index, leg] of resolved.entries()) {
-		if (leg.riskPartner === BigInt(index)) continue;
-		const partner = resolved[Number(leg.riskPartner)];
-		if (partner === void 0 || partner.riskPartner !== BigInt(index)) invalid$1(`leg ${index} has a non-mutual risk partner`);
-	}
-	return resolved;
-}
-function getCandidateStrikes(params, spacing, tickSpacing, halfWidth) {
-	const lower = MIN_TICK + halfWidth > params.currentTick - halfWidth + 1n ? MIN_TICK + halfWidth : params.currentTick - halfWidth + 1n;
-	const upper = MAX_TICK - halfWidth < params.currentTick + halfWidth - 1n ? MAX_TICK - halfWidth : params.currentTick + halfWidth - 1n;
-	const firstStrike = ceilDiv$1(lower, tickSpacing) * tickSpacing;
-	const lastStrike = floorDiv(upper, tickSpacing) * tickSpacing;
-	const strikes = [];
-	for (let strike = firstStrike; strike <= lastStrike; strike += tickSpacing) if (isPriceGridStrike(strike, params, spacing, tickSpacing)) strikes.push(strike);
-	if (params.asset === 1n) strikes.reverse();
-	return strikes;
-}
-function buildTokenId$1(poolId, strike, width, asset, legs) {
-	const builder = createTokenIdBuilder(poolId);
-	for (const leg of legs) {
-		const config = {
-			strike,
-			width,
-			optionRatio: leg.optionRatio,
-			isLong: leg.isLong,
-			riskPartner: leg.riskPartner,
-			asset
-		};
-		if (leg.optionType === "call") builder.addCall(config);
-		else builder.addPut(config);
-	}
-	return builder.build();
-}
-function dividePositionSize$1(positionSize, count) {
-	if (positionSize < count) invalid$1(`positionSize ${positionSize} is too small for ${count} nonzero positions`);
-	const quotient = positionSize / count;
-	const remainder = positionSize % count;
-	const sizes = [];
-	for (let index = 0n; index < count; index += 1n) sizes.push(quotient + (index < remainder ? 1n : 0n));
-	return sizes;
-}
-/**
-* Generate a fixed quote-price lattice of co-strike TokenIds whose liquidity
-* ranges strictly contain the current tick. Returned arrays are ordered by
-* ascending quote strike price and are ready for `dispatch()`.
-*/
-function generateOverlappingTokenIds(params) {
-	if (params.poolId < 0n || params.poolId > MAX_UINT64$2) invalid$1("poolId must fit in uint64");
-	if (params.currentTick < MIN_TICK || params.currentTick > MAX_TICK) invalid$1(`currentTick must be between ${MIN_TICK} and ${MAX_TICK}`);
-	if (params.asset !== 0n && params.asset !== 1n) invalid$1("asset must be 0 or 1");
-	if (params.assetDecimals < 0n || params.assetDecimals > MAX_TOKEN_DECIMALS || params.quoteDecimals < 0n || params.quoteDecimals > MAX_TOKEN_DECIMALS) invalid$1("assetDecimals and quoteDecimals must be between 0 and 255");
-	if (params.positionSize <= 0n || params.positionSize > MAX_UINT128$3) invalid$1("positionSize must be between 1 and uint128.max");
-	const tickSpacing = decodeTickSpacing$1(params.poolId);
-	if (tickSpacing <= 0n) invalid$1("poolId tick spacing must be positive");
-	const standardTickWidth = STANDARD_TICK_WIDTHS[params.timescale];
-	if (standardTickWidth === void 0) invalid$1(`unknown timescale ${String(params.timescale)}`);
-	const width = (standardTickWidth + tickSpacing - 1n) / tickSpacing;
-	if (width <= 0n || width > LEG_LIMITS.MAX_WIDTH) invalid$1(`timescale width does not fit in the TokenId width field for tick spacing ${tickSpacing}`);
-	const halfWidth = width * tickSpacing / 2n;
-	if (halfWidth <= 0n) invalid$1("timescale width must span at least two ticks");
-	const spacing = parsePriceSpacing(params.strikePriceSpacing, params.quoteDecimals);
-	const legs = resolveLegs(params.legs);
-	const strikes = getCandidateStrikes(params, spacing, tickSpacing, halfWidth);
-	if (strikes.length === 0) invalid$1("no price-grid strikes overlap the current tick");
-	return {
-		positionIdList: strikes.map((strike) => buildTokenId$1(params.poolId, strike, width, params.asset, legs)),
-		positionSizes: dividePositionSize$1(params.positionSize, BigInt(strikes.length))
+	if (v4Result !== zeroAddress) return {
+		panopticPoolAddress: v4Result,
+		version: "v4"
 	};
+	throw new Error(`No PanopticPool found for poolId ${poolId}`);
 }
 
 //#endregion
-//#region src/panoptic/v2/tokenId/split.ts
-const POOL_ID_MASK$2 = (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
-const MAX_UINT128$2 = (1n << 128n) - 1n;
-const MAX_UINT256$1 = (1n << 256n) - 1n;
-function invalid(message) {
-	throw new PanopticValidationError(`splitTokenIdByTimescale: ${message}`);
-}
-function validateInput(tokenId, positionSize) {
-	if (tokenId < 0n || tokenId > MAX_UINT256$1) invalid("tokenId must fit in uint256");
-	if (positionSize <= 0n || positionSize > MAX_UINT128$2) invalid("positionSize must be between 1 and uint128.max");
-	const legs = decodeAllLegs(tokenId);
-	if (legs.length === 0) invalid("tokenId must contain at least one active leg");
-	for (const [index, leg] of legs.entries()) if (leg.index !== BigInt(index)) invalid("active legs must be contiguous from index 0");
-	const firstUnusedBit = TOKEN_ID_BITS.POOL_ID_SIZE + BigInt(legs.length) * TOKEN_ID_BITS.LEG_SIZE;
-	if (tokenId >> firstUnusedBit !== 0n) invalid("inactive leg slots must be empty");
-	const byIndex = new Map(legs.map((leg) => [leg.index, leg]));
-	for (const leg of legs) {
-		const partner = byIndex.get(leg.riskPartner);
-		if (partner === void 0) invalid(`leg ${leg.index} references an inactive risk partner`);
-		if (partner.index !== leg.index && partner.riskPartner !== leg.index) invalid(`leg ${leg.index} has a non-mutual risk partner`);
+//#region src/panoptic/v2/reads/minePoolAddressLocal.ts
+/**
+* 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 legs;
-}
-function isCall(leg) {
-	return leg.tokenType === leg.asset;
-}
-function isEconomicStraddlePair(left, right) {
-	return isCall(left) !== isCall(right) && left.asset === right.asset && left.optionRatio === right.optionRatio && left.isLong === right.isLong && left.strike === right.strike && left.width === right.width;
+	return bytes;
 }
-/** Preserve mutual pairs, then pair self-partnered economic straddles in source order. */
-function groupOptionLegs(optionLegs) {
-	const byIndex = new Map(optionLegs.map((leg) => [leg.index, leg]));
-	const consumed = new Set();
-	const groups = [];
-	for (const leg of optionLegs) {
-		if (consumed.has(leg.index)) continue;
-		if (leg.riskPartner !== leg.index) {
-			const riskPartner = byIndex.get(leg.riskPartner);
-			if (riskPartner === void 0) invalid(`mutual risk pair containing leg ${leg.index} cannot be separated`);
-			consumed.add(leg.index);
-			consumed.add(riskPartner.index);
-			groups.push([leg, riskPartner]);
-			continue;
-		}
-		const partner = optionLegs.find((candidate) => candidate.index > leg.index && !consumed.has(candidate.index) && candidate.riskPartner === candidate.index && isEconomicStraddlePair(leg, candidate));
-		consumed.add(leg.index);
-		if (partner === void 0) {
-			groups.push([leg]);
-			continue;
-		}
-		consumed.add(partner.index);
-		groups.push([leg, partner]);
-	}
-	return groups;
+/** 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;
 }
-function remapRiskPartner(leg, indexBySource) {
-	const riskPartner = indexBySource.get(leg.riskPartner);
-	if (riskPartner === void 0) invalid(`risk partner for leg ${leg.index} is missing from its output group`);
-	return riskPartner;
-}
-function buildTokenId(poolId, legs, transform) {
-	const indexBySource = new Map(legs.map((leg, index) => [leg.index, BigInt(index)]));
-	let output = poolId;
-	for (const [index, leg] of legs.entries()) {
-		const newIndex = BigInt(index);
-		const { strike, width } = transform(leg);
-		if (strike < LEG_LIMITS.MIN_STRIKE || strike > LEG_LIMITS.MAX_STRIKE) invalid(`generated strike ${strike} does not fit in int24`);
-		if (width < 0n || width > LEG_LIMITS.MAX_WIDTH) invalid(`generated width ${width} does not fit in the TokenId width field`);
-		output = addLegToTokenId(output, {
-			index: newIndex,
-			asset: leg.asset,
-			optionRatio: leg.optionRatio,
-			isLong: leg.isLong ? 1n : 0n,
-			tokenType: leg.tokenType,
-			riskPartner: remapRiskPartner(leg, indexBySource),
-			strike,
-			width
-		});
-	}
-	return output;
-}
-function childWidths(sourceWidth, targetWidth) {
-	if (sourceWidth <= targetWidth) return [sourceWidth];
-	const fullWidthCount = sourceWidth / targetWidth;
-	const remainder = sourceWidth % targetWidth;
-	const widths = [];
-	for (let remaining = fullWidthCount; remaining > 0n; remaining -= 1n) widths.push(targetWidth);
-	if (remainder > 0n) widths.push(remainder);
-	return widths;
-}
-function dividePositionSize(positionSize, count) {
-	const countBigInt = BigInt(count);
-	if (positionSize < countBigInt) invalid(`positionSize ${positionSize} is too small for ${count} nonzero child positions`);
-	const quotient = positionSize / countBigInt;
-	const remainder = positionSize % countBigInt;
-	return Array.from({ length: count }, (_, index) => quotient + (BigInt(index) < remainder ? 1n : 0n));
-}
-function splitGroup(poolId, group, tickSpacing, targetWidth, positionSize) {
-	const sourceWidth = group[0]?.width;
-	if (sourceWidth === void 0 || sourceWidth === 0n) invalid("option group must have nonzero width");
-	if (group.some((leg) => leg.width !== sourceWidth)) invalid("all legs in an option group must have the same width");
-	const widths = childWidths(sourceWidth, targetWidth);
-	const positionSizes = dividePositionSize(positionSize, widths.length);
-	let consumedWidth = 0n;
-	const positionIdList = widths.map((width) => {
-		const offset = consumedWidth;
-		consumedWidth += width;
-		return buildTokenId(poolId, group, (leg) => {
-			const sourceLower = leg.strike - sourceWidth * tickSpacing / 2n;
-			const childLower = sourceLower + offset * tickSpacing;
-			const strike = childLower + width * tickSpacing / 2n;
-			return {
-				strike,
-				width
-			};
-		});
-	});
-	return {
-		positionIdList,
-		positionSizes
-	};
-}
-/**
-* Split every standalone option, economic straddle, or mutual risk pair in a
-* TokenId into a shorter standard timescale. Width-zero credit/loan legs are
-* emitted together as one final position. Returned arrays are parallel and
-* ready for `dispatch()`.
-*
-* Each option group divides `positionSize` independently across its children.
-* Integer remainder units are assigned to the lower children first.
-*/
-function splitTokenIdByTimescale(tokenId, positionSize, targetTimescale) {
-	const legs = validateInput(tokenId, positionSize);
-	const tickSpacing = decodeTickSpacing$1(tokenId);
-	if (tickSpacing <= 0n) invalid("tokenId tick spacing must be positive");
-	const targetTickWidth = STANDARD_TICK_WIDTHS[targetTimescale];
-	if (targetTickWidth === void 0) invalid(`unknown target timescale ${String(targetTimescale)}`);
-	const targetWidth = (targetTickWidth + tickSpacing - 1n) / tickSpacing;
-	const poolId = tokenId & POOL_ID_MASK$2;
-	const optionLegs = legs.filter((leg) => leg.width > 0n);
-	const fundingLegs = legs.filter((leg) => leg.width === 0n);
-	const positionIdList = [];
-	const positionSizes = [];
-	for (const group of groupOptionLegs(optionLegs)) {
-		const split = splitGroup(poolId, group, tickSpacing, targetWidth, positionSize);
-		positionIdList.push(...split.positionIdList);
-		positionSizes.push(...split.positionSizes);
-	}
-	if (fundingLegs.length > 0) {
-		positionIdList.push(buildTokenId(poolId, fundingLegs, (leg) => ({
-			strike: leg.strike,
-			width: leg.width
-		})));
-		positionSizes.push(positionSize);
-	}
-	return {
-		positionIdList,
-		positionSizes
-	};
-}
-
-//#endregion
-//#region src/panoptic/v2/sfpmSwap/calldata.ts
-/**
-* 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.
-*/
-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
-	};
-}
-
-//#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.
-*/
-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);
-}
-/**
-* Ensure a Uniswap v3 pool is registered on the SFPM, sending `initializeAMMPool`
-* only if it is not already registered. Returns the resolved poolId.
-*
-* 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 ensureSfpmV3PoolInitialized(params) {
-	const { client, wallet, sfpmAddress, token0, token1, fee, expectedPool } = params;
-	const vegoid = params.vegoid ?? Number(DEFAULT_VEGOID);
-	const poolId = await fetchSfpmV3PoolId({
-		client,
-		sfpmAddress,
-		token0,
-		token1,
-		fee,
-		vegoid
-	});
-	const registered = await client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "getUniswapV3PoolFromId",
-		args: [poolId]
-	});
-	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
-	};
-}
-
-//#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;
-}
-/**
-* 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
-	};
-}
-
-//#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)
-	};
-}
-/** 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);
-}
-/**
-* 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.
-*/
-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
-		};
-	}
-}
-
-//#endregion
-//#region src/panoptic/v2/reads/sfpm.ts
-/**
-* Resolve an SFPM poolId to its corresponding Uniswap V3 pool address.
-*
-* Calls `SemiFungiblePositionManagerV3.getUniswapV3PoolFromId(poolId)`.
-*/
-async function getUniswapV3PoolFromId(params) {
-	const { client, sfpmAddress, poolId } = params;
-	return client.readContract({
-		address: sfpmAddress,
-		abi: semiFungiblePositionManagerV3Abi,
-		functionName: "getUniswapV3PoolFromId",
-		args: [poolId]
-	});
-}
-/**
-* Resolve an SFPM poolId to its corresponding Uniswap V4 pool key.
-*
-* Calls `SemiFungiblePositionManagerV4.getUniswapV4PoolKeyFromId(poolId)`.
-*/
-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
-	};
-}
-/**
-* 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]
-	});
-	return {
-		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/reads/factory.ts
-/**
-* Get the token URI from a PanopticFactory NFT.
-*/
-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]
-	});
-}
-/**
-* 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]
-	});
-}
-/**
-* 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
-		]
-	});
-}
-/**
-* Get the PanopticPool address for a given pool and risk engine.
-*/
-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]
-	});
-}
-/**
-* Mine for an optimal pool address salt with high rarity.
-*/
-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]
-	};
-}
-/**
-* Simulate a pool deployment to get the predicted pool address.
-*
-* Uses `simulateContract` on `deployNewPool` — the return value is the new pool address
-* without actually executing the transaction.
-*/
-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;
-	}
-	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
-		});
-		return getPanopticPoolAddress({
-			version: "v3",
-			client,
-			factoryAddress,
-			univ3pool,
-			riskEngine
-		});
-	}
-	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/reads/minePoolAddressLocal.ts
-/**
-* 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;
+/** 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.
@@ -1962,330 +956,75 @@ function computePoolIdV4(poolKey) {
 	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;
-			}
-		}
-		if (done) break;
-		await new Promise((resolve) => setTimeout(resolve, 0));
-	}
-	return {
-		bestSalt,
-		highestRarity
-	};
-}
-
-//#endregion
-//#region src/panoptic/v2/reads/premia.ts
-/**
-* Get premia totals for an account.
-*
-* Returns the total short and long premium across all positions.
-* Short premium is owed TO the account (earned from selling options).
-* Long premium is owed BY the account (paid for buying options).
-*
-* @param params - The parameters
-* @returns Premia totals with block metadata
-*
-* @example
-* ```typescript
-* const premia = await getAccountPremia({
-*   client,
-*   poolAddress,
-*   account,
-*   tokenIds: [tokenId1, tokenId2],
-*   includePendingPremium: true,
-* })
-*
-* console.log('Short premium earned:', premia.shortPremium0, premia.shortPremium1)
-* console.log('Long premium owed:', premia.longPremium0, premia.longPremium1)
-* ```
-*/
-async function getAccountPremia(params) {
-	const { client, poolAddress, account, tokenIds, includePendingPremium = true, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
-	if (tokenIds.length === 0) {
-		const _meta$1 = params._meta ?? await getBlockMeta({
-			client,
-			blockNumber: targetBlockNumber
-		});
-		return {
-			shortPremium0: 0n,
-			shortPremium1: 0n,
-			longPremium0: 0n,
-			longPremium1: 0n,
-			includePendingPremium,
-			_meta: _meta$1
-		};
-	}
-	const [[shortPremiumPacked, longPremiumPacked], _meta] = await Promise.all([client.readContract({
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			includePendingPremium,
-			tokenIds
-		],
-		blockNumber: targetBlockNumber
-	}), params._meta ?? getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	})]);
-	const shortPremium = decodeLeftRightUnsigned(shortPremiumPacked);
-	const longPremium = decodeLeftRightUnsigned(longPremiumPacked);
-	return {
-		shortPremium0: shortPremium.right,
-		shortPremium1: shortPremium.left,
-		longPremium0: longPremium.right,
-		longPremium1: longPremium.left,
-		includePendingPremium,
-		_meta
-	};
-}
-/**
-* Get positions with per-position premia data.
-*
-* Uses multicall to batch individual getFullPositionsData calls
-* for each position, giving us per-position premia in a single RPC request.
-*
-* @param params - The parameters
-* @returns Positions with premia and totals with block metadata
-*
-* @example
-* ```typescript
-* const result = await getPositionsWithPremia({
-*   client,
-*   poolAddress,
-*   account,
-*   tokenIds: [tokenId1, tokenId2],
-* })
-*
-* for (const position of result.positions) {
-*   console.log('Position:', position.tokenId)
-*   console.log('Premia:', position.premiaOwed0, position.premiaOwed1)
-* }
-* console.log('Total short premium:', result.shortPremium0, result.shortPremium1)
-* ```
-*/
-async function getPositionsWithPremia(params) {
-	const { client, poolAddress, account, tokenIds, includePendingPremium = true, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? params._meta?.blockNumber ?? await client.getBlockNumber();
-	if (tokenIds.length === 0) {
-		const _meta$1 = params._meta ?? await getBlockMeta({
-			client,
-			blockNumber: targetBlockNumber
-		});
-		return {
-			positions: [],
-			shortPremium0: 0n,
-			shortPremium1: 0n,
-			longPremium0: 0n,
-			longPremium1: 0n,
-			includePendingPremium,
-			_meta: _meta$1
-		};
-	}
-	const contracts = tokenIds.map((tokenId) => ({
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			includePendingPremium,
-			[tokenId]
-		]
-	}));
-	const [multicallResults, _meta] = await Promise.all([client.multicall({
-		contracts,
-		blockNumber: targetBlockNumber,
-		allowFailure: true
-	}), params._meta ?? getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	})]);
-	const positions = [];
-	let totalShortPremium0 = 0n;
-	let totalShortPremium1 = 0n;
-	let totalLongPremium0 = 0n;
-	let totalLongPremium1 = 0n;
-	for (let i = 0; i < tokenIds.length; i++) {
-		const tokenId = tokenIds[i];
-		const result = multicallResults[i];
-		if (result.status !== "success") continue;
-		const [shortPremiumPacked, longPremiumPacked, balances] = result.result;
-		const shortPremium = decodeLeftRightUnsigned(shortPremiumPacked);
-		const longPremium = decodeLeftRightUnsigned(longPremiumPacked);
-		totalShortPremium0 += shortPremium.right;
-		totalShortPremium1 += shortPremium.left;
-		totalLongPremium0 += longPremium.right;
-		totalLongPremium1 += longPremium.left;
-		const balanceData = balances[0];
-		if (balanceData === void 0) continue;
-		const positionSize = balanceData & (1n << 128n) - 1n;
-		if (positionSize === 0n) continue;
-		const poolUtilization0 = balanceData >> 128n & 0xffffn;
-		const poolUtilization1 = balanceData >> 144n & 0xffffn;
-		let tickAtMint = balanceData >> 160n & 0xffffffn;
-		if (tickAtMint > 0x7fffffn) tickAtMint = tickAtMint - 0x1000000n;
-		const timestampAtMint = balanceData >> 184n & 0xffffffffn;
-		const blockAtMint = balanceData >> 216n & (1n << 39n) - 1n;
-		const swapAtMint = balanceData >> 255n === 1n;
-		const decoded = decodePosition(tokenId);
-		const tickSpacing = decodeTickSpacing(tokenId);
-		const legs = decoded.legs.map((leg) => {
-			const width = leg.width;
-			const strike = leg.strike;
-			const tickLower = strike - width * tickSpacing / 2n;
-			const tickUpper = strike + width * tickSpacing / 2n;
-			return {
-				index: BigInt(leg.index),
-				asset: leg.asset,
-				optionRatio: leg.optionRatio,
-				isLong: leg.isLong === 1n,
-				tokenType: leg.tokenType,
-				riskPartner: leg.riskPartner,
-				strike,
-				width,
-				tickLower,
-				tickUpper
-			};
-		});
-		const premiaOwed0 = shortPremium.right - longPremium.right;
-		const premiaOwed1 = shortPremium.left - longPremium.left;
-		positions.push({
-			tokenId,
-			positionSize,
-			owner: account,
-			poolAddress,
-			legs,
-			poolUtilization0AtMint: poolUtilization0,
-			poolUtilization1AtMint: poolUtilization1,
-			tickAtMint,
-			timestampAtMint,
-			blockNumberAtMint: blockAtMint,
-			swapAtMint,
-			premiaOwed0,
-			premiaOwed1,
-			assetIndex: legs.length > 0 ? legs[0].asset : 0n,
-			_meta
-		});
-	}
-	return {
-		positions,
-		shortPremium0: totalShortPremium0,
-		shortPremium1: totalShortPremium1,
-		longPremium0: totalLongPremium0,
-		longPremium1: totalLongPremium1,
-		includePendingPremium,
-		_meta
-	};
+		{ type: "uint24" },
+		{ type: "int24" },
+		{ type: "address" }
+	], [
+		poolKey.currency0,
+		poolKey.currency1,
+		Number(poolKey.fee),
+		Number(poolKey.tickSpacing),
+		poolKey.hooks
+	]);
+	return BigInt(keccak256(encoded));
 }
 /**
-* Get the unsettled short premium an account would forfeit by closing now.
+* Construct the bytes32 CREATE3 salt for PanopticFactoryV4.
 *
-* Calls `getFullPositionsData` twice in one multicall — once with
-* `includePendingPremium = true` (everything owed to the short legs) and once
-* with `false` (only what is available to collect). The difference is the
-* premium still owed by buyers that has not been settled; closing before it
-* settles forfeits it. Settling buyers first (see `settlePremiumFrom`) moves
-* that premium into the available bucket.
+* 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 - The parameters
-* @returns Owed, available, and forfeitable premium with block metadata
+* @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 getForfeitablePremium(params) {
-	const { client, poolAddress, account, tokenIds, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const contracts = [true, false].map((includePendingPremium) => ({
-		address: poolAddress,
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			includePendingPremium,
-			tokenIds
-		]
-	}));
-	const [multicallResults, _meta] = await Promise.all([client.multicall({
-		contracts,
-		blockNumber: targetBlockNumber,
-		allowFailure: false
-	}), getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	})]);
-	const owed = decodeLeftRightUnsigned(multicallResults[0][0]);
-	const available = decodeLeftRightUnsigned(multicallResults[1][0]);
-	const forfeit0 = owed.right > available.right ? owed.right - available.right : 0n;
-	const forfeit1 = owed.left > available.left ? owed.left - available.left : 0n;
+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));
+	}
 	return {
-		owed0: owed.right,
-		owed1: owed.left,
-		available0: available.right,
-		available1: available.left,
-		forfeit0,
-		forfeit1,
-		_meta
+		bestSalt,
+		highestRarity
 	};
 }
 
@@ -2606,7 +1345,7 @@ function maximumAmountIn(estimatedAmountIn, slippageBps) {
 	if (slippageBps < 0n) throw new PanopticError("slippageBps must be non-negative");
 	return (estimatedAmountIn * (BPS_DENOMINATOR$2 + slippageBps) + BPS_DENOMINATOR$2 - 1n) / BPS_DENOMINATOR$2;
 }
-function ceilDiv(numerator, denominator) {
+function ceilDiv$1(numerator, denominator) {
 	return (numerator + denominator - 1n) / denominator;
 }
 function getInputAmount(tokenFlow, tokenInIndex) {
@@ -2721,7 +1460,7 @@ async function quoteTokenShortfallRecovery(params) {
 				error: new PanopticError("Insufficient source collateral for the recovery swap")
 			};
 			if (estimatedAmountOut < requiredOutput) {
-				creditInput = estimatedAmountOut > 0n ? ceilDiv(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
+				creditInput = estimatedAmountOut > 0n ? ceilDiv$1(creditInput * requiredOutput, estimatedAmountOut) + 1n : creditInput * 2n;
 				continue;
 			}
 			const recoveredDispatch = buildPrefixedExactInputRecoveryDispatch({
@@ -2775,7 +1514,7 @@ async function quoteTokenShortfallRecovery(params) {
 			};
 			const residual = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 			requiredOutput += residual > 0n ? residual : requiredOutput;
-			creditInput = ceilDiv(creditInput * requiredOutput, estimatedAmountOut) + 1n;
+			creditInput = ceilDiv$1(creditInput * requiredOutput, estimatedAmountOut) + 1n;
 		}
 		return {
 			available: false,
@@ -2831,7 +1570,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 		const sourceBalance = getBalanceBefore(swapSimulation.tokenFlow, tokenInIndex);
 		if (swapOutput < amountOut) {
-			creditOutSize = swapOutput > 0n ? ceilDiv(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+			creditOutSize = swapOutput > 0n ? ceilDiv$1(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 			continue;
 		}
 		if (sourceBalance < maxAmountIn) return {
@@ -2890,7 +1629,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const decodedShortfall = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 		const additionalAmountOut = decodedShortfall > 0n ? decodedShortfall : amountOut;
 		amountOut += additionalAmountOut;
-		creditOutSize = swapOutput > 0n ? ceilDiv(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+		creditOutSize = swapOutput > 0n ? ceilDiv$1(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 	}
 	return {
 		available: false,
@@ -6986,568 +5725,244 @@ async function getPositionChunkData(params) {
 		abi: panopticQueryAbi,
 		functionName: "getChunkData",
 		args: [poolAddress, tokenIds],
-		blockNumber: targetBlockNumber
-	}), getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	})]);
-	const positions = tokenIds.map((tokenId, posIndex) => {
-		const positionData = chunkData[posIndex];
-		const legs = [];
-		for (let legIndex = 0; legIndex < 4; legIndex++) {
-			const legData = positionData[legIndex];
-			const netLiquidity = legData[0];
-			const removedLiquidity = legData[1];
-			if (netLiquidity > 0n || removedLiquidity > 0n) legs.push({
-				legIndex,
-				netLiquidity,
-				removedLiquidity,
-				spreadWad: calculateSpreadWad(netLiquidity, removedLiquidity, vegoid)
-			});
-		}
-		return {
-			tokenId,
-			legs
-		};
-	});
-	return {
-		positions,
-		_meta
-	};
-}
-
-//#endregion
-//#region src/panoptic/v2/sync/pendingPositions.ts
-/**
-* Add a pending position for optimistic updates.
-*
-* Called when openPosition() submits a transaction.
-*
-* @param params - Parameters
-*/
-async function addPendingPosition(params) {
-	const { chainId, poolAddress, account, storage, position } = params;
-	const key = getPendingPositionsKey(chainId, poolAddress, account);
-	const existingData = await storage.get(key);
-	let pending;
-	if (existingData) try {
-		pending = jsonSerializer.parse(existingData);
-	} catch {
-		pending = [];
-	}
-	else pending = [];
-	pending.push(position);
-	await storage.set(key, jsonSerializer.stringify(pending));
-}
-/**
-* Get all pending positions for an account.
-*
-* @param params - Parameters
-* @returns Array of pending positions
-*/
-async function getPendingPositions(params) {
-	const { chainId, poolAddress, account, storage } = params;
-	const key = getPendingPositionsKey(chainId, poolAddress, account);
-	const data = await storage.get(key);
-	if (!data) return [];
-	try {
-		const pending = jsonSerializer.parse(data);
-		return pending.filter((p) => p.status === "pending");
-	} catch {
-		return [];
-	}
-}
-/**
-* Mark a pending position as confirmed.
-*
-* Called when syncPositions() finds the OptionMinted event.
-*
-* @param params - Parameters
-*/
-async function confirmPendingPosition(params) {
-	const { chainId, poolAddress, account, storage, tokenId } = params;
-	const key = getPendingPositionsKey(chainId, poolAddress, account);
-	const existingData = await storage.get(key);
-	if (!existingData) return;
-	let pending;
-	try {
-		pending = jsonSerializer.parse(existingData);
-	} catch {
-		return;
-	}
-	const updated = pending.map((p) => p.tokenId === tokenId ? {
-		...p,
-		status: "confirmed"
-	} : p);
-	const remaining = updated.filter((p) => p.status === "pending");
-	if (remaining.length === 0) await storage.delete(key);
-	else await storage.set(key, jsonSerializer.stringify(remaining));
-}
-/**
-* Mark a pending position as failed (transaction reverted).
-*
-* @param params - Parameters
-*/
-async function failPendingPosition(params) {
-	const { chainId, poolAddress, account, storage, txHash } = params;
-	const key = getPendingPositionsKey(chainId, poolAddress, account);
-	const existingData = await storage.get(key);
-	if (!existingData) return;
-	let pending;
-	try {
-		pending = jsonSerializer.parse(existingData);
-	} catch {
-		return;
-	}
-	const remaining = pending.filter((p) => p.txHash !== txHash);
-	if (remaining.length === 0) await storage.delete(key);
-	else await storage.set(key, jsonSerializer.stringify(remaining));
-}
-/**
-* Clear all pending positions for an account.
-*
-* @param params - Parameters
-*/
-async function clearPendingPositions(params) {
-	const { chainId, poolAddress, account, storage } = params;
-	const key = getPendingPositionsKey(chainId, poolAddress, account);
-	await storage.delete(key);
-}
-/**
-* Clean up stale pending positions.
-*
-* Removes pending positions older than the specified block threshold.
-* This handles cases where transactions were dropped from the mempool.
-*
-* @param params - Parameters
-* @param maxAgeBlocks - Maximum age in blocks (default: 100)
-* @param currentBlock - Current block number
-*/
-async function cleanupStalePendingPositions(params, currentBlock, maxAgeBlocks = 100n) {
-	const { chainId, poolAddress, account, storage } = params;
-	const key = getPendingPositionsKey(chainId, poolAddress, account);
-	const existingData = await storage.get(key);
-	if (!existingData) return;
-	let pending;
-	try {
-		pending = jsonSerializer.parse(existingData);
-	} catch {
-		return;
-	}
-	const threshold = currentBlock - maxAgeBlocks;
-	const remaining = pending.filter((p) => p.status === "pending" && p.submittedAtBlock > threshold);
-	if (remaining.length === 0) await storage.delete(key);
-	else if (remaining.length !== pending.length) await storage.set(key, jsonSerializer.stringify(remaining));
-}
-
-//#endregion
-//#region src/panoptic/v2/simulations/simulateBatchDispatch.ts
-/**
-* Simulate a batch dispatch built from `items` + the current on-chain
-* positionIdList. Returns batch diagnostics OR a real simulation result.
-*/
-async function simulateBatchDispatch(params) {
-	const { client, poolAddress, account, items, existingPositionIds, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
-	const { args, diagnostics } = buildBatchDispatchArgs({
-		items,
-		existingPositionIds,
-		usePremiaAsCollateral,
-		builderCode
-	});
-	if (args === null) {
-		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-		const meta = await getBlockMeta({
-			client,
-			blockNumber: targetBlockNumber
-		});
+		blockNumber: targetBlockNumber
+	}), getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	const positions = tokenIds.map((tokenId, posIndex) => {
+		const positionData = chunkData[posIndex];
+		const legs = [];
+		for (let legIndex = 0; legIndex < 4; legIndex++) {
+			const legData = positionData[legIndex];
+			const netLiquidity = legData[0];
+			const removedLiquidity = legData[1];
+			if (netLiquidity > 0n || removedLiquidity > 0n) legs.push({
+				legIndex,
+				netLiquidity,
+				removedLiquidity,
+				spreadWad: calculateSpreadWad(netLiquidity, removedLiquidity, vegoid)
+			});
+		}
 		return {
-			success: false,
-			diagnostics,
-			_meta: meta
+			tokenId,
+			legs
 		};
-	}
-	const sim = await simulateDispatch({
-		client,
-		poolAddress,
-		account,
-		positionIdList: args.positionIdList,
-		finalPositionIdList: args.finalPositionIdList,
-		existingPositionIdList: existingPositionIds,
-		positionSizes: args.positionSizes,
-		tickAndSpreadLimits: args.tickAndSpreadLimits,
-		usePremiaAsCollateral: args.usePremiaAsCollateral,
-		builderCode: args.builderCode,
-		blockNumber
 	});
 	return {
-		...sim,
-		diagnostics: []
+		positions,
+		_meta
 	};
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateClosePosition.ts
+//#region src/panoptic/v2/sync/pendingPositions.ts
 /**
-* Simulate closing a position.
+* Add a pending position for optimistic updates.
 *
-* Uses PanopticPool.multicall with getAssetsOf-dispatch-getAssetsOf pattern
-* to measure exact collateral asset movements from the burn.
+* Called when openPosition() submits a transaction.
 *
-* @param params - Simulation parameters
-* @returns Simulation result with close data or error
+* @param params - Parameters
 */
-async function simulateClosePosition(params) {
-	const { client, poolAddress, account, positionIdList, tokenId, tickLimitLow, tickLimitHigh, spreadLimit = 0n, swapAtMint = false, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
-	const tickLimits$1 = swapAtMint ? [
-		Number(tickLimitHigh),
-		Number(tickLimitLow),
-		Number(spreadLimit)
-	] : [
-		Number(tickLimitLow),
-		Number(tickLimitHigh),
-		Number(spreadLimit)
-	];
+async function addPendingPosition(params) {
+	const { chainId, poolAddress, account, storage, position } = params;
+	const key = getPendingPositionsKey(chainId, poolAddress, account);
+	const existingData = await storage.get(key);
+	let pending;
+	if (existingData) try {
+		pending = jsonSerializer.parse(existingData);
+	} catch {
+		pending = [];
+	}
+	else pending = [];
+	pending.push(position);
+	await storage.set(key, jsonSerializer.stringify(pending));
+}
+/**
+* Get all pending positions for an account.
+*
+* @param params - Parameters
+* @returns Array of pending positions
+*/
+async function getPendingPositions(params) {
+	const { chainId, poolAddress, account, storage } = params;
+	const key = getPendingPositionsKey(chainId, poolAddress, account);
+	const data = await storage.get(key);
+	if (!data) return [];
 	try {
-		const finalPositionIdList = positionIdList.filter((id) => id !== tokenId);
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatch",
-			args: [
-				[tokenId],
-				finalPositionIdList,
-				[0n],
-				[tickLimits$1],
-				usePremiaAsCollateral,
-				builderCode
-			]
-		});
-		const flowResult = await simulateWithTokenFlow({
-			client,
-			poolAddress,
-			user: account,
-			callData,
-			blockNumber: targetBlockNumber
-		});
-		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Token flow simulation failed");
-		const tokenFlow = flowResult.tokenFlow;
-		const _meta = await metaPromise;
-		const data = {
-			amount0Received: tokenFlow.delta0,
-			amount1Received: tokenFlow.delta1,
-			premiaCollected0: null,
-			premiaCollected1: null,
-			postCollateral0: tokenFlow.balanceAfter0,
-			postCollateral1: tokenFlow.balanceAfter1,
-			realizedPnL0: null,
-			realizedPnL1: null
-		};
-		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 pending = jsonSerializer.parse(data);
+		return pending.filter((p) => p.status === "pending");
+	} catch {
+		return [];
 	}
 }
-
-//#endregion
-//#region src/panoptic/v2/simulations/simulateForceExercise.ts
 /**
-* Simulate a force exercise operation.
+* Mark a pending position as confirmed.
 *
-* @param params - Simulation parameters
-* @returns Simulation result with exercise data or error
+* Called when syncPositions() finds the OptionMinted event.
+*
+* @param params - Parameters
 */
-async function simulateForceExercise(params) {
-	const { client, poolAddress, account, user, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
-	const emptyTokenFlow = {
-		delta0: 0n,
-		delta1: 0n,
-		balanceBefore0: 0n,
-		balanceBefore1: 0n,
-		balanceAfter0: 0n,
-		balanceAfter1: 0n,
-		tickBefore: null,
-		tickAfter: null
-	};
+async function confirmPendingPosition(params) {
+	const { chainId, poolAddress, account, storage, tokenId } = params;
+	const key = getPendingPositionsKey(chainId, poolAddress, account);
+	const existingData = await storage.get(key);
+	if (!existingData) return;
+	let pending;
 	try {
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatchFrom",
-			args: [
-				positionIdListFrom,
-				user,
-				positionIdListTo,
-				positionIdListToFinal,
-				0n
-			]
-		});
-		const flowResult = await simulateWithTokenFlow({
-			client,
-			poolAddress,
-			user: account,
-			callData,
-			blockNumber: targetBlockNumber
-		});
-		if (!flowResult.success || !flowResult.tokenFlow) {
-			const errorMessage = flowResult.error || "Simulation failed";
-			const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
-			if (isNotExercisable) {
-				const _meta$1 = await metaPromise;
-				const data$1 = {
-					exerciseFee0: 0n,
-					exerciseFee1: 0n,
-					canExercise: false,
-					reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
-				};
-				return {
-					success: true,
-					data: data$1,
-					gasEstimate: 0n,
-					tokenFlow: emptyTokenFlow,
-					_meta: _meta$1
-				};
-			}
-			throw new PanopticError(errorMessage);
-		}
-		const _meta = await metaPromise;
-		const tokenFlow = flowResult.tokenFlow;
-		const data = {
-			exerciseFee0: tokenFlow.delta0,
-			exerciseFee1: tokenFlow.delta1,
-			canExercise: true
-		};
-		return {
-			success: true,
-			data,
-			gasEstimate: flowResult.gasEstimate,
-			tokenFlow,
-			_meta
-		};
-	} catch (error) {
-		const _meta = await metaPromise;
-		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
-		const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
-		if (isNotExercisable) {
-			const data = {
-				exerciseFee0: 0n,
-				exerciseFee1: 0n,
-				canExercise: false,
-				reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
-			};
-			return {
-				success: true,
-				data,
-				gasEstimate: 0n,
-				tokenFlow: emptyTokenFlow,
-				_meta
-			};
-		}
-		return {
-			success: false,
-			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
-			_meta
-		};
+		pending = jsonSerializer.parse(existingData);
+	} catch {
+		return;
 	}
+	const updated = pending.map((p) => p.tokenId === tokenId ? {
+		...p,
+		status: "confirmed"
+	} : p);
+	const remaining = updated.filter((p) => p.status === "pending");
+	if (remaining.length === 0) await storage.delete(key);
+	else await storage.set(key, jsonSerializer.stringify(remaining));
+}
+/**
+* Mark a pending position as failed (transaction reverted).
+*
+* @param params - Parameters
+*/
+async function failPendingPosition(params) {
+	const { chainId, poolAddress, account, storage, txHash } = params;
+	const key = getPendingPositionsKey(chainId, poolAddress, account);
+	const existingData = await storage.get(key);
+	if (!existingData) return;
+	let pending;
+	try {
+		pending = jsonSerializer.parse(existingData);
+	} catch {
+		return;
+	}
+	const remaining = pending.filter((p) => p.txHash !== txHash);
+	if (remaining.length === 0) await storage.delete(key);
+	else await storage.set(key, jsonSerializer.stringify(remaining));
+}
+/**
+* Clear all pending positions for an account.
+*
+* @param params - Parameters
+*/
+async function clearPendingPositions(params) {
+	const { chainId, poolAddress, account, storage } = params;
+	const key = getPendingPositionsKey(chainId, poolAddress, account);
+	await storage.delete(key);
+}
+/**
+* Clean up stale pending positions.
+*
+* Removes pending positions older than the specified block threshold.
+* This handles cases where transactions were dropped from the mempool.
+*
+* @param params - Parameters
+* @param maxAgeBlocks - Maximum age in blocks (default: 100)
+* @param currentBlock - Current block number
+*/
+async function cleanupStalePendingPositions(params, currentBlock, maxAgeBlocks = 100n) {
+	const { chainId, poolAddress, account, storage } = params;
+	const key = getPendingPositionsKey(chainId, poolAddress, account);
+	const existingData = await storage.get(key);
+	if (!existingData) return;
+	let pending;
+	try {
+		pending = jsonSerializer.parse(existingData);
+	} catch {
+		return;
+	}
+	const threshold = currentBlock - maxAgeBlocks;
+	const remaining = pending.filter((p) => p.status === "pending" && p.submittedAtBlock > threshold);
+	if (remaining.length === 0) await storage.delete(key);
+	else if (remaining.length !== pending.length) await storage.set(key, jsonSerializer.stringify(remaining));
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateLiquidate.ts
+//#region src/panoptic/v2/simulations/simulateBatchDispatch.ts
 /**
-* Simulate a liquidation operation.
-*
-* @param params - Simulation parameters
-* @returns Simulation result with liquidation data or error
+* Simulate a batch dispatch built from `items` + the current on-chain
+* positionIdList. Returns batch diagnostics OR a real simulation result.
 */
-async function simulateLiquidate(params) {
-	const { client, poolAddress, account, liquidatee, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
+async function simulateBatchDispatch(params) {
+	const { client, poolAddress, account, items, existingPositionIds, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
+	const { args, diagnostics } = buildBatchDispatchArgs({
+		items,
+		existingPositionIds,
+		usePremiaAsCollateral,
+		builderCode
 	});
-	const emptyTokenFlow = {
-		delta0: 0n,
-		delta1: 0n,
-		balanceBefore0: 0n,
-		balanceBefore1: 0n,
-		balanceAfter0: 0n,
-		balanceAfter1: 0n,
-		tickBefore: null,
-		tickAfter: null
-	};
-	try {
-		const callData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "dispatchFrom",
-			args: [
-				positionIdListFrom,
-				liquidatee,
-				positionIdListTo,
-				positionIdListToFinal,
-				0n
-			]
-		});
-		const flowResult = await simulateWithTokenFlow({
+	if (args === null) {
+		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+		const meta = await getBlockMeta({
 			client,
-			poolAddress,
-			user: account,
-			callData,
 			blockNumber: targetBlockNumber
 		});
-		if (!flowResult.success || !flowResult.tokenFlow) {
-			const errorMessage = flowResult.error || "Simulation failed";
-			const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
-			if (isNotLiquidatable) {
-				const _meta$1 = await metaPromise;
-				const data$1 = {
-					bonus0: 0n,
-					bonus1: 0n,
-					positionsClosed: [],
-					isLiquidatable: false,
-					shortfall0: 0n,
-					shortfall1: 0n
-				};
-				return {
-					success: true,
-					data: data$1,
-					gasEstimate: 0n,
-					tokenFlow: emptyTokenFlow,
-					_meta: _meta$1
-				};
-			}
-			throw new PanopticError(errorMessage);
-		}
-		const _meta = await metaPromise;
-		const tokenFlow = flowResult.tokenFlow;
-		const positionsClosed = positionIdListTo.filter((id) => !positionIdListToFinal.includes(id));
-		const data = {
-			bonus0: tokenFlow.delta0 > 0n ? tokenFlow.delta0 : 0n,
-			bonus1: tokenFlow.delta1 > 0n ? tokenFlow.delta1 : 0n,
-			positionsClosed,
-			isLiquidatable: true,
-			shortfall0: 0n,
-			shortfall1: 0n
-		};
-		return {
-			success: true,
-			data,
-			gasEstimate: flowResult.gasEstimate,
-			tokenFlow,
-			_meta
-		};
-	} catch (error) {
-		const _meta = await metaPromise;
-		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
-		const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
-		if (isNotLiquidatable) {
-			const data = {
-				bonus0: 0n,
-				bonus1: 0n,
-				positionsClosed: [],
-				isLiquidatable: false,
-				shortfall0: 0n,
-				shortfall1: 0n
-			};
-			return {
-				success: true,
-				data,
-				gasEstimate: 0n,
-				tokenFlow: emptyTokenFlow,
-				_meta
-			};
-		}
 		return {
 			success: false,
-			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
-			_meta
+			diagnostics,
+			_meta: meta
 		};
 	}
+	const sim = await simulateDispatch({
+		client,
+		poolAddress,
+		account,
+		positionIdList: args.positionIdList,
+		finalPositionIdList: args.finalPositionIdList,
+		existingPositionIdList: existingPositionIds,
+		positionSizes: args.positionSizes,
+		tickAndSpreadLimits: args.tickAndSpreadLimits,
+		usePremiaAsCollateral: args.usePremiaAsCollateral,
+		builderCode: args.builderCode,
+		blockNumber
+	});
+	return {
+		...sim,
+		diagnostics: []
+	};
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateSettle.ts
-/** BIT_MASK_128 = (1n << 128n) - 1n */
-const BIT_MASK_128 = (1n << 128n) - 1n;
-/**
-* PanopticPool multicall ABI (inherited from Uniswap).
-*/
-const multicallAbi = [{
-	type: "function",
-	name: "multicall",
-	inputs: [{
-		name: "data",
-		type: "bytes[]"
-	}],
-	outputs: [{
-		name: "results",
-		type: "bytes[]"
-	}],
-	stateMutability: "nonpayable"
-}];
+//#region src/panoptic/v2/simulations/simulateClosePosition.ts
 /**
-* Simulate premium settlement.
+* Simulate closing a position.
 *
-* When `tokenId` is provided, the simulation also computes forfeit amounts
-* by chaining the dispatch with `getFullPositionsData` reads
-* in a single multicall.
+* Uses PanopticPool.multicall with getAssetsOf-dispatch-getAssetsOf pattern
+* to measure exact collateral asset movements from the burn.
 *
 * @param params - Simulation parameters
-* @returns Simulation result with settlement data or error
+* @returns Simulation result with close data or error
 */
-async function simulateSettle(params) {
-	const { client, poolAddress, account, positionIdList, finalPositionIdList, positionSizes: providedSizes, tokenId, blockNumber } = params;
+async function simulateClosePosition(params) {
+	const { client, poolAddress, account, positionIdList, tokenId, tickLimitLow, tickLimitHigh, spreadLimit = 0n, swapAtMint = false, usePremiaAsCollateral = false, builderCode = 0n, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	});
+	const tickLimits$1 = swapAtMint ? [
+		Number(tickLimitHigh),
+		Number(tickLimitLow),
+		Number(spreadLimit)
+	] : [
+		Number(tickLimitLow),
+		Number(tickLimitHigh),
+		Number(spreadLimit)
+	];
 	try {
-		if (providedSizes && providedSizes.length !== positionIdList.length) throw new PanopticError("simulateSettle: positionSizes length must match positionIdList");
-		const positionSizes = providedSizes ?? await getCurrentPositionSizes({
-			client,
-			poolAddress,
-			account,
-			positionIdList,
-			blockNumber: targetBlockNumber
-		});
-		const tickAndSpreadLimits = positionIdList.map(() => [
-			-887272n,
-			887272n,
-			0n
-		]);
+		const finalPositionIdList = positionIdList.filter((id) => id !== tokenId);
 		const callData = encodeFunctionData({
 			abi: panopticPoolV2Abi,
 			functionName: "dispatch",
 			args: [
-				positionIdList,
-				finalPositionIdList ?? positionIdList,
-				positionSizes.map((s) => BigInt(s)),
-				tickAndSpreadLimits.map((t) => [
-					Number(t[0]),
-					Number(t[1]),
-					Number(t[2])
-				]),
-				false,
-				0n
+				[tokenId],
+				finalPositionIdList,
+				[0n],
+				[tickLimits$1],
+				usePremiaAsCollateral,
+				builderCode
 			]
 		});
 		const flowResult = await simulateWithTokenFlow({
@@ -7559,23 +5974,16 @@ async function simulateSettle(params) {
 		});
 		if (!flowResult.success || !flowResult.tokenFlow) throw flowResult.rawError ?? new PanopticError(flowResult.error || "Token flow simulation failed");
 		const tokenFlow = flowResult.tokenFlow;
-		let forfeitAmounts;
-		if (tokenId !== void 0) forfeitAmounts = await computeForfeitAmounts({
-			client,
-			poolAddress,
-			account,
-			positionIdList,
-			tokenId,
-			dispatchCallData: callData,
-			blockNumber: targetBlockNumber
-		});
 		const _meta = await metaPromise;
 		const data = {
-			premiaReceived0: tokenFlow.delta0,
-			premiaReceived1: tokenFlow.delta1,
+			amount0Received: tokenFlow.delta0,
+			amount1Received: tokenFlow.delta1,
+			premiaCollected0: null,
+			premiaCollected1: null,
 			postCollateral0: tokenFlow.balanceAfter0,
 			postCollateral1: tokenFlow.balanceAfter1,
-			forfeitAmounts
+			realizedPnL0: null,
+			realizedPnL1: null
 		};
 		return {
 			success: true,
@@ -7593,95 +6001,17 @@ async function simulateSettle(params) {
 		};
 	}
 }
-/**
-* Compute forfeit amounts by chaining dispatch + getFullPositionsData
-* in a single PanopticPool.multicall.
-*/
-async function computeForfeitAmounts(params) {
-	const { client, poolAddress, account, tokenId, dispatchCallData, blockNumber } = params;
-	const feesCallAvailable = encodeFunctionData({
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			false,
-			[tokenId]
-		]
-	});
-	const feesCallTotal = encodeFunctionData({
-		abi: panopticPoolV2Abi,
-		functionName: "getFullPositionsData",
-		args: [
-			account,
-			true,
-			[tokenId]
-		]
-	});
-	try {
-		const { result } = await client.simulateContract({
-			address: poolAddress,
-			abi: multicallAbi,
-			functionName: "multicall",
-			args: [[
-				dispatchCallData,
-				feesCallAvailable,
-				feesCallTotal
-			]],
-			account,
-			blockNumber
-		});
-		const decodeFeesResult = (data) => {
-			return decodeFunctionResult({
-				abi: panopticPoolV2Abi,
-				functionName: "getFullPositionsData",
-				data
-			})[0];
-		};
-		const availablePremium = decodeFeesResult(result[1]);
-		const totalPremium = decodeFeesResult(result[2]);
-		const available0 = availablePremium & BIT_MASK_128;
-		const available1 = availablePremium >> 128n;
-		const total0 = totalPremium & BIT_MASK_128;
-		const total1 = totalPremium >> 128n;
-		return [total0 - available0, total1 - available1];
-	} catch (error) {
-		throw new PanopticError("Forfeit amount computation failed", error instanceof Error ? error : void 0);
-	}
-}
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateSettlePremiumFrom.ts
-/** Soft-failure revert markers for settle premium (target-state issues, not caller errors). */
-const SOFT_FAILURES = [
-	{
-		marker: "AccountInsolvent",
-		reason: "Target account is insolvent; premium cannot be settled"
-	},
-	{
-		marker: "PositionNotOwned",
-		reason: "Target account no longer owns the position"
-	},
-	{
-		marker: "StaleOracle",
-		reason: "Oracle price is stale; settlement temporarily unavailable"
-	},
-	{
-		marker: "InputListFail",
-		reason: "Position list is stale (target positions changed)"
-	}
-];
+//#region src/panoptic/v2/simulations/simulateForceExercise.ts
 /**
-* Simulate settling another account's accumulated long premium via `dispatchFrom`
-* (equal-length `positionIdListTo`/`positionIdListToFinal` selects the settle mode).
-*
-* The measured token flow is the CALLER's collateral delta — i.e. the premium
-* the caller receives from the settlement (for chunks they sold).
+* Simulate a force exercise operation.
 *
 * @param params - Simulation parameters
-* @returns Simulation result with settled premium data or error
+* @returns Simulation result with exercise data or error
 */
-async function simulateSettlePremiumFrom(params) {
-	const { client, poolAddress, account, user, positionIdListFrom, positionIdList, tokenId, blockNumber } = params;
+async function simulateForceExercise(params) {
+	const { client, poolAddress, account, user, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
@@ -7697,65 +6027,39 @@ async function simulateSettlePremiumFrom(params) {
 		tickBefore: null,
 		tickAfter: null
 	};
-	const softFailure = (errorMessage) => {
-		const match = SOFT_FAILURES.find(({ marker }) => errorMessage.includes(marker));
-		return match ? {
-			premium0: 0n,
-			premium1: 0n,
-			settled0: 0n,
-			settled1: 0n,
-			canSettle: false,
-			reason: match.reason
-		} : null;
-	};
 	try {
-		const orderedList = tokenId !== void 0 ? orderListForSettle(positionIdList, tokenId) : positionIdList;
 		const callData = encodeFunctionData({
 			abi: panopticPoolV2Abi,
 			functionName: "dispatchFrom",
 			args: [
 				positionIdListFrom,
 				user,
-				orderedList,
-				orderedList,
+				positionIdListTo,
+				positionIdListToFinal,
 				0n
 			]
 		});
-		const availablePremiumCallData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				account,
-				false,
-				positionIdListFrom
-			]
-		});
-		const buyerOwedCallData = encodeFunctionData({
-			abi: panopticPoolV2Abi,
-			functionName: "getFullPositionsData",
-			args: [
-				user,
-				true,
-				orderedList
-			]
-		});
 		const flowResult = await simulateWithTokenFlow({
 			client,
 			poolAddress,
 			user: account,
 			callData,
-			blockNumber: targetBlockNumber,
-			preCallData: [availablePremiumCallData, buyerOwedCallData],
-			postCallData: [availablePremiumCallData, buyerOwedCallData]
+			blockNumber: targetBlockNumber
 		});
 		if (!flowResult.success || !flowResult.tokenFlow) {
 			const errorMessage = flowResult.error || "Simulation failed";
-			const soft = softFailure(errorMessage);
-			if (soft) {
+			const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
+			if (isNotExercisable) {
 				const _meta$1 = await metaPromise;
+				const data$1 = {
+					exerciseFee0: 0n,
+					exerciseFee1: 0n,
+					canExercise: false,
+					reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
+				};
 				return {
 					success: true,
-					data: soft,
+					data: data$1,
 					gasEstimate: 0n,
 					tokenFlow: emptyTokenFlow,
 					_meta: _meta$1
@@ -7765,47 +6069,10 @@ async function simulateSettlePremiumFrom(params) {
 		}
 		const _meta = await metaPromise;
 		const tokenFlow = flowResult.tokenFlow;
-		const decodePremia = (raw) => {
-			const [shortPremiumPacked, longPremiumPacked] = decodeFunctionResult({
-				abi: panopticPoolV2Abi,
-				functionName: "getFullPositionsData",
-				data: raw
-			});
-			const short = decodeLeftRightUnsigned(shortPremiumPacked);
-			const long = decodeLeftRightUnsigned(longPremiumPacked);
-			return {
-				short0: short.right,
-				short1: short.left,
-				long0: long.right,
-				long1: long.left
-			};
-		};
-		let premium0 = 0n;
-		let premium1 = 0n;
-		const preRaw = flowResult.preCallResults?.[0];
-		const postRaw = flowResult.postCallResults?.[0];
-		if (preRaw !== void 0 && postRaw !== void 0) {
-			const pre = decodePremia(preRaw);
-			const post = decodePremia(postRaw);
-			premium0 = post.short0 > pre.short0 ? post.short0 - pre.short0 : 0n;
-			premium1 = post.short1 > pre.short1 ? post.short1 - pre.short1 : 0n;
-		}
-		let settled0 = 0n;
-		let settled1 = 0n;
-		const preBuyerRaw = flowResult.preCallResults?.[1];
-		const postBuyerRaw = flowResult.postCallResults?.[1];
-		if (preBuyerRaw !== void 0 && postBuyerRaw !== void 0) {
-			const pre = decodePremia(preBuyerRaw);
-			const post = decodePremia(postBuyerRaw);
-			settled0 = pre.long0 > post.long0 ? pre.long0 - post.long0 : 0n;
-			settled1 = pre.long1 > post.long1 ? pre.long1 - post.long1 : 0n;
-		}
 		const data = {
-			premium0,
-			premium1,
-			settled0,
-			settled1,
-			canSettle: true
+			exerciseFee0: tokenFlow.delta0,
+			exerciseFee1: tokenFlow.delta1,
+			canExercise: true
 		};
 		return {
 			success: true,
@@ -7817,14 +6084,22 @@ async function simulateSettlePremiumFrom(params) {
 	} catch (error) {
 		const _meta = await metaPromise;
 		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
-		const soft = softFailure(errorMessage);
-		if (soft) return {
-			success: true,
-			data: soft,
-			gasEstimate: 0n,
-			tokenFlow: emptyTokenFlow,
-			_meta
-		};
+		const isNotExercisable = errorMessage.includes("NoLegsExercisable") || errorMessage.includes("NotALongLeg");
+		if (isNotExercisable) {
+			const data = {
+				exerciseFee0: 0n,
+				exerciseFee1: 0n,
+				canExercise: false,
+				reason: errorMessage.includes("NoLegsExercisable") ? "No legs are exercisable (not ITM)" : "Position does not have a long leg"
+			};
+			return {
+				success: true,
+				data,
+				gasEstimate: 0n,
+				tokenFlow: emptyTokenFlow,
+				_meta
+			};
+		}
 		return {
 			success: false,
 			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
@@ -7834,89 +6109,41 @@ async function simulateSettlePremiumFrom(params) {
 }
 
 //#endregion
-//#region src/panoptic/v2/simulations/simulateSettlePremiumBatch.ts
+//#region src/panoptic/v2/simulations/simulateLiquidate.ts
 /**
-* Simulate settling each target buyer's owed long premium, all at one block.
-*
-* Individual failures (insolvent buyer, stale list, …) are soft: the target
-* lands in the unsettleable partition instead of failing the batch. Only
-* unexpected errors reject.
+* Simulate a liquidation operation.
 *
 * @param params - Simulation parameters
-* @returns Partitioned targets with per-target premium and totals
+* @returns Simulation result with liquidation data or error
 */
-async function simulateSettlePremiumBatch(params) {
-	const { client, poolAddress, account, positionIdListFrom, targets, blockNumber } = params;
+async function simulateLiquidate(params) {
+	const { client, poolAddress, account, liquidatee, positionIdListFrom, positionIdListTo, positionIdListToFinal, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	});
-	const simulations = await Promise.all(targets.map((target) => simulateSettlePremiumFrom({
-		client,
-		poolAddress,
-		account,
-		user: target.user,
-		positionIdListFrom,
-		positionIdList: target.positionIdList,
-		tokenId: target.tokenId,
-		blockNumber: targetBlockNumber
-	})));
-	const results = [];
-	const settleable = [];
-	let unsettleableCount = 0;
-	let premium0 = 0n;
-	let premium1 = 0n;
-	simulations.forEach((sim, i) => {
-		const simulation = sim.success ? sim.data : {
-			premium0: 0n,
-			premium1: 0n,
-			settled0: 0n,
-			settled1: 0n,
-			canSettle: false,
-			reason: sim.error.message
-		};
-		results.push({
-			target: targets[i],
-			simulation
-		});
-		if (simulation.canSettle) {
-			settleable.push(targets[i]);
-			premium0 += simulation.premium0;
-			premium1 += simulation.premium1;
-		} else unsettleableCount += 1;
-	});
-	const _meta = await metaPromise;
-	return {
-		results,
-		settleable,
-		unsettleableCount,
-		premium0,
-		premium1,
-		_meta
+	const emptyTokenFlow = {
+		delta0: 0n,
+		delta1: 0n,
+		balanceBefore0: 0n,
+		balanceBefore1: 0n,
+		balanceAfter0: 0n,
+		balanceAfter1: 0n,
+		tickBefore: null,
+		tickAfter: null
 	};
-}
-/**
-* Simulate a full settle sequence (all settles + optional close) as the one
-* multicall that `executeSettleSequence` submits, measuring the caller's
-* total token flow and gas.
-*
-* @param params - Simulation parameters
-* @returns Simulation result with the caller's net flow, or error
-*/
-async function simulateSettleSequence(params) {
-	const { client, poolAddress, account, blockNumber } = params;
-	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
-	const metaPromise = getBlockMeta({
-		client,
-		blockNumber: targetBlockNumber
-	});
 	try {
-		const calls = buildSettleSequenceCalls(params);
 		const callData = encodeFunctionData({
 			abi: panopticPoolV2Abi,
-			functionName: "multicall",
-			args: [calls]
+			functionName: "dispatchFrom",
+			args: [
+				positionIdListFrom,
+				liquidatee,
+				positionIdListTo,
+				positionIdListToFinal,
+				0n
+			]
 		});
 		const flowResult = await simulateWithTokenFlow({
 			client,
@@ -7925,15 +6152,43 @@ async function simulateSettleSequence(params) {
 			callData,
 			blockNumber: targetBlockNumber
 		});
-		if (!flowResult.success || !flowResult.tokenFlow) throw new PanopticError(flowResult.error || "Simulation failed");
+		if (!flowResult.success || !flowResult.tokenFlow) {
+			const errorMessage = flowResult.error || "Simulation failed";
+			const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
+			if (isNotLiquidatable) {
+				const _meta$1 = await metaPromise;
+				const data$1 = {
+					bonus0: 0n,
+					bonus1: 0n,
+					positionsClosed: [],
+					isLiquidatable: false,
+					shortfall0: 0n,
+					shortfall1: 0n
+				};
+				return {
+					success: true,
+					data: data$1,
+					gasEstimate: 0n,
+					tokenFlow: emptyTokenFlow,
+					_meta: _meta$1
+				};
+			}
+			throw new PanopticError(errorMessage);
+		}
 		const _meta = await metaPromise;
 		const tokenFlow = flowResult.tokenFlow;
+		const positionsClosed = positionIdListTo.filter((id) => !positionIdListToFinal.includes(id));
+		const data = {
+			bonus0: tokenFlow.delta0 > 0n ? tokenFlow.delta0 : 0n,
+			bonus1: tokenFlow.delta1 > 0n ? tokenFlow.delta1 : 0n,
+			positionsClosed,
+			isLiquidatable: true,
+			shortfall0: 0n,
+			shortfall1: 0n
+		};
 		return {
 			success: true,
-			data: {
-				delta0: tokenFlow.delta0,
-				delta1: tokenFlow.delta1
-			},
+			data,
 			gasEstimate: flowResult.gasEstimate,
 			tokenFlow,
 			_meta
@@ -7941,6 +6196,24 @@ async function simulateSettleSequence(params) {
 	} catch (error) {
 		const _meta = await metaPromise;
 		const errorMessage = error instanceof Error ? error.message : "Simulation failed";
+		const isNotLiquidatable = errorMessage.includes("NotMarginCalled") || errorMessage.includes("AccountInsolvent");
+		if (isNotLiquidatable) {
+			const data = {
+				bonus0: 0n,
+				bonus1: 0n,
+				positionsClosed: [],
+				isLiquidatable: false,
+				shortfall0: 0n,
+				shortfall1: 0n
+			};
+			return {
+				success: true,
+				data,
+				gasEstimate: 0n,
+				tokenFlow: emptyTokenFlow,
+				_meta
+			};
+		}
 		return {
 			success: false,
 			error: error instanceof PanopticError ? error : new PanopticError(errorMessage, error instanceof Error ? error : void 0),
@@ -9954,6 +8227,441 @@ function createEventPoller(params) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/strike/ladder.ts
+/** Target number of rungs across a leg's full range (lower tick → upper tick). */
+const STRIKE_LADDER_TARGET_STRIKES = 16n;
+/** Nice increment mantissas, in tenths (1, 2.5, 5) × 10ⁿ. */
+const NICE_MANTISSAS_TENTHS = [
+	10n,
+	25n,
+	50n
+];
+/** Upper bound on rung hops when searching for a tick-changing step. */
+const MAX_STEP_ITERATIONS = 512;
+/** Decimal precision used when rendering exact tick prices as strings. */
+const PRICE_PRECISION = 30n;
+function floorDiv(a, b) {
+	const q = a / b;
+	return a % b !== 0n && a < 0n !== b < 0n ? q - 1n : q;
+}
+function floorMod(a, b) {
+	return a - floorDiv(a, b) * b;
+}
+function ceilDiv(a, b) {
+	return -floorDiv(-a, b);
+}
+/** round(a / b) to nearest, ties up. */
+function roundDiv(a, b) {
+	return floorDiv(2n * a + b, 2n * b);
+}
+function pow10(exp) {
+	let result = 1n;
+	for (let i = 0n; i < exp; i++) result *= 10n;
+	return result;
+}
+function gcd(a, b) {
+	a = a < 0n ? -a : a;
+	b = b < 0n ? -b : b;
+	while (b !== 0n) [a, b] = [b, a % b];
+	return a;
+}
+function reduce(f) {
+	const g = gcd(f.numerator, f.denominator);
+	return g <= 1n ? f : {
+		numerator: f.numerator / g,
+		denominator: f.denominator / g
+	};
+}
+function fromBigint(n) {
+	return {
+		numerator: n,
+		denominator: 1n
+	};
+}
+function mul(a, b) {
+	return reduce({
+		numerator: a.numerator * b.numerator,
+		denominator: a.denominator * b.denominator
+	});
+}
+function add(a, b) {
+	return reduce({
+		numerator: a.numerator * b.denominator + b.numerator * a.denominator,
+		denominator: a.denominator * b.denominator
+	});
+}
+function sub(a, b) {
+	return add(a, {
+		numerator: -b.numerator,
+		denominator: b.denominator
+	});
+}
+/** -1 | 0 | 1 comparing a to b. */
+function cmp(a, b) {
+	const l = a.numerator * b.denominator;
+	const r = b.numerator * a.denominator;
+	return l === r ? 0 : l < r ? -1 : 1;
+}
+const LADDER_MIN = fromBigint(1n);
+/** Largest normalised price on the ladder. Prices above are "outside". */
+const LADDER_MAX = fromBigint(1000000n);
+function parseDecimal(value) {
+	const trimmed = value.trim();
+	const [basePart, exponentPart] = trimmed.toLowerCase().split("e");
+	const [integerStr, fractionalStr = ""] = basePart.split(".");
+	let numerator = BigInt(`${integerStr === "" ? "0" : integerStr}${fractionalStr}`);
+	let denominator = pow10(BigInt(fractionalStr.length));
+	if (exponentPart !== void 0 && exponentPart !== "") {
+		const exponent = BigInt(exponentPart);
+		if (exponent > 0n) numerator *= pow10(exponent);
+		else if (exponent < 0n) denominator *= pow10(-exponent);
+	}
+	if (numerator <= 0n) throw new Error("Price must be positive");
+	return reduce({
+		numerator,
+		denominator
+	});
+}
+/** Render a positive fraction as a decimal string with trailing zeros trimmed. */
+function fractionToDecimal(f, precision) {
+	const scaled = f.numerator * pow10(precision) / f.denominator;
+	const digits = scaled.toString().padStart(Number(precision) + 1, "0");
+	const intPart = digits.slice(0, digits.length - Number(precision));
+	const fracPart = digits.slice(digits.length - Number(precision)).replace(/0+$/, "");
+	return fracPart.length === 0 ? intPart : `${intPart}.${fracPart}`;
+}
+/** 10^k as an exact fraction, k may be negative. */
+function powerOfTen(k) {
+	return k >= 0n ? fromBigint(pow10(k)) : {
+		numerator: 1n,
+		denominator: pow10(-k)
+	};
+}
+/** floor(log10(f)) for a positive fraction. */
+function floorLog10(f) {
+	let e = BigInt(f.numerator.toString().length - f.denominator.toString().length);
+	while (cmp(f, powerOfTen(e)) < 0) e -= 1n;
+	while (cmp(f, powerOfTen(e + 1n)) >= 0) e += 1n;
+	return e;
+}
+function orientTick(tick, orient) {
+	return orient.asset === 0n ? tick : -tick;
+}
+/** Exact-enough price of `tick` in the caller's orientation. */
+function tickToOrientedPrice(tick, orient) {
+	const price = tickToPriceDecimalScaled(orientTick(tick, orient), orient.assetDecimals, orient.quoteDecimals, PRICE_PRECISION);
+	return parseDecimal(price);
+}
+/** Nearest integer tick for a caller-oriented decimal price. */
+function orientedPriceToTick(price, orient) {
+	const t = priceToTick(price, orient.assetDecimals, orient.quoteDecimals);
+	return orientTick(t, orient);
+}
+/**
+* Relative rung step for a leg: `1.0001^(round(width·tickSpacing / TARGET)) − 1`.
+* Rungs scale with price (they are multiples of a price-proportional increment), so
+* spacing them by the range's TARGET-th root yields ≈TARGET rungs across the range
+* regardless of how wide it is.
+*/
+function relativeStep(width, tickSpacing) {
+	validateGeometry(width, tickSpacing);
+	const ticks = roundDiv(width * tickSpacing, STRIKE_LADDER_TARGET_STRIKES);
+	const ratio = parseDecimal(tickToPriceDecimalScaled(ticks < 1n ? 1n : ticks, 0n, 0n, PRICE_PRECISION));
+	return sub(ratio, fromBigint(1n));
+}
+/** Nice increment `m × 10ⁿ` (m ∈ {1, 2.5, 5}) with the smallest log-distance to `raw`. */
+function niceIncrement(raw) {
+	const e = floorLog10(raw);
+	const scale = (tenths) => mul(fromBigint(tenths), powerOfTen(e - 1n));
+	const candidates = [...NICE_MANTISSAS_TENTHS.map(scale), scale(100n)];
+	let lo = candidates[0] ?? powerOfTen(e);
+	for (const hi of candidates.slice(1)) {
+		if (cmp(raw, hi) < 0) return cmp(mul(raw, raw), mul(lo, hi)) <= 0 ? lo : hi;
+		lo = hi;
+	}
+	return lo;
+}
+/** Rung increment at normalised price `p` for the given relative step. */
+function incrementAt(p, rf) {
+	return niceIncrement(mul(p, rf));
+}
+/** Normalise a price to `max(p, 1/p)` and remember whether it was inverted. */
+function normalise(price) {
+	if (price.numerator >= price.denominator) return {
+		value: price,
+		reciprocal: false
+	};
+	return {
+		value: {
+			numerator: price.denominator,
+			denominator: price.numerator
+		},
+		reciprocal: true
+	};
+}
+/** Is `r` a multiple of `inc`? */
+function isMultiple(r, inc) {
+	return r.numerator * inc.denominator % (r.denominator * inc.numerator) === 0n;
+}
+/** Smallest multiple of `inc` strictly greater than `x`. */
+function ceilMultipleStrict(x, inc) {
+	const k = floorDiv(x.numerator * inc.denominator, x.denominator * inc.numerator) + 1n;
+	return mul(fromBigint(k), inc);
+}
+/** Largest multiple of `inc` strictly smaller than `x`. */
+function floorMultipleStrict(x, inc) {
+	const k = ceilDiv(x.numerator * inc.denominator, x.denominator * inc.numerator) - 1n;
+	return mul(fromBigint(k), inc);
+}
+/**
+* The rung set is `{ r : r is a multiple of incrementAt(r) }`. Because the
+* increment grows with price, a multiple of a finer increment can land inside a
+* coarser band where it is no longer a rung; these helpers push such a candidate
+* up/down until it is a multiple of its own band's increment.
+*/
+function isRung(r, rf) {
+	return r.numerator > 0n && isMultiple(r, incrementAt(r, rf));
+}
+function fixUp(c, rf) {
+	for (let i = 0; i < 64 && !isRung(c, rf); i++) c = ceilMultipleStrict(c, incrementAt(c, rf));
+	return c;
+}
+function fixDown(c, rf) {
+	for (let i = 0; i < 64 && c.numerator > 0n && !isRung(c, rf); i++) c = floorMultipleStrict(c, incrementAt(c, rf));
+	return c;
+}
+/** Smallest rung strictly above `x` (may exceed the ladder top). */
+function nextRungAbove(x, rf) {
+	const incHere = incrementAt(x, rf);
+	const incs = [incHere, incrementAt(add(x, incHere), rf)];
+	let best = null;
+	for (const inc of incs) {
+		const c = fixUp(ceilMultipleStrict(x, inc), rf);
+		if (cmp(c, x) > 0 && (best === null || cmp(c, best) < 0)) best = c;
+	}
+	if (best === null) throw new PanopticValidationError("No ladder rung above price");
+	return best;
+}
+/** Largest rung strictly below `x` (may fall below the ladder floor). */
+function prevRungBelow(x, rf) {
+	const incHere = incrementAt(x, rf);
+	const finer = incrementAt(sub(x, incHere), rf);
+	let best = null;
+	for (const inc of [incHere, finer]) {
+		const c = fixDown(floorMultipleStrict(x, inc), rf);
+		if (c.numerator > 0n && cmp(c, x) < 0 && (best === null || cmp(c, best) > 0)) best = c;
+	}
+	return best ?? fromBigint(0n);
+}
+/** Nearest rung price to a normalised price, or null when above the ladder. */
+function nearestRungPrice(normalised, rf) {
+	let rung;
+	if (isRung(normalised, rf)) rung = normalised;
+	else {
+		const up = nextRungAbove(normalised, rf);
+		const down = prevRungBelow(normalised, rf);
+		if (down.numerator <= 0n) rung = up;
+		else rung = cmp(sub(normalised, down), sub(up, normalised)) <= 0 ? down : up;
+	}
+	if (cmp(rung, LADDER_MIN) < 0) rung = LADDER_MIN;
+	if (cmp(rung, LADDER_MAX) > 0) return null;
+	return rung;
+}
+/** Step one rung up (+1) or down (-1) on the normalised ladder. Null when leaving it. */
+function stepRungPrice(rung, direction, rf) {
+	const next = direction > 0n ? nextRungAbove(rung, rf) : prevRungBelow(rung, rf);
+	if (cmp(next, LADDER_MIN) < 0 || cmp(next, LADDER_MAX) > 0) return null;
+	return next;
+}
+/** Nominal caller-oriented price of a rung as an exact fraction. */
+function rungToPrice(rung) {
+	return rung.reciprocal ? {
+		numerator: rung.price.denominator,
+		denominator: rung.price.numerator
+	} : rung.price;
+}
+function rungToPriceString(rung) {
+	return fractionToDecimal(rungToPrice(rung), PRICE_PRECISION);
+}
+function nearestRung(price, rf) {
+	const { value, reciprocal } = normalise(price);
+	const p = nearestRungPrice(value, rf);
+	return p === null ? null : {
+		price: p,
+		reciprocal
+	};
+}
+/**
+* Step a rung in the caller's price direction. For reciprocal quotes a higher
+* caller price is a lower normalised price, so the direction flips.
+*/
+function stepRung(rung, direction, rf) {
+	const normalisedDir = rung.reciprocal ? direction > 0n ? -1n : 1n : direction;
+	const p = stepRungPrice(rung.price, normalisedDir, rf);
+	return p === null ? null : {
+		price: p,
+		reciprocal: rung.reciprocal
+	};
+}
+/** Reject geometry the ladder cannot place: non-positive inputs or a span wider than the tick domain. */
+function validateGeometry(width, tickSpacing) {
+	if (width <= 0n) throw new PanopticValidationError("width must be positive");
+	if (tickSpacing <= 0n) throw new PanopticValidationError("tickSpacing must be positive");
+	if (width * tickSpacing > MAX_TICK - MIN_TICK) throw new PanopticValidationError("width * tickSpacing exceeds the tick domain");
+}
+/** `rangeDown`/`rangeUp` exactly as `PanopticMath.getRangesFromStrike`. */
+function rangesFromStrike(width, tickSpacing) {
+	const span = width * tickSpacing;
+	return {
+		rangeDown: span / 2n,
+		rangeUp: ceilDiv(span, 2n)
+	};
+}
+/**
+* Nearest valid strike tick to `exactTick` for `width`/`tickSpacing`.
+* Valid strikes satisfy `strike ≡ rangeDown (mod tickSpacing)`; the result is
+* shifted in whole tick spacings so the leg's ticks stay within `[MIN_TICK, MAX_TICK]`.
+*/
+function canonicalStrikeForWidth(exactTick, width, tickSpacing) {
+	validateGeometry(width, tickSpacing);
+	const { rangeDown, rangeUp } = rangesFromStrike(width, tickSpacing);
+	const offset = floorMod(rangeDown, tickSpacing);
+	let strike = roundDiv(exactTick - offset, tickSpacing) * tickSpacing + offset;
+	while (strike - rangeDown < MIN_TICK) strike += tickSpacing;
+	while (strike + rangeUp > MAX_TICK) strike -= tickSpacing;
+	return strike;
+}
+function rungToStrike(rung, geom) {
+	const nominalPrice = rungToPriceString(rung);
+	const exactTick = orientedPriceToTick(nominalPrice, geom.orient);
+	return {
+		tick: canonicalStrikeForWidth(exactTick, geom.width, geom.tickSpacing),
+		nominalPrice
+	};
+}
+function classifyTick(tick, geom, rf) {
+	const rung = nearestRung(tickToOrientedPrice(tick, geom.orient), rf);
+	if (rung === null) return { kind: "outside-ladder" };
+	const canonical = rungToStrike(rung, geom);
+	return canonical.tick === tick ? {
+		kind: "ladder",
+		nominalPrice: canonical.nominalPrice
+	} : { kind: "off-ladder" };
+}
+/**
+* A rung's canonical tick is only usable when that tick classifies back to the
+* same rung (`classifyStrike` → 'ladder'). When rungs are finer than the tick
+* grid two rungs can share a tick and only one of them "owns" it; return the
+* owner's strike, or null when this rung does not own its tick.
+*/
+function ownedStrike(rung, geom, rf) {
+	const strike = rungToStrike(rung, geom);
+	const cls = classifyTick(strike.tick, geom, rf);
+	return cls.kind === "ladder" ? {
+		tick: strike.tick,
+		nominalPrice: cls.nominalPrice
+	} : null;
+}
+/**
+* Classify a strike tick against the ladder for its width.
+*
+* - `ladder`: the tick is the canonical tick of its nearest rung → show `nominalPrice`.
+* - `off-ladder`: an in-range tick that is not a rung's canonical tick (e.g. real AMM
+*   liquidity at an arbitrary strike) → show the exact price.
+* - `outside-ladder`: the normalised price exceeds 1,000,000 → legacy behaviour.
+*/
+function classifyStrike(params) {
+	return classifyTick(params.tick, params, relativeStep(params.width, params.tickSpacing));
+}
+/**
+* Resolve a tick to a ladder strike.
+*
+* - `step` 0 (default): the ladder tick nearest to `tick` (the tick's own rung when
+*   it owns one, otherwise the closest owned neighbour).
+* - `step` ±1: the nearest ladder tick strictly beyond `tick` in that price direction
+*   (rungs finer than the tick grid can collapse onto one tick, so a single rung hop
+*   may not move the strike).
+*
+* Returns null when the target lies outside the ladder (normalised price > 1e6).
+*/
+function resolveLadderStrike(params) {
+	const step = params.step ?? 0n;
+	const rf = relativeStep(params.width, params.tickSpacing);
+	const start = nearestRung(tickToOrientedPrice(params.tick, params.orient), rf);
+	if (start === null) return null;
+	const startOriented = orientTick(params.tick, params.orient);
+	if (step === 0n) {
+		const own = ownedStrike(start, params, rf);
+		if (own !== null) return own;
+		let lo = start;
+		let hi = start;
+		for (let i = 0; i < MAX_STEP_ITERATIONS; i++) {
+			lo = lo === null ? null : stepRung(lo, -1n, rf);
+			hi = hi === null ? null : stepRung(hi, 1n, rf);
+			const a = lo === null ? null : ownedStrike(lo, params, rf);
+			const b = hi === null ? null : ownedStrike(hi, params, rf);
+			if (a !== null && b !== null) {
+				const da = startOriented - orientTick(a.tick, params.orient);
+				const db = orientTick(b.tick, params.orient) - startOriented;
+				return da <= db ? a : b;
+			}
+			if (a !== null) return a;
+			if (b !== null) return b;
+			if (lo === null && hi === null) return null;
+		}
+		return null;
+	}
+	let rung = start;
+	for (let i = 0; i < MAX_STEP_ITERATIONS && rung !== null; i++) {
+		const own = ownedStrike(rung, params, rf);
+		if (own !== null) {
+			const oriented = orientTick(own.tick, params.orient);
+			if (step > 0n ? oriented > startOriented : oriented < startOriented) return own;
+		}
+		rung = stepRung(rung, step, rf);
+	}
+	return null;
+}
+/**
+* Generate up to `count` ladder strikes centred on `centerTick`, sorted by
+* ascending caller price and deduplicated by tick. Rungs beyond the ladder are
+* omitted (the result may be shorter than `count`). Returns null when the
+* centre itself lies outside the ladder and `[]` when `count` is 0.
+*/
+function ladderStrikeSequence(params) {
+	const rf = relativeStep(params.width, params.tickSpacing);
+	if (params.count <= 0) return [];
+	const center = nearestRung(tickToOrientedPrice(params.centerTick, params.orient), rf);
+	if (center === null) return null;
+	const half = Math.floor(params.count / 2);
+	const below = [];
+	const above = [];
+	let r = center;
+	for (let i = 0; i < half && r !== null; i++) {
+		r = stepRung(r, -1n, rf);
+		if (r !== null) below.push(r);
+	}
+	r = center;
+	for (let i = 0; i < params.count - half - 1 && r !== null; i++) {
+		r = stepRung(r, 1n, rf);
+		if (r !== null) above.push(r);
+	}
+	const seen = new Set();
+	const out = [];
+	for (const rung of [
+		...below.reverse(),
+		center,
+		...above
+	]) {
+		const strike = ownedStrike(rung, params, rf);
+		if (strike === null || seen.has(strike.tick)) continue;
+		seen.add(strike.tick);
+		out.push(strike);
+	}
+	return out;
+}
+
 //#endregion
 //#region src/panoptic/v2/bot/index.ts
 /**
@@ -10183,4 +8891,4 @@ function isGasError(error) {
 }
 
 //#endregion
-export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, REQUIRED_BASE_ERROR_SENTINEL, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateSpreadWad, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, createPoolFormatters, decodePanopticTokenURI, deriveUniqueTokenId, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPoolIdHex, formatRatioPercent, formatTimestamp, formatTimestampLocale, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWei, generateOverlappingTokenIds, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getAccountPremia, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getForfeitablePremium, getGuardianUnlockState, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolDisplayId, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionsWithPremia, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTokenListId, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseBps, parseCollateralLog, parsePoolLog, parseTokenListId, planDeriveStrategy, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, removeTrackedChunks, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scanChunks, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSettlePremiumBatch, simulateSettlePremiumFrom, simulateSettleSequence, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, splitTokenIdByTimescale, truncateAddress, watchEvents };
+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 };