@panoptic-eng/sdk 1.0.49 → 1.0.51

package/dist/uniswap/index.js

@@ -1,5 +1,132 @@
+import Decimal from "decimal.js";
 import { BaseError, ContractFunctionRevertedError, decodeAbiParameters, decodeEventLog, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAbiItem, isAddressEqual, keccak256, maxUint256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
 
+//#region src/uniswap/estimateLpFees.ts
+const D$1 = Decimal.clone({ precision: 60 });
+const validTick = (tick) => Number.isInteger(tick) && Math.abs(tick) <= 887272;
+/**
+* Hypothetical added LP liquidity, with no compounding or price impact. Fees are raw
+* token units. Bullish candles follow O→L→H→C; bearish candles O→H→L→C.
+* Uniswap v3 deltas distribute absolute volume between inputs and outputs; only
+* inputs pay fees. Split moves at every LP boundary, so overlapping ranges share
+* the same denominator and out-of-range portions earn nothing.
+*
+* Closing historical liquidity approximates liquidity throughout a candle. If
+* absent, infer it from volume / path deltas. Flat candles with volume use equal
+* buy/sell flow and require historical liquidity; otherwise report them skipped.
+* OHLC cannot recover unseen oscillations, exact swap ordering or liquidity changes.
+*/
+function estimateLpFees({ candles, ranges, feePips }) {
+	if (feePips < 0n || feePips >= 1000000n) throw new Error("Invalid swap fee");
+	for (const range of ranges) if (!validTick(range.tickLower) || !validTick(range.tickUpper) || range.tickLower >= range.tickUpper || range.liquidity < 0n) throw new Error("Invalid LP range");
+	const fee = new D$1(feePips.toString()).div(1e6);
+	const net = new D$1(1).minus(fee);
+	const sqrtCache = new Map();
+	const sqrtAt = (tick) => {
+		const cached = sqrtCache.get(tick);
+		if (cached) return cached;
+		const sqrt = new D$1("1.0001").pow(new D$1(tick).div(2));
+		sqrtCache.set(tick, sqrt);
+		return sqrt;
+	};
+	const positions = ranges.map((r) => ({
+		...r,
+		liquidity: new D$1(r.liquidity.toString())
+	}));
+	let fees0 = new D$1(0);
+	let fees1 = new D$1(0);
+	let skippedCandles = 0;
+	let inferredCandles = 0;
+	let previousTime = -Infinity;
+	const points = candles.map((candle) => {
+		const { o, h, l, c, t } = candle;
+		if (!Number.isSafeInteger(t) || t <= previousTime || ![
+			o,
+			h,
+			l,
+			c
+		].every(validTick) || l > Math.min(o, c) || h < Math.max(o, c) || l > h) throw new Error("Invalid or unordered OHLC candles");
+		previousTime = t;
+		const v0 = new D$1(candle.v0);
+		const v1 = new D$1(candle.v1);
+		const historical = new D$1(candle.liq ?? "0");
+		if (![
+			v0,
+			v1,
+			historical
+		].every((v) => v.isFinite() && v.isInteger() && v.gte(0))) throw new Error("Invalid candle volume or liquidity");
+		const path = c >= o ? [
+			o,
+			l,
+			h,
+			c
+		] : [
+			o,
+			h,
+			l,
+			c
+		];
+		const steps = [];
+		for (let i = 1; i < path.length; i++) {
+			const from = path[i - 1];
+			const to = path[i];
+			if (from === void 0 || to === void 0 || from === to) continue;
+			const lower = Math.min(from, to);
+			const upper = Math.max(from, to);
+			const cuts = [...new Set([
+				lower,
+				upper,
+				...positions.flatMap((p) => [p.tickLower, p.tickUpper])
+			])].filter((tick) => tick >= lower && tick <= upper).sort((a, b) => a - b);
+			for (let j = 1; j < cuts.length; j++) {
+				const a = cuts[j - 1];
+				const b = cuts[j];
+				if (a === void 0 || b === void 0) continue;
+				const sa = sqrtAt(a);
+				const sb = sqrtAt(b);
+				steps.push({
+					lower: a,
+					upper: b,
+					up: to > from,
+					d0: new D$1(1).div(sa).minus(new D$1(1).div(sb)),
+					d1: sb.minus(sa)
+				});
+			}
+		}
+		const total0 = steps.reduce((sum, s) => sum.plus(s.up ? s.d0 : s.d0.div(net)), new D$1(0));
+		const total1 = steps.reduce((sum, s) => sum.plus(s.up ? s.d1.div(net) : s.d1), new D$1(0));
+		const hasVolume = v0.gt(0) || v1.gt(0);
+		const inferred = total0.gt(0) && total1.gt(0) ? v0.div(total0).plus(v1.div(total1)).div(2) : new D$1(0);
+		const poolLiquidity = historical.gt(0) ? historical : inferred;
+		if (hasVolume && poolLiquidity.eq(0)) skippedCandles++;
+		else if (hasVolume && fee.gt(0)) {
+			if (historical.eq(0)) inferredCandles++;
+			if (steps.length === 0) {
+				const active = positions.filter((p) => p.tickLower <= c && c < p.tickUpper).reduce((sum, p) => sum.plus(p.liquidity), new D$1(0));
+				const share = active.div(poolLiquidity.plus(active));
+				fees0 = fees0.plus(v0.div(new D$1(2).minus(fee)).mul(fee).mul(share));
+				fees1 = fees1.plus(v1.div(new D$1(2).minus(fee)).mul(fee).mul(share));
+			} else for (const step of steps) {
+				const active = positions.filter((p) => p.tickLower <= step.lower && p.tickUpper >= step.upper).reduce((sum, p) => sum.plus(p.liquidity), new D$1(0));
+				const share = active.div(poolLiquidity.plus(active));
+				if (step.up) fees1 = fees1.plus(v1.mul(step.d1.div(net)).div(total1).mul(fee).mul(share));
+				else fees0 = fees0.plus(v0.mul(step.d0.div(net)).div(total0).mul(fee).mul(share));
+			}
+		}
+		return {
+			time: t,
+			fees0: BigInt(fees0.floor().toFixed(0)),
+			fees1: BigInt(fees1.floor().toFixed(0))
+		};
+	});
+	return {
+		points,
+		skippedCandles,
+		inferredCandles
+	};
+}
+
+//#endregion
 //#region src/panoptic/v2/utils/constants.ts
 /**
 * Constants for the Panoptic v2 SDK.
@@ -63,65 +190,6 @@ function tickToSqrtPriceX96(tick) {
 const MIN_SQRT_PRICE_X96 = tickToSqrtPriceX96(MIN_TICK);
 const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
 
-//#endregion
-//#region src/uniswap/lpGreeks.ts
-const Q96$2 = 1n << 96n;
-const Q192$3 = 1n << 192n;
-/**
-* Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
-* at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
-* (`getAmountsForLiquidity`). All sqrt prices are X96. The current price is
-* clamped into the range, so out-of-range positions collapse to a single token.
-*/
-function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liquidity) {
-	const [sqrtA, sqrtB] = sqrtRatioAX96 <= sqrtRatioBX96 ? [sqrtRatioAX96, sqrtRatioBX96] : [sqrtRatioBX96, sqrtRatioAX96];
-	const sqrtC = sqrtPriceX96 < sqrtA ? sqrtA : sqrtPriceX96 > sqrtB ? sqrtB : sqrtPriceX96;
-	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$2 / (sqrtC * sqrtB) : 0n;
-	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$2 : 0n;
-	return {
-		amount0,
-		amount1
-	};
-}
-/**
-* Greeks (value, delta, gamma) for a Uniswap LP position in the chosen asset
-* frame. See the module docs for the unit conventions.
-*
-* Closed forms (in-range, numeraire = token1 / asset = token0):
-*   value = amount1 + amount0·P               (P = sqrtP² / 2^192)
-*   delta = amount0                            (= dV/dP)
-*   gamma = P²·d²V/dP² = -L·sqrt(P)/2          (short gamma)
-* The `assetIndex = 1` frame is the symmetric inverse (numeraire = token0).
-* Gamma is zero when the price is outside the range (no curvature there).
-*/
-function getLpGreeks(input) {
-	const { liquidity, tickLower, tickUpper, currentTick, assetIndex } = input;
-	const sqrtP = tickToSqrtPriceX96(currentTick);
-	const sqrtA = tickToSqrtPriceX96(tickLower);
-	const sqrtB = tickToSqrtPriceX96(tickUpper);
-	const { amount0, amount1 } = getAmountsForLiquidity(sqrtP, sqrtA, sqrtB, liquidity);
-	const sqrtP2 = sqrtP * sqrtP;
-	const inRange = sqrtP > sqrtA && sqrtP < sqrtB;
-	if (assetIndex === 0) {
-		const value$1 = amount1 + amount0 * sqrtP2 / Q192$3;
-		const delta$1 = amount0;
-		const gamma$1 = inRange ? -(liquidity * sqrtP) / (2n * Q96$2) : 0n;
-		return {
-			value: value$1,
-			delta: delta$1,
-			gamma: gamma$1
-		};
-	}
-	const value = amount0 + amount1 * Q192$3 / sqrtP2;
-	const delta = amount1;
-	const gamma = inRange ? -(liquidity * Q96$2) / (2n * sqrtP) : 0n;
-	return {
-		value,
-		delta,
-		gamma
-	};
-}
-
 //#endregion
 //#region src/panoptic/v2/errors/base.ts
 /**
@@ -3540,594 +3608,577 @@ const combinedAbi = [
 ];
 
 //#endregion
-//#region src/uniswap/v4/router/errors.ts
+//#region src/panoptic/v2/tokenId/constants.ts
 /**
-* The chain has no configured Uniswap v4 addresses and none were supplied via
-* overrides.
+* TokenId constants for the Panoptic v2 SDK.
+* @module v2/tokenId/constants
 */
-var UnsupportedChainError = class extends PanopticError {
-	name = "UnsupportedChainError";
-	constructor(chainId, cause) {
-		super(`Uniswap v4 router not configured for chain ${chainId}`, cause);
-		this.chainId = chainId;
-	}
-};
 /**
-* `tokenIn` is neither `currency0` nor `currency1` of the resolved pool.
+* Default vegoid value used in pool ID encoding.
 */
-var InvalidSwapTokenError = class extends PanopticError {
-	name = "InvalidSwapTokenError";
-	constructor(token, currency0, currency1, cause) {
-		super(`Token ${token} is not part of the pool (currency0=${currency0}, currency1=${currency1})`, cause);
-		this.token = token;
-		this.currency0 = currency0;
-		this.currency1 = currency1;
-	}
-};
+const DEFAULT_VEGOID = 8n;
 /**
-* An amount exceeds the uint128 range required by the v4 swap encoding.
+* Bit positions and sizes for TokenId encoding.
 */
