@panoptic-eng/sdk 1.0.31 → 1.0.33

package/dist/{v2-D3B5BKml.js → v2-B68I6nwv.js}

@@ -1,8 +1,8 @@
-import { formatTokenAmount$1 as formatTokenAmount, getAccountCollateral$1 as getAccountCollateral, panopticQueryAbi, parseTokenAmount$1 as parseTokenAmount, readBlockAndAggregate, requireReturnData } from "./irm-iAI9hTYQ.js";
-import { AccountInsolventError$1 as AccountInsolventError, ChunkLimitError$1 as ChunkLimitError, DEFAULT_VEGOID$1 as DEFAULT_VEGOID, InvalidHistoryRangeError$1 as InvalidHistoryRangeError, NotEnoughTokensError$1 as NotEnoughTokensError, PanopticError, PanopticValidationError$1 as PanopticValidationError, StorageDataNotFoundError, collateralTrackerV2Abi, decodeLeftRightSigned$1 as decodeLeftRightSigned, decodeLeftRightUnsigned$1 as decodeLeftRightUnsigned, decodePosition, decodePositionBalance, decodeTickSpacing$1 as decodeTickSpacing, getBlockMeta$1 as getBlockMeta, getPool, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi$1, parsePanopticError$1 as parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./position-ClU7GrTa.js";
+import { StateViewAbi, formatTokenAmount$1 as formatTokenAmount, getAccountCollateral$1 as getAccountCollateral, panopticQueryAbi, parseTokenAmount$1 as parseTokenAmount, readBlockAndAggregate, requireReturnData } from "./irm-JPcV9ykY.js";
+import { AccountInsolventError$1 as AccountInsolventError, ChunkLimitError$1 as ChunkLimitError, DEFAULT_VEGOID$1 as DEFAULT_VEGOID, InvalidHistoryRangeError$1 as InvalidHistoryRangeError, NotEnoughTokensError$1 as NotEnoughTokensError, PanopticError, PanopticValidationError$1 as PanopticValidationError, StorageDataNotFoundError, WrongUniswapPoolError$1 as WrongUniswapPoolError, collateralTrackerV2Abi, decodeLeftRightSigned$1 as decodeLeftRightSigned, decodeLeftRightUnsigned$1 as decodeLeftRightUnsigned, decodePosition, decodePositionBalance, decodeTickSpacing$1 as decodeTickSpacing, getBlockMeta$1 as getBlockMeta, getPool, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi$1, parsePanopticError$1 as parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./position-C8rkkKhi.js";
 import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, WAD, calculatePositionDelta, calculatePositionGamma, calculatePositionValue, priceToTick, sqrtPriceX96ToTick, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96 } from "./greeks-GysWXct-.js";
-import { addLegToTokenId$1 as addLegToTokenId, buildBatchDispatchArgs$1 as buildBatchDispatchArgs, buildUniqueCredit$1 as buildUniqueCredit, countLegs$1 as countLegs, decodeAllLegs$1 as decodeAllLegs, decodeTokenId$1 as decodeTokenId, getClosedPositionsKey$1 as getClosedPositionsKey, getPendingPositionsKey$1 as getPendingPositionsKey, getPoolMetaKey$1 as getPoolMetaKey, getPositionMetaKey$1 as getPositionMetaKey, getPositionsKey$1 as getPositionsKey, getTrackedChunksKey$1 as getTrackedChunksKey, getTrackedPositionIds$1 as getTrackedPositionIds, jsonSerializer$1 as jsonSerializer, loadCheckpoint$1 as loadCheckpoint, resolveTokenIndex$1 as resolveTokenIndex, simulateOpenPosition$1 as simulateOpenPosition, simulateWithTokenFlow } from "./writes-DQLGdkJ5.js";
-import { ContractFunctionExecutionError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, keccak256, zeroAddress } from "viem";
+import { addLegToTokenId$1 as addLegToTokenId, buildBatchDispatchArgs$1 as buildBatchDispatchArgs, buildUniqueCredit$1 as buildUniqueCredit, countLegs$1 as countLegs, createTokenIdBuilder$1 as createTokenIdBuilder, decodeAllLegs$1 as decodeAllLegs, decodeTokenId$1 as decodeTokenId, getClosedPositionsKey$1 as getClosedPositionsKey, getPendingPositionsKey$1 as getPendingPositionsKey, getPoolMetaKey$1 as getPoolMetaKey, getPositionMetaKey$1 as getPositionMetaKey, getPositionsKey$1 as getPositionsKey, getTrackedChunksKey$1 as getTrackedChunksKey, getTrackedPositionIds$1 as getTrackedPositionIds, jsonSerializer$1 as jsonSerializer, loadCheckpoint$1 as loadCheckpoint, resolveTokenIndex$1 as resolveTokenIndex, simulateOpenPosition$1 as simulateOpenPosition, simulateWithTokenFlow } from "./writes-AupZCK4M.js";
+import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, keccak256, toHex, zeroAddress } from "viem";
 import { multicall } from "viem/actions";
 
 //#region src/panoptic/v2/clients/blocksByTimestamp.ts