-var AmountExceedsUint128Error = class extends PanopticError {
-	name = "AmountExceedsUint128Error";
-	constructor(amount, cause) {
-		super(`Amount ${amount} exceeds uint128 maximum`, cause);
-		this.amount = amount;
-	}
+const TOKEN_ID_BITS = {
+	POOL_ID_SIZE: 64n,
+	VEGOID_STARTING_BIT: 40n,
+	VEGOID_SIZE: 8n,
+	TICK_SPACING_STARTING_BIT: 48n,
+	TICK_SPACING_SIZE: 16n,
+	LEG_SIZE: 48n,
+	MAX_LEGS: 4n
 };
 /**
-* A native-ETH swap needs a trailing Universal Router SWEEP to deliver the ETH
-* output (or refund the input overpay), but no `recipient` was supplied.
+* Bit positions within a leg (relative to leg start).
 */
-var MissingSweepRecipientError = class extends PanopticError {
-	name = "MissingSweepRecipientError";
-	constructor(cause) {
-		super("A recipient is required to sweep native ETH back to the user", cause);
-	}
+const LEG_BITS = {
+	ASSET_BIT: 0n,
+	ASSET_SIZE: 1n,
+	RATIO_BIT: 1n,
+	RATIO_SIZE: 7n,
+	IS_LONG_BIT: 8n,
+	IS_LONG_SIZE: 1n,
+	TOKEN_TYPE_BIT: 9n,
+	TOKEN_TYPE_SIZE: 1n,
+	RISK_PARTNER_BIT: 10n,
+	RISK_PARTNER_SIZE: 2n,
+	STRIKE_BIT: 12n,
+	STRIKE_SIZE: 24n,
+	WIDTH_BIT: 36n,
+	WIDTH_SIZE: 12n
 };
 /**
-* The V4Quoter is not available for the chain (no fallback in v1).
+* Masks for extracting/encoding leg fields.
 */
-var QuoterUnavailableError = class extends PanopticError {
-	name = "QuoterUnavailableError";
-	constructor(chainId, cause) {
-		super(`V4Quoter unavailable for chain ${chainId}`, cause);
-		this.chainId = chainId;
-	}
+const LEG_MASKS = {
+	ASSET: (1n << LEG_BITS.ASSET_SIZE) - 1n,
+	RATIO: (1n << LEG_BITS.RATIO_SIZE) - 1n,
+	IS_LONG: (1n << LEG_BITS.IS_LONG_SIZE) - 1n,
+	TOKEN_TYPE: (1n << LEG_BITS.TOKEN_TYPE_SIZE) - 1n,
+	RISK_PARTNER: (1n << LEG_BITS.RISK_PARTNER_SIZE) - 1n,
+	STRIKE: (1n << LEG_BITS.STRIKE_SIZE) - 1n,
+	WIDTH: (1n << LEG_BITS.WIDTH_SIZE) - 1n,
+	LEG: (1n << TOKEN_ID_BITS.LEG_SIZE) - 1n
 };
-
-//#endregion
-//#region src/uniswap/v3/addresses.ts
 /**
-* Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only
-* after verifying against the canonical Uniswap v3 deployment listing.
+* Maximum and minimum values for leg fields.
 */
-const UNISWAP_V3_ADDRESSES = { 1: {
-	quoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-	nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
-} };
+const LEG_LIMITS = {
+	MAX_RATIO: 127n,
+	MAX_WIDTH: 4095n,
+	MAX_STRIKE: 8388607n,
+	MIN_STRIKE: -8388608n
+};
 /**
-* Resolve Uniswap v3 addresses for a chain, applying optional overrides.
-*
-* @throws {UnsupportedChainError} when the chain is not listed and overrides do
-*   not supply every required address.
+* Value used to convert negative strike to unsigned representation.
+* Strike is stored as int24, so we use 2^24 for conversion.
 */
-function getUniswapV3Addresses(chainId, overrides) {
-	const id = Number(chainId);
-	const base = UNISWAP_V3_ADDRESSES[id];
-	const merged = {
-		...base,
-		...overrides
-	};
-	if (!merged.quoterV2 || !merged.nonfungiblePositionManager) throw new UnsupportedChainError(BigInt(id));
-	return merged;
-}
+const STRIKE_CONVERSION_FACTOR = 16777216n;
 
 //#endregion
-//#region src/uniswap/v4/abis/universalRouter.ts
+//#region src/panoptic/v2/tokenId/encoding.ts
 /**
-* Minimal Universal Router ABI (only the `execute` overload we use).
-* @module uniswap/v4/abis/universalRouter
+* Convert an unsigned encoded strike back to signed representation.
+*
+* @param encodedStrike - The unsigned encoded strike
+* @returns The signed strike tick
 */
-const universalRouterAbi = [{
-	type: "function",
-	name: "execute",
-	stateMutability: "payable",
-	inputs: [
-		{
-			name: "commands",
-			type: "bytes"
-		},
-		{
-			name: "inputs",
-			type: "bytes[]"
-		},
-		{
-			name: "deadline",
-			type: "uint256"
-		}
-	],
-	outputs: []
-}];
-
-//#endregion
-//#region src/uniswap/v3/router/encodeSwap.ts
-/** Universal Router command byte for a v3 exact-in swap. */
-const V3_SWAP_EXACT_IN = 0;
+function convertStrikeToSigned(encodedStrike) {
+	if (encodedStrike > 2n ** 23n - 1n) return encodedStrike - STRIKE_CONVERSION_FACTOR;
+	return encodedStrike;
+}
 /**
-* Universal Router recipient sentinel: the router maps `address(1)` to
-* `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.
+* Get the bit offset for a leg at the given index.
+*
+* @param legIndex - The leg index (0-3)
+* @returns The bit offset from the start of the legs section
 */
-const MSG_SENDER = "0x0000000000000000000000000000000000000001";
-const UINT128_MAX$4 = (1n << 128n) - 1n;
-const v3ExactInInputAbi = [
-	{
-		name: "recipient",
-		type: "address"
-	},
-	{
-		name: "amountIn",
-		type: "uint256"
-	},
-	{
-		name: "amountOutMinimum",
-		type: "uint256"
-	},
-	{
-		name: "path",
-		type: "bytes"
-	},
-	{
-		name: "payerIsUser",
-		type: "bool"
-	}
-];
-function assertUint128$1(amount) {
-	if (amount < 0n || amount > UINT128_MAX$4) throw new AmountExceedsUint128Error(amount);
+function getLegOffset(legIndex) {
+	return legIndex * TOKEN_ID_BITS.LEG_SIZE;
 }
 /**
-* Encode the packed v3 single-hop path `tokenIn ++ fee(uint24) ++ tokenOut`.
+* Decode a single leg from a TokenId.
+*
+* @param tokenId - The TokenId to decode
+* @param legIndex - The leg index (0-3)
+* @returns The decoded leg data
 */
-function encodeV3Path(tokenIn, fee, tokenOut) {
-	if (fee < 0n || fee > 0xffffffn) throw new PanopticError(`v3 fee ${fee} exceeds uint24`);
-	return encodePacked([
-		"address",
-		"uint24",
-		"address"
-	], [
-		tokenIn,
-		Number(fee),
-		tokenOut
-	]);
+function decodeLeg(tokenId, legIndex) {
+	const offset = getLegOffset(legIndex) + TOKEN_ID_BITS.POOL_ID_SIZE;
+	const leg = tokenId >> offset & LEG_MASKS.LEG;
+	const asset = leg & LEG_MASKS.ASSET;
+	const optionRatio = leg >> LEG_BITS.RATIO_BIT & LEG_MASKS.RATIO;
+	const isLong = (leg >> LEG_BITS.IS_LONG_BIT & LEG_MASKS.IS_LONG) === 1n;
+	const tokenType = leg >> LEG_BITS.TOKEN_TYPE_BIT & LEG_MASKS.TOKEN_TYPE;
+	const riskPartner = leg >> LEG_BITS.RISK_PARTNER_BIT & LEG_MASKS.RISK_PARTNER;
+	const encodedStrike = leg >> LEG_BITS.STRIKE_BIT & LEG_MASKS.STRIKE;
+	const strike = convertStrikeToSigned(encodedStrike);
+	const width = leg >> LEG_BITS.WIDTH_BIT & LEG_MASKS.WIDTH;
+	return {
+		index: legIndex,
+		asset,
+		optionRatio,
+		isLong,
+		tokenType,
+		riskPartner,
+		strike,
+		width
+	};
 }
 /**
-* Build the typed `execute(...)` args for an exact-in single-hop v3 swap whose
-* output is delivered to the `execute` caller (recipient = MSG_SENDER).
+* Decode all active legs from a TokenId.
+*
+* @param tokenId - The TokenId to decode
+* @returns Array of decoded legs (only active legs with optionRatio > 0)
 */
-function buildV3SwapExecuteArgs(args) {
-	const { tokenIn, tokenOut, fee, amountIn, amountOutMinimum, deadline } = args;
-	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-in router builder");
-	assertUint128$1(amountIn);
-	assertUint128$1(amountOutMinimum);
-	const path = encodeV3Path(tokenIn, fee, tokenOut);
-	const input = encodeAbiParameters(v3ExactInInputAbi, [
-		MSG_SENDER,
-		amountIn,
-		amountOutMinimum,
-		path,
-		true
-	]);
-	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_IN]);
+function decodeAllLegs(tokenId) {
+	const legs = [];
+	for (let i = 0n; i < TOKEN_ID_BITS.MAX_LEGS; i++) {
+		const leg = decodeLeg(tokenId, i);
+		if (leg.optionRatio > 0n) legs.push(leg);
+	}
+	return legs;
+}
+
+//#endregion
+//#region src/panoptic/v2/tokenId/deriveUniqueTokenId.ts
+const POOL_ID_MASK$2 = (1n << 64n) - 1n;
+const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
+const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
+const Q192$3 = 1n << 192n;
+
+//#endregion
+//#region src/panoptic/v2/formatters/rates.ts
+const SECONDS_PER_DAY = 86400n;
+const DAYS_PER_YEAR = 365n;
+const SECONDS_PER_YEAR = SECONDS_PER_DAY * DAYS_PER_YEAR;
+
+//#endregion
+//#region src/panoptic/v2/tokenId/generateOverlapping.ts
+const MAX_UINT64 = (1n << 64n) - 1n;
+const MAX_UINT128$2 = (1n << 128n) - 1n;
+const Q192$2 = 1n << 192n;
+
+//#endregion
+//#region src/panoptic/v2/tokenId/split.ts
+const POOL_ID_MASK$1 = (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
+const MAX_UINT128$1 = (1n << 128n) - 1n;
+const MAX_UINT256 = (1n << 256n) - 1n;
+
+//#endregion
+//#region src/uniswap/lpDeposit.ts
+const Q96$3 = 1n << 96n;
+const ceilDiv = (n, d) => (n + d - 1n) / d;
+/** Uniswap mint principal in raw token units, rounded up per leg, plus 5% headroom. */
+function getLpDepositAmounts(ranges, sqrtPriceX96) {
+	return getLpDepositBreakdown(ranges, sqrtPriceX96).total;
+}
+/** Principal and separately identified funding headroom, in native token units. */
+function getLpDepositBreakdown(ranges, sqrtPriceX96) {
+	if (sqrtPriceX96 <= 0n) throw new Error("Invalid pool price");
+	let amount0 = 0n;
+	let amount1 = 0n;
+	for (const { tickLower, tickUpper, liquidity } of ranges) {
+		if (!Number.isInteger(tickLower) || !Number.isInteger(tickUpper) || tickLower < -887272 || tickUpper > 887272 || tickLower >= tickUpper || liquidity < 0n) throw new Error("Invalid LP range");
+		const lower = tickToSqrtPriceX96(BigInt(tickLower));
+		const upper = tickToSqrtPriceX96(BigInt(tickUpper));
+		const price = sqrtPriceX96 < lower ? lower : sqrtPriceX96 > upper ? upper : sqrtPriceX96;
+		amount0 += ceilDiv(liquidity * Q96$3 * (upper - price), upper * price);
+		amount1 += ceilDiv(liquidity * (price - lower), Q96$3);
+	}
+	const buffer = {
+		amount0: ceilDiv(amount0 * 5n, 100n),
+		amount1: ceilDiv(amount1 * 5n, 100n)
+	};
 	return {
-		args: [
-			commands,
-			[input],
-			deadline
-		],
-		value: 0n
+		principal: {
+			amount0,
+			amount1
+		},
+		buffer,
+		total: {
+			amount0: amount0 + buffer.amount0,
+			amount1: amount1 + buffer.amount1
+		}
 	};
 }
-/**
-* Build the `execute(commands, inputs, deadline)` calldata for an exact-in
-* single-hop v3 swap.
-*/
-function buildV3SwapExecuteCalldata(args) {
-	const { args: executeArgs, value } = buildV3SwapExecuteArgs(args);
-	const data = encodeFunctionData({
-		abi: universalRouterAbi,
-		functionName: "execute",
-		args: executeArgs
+/** Full deployed liquidity value; never a leveraged protocol margin estimate. */
+function getLpPositionFunding(params) {
+	const { tokenId, positionSize, tickSpacing, sqrtPriceX96, valuationSqrtPriceX96, quoteTokenIndex } = params;
+	if (positionSize < 0n || tickSpacing <= 0n || valuationSqrtPriceX96 <= 0n) throw new Error("Invalid LP funding input");
+	const legs = decodeAllLegs(tokenId);
+	if (legs.length === 0 || legs.some((leg) => leg.isLong || leg.width === 0n)) throw new Error("AMM Liquidity requires short liquidity legs without loans or credits");
+	const ranges = legs.map((leg) => {
+		const width = leg.width * tickSpacing;
+		const tickLower = leg.strike - width / 2n;
+		const tickUpper = leg.strike + (width + 1n) / 2n;
+		const lower = tickToSqrtPriceX96(tickLower);
+		const upper = tickToSqrtPriceX96(tickUpper);
+		const amount = positionSize * leg.optionRatio;
+		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96$3) / (upper - lower) : amount * Q96$3 / (upper - lower);
+		return {
+			tickLower: Number(tickLower),
+			tickUpper: Number(tickUpper),
+			liquidity
+		};
 	});
+	const breakdown = getLpDepositBreakdown(ranges, sqrtPriceX96);
+	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
+	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv(amount1 * Q96$3 * Q96$3, priceSquared) : amount1 + ceilDiv(amount0 * priceSquared, Q96$3 * Q96$3);
+	const principalInQuote = value(breakdown.principal);
+	const totalInQuote = value(breakdown.total);
 	return {
-		data,
-		value
+		...breakdown,
+		principalInQuote,
+		bufferInQuote: totalInQuote - principalInQuote,
+		totalInQuote
+	};
+}
+/** Remaining deposit in the requested token mix, rounded up to cover the shortfall. */
+function getLpFundingDeposit({ funding, availableInQuote, minimumInQuote = 0n, quoteTokenIndex, valuationSqrtPriceX96, quotePercent }) {
+	if (valuationSqrtPriceX96 <= 0n || quotePercent !== void 0 && (quotePercent < 0n || quotePercent > 100n)) throw new Error("Invalid LP funding split");
+	const requiredInQuote = minimumInQuote > funding.totalInQuote ? minimumInQuote : funding.totalInQuote;
+	const shortfallInQuote = requiredInQuote > availableInQuote ? requiredInQuote - availableInQuote : 0n;
+	const defaultQuotePercent = funding.totalInQuote > 0n ? (quoteTokenIndex === 0 ? funding.total.amount0 : funding.total.amount1) * 100n / funding.totalInQuote : 100n;
+	if (quotePercent === void 0) return {
+		requiredInQuote,
+		shortfallInQuote,
+		defaultQuotePercent,
+		amount0: funding.totalInQuote > 0n ? ceilDiv(funding.total.amount0 * shortfallInQuote, funding.totalInQuote) : 0n,
+		amount1: funding.totalInQuote > 0n ? ceilDiv(funding.total.amount1 * shortfallInQuote, funding.totalInQuote) : 0n
 	};
+	const quoteAmount = shortfallInQuote * quotePercent / 100n;
+	const assetValue = shortfallInQuote - quoteAmount;
+	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
+	return {
+		requiredInQuote,
+		shortfallInQuote,
+		defaultQuotePercent,
+		amount0: quoteTokenIndex === 0 ? quoteAmount : ceilDiv(assetValue * Q96$3 * Q96$3, priceSquared),
+		amount1: quoteTokenIndex === 1 ? quoteAmount : ceilDiv(assetValue * priceSquared, Q96$3 * Q96$3)
+	};
+}
+/** Largest raw size funded by available collateral, including native-token rounding. */
+function getMaxLpPositionSize(params) {
+	if (params.minimumRequirement && (params.minimumRequirement.referenceSize <= 0n || params.minimumRequirement.requiredInQuote < 0n)) throw new Error("Invalid reference requirement");
+	if (params.availableInQuote <= 0n) return 0n;
+	let low = 0n;
+	let high = (1n << 128n) - 1n;
+	while (low < high) {
+		const mid = (low + high + 1n) / 2n;
+		const funding = getLpPositionFunding({
+			...params,
+			positionSize: mid
+		});
+		const minimum = params.minimumRequirement ? ceilDiv(params.minimumRequirement.requiredInQuote * mid, params.minimumRequirement.referenceSize) : 0n;
+		if (funding.totalInQuote <= params.availableInQuote && minimum <= params.availableInQuote) low = mid;
+		else high = mid - 1n;
+	}
+	return low;
 }
 
 //#endregion
-//#region src/uniswap/v3/abis/quoterV2.ts
+//#region src/uniswap/lpGreeks.ts
+const Q96$2 = 1n << 96n;
+const Q192$1 = 1n << 192n;
+/**
+* Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
+* at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
+* (`getAmountsForLiquidity`). All sqrt prices are X96. The current price is
+* clamped into the range, so out-of-range positions collapse to a single token.
+*/
+function getAmountsForLiquidity(sqrtPriceX96, sqrtRatioAX96, sqrtRatioBX96, liquidity) {
+	const [sqrtA, sqrtB] = sqrtRatioAX96 <= sqrtRatioBX96 ? [sqrtRatioAX96, sqrtRatioBX96] : [sqrtRatioBX96, sqrtRatioAX96];
+	const sqrtC = sqrtPriceX96 < sqrtA ? sqrtA : sqrtPriceX96 > sqrtB ? sqrtB : sqrtPriceX96;
+	const amount0 = sqrtC < sqrtB ? liquidity * (sqrtB - sqrtC) * Q96$2 / (sqrtC * sqrtB) : 0n;
+	const amount1 = sqrtC > sqrtA ? liquidity * (sqrtC - sqrtA) / Q96$2 : 0n;
+	return {
+		amount0,
+		amount1
+	};
+}
 /**
-* Minimal Uniswap v3 QuoterV2 ABI (`quoteExactInputSingle`).
+* Greeks (value, delta, gamma) for a Uniswap LP position in the chosen asset
+* frame. See the module docs for the unit conventions.
 *
-* QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /
-* `simulateContract`), so it must be simulated, not read.
-* @module uniswap/v3/abis/quoterV2
+* Closed forms (in-range, numeraire = token1 / asset = token0):
+*   value = amount1 + amount0·P               (P = sqrtP² / 2^192)
+*   delta = amount0                            (= dV/dP)
+*   gamma = P²·d²V/dP² = -L·sqrt(P)/2          (short gamma)
+* The `assetIndex = 1` frame is the symmetric inverse (numeraire = token0).
+* Gamma is zero when the price is outside the range (no curvature there).
 */
-const quoterV2Abi = [{
-	type: "function",
-	name: "quoteExactInputSingle",
-	stateMutability: "nonpayable",
-	inputs: [{
-		name: "params",
-		type: "tuple",
-		components: [
-			{
-				name: "tokenIn",
-				type: "address"
-			},
-			{
-				name: "tokenOut",
-				type: "address"
-			},
-			{
-				name: "amountIn",
-				type: "uint256"
-			},
-			{
-				name: "fee",
-				type: "uint24"
-			},
-			{
-				name: "sqrtPriceLimitX96",
-				type: "uint160"
-			}
-		]
-	}],
-	outputs: [
-		{
-			name: "amountOut",
-			type: "uint256"
-		},
-		{
-			name: "sqrtPriceX96After",
-			type: "uint160"
-		},
-		{
-			name: "initializedTicksCrossed",
-			type: "uint32"
-		},
-		{
-			name: "gasEstimate",
-			type: "uint256"
-		}
-	]
-}];
+function getLpGreeks(input) {
+	const { liquidity, tickLower, tickUpper, currentTick, assetIndex } = input;
+	const sqrtP = tickToSqrtPriceX96(currentTick);
+	const sqrtA = tickToSqrtPriceX96(tickLower);
+	const sqrtB = tickToSqrtPriceX96(tickUpper);
+	const { amount0, amount1 } = getAmountsForLiquidity(sqrtP, sqrtA, sqrtB, liquidity);
+	const sqrtP2 = sqrtP * sqrtP;
+	const inRange = sqrtP > sqrtA && sqrtP < sqrtB;
+	if (assetIndex === 0) {
+		const value$1 = amount1 + amount0 * sqrtP2 / Q192$1;
+		const delta$1 = amount0;
+		const gamma$1 = inRange ? -(liquidity * sqrtP) / (2n * Q96$2) : 0n;
+		return {
+			value: value$1,
+			delta: delta$1,
+			gamma: gamma$1
+		};
+	}
+	const value = amount0 + amount1 * Q192$1 / sqrtP2;
+	const delta = amount1;
+	const gamma = inRange ? -(liquidity * Q96$2) / (2n * sqrtP) : 0n;
+	return {
+		value,
+		delta,
+		gamma
+	};
+}
 
 //#endregion
-//#region src/uniswap/v3/router/quote.ts
-const BPS_DENOMINATOR$2 = 10000n;
-const UINT128_MAX$3 = (1n << 128n) - 1n;
+//#region src/uniswap/lpFeeReturn.ts
+const D = Decimal.clone({ precision: 60 });
+/** Simple fee APR over the full selected viewport, without compounding. */
+function annualizeLpFeeReturn(feeReturnPercent, durationSeconds) {
+	if (durationSeconds <= 0n) throw new Error("APR requires a positive window duration");
+	return new D(feeReturnPercent).mul(31536e3).div(durationSeconds.toString());
+}
 /**
-* Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
-* pool does not exist / has no liquidity) so callers can skip that pool when
-* ranking venues, rather than aborting the whole cycle.
+* Combine both fee tokens into a fee-only return on deployed LP capital.
+* Value both capital and fees at the window's opening price: this keeps fee
+* return flat when accrual stops and makes the ratio independent of quote
+* orientation. Raw token amounts already account for differing decimals.
+* Excludes principal price changes, impermanent loss and costs; not annualized.
+* Returns undefined when the position has no representable deployed capital.
 */
-async function quoteV3ExactIn(params) {
-	const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params;
-	if (amountIn < 0n || amountIn > UINT128_MAX$3) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
-	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$2) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
-	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
-	try {
-		const { result } = await client.simulateContract({
-			address: quoterV2,
-			abi: quoterV2Abi,
-			functionName: "quoteExactInputSingle",
-			blockNumber,
-			args: [{
-				tokenIn,
-				tokenOut,
-				amountIn,
-				fee: Number(fee),
-				sqrtPriceLimitX96: 0n
-			}]
-		});
-		const [amountOut, , , gasEstimate] = result;
-		const amountOutMinimum = amountOut * (BPS_DENOMINATOR$2 - slippageBps) / BPS_DENOMINATOR$2;
+function getLpFeeReturnSeries({ points, ranges, startTick }) {
+	const validTick$1 = (tick) => Number.isInteger(tick) && Math.abs(tick) <= 887272;
+	if (!validTick$1(startTick)) throw new Error("Invalid valuation tick");
+	const sqrtP = tickToSqrtPriceX96(BigInt(startTick));
+	const price = new D(sqrtP.toString()).pow(2).div(new D((1n << 192n).toString()));
+	let capital0 = 0n;
+	let capital1 = 0n;
+	for (const range of ranges) {
+		if (!validTick$1(range.tickLower) || !validTick$1(range.tickUpper) || range.tickLower >= range.tickUpper || range.liquidity < 0n) throw new Error("Invalid LP range");
+		const amounts = getAmountsForLiquidity(sqrtP, tickToSqrtPriceX96(BigInt(range.tickLower)), tickToSqrtPriceX96(BigInt(range.tickUpper)), range.liquidity);
+		capital0 += amounts.amount0;
+		capital1 += amounts.amount1;
+	}
+	const capital = new D(capital0.toString()).mul(price).plus(capital1.toString());
+	if (capital.isZero()) return void 0;
+	return points.map((point) => {
+		if (point.fees0 < 0n || point.fees1 < 0n) throw new Error("Invalid fee amount");
+		const fees = new D(point.fees0.toString()).mul(price).plus(point.fees1.toString());
 		return {
-			amountOut,
-			amountOutMinimum,
-			gasEstimate
+			...point,
+			feeReturnPercent: fees.div(capital).mul(100)
 		};
-	} catch (err) {
-		if (isRevert$1(err)) return null;
-		throw err;
-	}
-}
-/** True only for genuine contract reverts (missing pool / no liquidity). */
-function isRevert$1(err) {
-	return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof ContractFunctionRevertedError;
+	});
 }
 
 //#endregion
-//#region src/uniswap/v4/addresses.ts
+//#region src/uniswap/v4/router/errors.ts
 /**
-* Canonical Permit2, identical across all chains.
+* The chain has no configured Uniswap v4 addresses and none were supplied via
+* overrides.
 */
-const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var UnsupportedChainError = class extends PanopticError {
+	name = "UnsupportedChainError";
+	constructor(chainId, cause) {
+		super(`Uniswap v4 router not configured for chain ${chainId}`, cause);
+		this.chainId = chainId;
+	}
+};
 /**
-* Verified Uniswap v4 deployment addresses keyed by chainId.
-*
-* Sourced from the official Uniswap v4 deployments. Add a chain here only after
-* verifying each address against the canonical Uniswap deployment listing —
-* Universal Router in particular is NOT the same address across chains.
+* `tokenIn` is neither `currency0` nor `currency1` of the resolved pool.
 */
-const UNISWAP_V4_ADDRESSES = { 1: {
-	universalRouter: "0x66a9893cC07D91D95644AEDD05D03f95e1dBA8Af",
-	v4Quoter: "0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203",
-	poolManager: "0x000000000004444c5dc75cB358380D2e3dE08A90",
-	positionManager: "0xbD216513d74C8cf14cf4747E6AaA6420FF64ee9e",
-	permit2: PERMIT2_ADDRESS
-} };
+var InvalidSwapTokenError = class extends PanopticError {
+	name = "InvalidSwapTokenError";
+	constructor(token, currency0, currency1, cause) {
+		super(`Token ${token} is not part of the pool (currency0=${currency0}, currency1=${currency1})`, cause);
+		this.token = token;
+		this.currency0 = currency0;
+		this.currency1 = currency1;
+	}
+};
 /**
-* Resolve the Uniswap v4 addresses for a chain, applying optional overrides.
-*
-* @param chainId - Target chain ID.
-* @param overrides - Partial override of any address (e.g. for fork tests).
-* @returns Fully-resolved {@link UniswapV4Addresses}.
-* @throws {UnsupportedChainError} when the chain is not listed and the
-*   overrides do not supply every required address.
+* An amount exceeds the uint128 range required by the v4 swap encoding.
 */
-function getUniswapV4Addresses(chainId, overrides) {
-	const base = UNISWAP_V4_ADDRESSES[Number(chainId)];
+var AmountExceedsUint128Error = class extends PanopticError {
+	name = "AmountExceedsUint128Error";
+	constructor(amount, cause) {
+		super(`Amount ${amount} exceeds uint128 maximum`, cause);
+		this.amount = amount;
+	}
+};
+/**
+* A native-ETH swap needs a trailing Universal Router SWEEP to deliver the ETH
+* output (or refund the input overpay), but no `recipient` was supplied.
+*/
+var MissingSweepRecipientError = class extends PanopticError {
+	name = "MissingSweepRecipientError";
+	constructor(cause) {
+		super("A recipient is required to sweep native ETH back to the user", cause);
+	}
+};
+/**
+* The V4Quoter is not available for the chain (no fallback in v1).
+*/
+var QuoterUnavailableError = class extends PanopticError {
+	name = "QuoterUnavailableError";
+	constructor(chainId, cause) {
+		super(`V4Quoter unavailable for chain ${chainId}`, cause);
+		this.chainId = chainId;
+	}
+};
+
+//#endregion
+//#region src/uniswap/v3/addresses.ts
+/**
+* Verified Uniswap v3 QuoterV2 addresses keyed by chainId. Add a chain only
+* after verifying against the canonical Uniswap v3 deployment listing.
+*/
+const UNISWAP_V3_ADDRESSES = {
+	1: {
+		quoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+		nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
+	},
+	4663: {
+		quoterV2: "0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7",
+		nonfungiblePositionManager: "0x73991a25c818bf1f1128deaab1492d45638de0d3"
+	}
+};
+/**
+* Resolve Uniswap v3 addresses for a chain, applying optional overrides.
+*
+* @throws {UnsupportedChainError} when the chain is not listed and overrides do
+*   not supply every required address.
+*/
+function getUniswapV3Addresses(chainId, overrides) {
+	const id = Number(chainId);
+	const base = UNISWAP_V3_ADDRESSES[id];
 	const merged = {
 		...base,
-		...overrides,
-		permit2: overrides?.permit2 ?? base?.permit2 ?? PERMIT2_ADDRESS
+		...overrides
 	};
-	if (merged.universalRouter === void 0 || merged.v4Quoter === void 0 || merged.poolManager === void 0 || merged.positionManager === void 0 || merged.permit2 === void 0) throw new UnsupportedChainError(chainId);
+	if (!merged.quoterV2 || !merged.nonfungiblePositionManager) throw new UnsupportedChainError(BigInt(id));
 	return merged;
 }
 
 //#endregion
-//#region src/uniswap/v4/router/encodeSwap.ts
-/** Universal Router command byte for a v4 swap. */
-const V4_SWAP = 16;
-/** v4 action: exact-in single-hop swap. */
-const SWAP_EXACT_IN_SINGLE = 6;
-/** v4 action: pay all of the input currency owed. */
-const SETTLE_ALL = 12;
-/** v4 action: take all of the output currency owed. */
-const TAKE_ALL = 15;
-/** v4 action: take an output currency to an explicit recipient. */
-const TAKE = 14;
-/** v4 action: exact-out single-hop swap. */
-const SWAP_EXACT_OUT_SINGLE = 8;
-/** Universal Router command: sweep the router's token balance to a recipient. */
-const SWEEP = 4;
-/** v4 sentinel: take the full positive currency delta (used with TAKE). */
-const OPEN_DELTA = 0n;
-const UINT128_MAX$2 = (1n << 128n) - 1n;
-const poolKeyComponents = [
-	{
-		name: "currency0",
-		type: "address"
-	},
-	{
-		name: "currency1",
-		type: "address"
-	},
-	{
-		name: "fee",
-		type: "uint24"
-	},
-	{
-		name: "tickSpacing",
-		type: "int24"
-	},
-	{
-		name: "hooks",
-		type: "address"
-	}
-];
-const exactInputSingleParamsAbi = [{
-	type: "tuple",
-	components: [
-		{
-			name: "poolKey",
-			type: "tuple",
-			components: poolKeyComponents
-		},
-		{
-			name: "zeroForOne",
-			type: "bool"
-		},
-		{
-			name: "amountIn",
-			type: "uint128"
-		},
-		{
-			name: "amountOutMinimum",
-			type: "uint128"
-		},
+//#region src/uniswap/v4/abis/universalRouter.ts
+/**
+* Minimal Universal Router ABI (only the `execute` overload we use).
+* @module uniswap/v4/abis/universalRouter
+*/
+const universalRouterAbi = [{
+	type: "function",
+	name: "execute",
+	stateMutability: "payable",
+	inputs: [
 		{
-			name: "hookData",
+			name: "commands",
 			type: "bytes"
-		}
-	]
-}];
-const exactOutputSingleParamsAbi = [{
-	type: "tuple",
-	components: [
-		{
-			name: "poolKey",
-			type: "tuple",
-			components: poolKeyComponents
-		},
-		{
-			name: "zeroForOne",
-			type: "bool"
-		},
-		{
-			name: "amountOut",
-			type: "uint128"
 		},
 		{
-			name: "amountInMaximum",
-			type: "uint128"
+			name: "inputs",
+			type: "bytes[]"
 		},
 		{
-			name: "hookData",
-			type: "bytes"
+			name: "deadline",
+			type: "uint256"
 		}
-	]
-}];
-const currencyAmountAbi = [{
-	name: "currency",
-	type: "address"
-}, {
-	name: "amount",
-	type: "uint256"
+	],
+	outputs: []
 }];
-const takeToRecipientAbi = [
-	{
-		name: "currency",
-		type: "address"
-	},
+
+//#endregion
+//#region src/uniswap/v3/router/encodeSwap.ts
+/** Universal Router command byte for a v3 exact-in swap. */
+const V3_SWAP_EXACT_IN = 0;
+/** Universal Router command byte for a v3 exact-out swap. */
+const V3_SWAP_EXACT_OUT = 1;
+/**
+* Universal Router recipient sentinel: the router maps `address(1)` to
+* `msg.sender` (the `execute` caller). Uniswap `Constants.MSG_SENDER`.
+*/
+const MSG_SENDER = "0x0000000000000000000000000000000000000001";
+const UINT128_MAX$4 = (1n << 128n) - 1n;
+const v3ExactInInputAbi = [
 	{
 		name: "recipient",
 		type: "address"
 	},
 	{
-		name: "amount",
+		name: "amountIn",
 		type: "uint256"
-	}
-];
-const sweepParamsAbi = [
+	},
 	{
-		name: "token",
-		type: "address"
+		name: "amountOutMinimum",
+		type: "uint256"
 	},
 	{
-		name: "recipient",
-		type: "address"
+		name: "path",
+		type: "bytes"
 	},
 	{
-		name: "amountMin",
-		type: "uint256"
+		name: "payerIsUser",
+		type: "bool"
 	}
 ];
-function assertUint128(amount) {
-	if (amount < 0n || amount > UINT128_MAX$2) throw new AmountExceedsUint128Error(amount);
+function assertUint128$1(amount) {
+	if (amount < 0n || amount > UINT128_MAX$4) throw new AmountExceedsUint128Error(amount);
 }
 /**
-* Encode the input for a Universal Router `SWEEP` command that forwards the
-* router's full native-ETH balance (above `amountMin = 0`) to `recipient`.
+* Encode the packed v3 single-hop path `tokenIn ++ fee(uint24) ++ tokenOut`.
 */
-function encodeEthSweepInput(recipient) {
-	return encodeAbiParameters(sweepParamsAbi, [
-		zeroAddress,
-		recipient,
-		0n
+function encodeV3Path(tokenIn, fee, tokenOut) {
+	if (fee < 0n || fee > 0xffffffn) throw new PanopticError(`v3 fee ${fee} exceeds uint24`);
+	return encodePacked([
+		"address",
+		"uint24",
+		"address"
+	], [
+		tokenIn,
+		Number(fee),
+		tokenOut
 	]);
 }
 /**
-* Build the output-take v4 action byte + param.
-*
-* Native-ETH output is taken with the explicit-recipient `TAKE` action so the
-* router forwards the ETH straight to `recipient` (the implicit-`msgSender`
-* `TAKE_ALL` leaves native ETH held by the router). ERC20 output uses
-* `TAKE_ALL`, which already credits the caller.
-*
-* @param nativeAmount - TAKE amount for native-ETH output: `OPEN_DELTA` (0) to
-*   take the full credit (exact-in, protected by the swap's min) or the exact
-*   output (exact-out).
-* @param erc20Amount - TAKE_ALL min/amount for ERC20 output: `amountOutMinimum`
-*   (exact-in) or the exact output (exact-out).
+* Build the typed `execute(...)` args for an exact-in single-hop v3 swap whose
+* output is delivered to the `execute` caller (recipient = MSG_SENDER).
 */
-function buildOutputTake(tokenOut, recipient, nativeAmount, erc20Amount) {
-	if (tokenOut === zeroAddress) {
-		if (recipient === void 0) throw new MissingSweepRecipientError();
-		return {
-			action: TAKE,
-			param: encodeAbiParameters(takeToRecipientAbi, [
-				zeroAddress,
-				recipient,
-				nativeAmount
-			])
-		};
-	}
-	return {
-		action: TAKE_ALL,
-		param: encodeAbiParameters(currencyAmountAbi, [tokenOut, erc20Amount])
-	};
-}
-/**
-* Build the typed `execute(...)` args + msg.value for an exact-in single-hop v4
-* swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
-*
-* When `tokenOut` is native ETH the explicit-recipient `TAKE` action forwards
-* the bought ETH to `recipient` (no trailing SWEEP is needed for exact-in).
-*
-* @returns `args` ready to spread into `execute` and the ETH `value` to send
-*   (= `amountIn` for native-ETH input, otherwise `0n`).
-*/
-function buildV4SwapExecuteArgs(args) {
-	const { poolKey, zeroForOne, amountIn, amountOutMinimum, tokenIn, tokenOut, deadline, recipient, hookData = "0x" } = args;
-	assertUint128(amountIn);
-	assertUint128(amountOutMinimum);
-	const swapParam = encodeAbiParameters(exactInputSingleParamsAbi, [{
-		poolKey: {
-			currency0: poolKey.currency0,
-			currency1: poolKey.currency1,
-			fee: Number(poolKey.fee),
-			tickSpacing: Number(poolKey.tickSpacing),
-			hooks: poolKey.hooks
-		},
-		zeroForOne,
+function buildV3SwapExecuteArgs(args) {
+	const { tokenIn, tokenOut, fee, amountIn, amountOutMinimum, deadline } = args;
+	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-in router builder");
+	assertUint128$1(amountIn);
+	assertUint128$1(amountOutMinimum);
+	const path = encodeV3Path(tokenIn, fee, tokenOut);
+	const input = encodeAbiParameters(v3ExactInInputAbi, [
+		MSG_SENDER,
 		amountIn,
 		amountOutMinimum,
-		hookData
-	}]);
-	const settleParam = encodeAbiParameters(currencyAmountAbi, [tokenIn, amountIn]);
-	const take = buildOutputTake(tokenOut, recipient, OPEN_DELTA, amountOutMinimum);
-	const actions = encodePacked([
-		"uint8",
-		"uint8",
-		"uint8"
-	], [
-		SWAP_EXACT_IN_SINGLE,
-		SETTLE_ALL,
-		take.action
+		path,
+		true
 	]);
-	const v4Input = encodeAbiParameters([{
-		name: "actions",
-		type: "bytes"
-	}, {
-		name: "params",
-		type: "bytes[]"
-	}], [actions, [
-		swapParam,
-		settleParam,
-		take.param
-	]]);
-	const commands = encodePacked(["uint8"], [V4_SWAP]);
-	const value = tokenIn === zeroAddress ? amountIn : 0n;
+	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_IN]);
 	return {
 		args: [
 			commands,
-			[v4Input],
+			[input],
 			deadline
 		],
-		value
+		value: 0n
 	};
 }
 /**
-* Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
-* exact-in single-hop v4 swap.
-*
-* @returns The encoded calldata and the ETH `value` to send.
+* Build the `execute(commands, inputs, deadline)` calldata for an exact-in
+* single-hop v3 swap.
 */
-function buildV4SwapExecuteCalldata(args) {
-	const { args: executeArgs, value } = buildV4SwapExecuteArgs(args);
+function buildV3SwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV3SwapExecuteArgs(args);
 	const data = encodeFunctionData({
 		abi: universalRouterAbi,
 		functionName: "execute",
@@ -4138,81 +4189,57 @@ function buildV4SwapExecuteCalldata(args) {
 		value
 	};
 }
+const v3ExactOutInputAbi = [
+	{
+		name: "recipient",
+		type: "address"
+	},
+	{
+		name: "amountOut",
+		type: "uint256"
+	},
+	{
+		name: "amountInMaximum",
+		type: "uint256"
+	},
+	{
+		name: "path",
+		type: "bytes"
+	},
+	{
+		name: "payerIsUser",
+		type: "bool"
+	}
+];
 /**
-* Build the typed `execute(...)` args + msg.value for an exact-out single-hop v4
-* swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
-*
-* For native-ETH input, `value` is `amountInMaximum` (an overpay) and a trailing
-* `SWEEP` action refunds the unused ETH to `recipient`. For ERC20 input, Permit2
-* pulls only the settled amount, so no SWEEP is appended and `value` is `0n`.
-*
-* @returns `args` ready to spread into `execute` and the ETH `value` to send.
+* Build the typed `execute(...)` args for an exact-out single-hop v3 swap.
+* The v3 exact-out path is reversed: `tokenOut ++ fee ++ tokenIn`.
 */
-function buildV4ExactOutSwapExecuteArgs(args) {
-	const { poolKey, zeroForOne, amountOut, amountInMaximum, tokenIn, tokenOut, deadline, recipient, hookData = "0x" } = args;
-	assertUint128(amountOut);
-	assertUint128(amountInMaximum);
-	const swapParam = encodeAbiParameters(exactOutputSingleParamsAbi, [{
-		poolKey: {
-			currency0: poolKey.currency0,
-			currency1: poolKey.currency1,
-			fee: Number(poolKey.fee),
-			tickSpacing: Number(poolKey.tickSpacing),
-			hooks: poolKey.hooks
-		},
-		zeroForOne,
+function buildV3ExactOutSwapExecuteArgs(args) {
+	const { tokenIn, tokenOut, fee, amountOut, amountInMaximum, deadline } = args;
+	if (tokenIn === zeroAddress || tokenOut === zeroAddress) throw new PanopticError("native ETH is not supported by the v3 exact-out router builder");
+	assertUint128$1(amountOut);
+	assertUint128$1(amountInMaximum);
+	const path = encodeV3Path(tokenOut, fee, tokenIn);
+	const input = encodeAbiParameters(v3ExactOutInputAbi, [
+		MSG_SENDER,
 		amountOut,
 		amountInMaximum,
-		hookData
-	}]);
-	const settleParam = encodeAbiParameters(currencyAmountAbi, [tokenIn, amountInMaximum]);
-	const take = buildOutputTake(tokenOut, recipient, amountOut, amountOut);
-	const actions = encodePacked([
-		"uint8",
-		"uint8",
-		"uint8"
-	], [
-		SWAP_EXACT_OUT_SINGLE,
-		SETTLE_ALL,
-		take.action
+		path,
+		true
 	]);
-	const v4Input = encodeAbiParameters([{
-		name: "actions",
-		type: "bytes"
-	}, {
-		name: "params",
-		type: "bytes[]"
-	}], [actions, [
-		swapParam,
-		settleParam,
-		take.param
-	]]);
-	const isNativeIn = tokenIn === zeroAddress;
-	const commandList = [V4_SWAP];
-	const inputs = [v4Input];
-	if (isNativeIn) {
-		commandList.push(SWEEP);
-		inputs.push(encodeEthSweepInput(recipient));
-	}
-	const commands = encodePacked(commandList.map(() => "uint8"), commandList);
-	const value = isNativeIn ? amountInMaximum : 0n;
+	const commands = encodePacked(["uint8"], [V3_SWAP_EXACT_OUT]);
 	return {
 		args: [
 			commands,
-			inputs,
+			[input],
 			deadline
 		],
-		value
+		value: 0n
 	};
 }
-/**
-* Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
-* exact-out single-hop v4 swap.
-*
-* @returns The encoded calldata and the ETH `value` to send.
-*/
-function buildV4ExactOutSwapExecuteCalldata(args) {
-	const { args: executeArgs, value } = buildV4ExactOutSwapExecuteArgs(args);
+function buildV3ExactOutSwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV3ExactOutSwapExecuteArgs(args);
 	const data = encodeFunctionData({
 		abi: universalRouterAbi,
 		functionName: "execute",
@@ -4225,351 +4252,266 @@ function buildV4ExactOutSwapExecuteCalldata(args) {
 }
 
 //#endregion
-//#region src/panoptic/v2/clients/blockMeta.ts
-/**
-* Get block metadata for a given block.
-* Used to tag all read results with same-block consistency proof.
-*
-* @param params - The parameters
-* @returns Block metadata
-*/
-async function getBlockMeta(params) {
-	const { client, blockNumber } = params;
-	const block = await client.getBlock({
-		blockNumber,
-		includeTransactions: false
-	});
-	return {
-		blockNumber: block.number,
-		blockHash: block.hash,
-		blockTimestamp: block.timestamp
-	};
-}
-
-//#endregion
-//#region src/panoptic/v2/writes/utils.ts
-/**
-* Decode PositionBalance packed data.
-*
-* Layout (from LSB to MSB):
-* - positionSize:     bits 0-127   (uint128)
-* - poolUtilization0: bits 128-143 (uint16)
-* - poolUtilization1: bits 144-159 (uint16)
-* - tickAtMint:       bits 160-183 (int24)
-* - timestampAtMint:  bits 184-215 (uint32)
-* - blockAtMint:      bits 216-254 (uint39)
-* - swapAtMint:       bit 255      (bool)
-*/
-function decodePositionBalance(balanceData) {
-	const positionSize = balanceData & (1n << 128n) - 1n;
-	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;
-	return {
-		positionSize,
-		poolUtilization0,
-		poolUtilization1,
-		tickAtMint,
-		timestampAtMint,
-		blockAtMint,
-		swapAtMint
-	};
-}
-/**
-* Decode LeftRightSigned packed value.
-*/
-function decodeLeftRightSigned(value) {
-	let right = value & (1n << 128n) - 1n;
-	let left = value >> 128n;
-	if (right >= 1n << 127n) right = right - (1n << 128n);
-	if (left >= 1n << 127n) left = left - (1n << 128n);
-	return {
-		right,
-		left
-	};
-}
+//#region src/uniswap/v3/abis/quoterV2.ts
 /**
-* Parse Panoptic events from transaction logs.
+* Minimal Uniswap v3 QuoterV2 ABI.
 *
-* @param logs - The transaction logs
-* @returns Parsed Panoptic events
+* QuoterV2 is revert/staticcall-based (nonpayable but intended for `eth_call` /
+* `simulateContract`), so it must be simulated, not read.
+* @module uniswap/v3/abis/quoterV2
 */
-function parsePanopticEvents(logs) {
-	const events = [];
-	for (const log of logs) {
-		const baseEvent = {
-			blockNumber: log.blockNumber ?? 0n,
-			blockHash: log.blockHash ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
-			transactionHash: log.transactionHash ?? "0x",
-			logIndex: BigInt(log.logIndex ?? 0)
-		};
-		try {
-			const poolEvent = decodeEventLog({
-				abi: panopticPoolV2Abi,
-				data: log.data,
-				topics: log.topics
-			});
-			if (poolEvent.eventName === "OptionMinted") {
-				const args = poolEvent.args;
-				const balance = decodePositionBalance(args.balanceData);
-				events.push({
-					type: "OptionMinted",
-					...baseEvent,
-					recipient: args.recipient,
-					tokenId: args.tokenId,
-					positionSize: balance.positionSize,
-					poolUtilization0: balance.poolUtilization0,
-					poolUtilization1: balance.poolUtilization1,
-					tickAtMint: balance.tickAtMint,
-					timestampAtMint: balance.timestampAtMint,
-					blockAtMint: balance.blockAtMint,
-					swapAtMint: balance.swapAtMint
-				});
-			} else if (poolEvent.eventName === "OptionBurnt") {
-				const args = poolEvent.args;
-				events.push({
-					type: "OptionBurnt",
-					...baseEvent,
-					recipient: args.recipient,
-					tokenId: args.tokenId,
-					positionSize: args.positionSize,
-					premiaByLeg: [
-						args.premiaByLeg[0] ?? 0n,
-						args.premiaByLeg[1] ?? 0n,
-						args.premiaByLeg[2] ?? 0n,
-						args.premiaByLeg[3] ?? 0n
-					]
-				});
-			} else if (poolEvent.eventName === "AccountLiquidated") {
-				const args = poolEvent.args;
-				const { right, left } = decodeLeftRightSigned(args.bonusAmounts);
-				events.push({
-					type: "AccountLiquidated",
-					...baseEvent,
-					liquidator: args.liquidator,
-					liquidatee: args.liquidatee,
-					bonusAmount0: right,
-					bonusAmount1: left
-				});
-			} else if (poolEvent.eventName === "ForcedExercised") {
-				const args = poolEvent.args;
-				const { right, left } = decodeLeftRightSigned(args.exerciseFee);
-				events.push({
-					type: "ForcedExercised",
-					...baseEvent,
-					exercisor: args.exercisor,
-					user: args.user,
-					tokenId: args.tokenId,
-					exerciseFee0: right,
-					exerciseFee1: left
-				});
-			} else if (poolEvent.eventName === "PremiumSettled") {
-				const args = poolEvent.args;
-				const { right, left } = decodeLeftRightSigned(args.settledAmounts);
-				events.push({
-					type: "PremiumSettled",
-					...baseEvent,
-					user: args.user,
-					tokenId: args.tokenId,
-					legIndex: args.legIndex,
-					settledAmount0: right,
-					settledAmount1: left
-				});
-			}
-		} catch {
-			try {
-				const collateralEvent = decodeEventLog({
-					abi: collateralTrackerV2Abi,
-					data: log.data,
-					topics: log.topics
-				});
-				if (collateralEvent.eventName === "Deposit") {
-					const args = collateralEvent.args;
-					events.push({
-						type: "Deposit",
-						...baseEvent,
-						sender: args.sender,
-						owner: args.owner,
-						assets: args.assets,
-						shares: args.shares
-					});
-				} else if (collateralEvent.eventName === "Withdraw") {
-					const args = collateralEvent.args;
-					events.push({
-						type: "Withdraw",
-						...baseEvent,
-						sender: args.sender,
-						receiver: args.receiver,
-						owner: args.owner,
-						assets: args.assets,
-						shares: args.shares
-					});
-				}
-			} catch {}
-		}
-	}
-	return events;
-}
-/**
-* Create a TxResult from a transaction hash.
-*
-* @param client - The public client
-* @param hash - The transaction hash
-* @returns TxResult with wait function
-*/
-function createTxResult(client, hash) {
-	return {
-		hash,
-		wait: async (confirmations) => {
-			const receipt = await client.waitForTransactionReceipt({
-				hash,
-				confirmations: confirmations !== void 0 ? Number(confirmations) : void 0
-			});
-			const events = parsePanopticEvents(receipt.logs);
-			return {
-				hash: receipt.transactionHash,
-				blockNumber: receipt.blockNumber,
-				blockHash: receipt.blockHash,
-				gasUsed: receipt.gasUsed,
-				status: receipt.status === "success" ? "success" : "reverted",
-				events
-			};
-		}
-	};
-}
-/**
-* Submit a write operation, supporting both direct wallet submission
-* and custom broadcaster paths with gas overrides.
-*
-* Normal path (no broadcaster): calls walletClient.writeContract() with gas overrides.
-* Broadcaster path: prepareTransactionRequest → apply overrides → signTransaction → broadcast.
-*
-* @param params - Submit write parameters
-* @returns TxResult
-*/
-async function submitWrite(params) {
-	const { client, walletClient, account, address, abi, functionName, args, value, txOverrides } = params;
-	const broadcaster = txOverrides?.broadcaster;
-	if (broadcaster) {
-		const data = encodeFunctionData({
-			abi,
-			functionName,
-			args
-		});
-		const broadcastAccount = walletClient.account ?? account;
-		const request = await walletClient.prepareTransactionRequest({
-			account: broadcastAccount,
-			to: address,
-			chain: walletClient.chain,
-			data,
-			...value !== void 0 && { value },
-			...txOverrides?.maxFeePerGas !== void 0 && { maxFeePerGas: txOverrides.maxFeePerGas },
-			...txOverrides?.maxPriorityFeePerGas !== void 0 && { maxPriorityFeePerGas: txOverrides.maxPriorityFeePerGas },
-			...txOverrides?.gas !== void 0 && { gas: txOverrides.gas },
-			...txOverrides?.nonce !== void 0 && { nonce: Number(txOverrides.nonce) }
-		});
-		const signedTx = await walletClient.signTransaction({
-			...request,
-			account: broadcastAccount
-		});
-		const hash$1 = await broadcaster.broadcast(signedTx);
-		return createTxResult(client, hash$1);
-	}
-	const gasOverrides = {};
-	if (txOverrides?.maxFeePerGas !== void 0) gasOverrides.maxFeePerGas = txOverrides.maxFeePerGas;
-	if (txOverrides?.maxPriorityFeePerGas !== void 0) gasOverrides.maxPriorityFeePerGas = txOverrides.maxPriorityFeePerGas;
-	if (txOverrides?.nonce !== void 0) gasOverrides.nonce = Number(txOverrides.nonce);
-	const resolvedAccount = walletClient.account ?? account;
-	if (txOverrides?.gas !== void 0) gasOverrides.gas = txOverrides.gas;
-	else {
-		const estimated = await client.estimateContractGas({
-			address,
-			abi,
-			functionName,
-			args,
-			account: resolvedAccount,
-			...value !== void 0 && { value }
-		});
-		gasOverrides.gas = estimated * 120n / 100n;
-	}
-	const hash = await walletClient.writeContract({
-		address,
-		abi,
-		functionName,
-		args,
-		account: resolvedAccount,
-		chain: walletClient.chain,
-		...value !== void 0 && { value },
-		...gasOverrides
-	});
-	return createTxResult(client, hash);
-}
-
-//#endregion
-//#region src/panoptic/v2/sync/snapshotRecovery.ts
-const rolesExecutionAbi = parseAbi(["function execTransactionWithRole(address to, uint256 value, bytes data, uint8 operation, bytes32 roleKey, bool shouldRevert)"]);
-/**
-* 4-byte function selectors for dispatch/dispatchFrom, derived from the generated ABI.
-* Used for scanning raw calldata inside smart contract wallet wrappers.
-*/
-const DISPATCH_SELECTOR = toFunctionSelector(panopticPoolV2Abi.find((e) => e.type === "function" && e.name === "dispatch")).slice(2);
-const DISPATCH_FROM_SELECTOR = toFunctionSelector(panopticPoolV2Abi.find((e) => e.type === "function" && e.name === "dispatchFrom")).slice(2);
-
-//#endregion
-//#region src/panoptic/v2/abis/stateView.ts
-/**
-* Minimal Uniswap V4 StateView ABI for fee growth reads.
-* Only includes functions needed by streamia history.
-*/
-const stateViewAbi = [
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getSlot0",
-		outputs: [
+const quoterV2Abi = [{
+	type: "function",
+	name: "quoteExactInputSingle",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
 			{
-				internalType: "uint160",
-				name: "sqrtPriceX96",
-				type: "uint160"
+				name: "tokenIn",
+				type: "address"
 			},
 			{
-				internalType: "int24",
-				name: "tick",
-				type: "int24"
+				name: "tokenOut",
+				type: "address"
 			},
 			{
-				internalType: "uint24",
-				name: "protocolFee",
-				type: "uint24"
+				name: "amountIn",
+				type: "uint256"
 			},
 			{
-				internalType: "uint24",
-				name: "lpFee",
+				name: "fee",
 				type: "uint24"
+			},
+			{
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
 			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [{
-			internalType: "PoolId",
-			name: "poolId",
-			type: "bytes32"
-		}],
-		name: "getFeeGrowthGlobals",
-		outputs: [{
-			internalType: "uint256",
-			name: "feeGrowthGlobal0",
-			type: "uint256"
-		}, {
+		]
+	}],
+	outputs: [
+		{
+			name: "amountOut",
+			type: "uint256"
+		},
+		{
+			name: "sqrtPriceX96After",
+			type: "uint160"
+		},
+		{
+			name: "initializedTicksCrossed",
+			type: "uint32"
+		},
+		{
+			name: "gasEstimate",
+			type: "uint256"
+		}
+	]
+}, {
+	type: "function",
+	name: "quoteExactOutputSingle",
+	stateMutability: "nonpayable",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
+			{
+				name: "tokenIn",
+				type: "address"
+			},
+			{
+				name: "tokenOut",
+				type: "address"
+			},
+			{
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				name: "fee",
+				type: "uint24"
+			},
+			{
+				name: "sqrtPriceLimitX96",
+				type: "uint160"
+			}
+		]
+	}],
+	outputs: [
+		{
+			name: "amountIn",
+			type: "uint256"
+		},
+		{
+			name: "sqrtPriceX96After",
+			type: "uint160"
+		},
+		{
+			name: "initializedTicksCrossed",
+			type: "uint32"
+		},
+		{
+			name: "gasEstimate",
+			type: "uint256"
+		}
+	]
+}];
+
+//#endregion
+//#region src/uniswap/v3/router/quote.ts
+const BPS_DENOMINATOR$2 = 10000n;
+const UINT128_MAX$3 = (1n << 128n) - 1n;
+/**
+* Quote an exact-in v3 swap. Returns `null` when the quote reverts (e.g. the
+* pool does not exist / has no liquidity) so callers can skip that pool when
+* ranking venues, rather than aborting the whole cycle.
+*/
+async function quoteV3ExactIn(params) {
+	const { client, chainId, tokenIn, tokenOut, fee, amountIn, slippageBps, blockNumber } = params;
+	if (amountIn < 0n || amountIn > UINT128_MAX$3) throw new PanopticError(`amountIn ${amountIn} exceeds uint128 maximum`);
+	assertSlippageBps$1(slippageBps);
+	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
+	try {
+		const { result } = await client.simulateContract({
+			address: quoterV2,
+			abi: quoterV2Abi,
+			functionName: "quoteExactInputSingle",
+			blockNumber,
+			args: [{
+				tokenIn,
+				tokenOut,
+				amountIn,
+				fee: Number(fee),
+				sqrtPriceLimitX96: 0n
+			}]
+		});
+		const [amountOut, , , gasEstimate] = result;
+		const amountOutMinimum = amountOut * (BPS_DENOMINATOR$2 - slippageBps) / BPS_DENOMINATOR$2;
+		return {
+			amountOut,
+			amountOutMinimum,
+			gasEstimate
+		};
+	} catch (err) {
+		if (isRevert$1(err)) return null;
+		throw err;
+	}
+}
+/**
+* Quote an exact-out v3 swap. Returns `null` on revert (no pool / no liquidity).
+*/
+async function quoteV3ExactOut(params) {
+	const { client, chainId, tokenIn, tokenOut, fee, amountOut, slippageBps, blockNumber } = params;
+	if (amountOut < 0n || amountOut > UINT128_MAX$3) throw new PanopticError(`amountOut ${amountOut} exceeds uint128 maximum`);
+	assertSlippageBps$1(slippageBps);
+	const { quoterV2 } = getUniswapV3Addresses(chainId, params.addresses);
+	try {
+		const { result } = await client.simulateContract({
+			address: quoterV2,
+			abi: quoterV2Abi,
+			functionName: "quoteExactOutputSingle",
+			blockNumber,
+			args: [{
+				tokenIn,
+				tokenOut,
+				amount: amountOut,
+				fee: Number(fee),
+				sqrtPriceLimitX96: 0n
+			}]
+		});
+		const [amountIn, , , gasEstimate] = result;
+		const amountInMaximum = (amountIn * (BPS_DENOMINATOR$2 + slippageBps) + BPS_DENOMINATOR$2 - 1n) / BPS_DENOMINATOR$2;
+		return {
+			amountIn,
+			amountInMaximum,
+			gasEstimate
+		};
+	} catch (err) {
+		if (isRevert$1(err)) return null;
+		throw err;
+	}
+}
+function assertSlippageBps$1(slippageBps) {
+	if (slippageBps < 0n || slippageBps > BPS_DENOMINATOR$2) throw new PanopticError(`invalid slippageBps ${slippageBps}, must be 0..10000`);
+}
+function isRevert$1(err) {
+	return err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionRevertedError) instanceof ContractFunctionRevertedError;
+}
+
+//#endregion
+//#region src/panoptic/v2/clients/blockMeta.ts
+/**
+* Get block metadata for a given block.
+* Used to tag all read results with same-block consistency proof.
+*
+* @param params - The parameters
+* @returns Block metadata
+*/
+async function getBlockMeta(params) {
+	const { client, blockNumber } = params;
+	const block = await client.getBlock({
+		blockNumber,
+		includeTransactions: false
+	});
+	return {
+		blockNumber: block.number,
+		blockHash: block.hash,
+		blockTimestamp: block.timestamp
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/abis/stateView.ts
+/**
+* Minimal Uniswap V4 StateView ABI for fee growth reads.
+* Only includes functions needed by streamia history.
+*/
+const stateViewAbi = [
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getSlot0",
+		outputs: [
+			{
+				internalType: "uint160",
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				internalType: "int24",
+				name: "tick",
+				type: "int24"
+			},
+			{
+				internalType: "uint24",
+				name: "protocolFee",
+				type: "uint24"
+			},
+			{
+				internalType: "uint24",
+				name: "lpFee",
+				type: "uint24"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "PoolId",
+			name: "poolId",
+			type: "bytes32"
+		}],
+		name: "getFeeGrowthGlobals",
+		outputs: [{
+			internalType: "uint256",
+			name: "feeGrowthGlobal0",
+			type: "uint256"
+		}, {
 			internalType: "uint256",
 			name: "feeGrowthGlobal1",
 			type: "uint256"
@@ -5174,134 +5116,938 @@ async function getPool(params) {
 	const healthStatus = safeModeRaw === 0 ? "active" : safeModeRaw === 1 ? "low_liquidity" : "paused";
 	const sqrtPriceX96 = tickToSqrtPriceX96(BigInt(currentTick));
 	return {
-		address: poolAddress,
-		chainId,
-		poolId: metadata.poolId,
-		poolKey,
-		tickSpacing,
-		collateralTracker0,
-		collateralTracker1,
-		riskEngine,
-		currentTick: BigInt(currentTick),
-		sqrtPriceX96,
-		uniswapPoolLiquidity,
-		healthStatus,
-		metadata,
-		_meta
+		address: poolAddress,
+		chainId,
+		poolId: metadata.poolId,
+		poolKey,
+		tickSpacing,
+		collateralTracker0,
+		collateralTracker1,
+		riskEngine,
+		currentTick: BigInt(currentTick),
+		sqrtPriceX96,
+		uniswapPoolLiquidity,
+		healthStatus,
+		metadata,
+		_meta
+	};
+}
+/**
+* Extract tickSpacing from the encoded 64-bit poolId.
+* Layout: poolAddress (5 bytes) + vegoid (1 byte) + tickSpacing (2 bytes).
+* tickSpacing occupies bits 48–63.
+*/
+function tickSpacingFromPoolId(poolId) {
+	return poolId >> 48n & 0xffffn;
+}
+/**
+* Parse pool key from ABI-encoded bytes.
+*
+* V4 pools: PoolKey struct is ABI-encoded as 5 consecutive 32-byte slots
+*   (currency0, currency1, fee, tickSpacing, hooks).
+*
+* V3 pools: poolKey() returns abi.encode(uniswapV3PoolAddress) — a single
+*   32-byte slot. The struct fields are not available, so currency0/currency1
+*   are zeroed and tickSpacing/fee are set to 0 (callers should use
+*   getV3PoolTickSpacing and getV3PoolFee respectively).
+*/
+function parsePoolKey(poolKeyBytes) {
+	const hex = poolKeyBytes.slice(2);
+	if (hex.length <= 64) return {
+		currency0: zeroAddress,
+		currency1: zeroAddress,
+		fee: 0n,
+		tickSpacing: 0n,
+		hooks: zeroAddress
+	};
+	if (hex.length < 320) throw new Error(`Malformed V4 pool key: expected 320 hex chars (160 bytes), got ${hex.length}`);
+	const currency0 = `0x${hex.slice(24, 64)}`;
+	const currency1 = `0x${hex.slice(88, 128)}`;
+	const fee = BigInt(`0x${hex.slice(128, 192)}`);
+	const tickSpacing = BigInt(`0x${hex.slice(192, 256)}`);
+	const hooks = `0x${hex.slice(280, 320)}`;
+	return {
+		currency0,
+		currency1,
+		fee,
+		tickSpacing,
+		hooks
+	};
+}
+
+//#endregion
+//#region src/uniswap/v3/router/resolveRoute.ts
+async function resolveV3SwapRoute(params) {
+	const { client, poolAddress, tokenIn } = params;
+	const meta = await getPoolMetadata({
+		client,
+		poolAddress
+	});
+	if (meta.isV4) throw new PanopticError("resolveV3SwapRoute called on a v4 pool");
+	const isToken0 = isAddressEqual(tokenIn, meta.token0Asset);
+	const isToken1 = isAddressEqual(tokenIn, meta.token1Asset);
+	if (!isToken0 && !isToken1) throw new InvalidSwapTokenError(tokenIn, meta.token0Asset, meta.token1Asset);
+	const zeroForOne = isToken0;
+	return {
+		tokenIn,
+		tokenOut: zeroForOne ? meta.token1Asset : meta.token0Asset,
+		fee: meta.fee,
+		zeroForOne
+	};
+}
+
+//#endregion
+//#region src/uniswap/v3/router/quoteViaRouter.ts
+const FALLBACK_META$1 = {
+	blockNumber: 0n,
+	blockTimestamp: 0n,
+	blockHash: "0x0"
+};
+async function quoteSwapExactInViaV3Router(params) {
+	const { client, poolAddress, chainId, tokenIn, amountIn, slippageBps, blockNumber, addresses } = params;
+	try {
+		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+		const metaPromise = getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		metaPromise.catch(() => void 0);
+		const route = await resolveV3SwapRoute({
+			client,
+			poolAddress,
+			tokenIn
+		});
+		const quote = await quoteV3ExactIn({
+			client,
+			chainId,
+			tokenIn: route.tokenIn,
+			tokenOut: route.tokenOut,
+			fee: route.fee,
+			amountIn,
+			slippageBps,
+			blockNumber: targetBlockNumber,
+			addresses
+		});
+		if (!quote) throw new PanopticError("v3 quote returned no result (pool may have no liquidity)");
+		const _meta = await metaPromise;
+		return {
+			success: true,
+			data: {
+				amountOut: quote.amountOut,
+				amountOutMinimum: quote.amountOutMinimum,
+				zeroForOne: route.zeroForOne,
+				tokenOut: route.tokenOut,
+				gasEstimate: quote.gasEstimate
+			},
+			gasEstimate: quote.gasEstimate,
+			_meta
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Quote failed", error instanceof Error ? error : void 0),
+			_meta: FALLBACK_META$1
+		};
+	}
+}
+async function quoteSwapExactOutViaV3Router(params) {
+	const { client, poolAddress, chainId, tokenIn, amountOut, slippageBps, blockNumber, addresses } = params;
+	try {
+		const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
+		const metaPromise = getBlockMeta({
+			client,
+			blockNumber: targetBlockNumber
+		});
+		metaPromise.catch(() => void 0);
+		const route = await resolveV3SwapRoute({
+			client,
+			poolAddress,
+			tokenIn
+		});
+		const quote = await quoteV3ExactOut({
+			client,
+			chainId,
+			tokenIn: route.tokenIn,
+			tokenOut: route.tokenOut,
+			fee: route.fee,
+			amountOut,
+			slippageBps,
+			blockNumber: targetBlockNumber,
+			addresses
+		});
+		if (!quote) throw new PanopticError("v3 quote returned no result (pool may have no liquidity)");
+		const _meta = await metaPromise;
+		return {
+			success: true,
+			data: {
+				amountIn: quote.amountIn,
+				amountInMaximum: quote.amountInMaximum,
+				zeroForOne: route.zeroForOne,
+				tokenOut: route.tokenOut,
+				gasEstimate: quote.gasEstimate
+			},
+			gasEstimate: quote.gasEstimate,
+			_meta
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof PanopticError ? error : new PanopticError(error instanceof Error ? error.message : "Quote failed", error instanceof Error ? error : void 0),
+			_meta: FALLBACK_META$1
+		};
+	}
+}
+
+//#endregion
+//#region src/panoptic/v2/writes/utils.ts
+/**
+* Decode PositionBalance packed data.
+*
+* Layout (from LSB to MSB):
+* - positionSize:     bits 0-127   (uint128)
+* - poolUtilization0: bits 128-143 (uint16)
+* - poolUtilization1: bits 144-159 (uint16)
+* - tickAtMint:       bits 160-183 (int24)
+* - timestampAtMint:  bits 184-215 (uint32)
+* - blockAtMint:      bits 216-254 (uint39)
+* - swapAtMint:       bit 255      (bool)
+*/
+function decodePositionBalance(balanceData) {
+	const positionSize = balanceData & (1n << 128n) - 1n;
+	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;
+	return {
+		positionSize,
+		poolUtilization0,
+		poolUtilization1,
+		tickAtMint,
+		timestampAtMint,
+		blockAtMint,
+		swapAtMint
+	};
+}
+/**
+* Decode LeftRightSigned packed value.
+*/
+function decodeLeftRightSigned(value) {
+	let right = value & (1n << 128n) - 1n;
+	let left = value >> 128n;
+	if (right >= 1n << 127n) right = right - (1n << 128n);
+	if (left >= 1n << 127n) left = left - (1n << 128n);
+	return {
+		right,
+		left
+	};
+}
+/**
+* Parse Panoptic events from transaction logs.
+*
+* @param logs - The transaction logs
+* @returns Parsed Panoptic events
+*/
+function parsePanopticEvents(logs) {
+	const events = [];
+	for (const log of logs) {
+		const baseEvent = {
+			blockNumber: log.blockNumber ?? 0n,
+			blockHash: log.blockHash ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+			transactionHash: log.transactionHash ?? "0x",
+			logIndex: BigInt(log.logIndex ?? 0)
+		};
+		try {
+			const poolEvent = decodeEventLog({
+				abi: panopticPoolV2Abi,
+				data: log.data,
+				topics: log.topics
+			});
+			if (poolEvent.eventName === "OptionMinted") {
+				const args = poolEvent.args;
+				const balance = decodePositionBalance(args.balanceData);
+				events.push({
+					type: "OptionMinted",
+					...baseEvent,
+					recipient: args.recipient,
+					tokenId: args.tokenId,
+					positionSize: balance.positionSize,
+					poolUtilization0: balance.poolUtilization0,
+					poolUtilization1: balance.poolUtilization1,
+					tickAtMint: balance.tickAtMint,
+					timestampAtMint: balance.timestampAtMint,
+					blockAtMint: balance.blockAtMint,
+					swapAtMint: balance.swapAtMint
+				});
+			} else if (poolEvent.eventName === "OptionBurnt") {
+				const args = poolEvent.args;
+				events.push({
+					type: "OptionBurnt",
+					...baseEvent,
+					recipient: args.recipient,
+					tokenId: args.tokenId,
+					positionSize: args.positionSize,
+					premiaByLeg: [
+						args.premiaByLeg[0] ?? 0n,
+						args.premiaByLeg[1] ?? 0n,
+						args.premiaByLeg[2] ?? 0n,
+						args.premiaByLeg[3] ?? 0n
+					]
+				});
+			} else if (poolEvent.eventName === "AccountLiquidated") {
+				const args = poolEvent.args;
+				const { right, left } = decodeLeftRightSigned(args.bonusAmounts);
+				events.push({
+					type: "AccountLiquidated",
+					...baseEvent,
+					liquidator: args.liquidator,
+					liquidatee: args.liquidatee,
+					bonusAmount0: right,
+					bonusAmount1: left
+				});
+			} else if (poolEvent.eventName === "ForcedExercised") {
+				const args = poolEvent.args;
+				const { right, left } = decodeLeftRightSigned(args.exerciseFee);
+				events.push({
+					type: "ForcedExercised",
+					...baseEvent,
+					exercisor: args.exercisor,
+					user: args.user,
+					tokenId: args.tokenId,
+					exerciseFee0: right,
+					exerciseFee1: left
+				});
+			} else if (poolEvent.eventName === "PremiumSettled") {
+				const args = poolEvent.args;
+				const { right, left } = decodeLeftRightSigned(args.settledAmounts);
+				events.push({
+					type: "PremiumSettled",
+					...baseEvent,
+					user: args.user,
+					tokenId: args.tokenId,
+					legIndex: args.legIndex,
+					settledAmount0: right,
+					settledAmount1: left
+				});
+			}
+		} catch {
+			try {
+				const collateralEvent = decodeEventLog({
+					abi: collateralTrackerV2Abi,
+					data: log.data,
+					topics: log.topics
+				});
+				if (collateralEvent.eventName === "Deposit") {
+					const args = collateralEvent.args;
+					events.push({
+						type: "Deposit",
+						...baseEvent,
+						sender: args.sender,
+						owner: args.owner,
+						assets: args.assets,
+						shares: args.shares
+					});
+				} else if (collateralEvent.eventName === "Withdraw") {
+					const args = collateralEvent.args;
+					events.push({
+						type: "Withdraw",
+						...baseEvent,
+						sender: args.sender,
+						receiver: args.receiver,
+						owner: args.owner,
+						assets: args.assets,
+						shares: args.shares
+					});
+				}
+			} catch {}
+		}
+	}
+	return events;
+}
+/**
+* Create a TxResult from a transaction hash.
+*
+* @param client - The public client
+* @param hash - The transaction hash
+* @returns TxResult with wait function
+*/
+function createTxResult(client, hash) {
+	return {
+		hash,
+		wait: async (confirmations) => {
+			const receipt = await client.waitForTransactionReceipt({
+				hash,
+				confirmations: confirmations !== void 0 ? Number(confirmations) : void 0
+			});
+			const events = parsePanopticEvents(receipt.logs);
+			return {
+				hash: receipt.transactionHash,
+				blockNumber: receipt.blockNumber,
+				blockHash: receipt.blockHash,
+				gasUsed: receipt.gasUsed,
+				status: receipt.status === "success" ? "success" : "reverted",
+				events
+			};
+		}
+	};
+}
+/**
+* Submit a write operation, supporting both direct wallet submission
+* and custom broadcaster paths with gas overrides.
+*
+* Normal path (no broadcaster): calls walletClient.writeContract() with gas overrides.
+* Broadcaster path: prepareTransactionRequest → apply overrides → signTransaction → broadcast.
+*
+* @param params - Submit write parameters
+* @returns TxResult
+*/
+async function submitWrite(params) {
+	const { client, walletClient, account, address, abi, functionName, args, value, txOverrides } = params;
+	const broadcaster = txOverrides?.broadcaster;
+	if (broadcaster) {
+		const data = encodeFunctionData({
+			abi,
+			functionName,
+			args
+		});
+		const broadcastAccount = walletClient.account ?? account;
+		const request = await walletClient.prepareTransactionRequest({
+			account: broadcastAccount,
+			to: address,
+			chain: walletClient.chain,
+			data,
+			...value !== void 0 && { value },
+			...txOverrides?.maxFeePerGas !== void 0 && { maxFeePerGas: txOverrides.maxFeePerGas },
+			...txOverrides?.maxPriorityFeePerGas !== void 0 && { maxPriorityFeePerGas: txOverrides.maxPriorityFeePerGas },
+			...txOverrides?.gas !== void 0 && { gas: txOverrides.gas },
+			...txOverrides?.nonce !== void 0 && { nonce: Number(txOverrides.nonce) }
+		});
+		const signedTx = await walletClient.signTransaction({
+			...request,
+			account: broadcastAccount
+		});
+		const hash$1 = await broadcaster.broadcast(signedTx);
+		return createTxResult(client, hash$1);
+	}
+	const gasOverrides = {};
+	if (txOverrides?.maxFeePerGas !== void 0) gasOverrides.maxFeePerGas = txOverrides.maxFeePerGas;
+	if (txOverrides?.maxPriorityFeePerGas !== void 0) gasOverrides.maxPriorityFeePerGas = txOverrides.maxPriorityFeePerGas;
+	if (txOverrides?.nonce !== void 0) gasOverrides.nonce = Number(txOverrides.nonce);
+	const resolvedAccount = walletClient.account ?? account;
+	if (txOverrides?.gas !== void 0) gasOverrides.gas = txOverrides.gas;
+	else {
+		const estimated = await client.estimateContractGas({
+			address,
+			abi,
+			functionName,
+			args,
+			account: resolvedAccount,
+			...value !== void 0 && { value }
+		});
+		gasOverrides.gas = estimated * 120n / 100n;
+	}
+	const hash = await walletClient.writeContract({
+		address,
+		abi,
+		functionName,
+		args,
+		account: resolvedAccount,
+		chain: walletClient.chain,
+		...value !== void 0 && { value },
+		...gasOverrides
+	});
+	return createTxResult(client, hash);
+}
+
+//#endregion
+//#region src/uniswap/v4/addresses.ts
+/**
+* Canonical Permit2, identical across all chains.
+*/
+const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+* Verified Uniswap v4 deployment addresses keyed by chainId.
+*
+* Sourced from the official Uniswap v4 deployments. Add a chain here only after
+* verifying each address against the canonical Uniswap deployment listing —
+* Universal Router in particular is NOT the same address across chains.
+*/
+const UNISWAP_V4_ADDRESSES = {
+	1: {
+		universalRouter: "0x66a9893cC07D91D95644AEDD05D03f95e1dBA8Af",
+		v4Quoter: "0x52F0E24D1c21C8A0cB1e5a5dD6198556BD9E1203",
+		poolManager: "0x000000000004444c5dc75cB358380D2e3dE08A90",
+		positionManager: "0xbD216513d74C8cf14cf4747E6AaA6420FF64ee9e",
+		permit2: PERMIT2_ADDRESS
+	},
+	4663: {
+		universalRouter: "0x8876789976decbfcbbbe364623c63652db8c0904",
+		v4Quoter: "0x8dc178efb8111bb0973dd9d722ebeff267c98f94",
+		poolManager: "0x8366a39cc670b4001a1121b8f6a443a643e40951",
+		positionManager: "0x58daec3116aae6d93017baaea7749052e8a04fa7",
+		permit2: PERMIT2_ADDRESS
+	}
+};
+/**
+* Resolve the Uniswap v4 addresses for a chain, applying optional overrides.
+*
+* @param chainId - Target chain ID.
+* @param overrides - Partial override of any address (e.g. for fork tests).
+* @returns Fully-resolved {@link UniswapV4Addresses}.
+* @throws {UnsupportedChainError} when the chain is not listed and the
+*   overrides do not supply every required address.
+*/
+function getUniswapV4Addresses(chainId, overrides) {
+	const base = UNISWAP_V4_ADDRESSES[Number(chainId)];
+	const merged = {
+		...base,
+		...overrides,
+		permit2: overrides?.permit2 ?? base?.permit2 ?? PERMIT2_ADDRESS
+	};
+	if (merged.universalRouter === void 0 || merged.v4Quoter === void 0 || merged.poolManager === void 0 || merged.positionManager === void 0 || merged.permit2 === void 0) throw new UnsupportedChainError(chainId);
+	return merged;
+}
+
+//#endregion
+//#region src/uniswap/v3/router/swap.ts
+const DEFAULT_DEADLINE_SECONDS$1 = 1800n;
+async function swapExactInViaV3Router(params) {
+	const { client, walletClient, account, poolAddress, chainId, tokenIn, amountIn, slippageBps, deadline, recipient, txOverrides, addresses } = params;
+	if (recipient !== void 0 && !isAddressEqual(recipient, account)) throw new PanopticError("Custom recipient is not supported yet; output goes to the sender");
+	const resolved = getUniswapV4Addresses(chainId, addresses);
+	const route = await resolveV3SwapRoute({
+		client,
+		poolAddress,
+		tokenIn
+	});
+	const quote = await quoteV3ExactIn({
+		client,
+		chainId,
+		tokenIn: route.tokenIn,
+		tokenOut: route.tokenOut,
+		fee: route.fee,
+		amountIn,
+		slippageBps,
+		addresses
+	});
+	if (!quote) throw new PanopticError("v3 quote failed (pool may have no liquidity)");
+	const resolvedDeadline = deadline ?? (await getBlockMeta({ client })).blockTimestamp + DEFAULT_DEADLINE_SECONDS$1;
+	const { args, value } = buildV3SwapExecuteArgs({
+		tokenIn: route.tokenIn,
+		tokenOut: route.tokenOut,
+		fee: route.fee,
+		amountIn,
+		amountOutMinimum: quote.amountOutMinimum,
+		deadline: resolvedDeadline
+	});
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: resolved.universalRouter,
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args,
+		value,
+		txOverrides
+	});
+}
+async function swapExactOutViaV3Router(params) {
+	const { client, walletClient, account, poolAddress, chainId, tokenIn, amountOut, slippageBps, deadline, recipient, txOverrides, addresses } = params;
+	if (recipient !== void 0 && !isAddressEqual(recipient, account)) throw new PanopticError("Custom recipient is not supported yet; output goes to the sender");
+	const resolved = getUniswapV4Addresses(chainId, addresses);
+	const route = await resolveV3SwapRoute({
+		client,
+		poolAddress,
+		tokenIn
+	});
+	const quote = await quoteV3ExactOut({
+		client,
+		chainId,
+		tokenIn: route.tokenIn,
+		tokenOut: route.tokenOut,
+		fee: route.fee,
+		amountOut,
+		slippageBps,
+		addresses
+	});
+	if (!quote) throw new PanopticError("v3 quote failed (pool may have no liquidity)");
+	const resolvedDeadline = deadline ?? (await getBlockMeta({ client })).blockTimestamp + DEFAULT_DEADLINE_SECONDS$1;
+	const { args, value } = buildV3ExactOutSwapExecuteArgs({
+		tokenIn: route.tokenIn,
+		tokenOut: route.tokenOut,
+		fee: route.fee,
+		amountOut,
+		amountInMaximum: quote.amountInMaximum,
+		deadline: resolvedDeadline
+	});
+	return submitWrite({
+		client,
+		walletClient,
+		account,
+		address: resolved.universalRouter,
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args,
+		value,
+		txOverrides
+	});
+}
+
+//#endregion
+//#region src/uniswap/v4/router/encodeSwap.ts
+/** Universal Router command byte for a v4 swap. */
+const V4_SWAP = 16;
+/** v4 action: exact-in single-hop swap. */
+const SWAP_EXACT_IN_SINGLE = 6;
+/** v4 action: pay all of the input currency owed. */
+const SETTLE_ALL = 12;
+/** v4 action: take all of the output currency owed. */
+const TAKE_ALL = 15;
+/** v4 action: take an output currency to an explicit recipient. */
+const TAKE = 14;
+/** v4 action: exact-out single-hop swap. */
+const SWAP_EXACT_OUT_SINGLE = 8;
+/** Universal Router command: sweep the router's token balance to a recipient. */
+const SWEEP = 4;
+/** v4 sentinel: take the full positive currency delta (used with TAKE). */
+const OPEN_DELTA = 0n;
+const UINT128_MAX$2 = (1n << 128n) - 1n;
+const poolKeyComponents = [
+	{
+		name: "currency0",
+		type: "address"
+	},
+	{
+		name: "currency1",
+		type: "address"
+	},
+	{
+		name: "fee",
+		type: "uint24"
+	},
+	{
+		name: "tickSpacing",
+		type: "int24"
+	},
+	{
+		name: "hooks",
+		type: "address"
+	}
+];
+const exactInputSingleParamsAbi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "poolKey",
+			type: "tuple",
+			components: poolKeyComponents
+		},
+		{
+			name: "zeroForOne",
+			type: "bool"
+		},
+		{
+			name: "amountIn",
+			type: "uint128"
+		},
+		{
+			name: "amountOutMinimum",
+			type: "uint128"
+		},
+		{
+			name: "hookData",
+			type: "bytes"
+		}
+	]
+}];
+const exactOutputSingleParamsAbi = [{
+	type: "tuple",
+	components: [
+		{
+			name: "poolKey",
+			type: "tuple",
+			components: poolKeyComponents
+		},
+		{
+			name: "zeroForOne",
+			type: "bool"
+		},
+		{
+			name: "amountOut",
+			type: "uint128"
+		},
+		{
+			name: "amountInMaximum",
+			type: "uint128"
+		},
+		{
+			name: "hookData",
+			type: "bytes"
+		}
+	]
+}];
+const currencyAmountAbi = [{
+	name: "currency",
+	type: "address"
+}, {
+	name: "amount",
+	type: "uint256"
+}];
+const takeToRecipientAbi = [
+	{
+		name: "currency",
+		type: "address"
+	},
+	{
+		name: "recipient",
+		type: "address"
+	},
+	{
+		name: "amount",
+		type: "uint256"
+	}
+];
+const sweepParamsAbi = [
+	{
+		name: "token",
+		type: "address"
+	},
+	{
+		name: "recipient",
+		type: "address"
+	},
+	{
+		name: "amountMin",
+		type: "uint256"
+	}
+];
+function assertUint128(amount) {
+	if (amount < 0n || amount > UINT128_MAX$2) throw new AmountExceedsUint128Error(amount);
+}
+/**
+* Encode the input for a Universal Router `SWEEP` command that forwards the
+* router's full native-ETH balance (above `amountMin = 0`) to `recipient`.
+*/
+function encodeEthSweepInput(recipient) {
+	return encodeAbiParameters(sweepParamsAbi, [
+		zeroAddress,
+		recipient,
+		0n
+	]);
+}
+/**
+* Build the output-take v4 action byte + param.
+*
+* Native-ETH output is taken with the explicit-recipient `TAKE` action so the
+* router forwards the ETH straight to `recipient` (the implicit-`msgSender`
+* `TAKE_ALL` leaves native ETH held by the router). ERC20 output uses
+* `TAKE_ALL`, which already credits the caller.
+*
+* @param nativeAmount - TAKE amount for native-ETH output: `OPEN_DELTA` (0) to
+*   take the full credit (exact-in, protected by the swap's min) or the exact
+*   output (exact-out).
+* @param erc20Amount - TAKE_ALL min/amount for ERC20 output: `amountOutMinimum`
+*   (exact-in) or the exact output (exact-out).
+*/
+function buildOutputTake(tokenOut, recipient, nativeAmount, erc20Amount) {
+	if (tokenOut === zeroAddress) {
+		if (recipient === void 0) throw new MissingSweepRecipientError();
+		return {
+			action: TAKE,
+			param: encodeAbiParameters(takeToRecipientAbi, [
+				zeroAddress,
+				recipient,
+				nativeAmount
+			])
+		};
+	}
+	return {
+		action: TAKE_ALL,
+		param: encodeAbiParameters(currencyAmountAbi, [tokenOut, erc20Amount])
+	};
+}
+/**
+* Build the typed `execute(...)` args + msg.value for an exact-in single-hop v4
+* swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
+*
+* When `tokenOut` is native ETH the explicit-recipient `TAKE` action forwards
+* the bought ETH to `recipient` (no trailing SWEEP is needed for exact-in).
+*
+* @returns `args` ready to spread into `execute` and the ETH `value` to send
+*   (= `amountIn` for native-ETH input, otherwise `0n`).
+*/
+function buildV4SwapExecuteArgs(args) {
+	const { poolKey, zeroForOne, amountIn, amountOutMinimum, tokenIn, tokenOut, deadline, recipient, hookData = "0x" } = args;
+	assertUint128(amountIn);
+	assertUint128(amountOutMinimum);
+	const swapParam = encodeAbiParameters(exactInputSingleParamsAbi, [{
+		poolKey: {
+			currency0: poolKey.currency0,
+			currency1: poolKey.currency1,
+			fee: Number(poolKey.fee),
+			tickSpacing: Number(poolKey.tickSpacing),
+			hooks: poolKey.hooks
+		},
+		zeroForOne,
+		amountIn,
+		amountOutMinimum,
+		hookData
+	}]);
+	const settleParam = encodeAbiParameters(currencyAmountAbi, [tokenIn, amountIn]);
+	const take = buildOutputTake(tokenOut, recipient, OPEN_DELTA, amountOutMinimum);
+	const actions = encodePacked([
+		"uint8",
+		"uint8",
+		"uint8"
+	], [
+		SWAP_EXACT_IN_SINGLE,
+		SETTLE_ALL,
+		take.action
+	]);
+	const v4Input = encodeAbiParameters([{
+		name: "actions",
+		type: "bytes"
+	}, {
+		name: "params",
+		type: "bytes[]"
+	}], [actions, [
+		swapParam,
+		settleParam,
+		take.param
+	]]);
+	const commands = encodePacked(["uint8"], [V4_SWAP]);
+	const value = tokenIn === zeroAddress ? amountIn : 0n;
+	return {
+		args: [
+			commands,
+			[v4Input],
+			deadline
+		],
+		value
 	};
 }
 /**
-* Extract tickSpacing from the encoded 64-bit poolId.
-* Layout: poolAddress (5 bytes) + vegoid (1 byte) + tickSpacing (2 bytes).
-* tickSpacing occupies bits 48–63.
+* Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
+* exact-in single-hop v4 swap.
+*
+* @returns The encoded calldata and the ETH `value` to send.
 */
-function tickSpacingFromPoolId(poolId) {
-	return poolId >> 48n & 0xffffn;
+function buildV4SwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV4SwapExecuteArgs(args);
+	const data = encodeFunctionData({
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args: executeArgs
+	});
+	return {
+		data,
+		value
+	};
 }
 /**
-* Parse pool key from ABI-encoded bytes.
+* Build the typed `execute(...)` args + msg.value for an exact-out single-hop v4
+* swap. Use this when submitting via viem (`writeContract` / `submitWrite`).
 *
-* V4 pools: PoolKey struct is ABI-encoded as 5 consecutive 32-byte slots
-*   (currency0, currency1, fee, tickSpacing, hooks).
+* For native-ETH input, `value` is `amountInMaximum` (an overpay) and a trailing
+* `SWEEP` action refunds the unused ETH to `recipient`. For ERC20 input, Permit2
+* pulls only the settled amount, so no SWEEP is appended and `value` is `0n`.
 *
-* V3 pools: poolKey() returns abi.encode(uniswapV3PoolAddress) — a single
-*   32-byte slot. The struct fields are not available, so currency0/currency1
-*   are zeroed and tickSpacing/fee are set to 0 (callers should use
-*   getV3PoolTickSpacing and getV3PoolFee respectively).
+* @returns `args` ready to spread into `execute` and the ETH `value` to send.
 */
-function parsePoolKey(poolKeyBytes) {
-	const hex = poolKeyBytes.slice(2);
-	if (hex.length <= 64) return {
-		currency0: zeroAddress,
-		currency1: zeroAddress,
-		fee: 0n,
-		tickSpacing: 0n,
-		hooks: zeroAddress
+function buildV4ExactOutSwapExecuteArgs(args) {
+	const { poolKey, zeroForOne, amountOut, amountInMaximum, tokenIn, tokenOut, deadline, recipient, hookData = "0x" } = args;
+	assertUint128(amountOut);
+	assertUint128(amountInMaximum);
+	const swapParam = encodeAbiParameters(exactOutputSingleParamsAbi, [{
+		poolKey: {
+			currency0: poolKey.currency0,
+			currency1: poolKey.currency1,
+			fee: Number(poolKey.fee),
+			tickSpacing: Number(poolKey.tickSpacing),
+			hooks: poolKey.hooks
+		},
+		zeroForOne,
+		amountOut,
+		amountInMaximum,
+		hookData
+	}]);
+	const settleParam = encodeAbiParameters(currencyAmountAbi, [tokenIn, amountInMaximum]);
+	const take = buildOutputTake(tokenOut, recipient, amountOut, amountOut);
+	const actions = encodePacked([
+		"uint8",
+		"uint8",
+		"uint8"
+	], [
+		SWAP_EXACT_OUT_SINGLE,
+		SETTLE_ALL,
+		take.action
+	]);
+	const v4Input = encodeAbiParameters([{
+		name: "actions",
+		type: "bytes"
+	}, {
+		name: "params",
+		type: "bytes[]"
+	}], [actions, [
+		swapParam,
+		settleParam,
+		take.param
+	]]);
+	const isNativeIn = tokenIn === zeroAddress;
+	const commandList = [V4_SWAP];
+	const inputs = [v4Input];
+	if (isNativeIn) {
+		commandList.push(SWEEP);
+		inputs.push(encodeEthSweepInput(recipient));
+	}
+	const commands = encodePacked(commandList.map(() => "uint8"), commandList);
+	const value = isNativeIn ? amountInMaximum : 0n;
+	return {
+		args: [
+			commands,
+			inputs,
+			deadline
+		],
+		value
 	};
-	if (hex.length < 320) throw new Error(`Malformed V4 pool key: expected 320 hex chars (160 bytes), got ${hex.length}`);
-	const currency0 = `0x${hex.slice(24, 64)}`;
-	const currency1 = `0x${hex.slice(88, 128)}`;
-	const fee = BigInt(`0x${hex.slice(128, 192)}`);
-	const tickSpacing = BigInt(`0x${hex.slice(192, 256)}`);
-	const hooks = `0x${hex.slice(280, 320)}`;
+}
+/**
+* Build the `execute(commands, inputs, deadline)` calldata + msg.value for an
+* exact-out single-hop v4 swap.
+*
+* @returns The encoded calldata and the ETH `value` to send.
+*/
+function buildV4ExactOutSwapExecuteCalldata(args) {
+	const { args: executeArgs, value } = buildV4ExactOutSwapExecuteArgs(args);
+	const data = encodeFunctionData({
+		abi: universalRouterAbi,
+		functionName: "execute",
+		args: executeArgs
+	});
 	return {
-		currency0,
-		currency1,
-		fee,
-		tickSpacing,
-		hooks
+		data,
+		value
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/sync/snapshotRecovery.ts
+const rolesExecutionAbi = parseAbi(["function execTransactionWithRole(address to, uint256 value, bytes data, uint8 operation, bytes32 roleKey, bool shouldRevert)"]);
+/**
+* 4-byte function selectors for dispatch/dispatchFrom, derived from the generated ABI.
+* Used for scanning raw calldata inside smart contract wallet wrappers.
+*/
+const DISPATCH_SELECTOR = toFunctionSelector(panopticPoolV2Abi.find((e) => e.type === "function" && e.name === "dispatch")).slice(2);
+const DISPATCH_FROM_SELECTOR = toFunctionSelector(panopticPoolV2Abi.find((e) => e.type === "function" && e.name === "dispatchFrom")).slice(2);
+
 //#endregion
 //#region src/panoptic/v2/greeks/index.ts
 /** Fixed-point scale constants for sqrtPriceX96 arithmetic */
 const Q96$1 = 1n << 96n;
-const Q192$2 = 1n << 192n;
-
-//#endregion
-//#region src/panoptic/v2/tokenId/constants.ts
-/**
-* TokenId constants for the Panoptic v2 SDK.
-* @module v2/tokenId/constants
-*/
-/**
-* Default vegoid value used in pool ID encoding.
-*/
-const DEFAULT_VEGOID = 8n;
-/**
-* Bit positions and sizes for TokenId encoding.
-*/
-const TOKEN_ID_BITS = {
-	POOL_ID_SIZE: 64n,
-	VEGOID_STARTING_BIT: 40n,
-	VEGOID_SIZE: 8n,
-	TICK_SPACING_STARTING_BIT: 48n,
-	TICK_SPACING_SIZE: 16n,
-	LEG_SIZE: 48n,
-	MAX_LEGS: 4n
-};
-/**
-* Bit positions within a leg (relative to leg start).
-*/
-const LEG_BITS = {
-	ASSET_BIT: 0n,
-	ASSET_SIZE: 1n,
-	RATIO_BIT: 1n,
-	RATIO_SIZE: 7n,
-	IS_LONG_BIT: 8n,
-	IS_LONG_SIZE: 1n,
-	TOKEN_TYPE_BIT: 9n,
-	TOKEN_TYPE_SIZE: 1n,
-	RISK_PARTNER_BIT: 10n,
-	RISK_PARTNER_SIZE: 2n,
-	STRIKE_BIT: 12n,
-	STRIKE_SIZE: 24n,
-	WIDTH_BIT: 36n,
-	WIDTH_SIZE: 12n
-};
-/**
-* Masks for extracting/encoding leg fields.
-*/
-const LEG_MASKS = {
-	ASSET: (1n << LEG_BITS.ASSET_SIZE) - 1n,
-	RATIO: (1n << LEG_BITS.RATIO_SIZE) - 1n,
-	IS_LONG: (1n << LEG_BITS.IS_LONG_SIZE) - 1n,
-	TOKEN_TYPE: (1n << LEG_BITS.TOKEN_TYPE_SIZE) - 1n,
-	RISK_PARTNER: (1n << LEG_BITS.RISK_PARTNER_SIZE) - 1n,
-	STRIKE: (1n << LEG_BITS.STRIKE_SIZE) - 1n,
-	WIDTH: (1n << LEG_BITS.WIDTH_SIZE) - 1n,
-	LEG: (1n << TOKEN_ID_BITS.LEG_SIZE) - 1n
-};
-/**
-* Maximum and minimum values for leg fields.
-*/
-const LEG_LIMITS = {
-	MAX_RATIO: 127n,
-	MAX_WIDTH: 4095n,
-	MAX_STRIKE: 8388607n,
-	MIN_STRIKE: -8388608n
-};
+const Q192 = 1n << 192n;
 
 //#endregion
 //#region src/panoptic/v2/utils/option-encoding-v2.ts
@@ -5334,31 +6080,6 @@ const OPTION_BURNT_EVENT = getAbiItem({
 	name: "OptionBurnt"
 });
 
-//#endregion
-//#region src/panoptic/v2/formatters/rates.ts
-const SECONDS_PER_DAY = 86400n;
-const DAYS_PER_YEAR = 365n;
-const SECONDS_PER_YEAR = SECONDS_PER_DAY * DAYS_PER_YEAR;
-
-//#endregion
-//#region src/panoptic/v2/tokenId/deriveUniqueTokenId.ts
-const POOL_ID_MASK$2 = (1n << 64n) - 1n;
-const MAX_LEGS = TOKEN_ID_BITS.MAX_LEGS;
-const MAX_OPTION_RATIO = LEG_LIMITS.MAX_RATIO;
-const Q192$1 = 1n << 192n;
-
-//#endregion
-//#region src/panoptic/v2/tokenId/generateOverlapping.ts
-const MAX_UINT64 = (1n << 64n) - 1n;
-const MAX_UINT128$2 = (1n << 128n) - 1n;
-const Q192 = 1n << 192n;
-
-//#endregion
-//#region src/panoptic/v2/tokenId/split.ts
-const POOL_ID_MASK$1 = (1n << TOKEN_ID_BITS.POOL_ID_SIZE) - 1n;
-const MAX_UINT128$1 = (1n << 128n) - 1n;
-const MAX_UINT256 = (1n << 256n) - 1n;
-
 //#endregion
 //#region src/panoptic/v2/writes/protectedSettle.ts
 const POOL_ID_MASK = (1n << 64n) - 1n;
@@ -5906,6 +6627,7 @@ async function swapExactInViaRouter(params) {
 	});
 	if (!quote.success) throw quote.error;
 	const resolvedDeadline = deadline ?? (await getBlockMeta({ client })).blockTimestamp + DEFAULT_DEADLINE_SECONDS;
+	if (!quote.data.poolKey) throw new PanopticError("v4 swap requires a poolKey from the quote");
 	const { args, value } = buildV4SwapExecuteArgs({
 		poolKey: quote.data.poolKey,
 		zeroForOne: quote.data.zeroForOne,
@@ -5961,6 +6683,7 @@ async function swapExactOutViaRouter(params) {
 	});
 	if (!quote.success) throw quote.error;
 	const resolvedDeadline = deadline ?? (await getBlockMeta({ client })).blockTimestamp + DEFAULT_DEADLINE_SECONDS;
+	if (!quote.data.poolKey) throw new PanopticError("v4 swap requires a poolKey from the quote");
 	const { args, value } = buildV4ExactOutSwapExecuteArgs({
 		poolKey: quote.data.poolKey,
 		zeroForOne: quote.data.zeroForOne,
@@ -5992,5 +6715,5 @@ async function swapExactOutViaRouterAndWait(params) {
 }
 
 //#endregion
-export { AmountExceedsUint128Error, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, V4_SWAP, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, encodeV3Path, getAmountsForLiquidity, getLpGreeks, getUniswapV3Addresses, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, quoteV3ExactIn, quoteV4ExactInByPoolKey, resolveSwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactOutViaRouter, swapExactOutViaRouterAndWait };
+export { AmountExceedsUint128Error, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, V4_SWAP, annualizeLpFeeReturn, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, checkRouterApproval, encodeV3Path, estimateLpFees, getAmountsForLiquidity, getLpDepositAmounts, getLpDepositBreakdown, getLpFeeReturnSeries, getLpFundingDeposit, getLpGreeks, getLpPositionFunding, getMaxLpPositionSize, getUniswapV3Addresses, getUniswapV4Addresses, quoteSwapExactInViaRouter, quoteSwapExactInViaV3Router, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router, quoteV3ExactIn, quoteV3ExactOut, quoteV4ExactInByPoolKey, resolveSwapRoute, resolveV3SwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactInViaV3Router, swapExactOutViaRouter, swapExactOutViaRouterAndWait, swapExactOutViaV3Router };
 //# sourceMappingURL=index.js.map