@@ -203,6 +203,277 @@ function interpolateBlocks(startBlock, endBlock, points) {
 	return Array.from({ length: points }, (_, i) => startBlock + range * BigInt(i) / BigInt(points - 1));
 }
 
+//#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
 /**
@@ -1477,8 +1748,8 @@ async function createFlowNeutralTokenId(params) {
 	if (tickBefore === null) throw new PanopticError("Cannot create flow-neutral position: current tick unavailable");
 	const sqrtPX96 = tickToSqrtPriceX96(tickBefore);
 	const valueAbs = (index, amount) => {
-		const abs = amount < 0n ? -amount : amount;
-		return index === 0n ? abs * sqrtPX96 * sqrtPX96 / Q192$1 : abs;
+		const abs$1 = amount < 0n ? -amount : amount;
+		return index === 0n ? abs$1 * sqrtPX96 * sqrtPX96 / Q192$1 : abs$1;
 	};
 	const flowFor = (index) => index === 0n ? credit.creditAmount0 : credit.creditAmount1;
 	if (queryAddress !== void 0) {
@@ -1596,6 +1867,35 @@ async function getMaxWithdrawable(params) {
 	};
 }
 /**
+* Read the maximum number of shares an account can redeem from a CollateralTracker.
+*
+* This is the ERC4626 `maxRedeem(owner)`, i.e. `min(availableShares, balanceOf(owner))`,
+* and returns 0 when the account has open positions (legs). Redeeming exactly this many
+* shares burns the account's full (available) share balance, so a MAX withdraw leaves no
+* rounding dust — unlike an assets-based `withdraw`, which round-trips shares↔assets.
+*
+* @param params - The parameters
+* @returns Maximum redeemable shares with block metadata
+*/
+async function getMaxRedeem(params) {
+	const { client, collateralTrackerAddress, account, blockNumber } = params;
+	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+	const [maxRedeem, _meta] = await Promise.all([client.readContract({
+		address: collateralTrackerAddress,
+		abi: collateralTrackerV2Abi,
+		functionName: "maxRedeem",
+		args: [account],
+		blockNumber: targetBlockNumber
+	}), getBlockMeta({
+		client,
+		blockNumber: targetBlockNumber
+	})]);
+	return {
+		maxRedeem,
+		_meta
+	};
+}
+/**
 * Try to simulate a solvency-checked withdraw with the given amount.
 */
 async function tryWithdrawSimulation(params) {
@@ -2848,7 +3148,7 @@ function calculateAccountGreeksPure(params) {
 const MIN_TICK$1 = -887272n;
 const MAX_TICK$1 = 887272n;
 const FP96 = 1n << 96n;
-const Q128$1 = 1n << 128n;
+const Q128$3 = 1n << 128n;
 /** Cap for a usage ratio with no collateral behind it. */
 const MAX_USAGE_BPS = 1000000n;
 const bigintMax = (a, b) => a > b ? a : b;
@@ -2866,16 +3166,16 @@ const MINT_BUFFER_DENOMINATOR = 10000000n;
 * Matches the on-chain `PanopticMath.convert0to1` truncation, with an
 * overflow-safe branch when `sqrtPriceX96^2` would not fit in uint256.
 */
-function convert0to1$1(amount, sqrtPriceX96) {
-	if (sqrtPriceX96 < Q128$1) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
+function convert0to1$2(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128$3) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
 	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
 	return amount * sp2Hi >> 128n;
 }
 /**
 * Convert a token1 amount to its token0-equivalent at the given sqrtPriceX96.
 */
-function convert1to0$1(amount, sqrtPriceX96) {
-	if (sqrtPriceX96 < Q128$1) {
+function convert1to0$2(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128$3) {
 		const denom = sqrtPriceX96 * sqrtPriceX96;
 		return amount * (1n << 192n) / denom;
 	}
@@ -3055,10 +3355,10 @@ async function getMarginBuffer(params) {
 	}
 	const sqrtPriceX96 = tickToSqrtPriceX96(currentTick);
 	const denominatedInToken = sqrtPriceX96 < FP96 ? 0 : 1;
-	const currentMargin0 = assets0 + convert1to0$1(assets1, sqrtPriceX96);
-	const requiredMargin0 = required0Native + convert1to0$1(required1Native, sqrtPriceX96);
-	const currentMargin1 = assets1 + convert0to1$1(assets0, sqrtPriceX96);
-	const requiredMargin1 = required1Native + convert0to1$1(required0Native, sqrtPriceX96);
+	const currentMargin0 = assets0 + convert1to0$2(assets1, sqrtPriceX96);
+	const requiredMargin0 = required0Native + convert1to0$2(required1Native, sqrtPriceX96);
+	const currentMargin1 = assets1 + convert0to1$2(assets0, sqrtPriceX96);
+	const requiredMargin1 = required1Native + convert0to1$2(required0Native, sqrtPriceX96);
 	const buffer0 = currentMargin0 - requiredMargin0;
 	const buffer1 = currentMargin1 - requiredMargin1;
 	const bufferPercent0 = requiredMargin0 === 0n ? null : buffer0 * 10000n / requiredMargin0;
@@ -3334,14 +3634,14 @@ async function getCollateralTotalAssetsBatch(client, collateralTrackerAddresses,
 
 //#endregion
 //#region src/panoptic/v2/reads/buyingPower.ts
-const Q128 = 1n << 128n;
-function convert0to1(amount, sqrtPriceX96) {
-	if (sqrtPriceX96 < Q128) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
+const Q128$2 = 1n << 128n;
+function convert0to1$1(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128$2) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
 	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
 	return amount * sp2Hi >> 128n;
 }
-function convert1to0(amount, sqrtPriceX96) {
-	if (sqrtPriceX96 < Q128) {
+function convert1to0$1(amount, sqrtPriceX96) {
+	if (sqrtPriceX96 < Q128$2) {
 		const denom = sqrtPriceX96 * sqrtPriceX96;
 		return amount * (1n << 192n) / denom;
 	}
@@ -3462,10 +3762,10 @@ async function getAccountBuyingPower(params) {
 		}
 	}
 	const sqrtPriceX96 = tickToSqrtPriceX96(currentTick);
-	const collateralBalance0 = assets0 + convert1to0(assets1, sqrtPriceX96);
-	const requiredCollateral0 = required0Native + convert1to0(required1Native, sqrtPriceX96);
-	const collateralBalance1 = assets1 + convert0to1(assets0, sqrtPriceX96);
-	const requiredCollateral1 = required1Native + convert0to1(required0Native, sqrtPriceX96);
+	const collateralBalance0 = assets0 + convert1to0$1(assets1, sqrtPriceX96);
+	const requiredCollateral0 = required0Native + convert1to0$1(required1Native, sqrtPriceX96);
+	const collateralBalance1 = assets1 + convert0to1$1(assets0, sqrtPriceX96);
+	const requiredCollateral1 = required1Native + convert0to1$1(required0Native, sqrtPriceX96);
 	return {
 		collateralBalance0,
 		requiredCollateral0,
@@ -3475,6 +3775,68 @@ async function getAccountBuyingPower(params) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/simulations/creditWrap.ts
+/**
+* Wrap a dispatch with a temporary credit leg that is opened and closed in the
+* same transaction, netting to a swap.
+*
+* `swapAtMint` is not a calldata flag — it is the ORDER of the tick-limit pair:
+* descending `[high, low]` turns the swap on, ascending `[low, high]` leaves it
+* off. Exactly one of the two legs carries it, and which one is what makes the
+* swap exact-in vs exact-out.
+*/
+function buildCreditWrappedDispatch(params) {
+	const { dispatch, creditTokenId, creditPositionSize, direction, placement } = params;
+	const low = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitLow : params.tickLimitHigh;
+	const high = params.tickLimitLow <= params.tickLimitHigh ? params.tickLimitHigh : params.tickLimitLow;
+	const swapping = [
+		high,
+		low,
+		0n
+	];
+	const notSwapping = [
+		low,
+		high,
+		0n
+	];
+	const mintLimits = direction === "exact-out" ? swapping : notSwapping;
+	const burnLimits = direction === "exact-out" ? notSwapping : swapping;
+	const wrapped = {
+		positionIdList: placement === "straddle" ? [
+			creditTokenId,
+			...dispatch.positionIdList,
+			creditTokenId
+		] : [
+			...dispatch.positionIdList,
+			creditTokenId,
+			creditTokenId
+		],
+		finalPositionIdList: [...dispatch.finalPositionIdList],
+		positionSizes: placement === "straddle" ? [
+			creditPositionSize,
+			...dispatch.positionSizes,
+			0n
+		] : [
+			...dispatch.positionSizes,
+			creditPositionSize,
+			0n
+		],
+		tickAndSpreadLimits: placement === "straddle" ? [
+			mintLimits,
+			...dispatch.tickAndSpreadLimits,
+			burnLimits
+		] : [
+			...dispatch.tickAndSpreadLimits,
+			mintLimits,
+			burnLimits
+		],
+		usePremiaAsCollateral: dispatch.usePremiaAsCollateral,
+		builderCode: dispatch.builderCode
+	};
+	return wrapped;
+}
+
 //#endregion
 //#region src/panoptic/v2/simulations/simulateDispatch.ts
 /**
@@ -3600,7 +3962,7 @@ async function simulateDispatch(params) {
 
 //#endregion
 //#region src/panoptic/v2/simulations/tokenShortfallRecovery.ts
-const BPS_DENOMINATOR = 10000n;
+const BPS_DENOMINATOR$1 = 10000n;
 const MAX_RECOVERY_QUOTE_ATTEMPTS = 8;
 /**
 * Wrap a dispatch with a temporary credit leg that sources the shortfall.
@@ -3613,39 +3975,11 @@ const MAX_RECOVERY_QUOTE_ATTEMPTS = 8;
 * token's utilization — the case that fails today on a >94% utilized tracker.
 */
 function buildTokenShortfallRecoveryDispatch(params) {
-	const { dispatch, creditTokenId, creditPositionSize, tickLimitLow, tickLimitHigh } = params;
-	const low = tickLimitLow <= tickLimitHigh ? tickLimitLow : tickLimitHigh;
-	const high = tickLimitLow <= tickLimitHigh ? tickLimitHigh : tickLimitLow;
-	const mintLimits = [
-		high,
-		low,
-		0n
-	];
-	const burnLimits = [
-		low,
-		high,
-		0n
-	];
-	return {
-		positionIdList: [
-			creditTokenId,
-			...dispatch.positionIdList,
-			creditTokenId
-		],
-		finalPositionIdList: [...dispatch.finalPositionIdList],
-		positionSizes: [
-			creditPositionSize,
-			...dispatch.positionSizes,
-			0n
-		],
-		tickAndSpreadLimits: [
-			mintLimits,
-			...dispatch.tickAndSpreadLimits,
-			burnLimits
-		],
-		usePremiaAsCollateral: dispatch.usePremiaAsCollateral,
-		builderCode: dispatch.builderCode
-	};
+	return buildCreditWrappedDispatch({
+		...params,
+		direction: "exact-out",
+		placement: "straddle"
+	});
 }
 /**
 * Extract a fully-decoded `NotEnoughTokens` revert from an arbitrary error.
@@ -3668,7 +4002,7 @@ function getNotEnoughTokensError(error) {
 }
 function maximumAmountIn(estimatedAmountIn, slippageBps) {
 	if (slippageBps < 0n) throw new PanopticError("slippageBps must be non-negative");
-	return (estimatedAmountIn * (BPS_DENOMINATOR + slippageBps) + BPS_DENOMINATOR - 1n) / BPS_DENOMINATOR;
+	return (estimatedAmountIn * (BPS_DENOMINATOR$1 + slippageBps) + BPS_DENOMINATOR$1 - 1n) / BPS_DENOMINATOR$1;
 }
 function getInputAmount(tokenFlow, tokenInIndex) {
 	const delta = tokenInIndex === 0n ? tokenFlow.delta0 : tokenFlow.delta1;
@@ -3693,10 +4027,10 @@ async function quoteTokenShortfallRecovery(params) {
 		reason: "invalid-shortfall",
 		detail: `requested=${shortfallError.assetsRequested} <= balance=${shortfallError.assetBalance}`
 	};
-	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR) return {
+	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR$1) return {
 		available: false,
 		reason: "invalid-slippage",
-		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR}]`
+		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR$1}]`
 	};
 	const tickLimitLow = params.tickLimitLow ?? MIN_TICK;
 	const tickLimitHigh = params.tickLimitHigh ?? MAX_TICK;
@@ -4030,7 +4364,14 @@ async function getUniswapFeeHistory(params) {
 			_meta: _meta$1
 		};
 	}
-	const [blockData, _meta] = await Promise.all([fetchUniswapFeeData(client, blockNumbers, legs, poolConfig), params._meta ? Promise.resolve(params._meta) : getBlockMeta({ client })]);
+	const [blockData, blockMetadata, _meta] = await Promise.all([
+		fetchUniswapFeeData(client, blockNumbers, legs, poolConfig),
+		Promise.all(blockNumbers.map((blockNumber) => getBlockMeta({
+			client,
+			blockNumber
+		}))),
+		params._meta ? Promise.resolve(params._meta) : getBlockMeta({ client })
+	]);
 	let initialFees0 = null;
 	let initialFees1 = null;
 	const snapshots = blockData.map((bd, i) => {
@@ -4040,7 +4381,8 @@ async function getUniswapFeeHistory(params) {
 			initialFees1 = total1;
 		}
 		return {
-			blockNumber: blockNumbers[i],
+			blockNumber: blockMetadata[i].blockNumber,
+			blockTimestamp: blockMetadata[i].blockTimestamp,
 			fees: {
 				token0: total0 - initialFees0,
 				token1: total1 - initialFees1
@@ -4639,6 +4981,224 @@ async function getUniswapV4PoolLiquidities(params) {
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/uniswapLpPosition.ts
+const nfpmAbi = [{
+	type: "function",
+	name: "positions",
+	inputs: [{
+		name: "tokenId",
+		type: "uint256"
+	}],
+	outputs: [
+		{
+			name: "nonce",
+			type: "uint96"
+		},
+		{
+			name: "operator",
+			type: "address"
+		},
+		{
+			name: "token0",
+			type: "address"
+		},
+		{
+			name: "token1",
+			type: "address"
+		},
+		{
+			name: "fee",
+			type: "uint24"
+		},
+		{
+			name: "tickLower",
+			type: "int24"
+		},
+		{
+			name: "tickUpper",
+			type: "int24"
+		},
+		{
+			name: "liquidity",
+			type: "uint128"
+		},
+		{
+			name: "feeGrowthInside0LastX128",
+			type: "uint256"
+		},
+		{
+			name: "feeGrowthInside1LastX128",
+			type: "uint256"
+		},
+		{
+			name: "tokensOwed0",
+			type: "uint128"
+		},
+		{
+			name: "tokensOwed1",
+			type: "uint128"
+		}
+	],
+	stateMutability: "view"
+}, {
+	type: "function",
+	name: "collect",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
+			{
+				name: "tokenId",
+				type: "uint256"
+			},
+			{
+				name: "recipient",
+				type: "address"
+			},
+			{
+				name: "amount0Max",
+				type: "uint128"
+			},
+			{
+				name: "amount1Max",
+				type: "uint128"
+			}
+		]
+	}],
+	outputs: [{
+		name: "amount0",
+		type: "uint256"
+	}, {
+		name: "amount1",
+		type: "uint256"
+	}],
+	stateMutability: "payable"
+}];
+const MAX_UINT128 = 2n ** 128n - 1n;
+const MAX_UINT256 = 2n ** 256n - 1n;
+const Q128$1 = 2n ** 128n;
+/**
+* Whether an error thrown by a viem contract call is an on-chain revert (as
+* opposed to a transport/RPC failure such as a timeout or rate limit).
+*/
+function isContractRevert(error) {
+	return error instanceof BaseError && error.walk((err) => err instanceof ContractFunctionRevertedError || err instanceof ExecutionRevertedError) != null;
+}
+/**
+* Fetch a Uniswap V3 LP position's state and uncollected fees.
+*
+* Fees come from simulating `collect` with max amounts as the owner — one
+* eth_call returning the exact claimable amounts (tokensOwed + fee growth
+* since the last poke). The simulation is best-effort: if it reverts (e.g.
+* an empty position), fees fall back to 0.
+*/
+async function getUniswapV3LpPositionState(params) {
+	const { client, nfpmAddress, tokenId, owner, blockNumber } = params;
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber
+	});
+	const position = await client.readContract({
+		address: nfpmAddress,
+		abi: nfpmAbi,
+		functionName: "positions",
+		args: [tokenId],
+		blockNumber: _meta.blockNumber
+	});
+	const [, , token0, token1, fee, tickLower, tickUpper, liquidity] = position;
+	let fees0 = 0n;
+	let fees1 = 0n;
+	try {
+		const { result } = await client.simulateContract({
+			address: nfpmAddress,
+			abi: nfpmAbi,
+			functionName: "collect",
+			args: [{
+				tokenId,
+				recipient: owner,
+				amount0Max: MAX_UINT128,
+				amount1Max: MAX_UINT128
+			}],
+			account: owner,
+			blockNumber: _meta.blockNumber
+		});
+		[fees0, fees1] = result;
+	} catch (error) {
+		if (!isContractRevert(error)) throw error;
+	}
+	return {
+		token0,
+		token1,
+		fee: Number(fee),
+		tickLower: Number(tickLower),
+		tickUpper: Number(tickUpper),
+		liquidity,
+		fees0,
+		fees1,
+		_meta
+	};
+}
+/**
+* Uncollected fees from a feeGrowthInside delta, mirroring v4-core's
+* `Position.calculatePositionFeesAccrued`: the subtraction wraps around
+* uint256 (feeGrowthInside can legitimately underflow in-protocol).
+*/
+function feesFromFeeGrowthDelta(feeGrowthInsideCurrentX128, feeGrowthInsideLastX128, liquidity) {
+	const delta = feeGrowthInsideCurrentX128 - feeGrowthInsideLastX128 & MAX_UINT256;
+	return delta * liquidity / Q128$1;
+}
+/**
+* Fetch a Uniswap V4 LP position's state and uncollected fees via StateView.
+*
+* The position inside PoolManager is keyed by (positionManager, tickLower,
+* tickUpper, salt) where posm uses `bytes32(tokenId)` as the salt. Fees on
+* pools with fee-taking hooks may be approximate.
+*/
+async function getUniswapV4LpPositionState(params) {
+	const { client, stateViewAddress, positionManagerAddress, poolId, tokenId, tickLower, tickUpper, blockNumber } = params;
+	const salt = toHex(tokenId, { size: 32 });
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber
+	});
+	const [positionInfo, feeGrowthInside] = await client.multicall({
+		allowFailure: false,
+		blockNumber: _meta.blockNumber,
+		contracts: [{
+			address: stateViewAddress,
+			abi: StateViewAbi,
+			functionName: "getPositionInfo",
+			args: [
+				poolId,
+				positionManagerAddress,
+				tickLower,
+				tickUpper,
+				salt
+			]
+		}, {
+			address: stateViewAddress,
+			abi: StateViewAbi,
+			functionName: "getFeeGrowthInside",
+			args: [
+				poolId,
+				tickLower,
+				tickUpper
+			]
+		}]
+	});
+	const [liquidity, feeGrowthInside0LastX128, feeGrowthInside1LastX128] = positionInfo;
+	const [feeGrowthInside0X128, feeGrowthInside1X128] = feeGrowthInside;
+	return {
+		liquidity,
+		tickLower,
+		tickUpper,
+		fees0: feesFromFeeGrowthDelta(feeGrowthInside0X128, feeGrowthInside0LastX128, liquidity),
+		fees1: feesFromFeeGrowthDelta(feeGrowthInside1X128, feeGrowthInside1LastX128, liquidity),
+		_meta
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/reads/priceHistory.ts
 /**
@@ -6569,6 +7129,251 @@ async function simulateSwapExactIn(params) {
 	}
 }
 
+//#endregion
+//#region src/panoptic/v2/utils/priceConvert.ts
+const Q128 = 1n << 128n;
+/**
+* A non-positive price has no meaningful conversion, and `convert1to0` would
+* divide by zero — surface that as a typed SDK error rather than a RangeError
+* thrown from inside the arithmetic.
+*/
+function assertPositivePrice(sqrtPriceX96) {
+	if (sqrtPriceX96 <= 0n) throw new PanopticError(`sqrtPriceX96 must be positive, got ${sqrtPriceX96}`);
+}
+/** Convert a token0 amount to its token1-equivalent at the given sqrtPriceX96. */
+function convert0to1(amount, sqrtPriceX96) {
+	assertPositivePrice(sqrtPriceX96);
+	if (sqrtPriceX96 < Q128) return amount * sqrtPriceX96 * sqrtPriceX96 >> 192n;
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * sp2Hi >> 128n;
+}
+/** Convert a token1 amount to its token0-equivalent at the given sqrtPriceX96. */
+function convert1to0(amount, sqrtPriceX96) {
+	assertPositivePrice(sqrtPriceX96);
+	if (sqrtPriceX96 < Q128) {
+		const denom = sqrtPriceX96 * sqrtPriceX96;
+		return amount * (1n << 192n) / denom;
+	}
+	const sp2Hi = sqrtPriceX96 * sqrtPriceX96 >> 64n;
+	return amount * (1n << 128n) / sp2Hi;
+}
+/**
+* Convert an amount denominated in `fromTokenIndex` into the other token's
+* terms, so the two sides of a pool flow can be compared on one scale.
+*/
+function convertToTokenIndex(amount, fromTokenIndex, toTokenIndex, sqrtPriceX96) {
+	if (fromTokenIndex === toTokenIndex) return amount;
+	return fromTokenIndex === 0n ? convert0to1(amount, sqrtPriceX96) : convert1to0(amount, sqrtPriceX96);
+}
+
+//#endregion
+//#region src/panoptic/v2/simulations/oneTokenFlow.ts
+const BPS_DENOMINATOR = 10000n;
+/**
+* Default {@link OneTokenFlowQuoteParams.minSwapRatioBps}: 0.5%.
+*
+* A swap pays a pool fee of roughly 5-30 bps plus slippage, so a non-target
+* flow below this fraction of the target flow cannot pay for itself — while
+* still leaving any residual small enough not to surprise someone who asked to
+* settle in one token.
+*/
+const DEFAULT_MIN_SWAP_RATIO_BPS = 50n;
+function deltaAt(tokenFlow, index) {
+	return index === 0n ? tokenFlow.delta0 : tokenFlow.delta1;
+}
+function balanceBeforeAt(tokenFlow, index) {
+	return index === 0n ? tokenFlow.balanceBefore0 : tokenFlow.balanceBefore1;
+}
+function abs(value) {
+	return value < 0n ? -value : value;
+}
+function padForSlippage(amount, slippageBps) {
+	return (amount * (BPS_DENOMINATOR + slippageBps) + BPS_DENOMINATOR - 1n) / BPS_DENOMINATOR;
+}
+/**
+* Quote a dispatch wrapped so its net flow lands in `targetTokenIndex` only.
+*
+* Three simulations, all pinned to one block and with no convergence loop:
+*
+* 1. the user's dispatch as-is, to measure the non-target flow to cancel;
+* 2. the credit legs alone, to price the swap and check the source balance;
+* 3. the wrapped dispatch, whose token flow is what the user is shown and what
+*    the residual dust is read from.
+*/
+async function quoteOneTokenFlow(params) {
+	const { targetTokenIndex } = params;
+	const minSwapRatioBps = params.minSwapRatioBps ?? DEFAULT_MIN_SWAP_RATIO_BPS;
+	if (targetTokenIndex !== 0n && targetTokenIndex !== 1n) return {
+		available: false,
+		reason: "invalid-target-token",
+		detail: `targetTokenIndex=${targetTokenIndex} is neither 0 nor 1`
+	};
+	if (params.slippageBps < 0n || params.slippageBps > BPS_DENOMINATOR) return {
+		available: false,
+		reason: "invalid-slippage",
+		detail: `slippageBps=${params.slippageBps} is outside [0, ${BPS_DENOMINATOR}]`
+	};
+	const tickLimitLow = params.tickLimitLow ?? MIN_TICK;
+	const tickLimitHigh = params.tickLimitHigh ?? MAX_TICK;
+	if (tickLimitLow >= tickLimitHigh) return {
+		available: false,
+		reason: "invalid-tick-limits",
+		detail: `tickLimitLow=${tickLimitLow} >= tickLimitHigh=${tickLimitHigh}`
+	};
+	const otherTokenIndex = targetTokenIndex === 0n ? 1n : 0n;
+	const targetBlockNumber = params.blockNumber ?? await params.client.getBlockNumber();
+	const simulateArgs = {
+		client: params.client,
+		poolAddress: params.poolAddress,
+		account: params.account,
+		existingPositionIdList: params.existingPositionIds,
+		blockNumber: targetBlockNumber
+	};
+	const pool = await getPool({
+		client: params.client,
+		poolAddress: params.poolAddress,
+		chainId: params.chainId,
+		blockNumber: targetBlockNumber
+	});
+	const token0 = pool.collateralTracker0.token;
+	const token1 = pool.collateralTracker1.token;
+	const targetToken = targetTokenIndex === 0n ? token0 : token1;
+	const otherToken = otherTokenIndex === 0n ? token0 : token1;
+	const otherTracker = otherTokenIndex === 0n ? pool.collateralTracker0.address : pool.collateralTracker1.address;
+	const baseSimulation = await simulateDispatch({
+		...simulateArgs,
+		...params.dispatch
+	});
+	let swapAmount;
+	let direction;
+	let baseTargetDelta = null;
+	if (baseSimulation.success && baseSimulation.tokenFlow !== void 0) {
+		baseTargetDelta = deltaAt(baseSimulation.tokenFlow, targetTokenIndex);
+		const otherDelta = deltaAt(baseSimulation.tokenFlow, otherTokenIndex);
+		if (otherDelta === 0n) return {
+			available: false,
+			reason: "already-single-token",
+			detail: "the dispatch does not move the non-target token"
+		};
+		direction = otherDelta < 0n ? "exact-out" : "exact-in";
+		swapAmount = abs(otherDelta);
+	} else {
+		const shortfall = baseSimulation.success ? null : getNotEnoughTokensError(baseSimulation.error);
+		if (shortfall === null) return {
+			available: false,
+			reason: "base-simulation-failed",
+			detail: baseSimulation.success ? "base simulation returned no token flow" : `base simulation reverted: ${baseSimulation.error.message}`,
+			error: baseSimulation.success ? void 0 : baseSimulation.error
+		};
+		if (shortfall.tokenAddress.toLowerCase() !== otherTracker.toLowerCase()) return {
+			available: false,
+			reason: "base-simulation-failed",
+			detail: `shortfall is in ${shortfall.tokenAddress}, not the non-target collateral ${otherTracker}`,
+			error: baseSimulation.success ? void 0 : baseSimulation.error
+		};
+		const pending = shortfall.assetsRequested - shortfall.assetBalance;
+		if (pending <= 0n) return {
+			available: false,
+			reason: "base-simulation-failed",
+			detail: `requested=${shortfall.assetsRequested} <= balance=${shortfall.assetBalance}`
+		};
+		direction = "exact-out";
+		swapAmount = pending;
+	}
+	if (baseTargetDelta !== null && minSwapRatioBps > 0n) {
+		const swapInTargetTerms = convertToTokenIndex(swapAmount, otherTokenIndex, targetTokenIndex, pool.sqrtPriceX96);
+		if (swapInTargetTerms * BPS_DENOMINATOR < minSwapRatioBps * abs(baseTargetDelta)) return {
+			available: false,
+			reason: "below-threshold",
+			detail: `non-target flow ${swapInTargetTerms} (in target token terms) is below ${minSwapRatioBps}bps of the target flow ${abs(baseTargetDelta)}`
+		};
+	}
+	const collisionIds = Array.from(new Set([
+		...params.existingPositionIds,
+		...params.dispatch.positionIdList,
+		...params.dispatch.finalPositionIdList
+	]));
+	const credit = buildUniqueCredit(pool.poolId, otherTokenIndex, otherTokenIndex, pool.currentTick, pool.tickSpacing, collisionIds, swapAmount);
+	const placement = direction === "exact-out" ? "straddle" : "append";
+	const creditWrapArgs = {
+		creditTokenId: credit.tokenId,
+		creditPositionSize: credit.adjustedSize,
+		tickLimitLow,
+		tickLimitHigh,
+		direction,
+		placement
+	};
+	let estimatedCounterAmount = 0n;
+	let maximumAmountIn$1 = 0n;
+	if (direction === "exact-out") {
+		const swapOnlyDispatch = buildCreditWrappedDispatch({
+			...creditWrapArgs,
+			dispatch: {
+				positionIdList: [],
+				finalPositionIdList: [...params.existingPositionIds],
+				positionSizes: [],
+				tickAndSpreadLimits: [],
+				usePremiaAsCollateral: false,
+				builderCode: 0n
+			}
+		});
+		const swapSimulation = await simulateDispatch({
+			...simulateArgs,
+			...swapOnlyDispatch
+		});
+		if (!swapSimulation.success || swapSimulation.tokenFlow === void 0) return {
+			available: false,
+			reason: "swap-unavailable",
+			detail: swapSimulation.success ? "swap-only simulation returned no token flow" : `swap-only simulation reverted: ${swapSimulation.error.message}`,
+			error: swapSimulation.success ? void 0 : swapSimulation.error
+		};
+		estimatedCounterAmount = abs(deltaAt(swapSimulation.tokenFlow, targetTokenIndex));
+		maximumAmountIn$1 = padForSlippage(estimatedCounterAmount, params.slippageBps);
+		const sourceBalance = balanceBeforeAt(swapSimulation.tokenFlow, targetTokenIndex);
+		if (sourceBalance < maximumAmountIn$1) return {
+			available: false,
+			reason: "swap-unavailable",
+			detail: `source balance ${sourceBalance} < maximumAmountIn ${maximumAmountIn$1} (estimated ${estimatedCounterAmount}, slippageBps ${params.slippageBps})`,
+			error: new PanopticError("Insufficient collateral to fund the one-token-out swap")
+		};
+	}
+	const wrappedDispatch = buildCreditWrappedDispatch({
+		...creditWrapArgs,
+		dispatch: params.dispatch
+	});
+	const wrappedSimulation = await simulateDispatch({
+		...simulateArgs,
+		...wrappedDispatch
+	});
+	if (!wrappedSimulation.success || wrappedSimulation.tokenFlow === void 0) return {
+		available: false,
+		reason: "wrap-unavailable",
+		detail: wrappedSimulation.success ? "wrapped dispatch simulation returned no token flow" : `wrapped dispatch reverted: ${wrappedSimulation.error.message}`,
+		error: wrappedSimulation.success ? void 0 : wrappedSimulation.error
+	};
+	if (direction === "exact-in" && baseTargetDelta !== null) estimatedCounterAmount = abs(deltaAt(wrappedSimulation.tokenFlow, targetTokenIndex) - baseTargetDelta);
+	return {
+		available: true,
+		quote: {
+			targetToken,
+			otherToken,
+			targetTokenIndex,
+			otherTokenIndex,
+			direction,
+			swapAmount,
+			estimatedCounterAmount,
+			maximumAmountIn: maximumAmountIn$1,
+			slippageBps: params.slippageBps,
+			netTargetChange: deltaAt(wrappedSimulation.tokenFlow, targetTokenIndex),
+			residualOtherChange: deltaAt(wrappedSimulation.tokenFlow, otherTokenIndex),
+			creditTokenId: credit.tokenId,
+			dispatch: wrappedDispatch,
+			tokenFlow: wrappedSimulation.tokenFlow,
+			_meta: wrappedSimulation._meta
+		}
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/abis/poolManager.ts
 /**
@@ -7703,5 +8508,5 @@ function createEventPoller(params) {
 }
 
 //#endregion
-export { DEFAULT_RECONNECT_CONFIG, REQUIRED_BASE_ERROR_SENTINEL, addPendingPosition, addTrackedChunks, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateSpreadWad, checkCollateralAcrossTicks, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, createPoolFormatters, decodePanopticTokenURI, encodePoolKeyBytes, encodeV3PoolKeyBytes, estimateBlockNumbers, estimateCollateralRequired, failPendingPosition, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPoolIdHex, formatRatioPercent, formatTimestamp, formatTimestampLocale, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWei, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getAccountPremia, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolDeploymentBlock, getPoolDisplayId, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionsWithPremia, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTokenListId, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseBps, parseCollateralLog, parsePoolLog, parseTokenListId, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteTokenShortfallRecovery, reconstructFromEvents, removeTrackedChunks, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scanChunks, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, truncateAddress, watchEvents };
-//# sourceMappingURL=v2-D3B5BKml.js.map
+export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, REQUIRED_BASE_ERROR_SENTINEL, addPendingPosition, addTrackedChunks, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateSpreadWad, checkCollateralAcrossTicks, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, createPoolFormatters, decodePanopticTokenURI, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralRequired, failPendingPosition, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPoolIdHex, formatRatioPercent, formatTimestamp, formatTimestampLocale, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWei, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getAccountPremia, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolDeploymentBlock, 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, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseBps, parseCollateralLog, parsePoolLog, parseTokenListId, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteOneTokenFlow, quoteSfpmSwap, quoteTokenShortfallRecovery, reconstructFromEvents, removeTrackedChunks, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scanChunks, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, truncateAddress, watchEvents };
+//# sourceMappingURL=v2-B68I6nwv.js.map