@panoptic-eng/sdk 1.0.74 → 1.0.76

package/dist/index.js

@@ -1,4 +1,4 @@
-import { BaseError, ContractFunctionRevertedError, concat, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAddress, hexToBigInt, keccak256, maxUint256, parseAbi, toBytes, toFunctionSelector, toHex, zeroAddress, zeroHash } from "viem";
+import { BaseError, ContractFunctionRevertedError, concat, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, getAddress, hexToBigInt, keccak256, maxUint256, parseAbi, parseTransaction, toBytes, toFunctionSelector, toHex, zeroAddress, zeroHash } from "viem";
 import { z } from "zod";
 import Decimal from "decimal.js";
 import { call, estimateFeesPerGas, getBlock, getBlockNumber, getFeeHistory, readContract, simulateContract, writeContract } from "viem/actions";
@@ -25971,7 +25971,7 @@ const NO_UPPER_LIQUIDATION_TICK = (1n << 23n) - 1n;
 
 //#endregion
 //#region src/panoptic/v2/formatters/tick.ts
-const Q192$2 = 1n << 192n;
+const Q192$4 = 1n << 192n;
 function tickToSqrtPriceX96(tick) {
 	if (tick < MIN_TICK || tick > MAX_TICK) throw new RangeError("Tick out of bounds");
 	const absTick = tick < 0n ? -tick : tick;
@@ -26006,7 +26006,7 @@ const MAX_SQRT_PRICE_X96 = tickToSqrtPriceX96(MAX_TICK);
 //#endregion
 //#region src/uniswap/lpGreeks.ts
 const Q96$2 = 1n << 96n;
-const Q192$1 = 1n << 192n;
+const Q192$3 = 1n << 192n;
 /**
 * Compute the token0/token1 amounts backing `liquidity` over `[sqrtA, sqrtB]`
 * at the current price `sqrtP`, mirroring Uniswap's `LiquidityAmounts`
@@ -26072,7 +26072,7 @@ function getLegTokenInventory(leg, currentTick, positionSize, tickSpacing, token
 //#region src/panoptic/v2/greeks/index.ts
 /** Fixed-point scale constants for sqrtPriceX96 arithmetic */
 const Q96 = 1n << 96n;
-const Q192 = 1n << 192n;
+const Q192$2 = 1n << 192n;
 /**
 * Convert tick to quote-denominated tick based on asset direction.
 *
@@ -26164,7 +26164,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 		const signedStrike = leg.asset === 0n ? leg.strike : -leg.strike;
 		const sqrtKraw = tickToSqrtPriceX96(signedStrike);
 		const KrawX192 = sqrtKraw * sqrtKraw;
-		const notional = divTrunc(m * KrawX192, Q192);
+		const notional = divTrunc(m * KrawX192, Q192$2);
 		return -notional;
 	}
 	if (halfWidthTick === 0n) {
@@ -26193,8 +26193,8 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 		const sqrtKR = tickToSqrtPriceX96(qStrikeTick + halfWidthTick);
 		const sqrtR = tickToSqrtPriceX96(halfWidthTick);
 		const rX192 = sqrtR * sqrtR;
-		const numerator = m * (sqrtKR - sqrtP) * Q192;
-		const denominator = sqrtP * (rX192 - Q192);
+		const numerator = m * (sqrtKR - sqrtP) * Q192$2;
+		const denominator = sqrtP * (rX192 - Q192$2);
 		vDelta = divTrunc(numerator, denominator);
 	}
 	const isPut = !isCall(leg.tokenType, isAssetToken0);
@@ -26217,7 +26217,7 @@ function getLegDelta(leg, currentTick, positionSize, poolTickSpacing, mintTick,
 			const sqrtKPmX96 = sqrtK * Q96 / sqrtPm;
 			const diff = sqrtR - sqrtKPmX96;
 			const diffSqX192 = diff * diff;
-			return divTrunc(m * diffSqX192, rX192 - Q192);
+			return divTrunc(m * diffSqX192, rX192 - Q192$2);
 		}
 	})();
 	return definedRisk ? debtDelta + vDelta : debtDelta + vDelta + itmDelta;
@@ -28921,7 +28921,8 @@ const UsdcPlpVaultMainnetProdConfig = {
 	}] },
 	deltaHedge: {
 		deltaThresholdBps: 1500n,
-		maxHedgeSlots: 3,
+		maxHedgeSlots: 5,
+		executionPolicy: "volatility-capture",
 		timedRehedge: {
 			elapsedMinutes: 1440,
 			jitterMinutes: 60,
@@ -33328,7 +33329,7 @@ function preparePriceHistory(history) {
 			price
 		}]] : [];
 	})).values()].sort((a, b) => a.timestampSec - b.timestampSec);
-	const priceAt = (timestamp) => {
+	const priceAt$1 = (timestamp) => {
 		const rightIndex = points.findIndex((point) => point.timestampSec >= timestamp);
 		const right = points[rightIndex];
 		if (right === void 0) return null;
@@ -33340,20 +33341,20 @@ function preparePriceHistory(history) {
 	return {
 		first: points[0]?.timestampSec,
 		last: points[points.length - 1]?.timestampSec,
-		priceAt,
+		priceAt: priceAt$1,
 		points
 	};
 }
 /** Largest sampled move from each eligible interval opening; equal extremes use the first. */
 function calculateMaxSignedPriceChanges(periods, history) {
-	const { priceAt, points } = preparePriceHistory(history);
+	const { priceAt: priceAt$1, points } = preparePriceHistory(history);
 	return periods.flatMap((period) => {
 		let maximum = new Precision$2(0);
 		const intervals = period.activeIntervals ?? [period];
 		if (intervals.length === 0) return [];
 		for (const interval of intervals) {
-			const start = priceAt(interval.startTimestampSec);
-			const end = priceAt(interval.endTimestampSec);
+			const start = priceAt$1(interval.startTimestampSec);
+			const end = priceAt$1(interval.endTimestampSec);
 			if (start === null || end === null) return [];
 			let intervalMaximum = new Precision$2(0);
 			for (const point of points) {
@@ -33383,7 +33384,7 @@ function calculateMeanMaxAbsolutePriceChange(periods, history) {
 }
 /** Non-overlapping seven-day observations, anchored to the first available share-price snapshot. */
 function calculateWeeklyVaultReturns(history) {
-	const { first, last, priceAt } = preparePriceHistory(history.map((point) => ({
+	const { first, last, priceAt: priceAt$1 } = preparePriceHistory(history.map((point) => ({
 		timestampSec: point.timestampSec,
 		price: point.sharePrice
 	})));
@@ -33391,8 +33392,8 @@ function calculateWeeklyVaultReturns(history) {
 	const weeks = [];
 	for (let start = first; start + WEEK <= last; start += WEEK) {
 		const end = start + WEEK;
-		const startPrice = priceAt(start);
-		const endPrice = priceAt(end);
+		const startPrice = priceAt$1(start);
+		const endPrice = priceAt$1(end);
 		if (startPrice === null || endPrice === null) continue;
 		const factor = endPrice.div(startPrice);
 		weeks.push({
@@ -34882,6 +34883,7 @@ const HypoVaultManagerConfigSchema = z.object({
 		targetDeltaBps: z.bigint().nonnegative().max(10000n).optional(),
 		deltaThresholdBps: z.bigint().positive().optional(),
 		maxHedgeSlots: z.number().int().positive().optional(),
+		executionPolicy: z.literal("volatility-capture").optional(),
 		timedRehedge: timedRehedgeSchema.optional()
 	}).optional(),
 	alerts: z.object({ outOfRangeEnabled: z.boolean().optional() }).optional(),
@@ -35137,7 +35139,7 @@ function mulDiv({ value, numerator, denominator }) {
 function getMinQueuedDepositEpoch({ queuedDeposits }) {
 	const eligible = queuedDeposits.filter((deposit) => deposit.amount > 0n).map((deposit) => deposit.epoch);
 	if (eligible.length === 0) return null;
-	return eligible.reduce((min, epoch) => epoch < min ? epoch : min);
+	return eligible.reduce((min$1, epoch) => epoch < min$1 ? epoch : min$1);
 }
 function calculateClaimableSharesFromQueuedDeposits({ queuedDeposits, depositEpochStates, currentDepositEpoch }) {
 	const epochStatesByEpoch = new Map(depositEpochStates.map((state) => [state.epoch, state]));
@@ -36306,8 +36308,8 @@ var VaultTransactionGasCostLimitError = class extends Error {
 	gasLimit;
 	maximumAffordableFeePerGas;
 	minimumRequiredFeePerGas;
-	constructor({ gasLimit, maximumAffordableFeePerGas, minimumRequiredFeePerGas }) {
-		super(`Vault transaction cannot fit the ${MAX_VAULT_TRANSACTION_GAS_COST.toString()} wei gas-cost limit: gasLimit=${gasLimit.toString()}, maximumAffordableFeePerGas=${maximumAffordableFeePerGas.toString()}, minimumRequiredFeePerGas=${minimumRequiredFeePerGas.toString()}`);
+	constructor({ gasLimit, maximumAffordableFeePerGas, minimumRequiredFeePerGas, maximumGasCost = MAX_VAULT_TRANSACTION_GAS_COST }) {
+		super(`Vault transaction cannot fit the ${maximumGasCost.toString()} wei gas-cost limit: gasLimit=${gasLimit.toString()}, maximumAffordableFeePerGas=${maximumAffordableFeePerGas.toString()}, minimumRequiredFeePerGas=${minimumRequiredFeePerGas.toString()}`);
 		this.name = "VaultTransactionGasCostLimitError";
 		this.gasLimit = gasLimit;
 		this.maximumAffordableFeePerGas = maximumAffordableFeePerGas;
@@ -36328,6 +36330,11 @@ var VaultTransactionReplacementLimitError = class extends Error {
 		this.maximumAffordableFeePerGas = maximumAffordableFeePerGas;
 	}
 };
+function resolveMaximumGasCost(feePolicy) {
+	const maximum = feePolicy?.maxTransactionGasCost ?? MAX_VAULT_TRANSACTION_GAS_COST;
+	if (maximum <= 0n) throw new Error("Vault transaction gas budget must be positive");
+	return maximum;
+}
 function ceilMultiplyFraction(value, numerator, denominator) {
 	return (value * numerator + denominator - 1n) / denominator;
 }
@@ -36402,30 +36409,32 @@ function resolveRpcPriorityFeeQuote({ baseFeePerGas, rawPriorityFeePerGas, minim
 		source: "rpc_priority_fee"
 	};
 }
-function getVaultTransactionReplacementFeeQuote({ originalQuote, historicalQuote, gasLimit, finalReplacement = false, staleBoundsReplacement = false }) {
+function getVaultTransactionReplacementFeeQuote({ originalQuote, historicalQuote, gasLimit, finalReplacement = false, staleBoundsReplacement = false, feePolicy }) {
 	if (gasLimit <= 0n) throw new Error(`Vault transaction gas limit must be positive, received ${gasLimit.toString()}`);
-	const bumpedPriorityFee = staleBoundsReplacement ? ceilMultiplyFraction(originalQuote.maxPriorityFeePerGas, REPLACEMENT_FEE_BUMP_NUMERATOR, REPLACEMENT_FEE_BUMP_DENOMINATOR) : ceilMultiplyFraction(originalQuote.maxPriorityFeePerGas, DELTA_HEDGE_PRIORITY_FEE_BUMP_NUMERATOR, DELTA_HEDGE_PRIORITY_FEE_BUMP_DENOMINATOR);
+	const bumpedPriorityFee = staleBoundsReplacement || feePolicy?.marketPriorityFees ? ceilMultiplyFraction(originalQuote.maxPriorityFeePerGas, REPLACEMENT_FEE_BUMP_NUMERATOR, REPLACEMENT_FEE_BUMP_DENOMINATOR) : ceilMultiplyFraction(originalQuote.maxPriorityFeePerGas, DELTA_HEDGE_PRIORITY_FEE_BUMP_NUMERATOR, DELTA_HEDGE_PRIORITY_FEE_BUMP_DENOMINATOR);
 	const bumpedMaxFee = ceilMultiplyFraction(originalQuote.maxFeePerGas, REPLACEMENT_FEE_BUMP_NUMERATOR, REPLACEMENT_FEE_BUMP_DENOMINATOR);
 	const escalatingPriorityFee = historicalQuote.maxPriorityFeePerGas > bumpedPriorityFee ? historicalQuote.maxPriorityFeePerGas : bumpedPriorityFee;
-	const priorityFeeLimit = staleBoundsReplacement ? MAX_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS : finalReplacement ? MAX_VAULT_PRIORITY_FEE_PER_GAS : MAX_DELTA_HEDGE_PRIORITY_FEE_PER_GAS;
-	const desiredMaxPriorityFeePerGas = finalReplacement ? MAX_VAULT_PRIORITY_FEE_PER_GAS : staleBoundsReplacement ? bumpedPriorityFee : escalatingPriorityFee;
+	const maximumGasCost = resolveMaximumGasCost(feePolicy);
+	const priorityFeeLimit = feePolicy?.marketPriorityFees ? maximumGasCost / gasLimit : staleBoundsReplacement ? MAX_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS : finalReplacement ? MAX_VAULT_PRIORITY_FEE_PER_GAS : MAX_DELTA_HEDGE_PRIORITY_FEE_PER_GAS;
+	const desiredMaxPriorityFeePerGas = feePolicy?.marketPriorityFees ? escalatingPriorityFee : finalReplacement ? MAX_VAULT_PRIORITY_FEE_PER_GAS : staleBoundsReplacement ? bumpedPriorityFee : escalatingPriorityFee;
 	const requiredReplacementPriorityFee = ceilMultiplyFraction(originalQuote.maxPriorityFeePerGas, REPLACEMENT_FEE_BUMP_NUMERATOR, REPLACEMENT_FEE_BUMP_DENOMINATOR);
 	const requiredMaxPriorityFeePerGas = desiredMaxPriorityFeePerGas < priorityFeeLimit ? desiredMaxPriorityFeePerGas : priorityFeeLimit;
 	if (requiredMaxPriorityFeePerGas < requiredReplacementPriorityFee) throw new VaultTransactionReplacementLimitError({
-		code: "PriorityFeeCapExceeded",
+		code: feePolicy?.marketPriorityFees ? "GasCostCapExceeded" : "PriorityFeeCapExceeded",
 		gasLimit,
 		requiredMaxFeePerGas: originalQuote.maxFeePerGas,
 		requiredMaxPriorityFeePerGas: requiredReplacementPriorityFee,
-		maximumAffordableFeePerGas: MAX_VAULT_TRANSACTION_GAS_COST / gasLimit
+		maximumAffordableFeePerGas: maximumGasCost / gasLimit
 	});
-	const bufferedBaseFee = historicalQuote.minimumMaxFeePerGas - (historicalQuote.minimumPriorityFeePerGas ?? MIN_VAULT_PRIORITY_FEE_PER_GAS);
+	const bufferedBaseFee = feePolicy?.marketPriorityFees ? historicalQuote.maxFeePerGas - historicalQuote.maxPriorityFeePerGas : historicalQuote.minimumMaxFeePerGas - (historicalQuote.minimumPriorityFeePerGas ?? MIN_VAULT_PRIORITY_FEE_PER_GAS);
 	const currentMarketMaxFee = bufferedBaseFee + requiredMaxPriorityFeePerGas;
 	const desiredMaxFeePerGas = currentMarketMaxFee > bumpedMaxFee ? currentMarketMaxFee : bumpedMaxFee;
-	const maximumAffordableFeePerGas = MAX_VAULT_TRANSACTION_GAS_COST / gasLimit;
-	if (bumpedMaxFee > maximumAffordableFeePerGas || requiredMaxPriorityFeePerGas > maximumAffordableFeePerGas) throw new VaultTransactionReplacementLimitError({
+	const maximumAffordableFeePerGas = maximumGasCost / gasLimit;
+	const minimumMarketFeePerGas = (historicalQuote.currentBaseFeePerGas ?? bufferedBaseFee) + requiredMaxPriorityFeePerGas;
+	if (bumpedMaxFee > maximumAffordableFeePerGas || requiredMaxPriorityFeePerGas > maximumAffordableFeePerGas || feePolicy?.marketPriorityFees && minimumMarketFeePerGas > maximumAffordableFeePerGas) throw new VaultTransactionReplacementLimitError({
 		code: "GasCostCapExceeded",
 		gasLimit,
-		requiredMaxFeePerGas: bumpedMaxFee,
+		requiredMaxFeePerGas: feePolicy?.marketPriorityFees && minimumMarketFeePerGas > bumpedMaxFee ? minimumMarketFeePerGas : bumpedMaxFee,
 		requiredMaxPriorityFeePerGas,
 		maximumAffordableFeePerGas
 	});
@@ -36448,13 +36457,15 @@ function resolveFallbackQuote({ maxFeePerGas: estimatedMaxFeePerGas, maxPriority
 		source: "viem_fallback"
 	};
 }
-function applyVaultTransactionGasCostLimit(quote, gasLimit) {
+function applyVaultTransactionGasCostLimit(quote, gasLimit, feePolicy) {
 	if (gasLimit <= 0n) throw new Error(`Vault transaction gas limit must be positive, received ${gasLimit.toString()}`);
-	const maximumAffordableFeePerGas = MAX_VAULT_TRANSACTION_GAS_COST / gasLimit;
+	const maximumGasCost = resolveMaximumGasCost(feePolicy);
+	const maximumAffordableFeePerGas = maximumGasCost / gasLimit;
 	if (maximumAffordableFeePerGas < quote.minimumMaxFeePerGas) throw new VaultTransactionGasCostLimitError({
 		gasLimit,
 		maximumAffordableFeePerGas,
-		minimumRequiredFeePerGas: quote.minimumMaxFeePerGas
+		minimumRequiredFeePerGas: quote.minimumMaxFeePerGas,
+		maximumGasCost
 	});
 	if (quote.maxFeePerGas <= maximumAffordableFeePerGas) return quote;
 	const bufferedBaseFee = quote.minimumMaxFeePerGas - (quote.minimumPriorityFeePerGas ?? MIN_VAULT_PRIORITY_FEE_PER_GAS);
@@ -36469,8 +36480,9 @@ function bufferVaultTransactionGasEstimate(gasEstimate) {
 	if (gasEstimate <= 0n) throw new Error(`Vault transaction gas estimate must be positive, received ${gasEstimate.toString()}`);
 	return ceilMultiplyFraction(gasEstimate, GAS_ESTIMATE_BUFFER_NUMERATOR, GAS_ESTIMATE_BUFFER_DENOMINATOR);
 }
-function validateVaultSignedTransactionFeeCaps(feeCaps, quote) {
+function validateVaultSignedTransactionFeeCaps(feeCaps, quote, feePolicy) {
 	const { chainId, gasLimit, maxFeePerGas, maxPriorityFeePerGas } = feeCaps;
+	const maximumGasCost = resolveMaximumGasCost(feePolicy);
 	const minimumPriorityFeePerGas = quote?.minimumPriorityFeePerGas ?? getChainPriorityFeeFloor(chainId) ?? MIN_VAULT_PRIORITY_FEE_PER_GAS;
 	if (maxFeePerGas === null || maxPriorityFeePerGas === null) return {
 		valid: false,
@@ -36487,15 +36499,15 @@ function validateVaultSignedTransactionFeeCaps(feeCaps, quote) {
 		code: "PriorityFeeTooLow",
 		reason: `Signed transaction maxPriorityFeePerGas (${maxPriorityFeePerGas.toString()} wei) must be at least ${minimumPriorityFeePerGas.toString()} wei.`
 	};
-	if (maxPriorityFeePerGas > MAX_VAULT_PRIORITY_FEE_PER_GAS) return {
+	if (!feePolicy?.marketPriorityFees && maxPriorityFeePerGas > MAX_VAULT_PRIORITY_FEE_PER_GAS) return {
 		valid: false,
 		code: "PriorityFeeTooHigh",
 		reason: `Signed transaction maxPriorityFeePerGas (${maxPriorityFeePerGas.toString()} wei) must not exceed ${MAX_VAULT_PRIORITY_FEE_PER_GAS.toString()} wei (3 gwei).`
 	};
-	if (gasLimit !== void 0 && gasLimit !== null && gasLimit * maxFeePerGas > MAX_VAULT_TRANSACTION_GAS_COST) return {
+	if (gasLimit !== void 0 && gasLimit !== null && gasLimit * maxFeePerGas > maximumGasCost) return {
 		valid: false,
 		code: "GasCostTooHigh",
-		reason: `Signed transaction maximum gas cost (${(gasLimit * maxFeePerGas).toString()} wei) must not exceed ${MAX_VAULT_TRANSACTION_GAS_COST.toString()} wei (0.015 ETH).`
+		reason: `Signed transaction maximum gas cost (${(gasLimit * maxFeePerGas).toString()} wei) must not exceed ${maximumGasCost.toString()} wei.`
 	};
 	if (quote !== void 0) {
 		const feeRequirementDescription = quote.currentBaseFeePerGas === void 0 ? "buffered next-block base fee" : "current base fee";
@@ -36922,6 +36934,118 @@ function formatPerSecondRateWadAsAprPct(ratePerSecondWad, precision) {
 	return formatWadPercent(annualizePerSecondRateWad(ratePerSecondWad), precision);
 }
 
+//#endregion
+//#region src/hypoVault/adaptiveHedgeFees.ts
+const SHOCK_LOOKBACK_SECONDS = 600n;
+const SHOCK_LATCH_SECONDS = 1200n;
+const VOLUSDC_INCIDENT_GAS_ENVELOPE = 1250000000000000000n;
+const VOLUSDC_HEDGE_FEE_POLICY = Object.freeze({
+	maxTransactionGasCost: VOLUSDC_INCIDENT_GAS_ENVELOPE * 8n / 9n,
+	marketPriorityFees: true
+});
+function resolveHedgeShock({ sqrtPriceX96, previousSqrtPriceX96, timestamp, activeUntil = 0n, priceAssetIndex }) {
+	if (sqrtPriceX96 <= 0n || previousSqrtPriceX96 <= 0n) throw new Error("Shock detection requires positive pool prices");
+	const previous$1 = previousSqrtPriceX96 ** 2n;
+	const current = sqrtPriceX96 ** 2n;
+	const difference = current > previous$1 ? current - previous$1 : previous$1 - current;
+	const denominator = priceAssetIndex === 0n ? previous$1 : current;
+	const shocked = difference * 10000n >= denominator * 200n;
+	const nextActiveUntil = shocked ? timestamp + SHOCK_LATCH_SECONDS : activeUntil;
+	return {
+		shocked,
+		activeUntil: nextActiveUntil,
+		active: timestamp < nextActiveUntil
+	};
+}
+async function getHedgeShock({ client, poolAddress, activeUntil, priceAssetIndex }) {
+	const blockTimeMs = client.chain?.blockTime;
+	if (blockTimeMs === void 0 || !Number.isSafeInteger(blockTimeMs) || blockTimeMs <= 0) throw new Error("Shock detection requires a valid network block time");
+	const averageBlockTimeMs = BigInt(blockTimeMs);
+	const lookbackBlocks = (SHOCK_LOOKBACK_SECONDS * 1000n + averageBlockTimeMs - 1n) / averageBlockTimeMs;
+	const block = await getBlock(client, { blockTag: "latest" });
+	const metadata = await getPoolMetadata({
+		client,
+		poolAddress
+	});
+	if (metadata.isV4) throw new Error("Adaptive hedge fees require a Uniswap v3 market");
+	const previousBlock = block.number > lookbackBlocks ? block.number - lookbackBlocks : 0n;
+	const address = metadata.underlyingPoolId;
+	const [current, previous$1] = await Promise.all([readContract(client, {
+		address,
+		abi: uniswapV3PoolAbi,
+		functionName: "slot0",
+		blockNumber: block.number
+	}), readContract(client, {
+		address,
+		abi: uniswapV3PoolAbi,
+		functionName: "slot0",
+		blockNumber: previousBlock
+	})]);
+	return {
+		...resolveHedgeShock({
+			sqrtPriceX96: current[0],
+			previousSqrtPriceX96: previous$1[0],
+			timestamp: block.timestamp,
+			activeUntil,
+			priceAssetIndex
+		}),
+		blockNumber: block.number,
+		blockHash: block.hash,
+		timestamp: block.timestamp
+	};
+}
+function resolveAdaptiveHedgeFeeQuote({ baseFeePerGas, rewards, urgent }) {
+	if (rewards.length === 0 || rewards.some((reward) => reward < 0n) || baseFeePerGas < 0n) throw new Error("Incomplete adaptive hedge fee history");
+	const sorted = [...rewards].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	const upper = sorted[Math.floor(sorted.length / 2)];
+	if (upper === void 0) throw new Error("Missing adaptive hedge fee median");
+	const lower = sorted[Math.max(0, Math.floor((sorted.length - 1) / 2))] ?? upper;
+	const rawPriorityFeePerGas = (lower + upper) / 2n;
+	const floor = urgent ? 3000000000n : 100000000n;
+	const maxPriorityFeePerGas = rawPriorityFeePerGas > floor ? rawPriorityFeePerGas : floor;
+	const maxFeePerGas = baseFeePerGas * 2n + maxPriorityFeePerGas;
+	return {
+		currentBaseFeePerGas: baseFeePerGas,
+		rawPriorityFeePerGas,
+		maxPriorityFeePerGas,
+		maxFeePerGas,
+		minimumMaxFeePerGas: baseFeePerGas + maxPriorityFeePerGas,
+		minimumPriorityFeePerGas: maxPriorityFeePerGas,
+		source: "adaptive_hedge"
+	};
+}
+async function getAdaptiveHedgeFeeQuote(client, urgent) {
+	const history = await getFeeHistory(client, {
+		blockCount: 5,
+		blockTag: "latest",
+		rewardPercentiles: urgent ? [75, 90] : [75]
+	});
+	const baseFeePerGas = history.baseFeePerGas.at(-2);
+	const rewards = history.reward?.flatMap((row) => {
+		const value = row[urgent ? 1 : 0];
+		return value === void 0 ? [] : [value];
+	});
+	if (baseFeePerGas === void 0 || history.baseFeePerGas.length !== 6 || history.reward?.length !== 5 || rewards === void 0 || rewards.length !== 5) throw new Error("Incomplete adaptive hedge fee history");
+	const quote = resolveAdaptiveHedgeFeeQuote({
+		baseFeePerGas,
+		rewards,
+		urgent
+	});
+	if (!urgent) return quote;
+	const competitiveRewards = history.reward?.flatMap((row) => row[0] === void 0 ? [] : [row[0]]);
+	if (competitiveRewards === void 0 || competitiveRewards.length !== 5) throw new Error("Incomplete competitive hedge fee history");
+	const competitive = resolveAdaptiveHedgeFeeQuote({
+		baseFeePerGas,
+		rewards: competitiveRewards,
+		urgent: true
+	});
+	if (competitive.maxPriorityFeePerGas > quote.maxPriorityFeePerGas) throw new Error("Inconsistent competitive hedge fee history");
+	return {
+		...quote,
+		competitivePriorityFeePerGas: competitive.maxPriorityFeePerGas
+	};
+}
+
 //#endregion
 //#region src/hypoVault/analytics/donations.ts
 const Precision$1 = Decimal.clone({ precision: 60 });
@@ -37482,6 +37606,753 @@ async function fetchVaultPositionExposureHistory(params) {
 	};
 }
 
+//#endregion
+//#region src/hypoVault/budgetedHedgeFees.ts
+function selectBudgetedHedgeFees({ quote, gasLimit, feePolicy, originalQuote }) {
+	const baseFee = quote.currentBaseFeePerGas;
+	const floor = quote.competitivePriorityFeePerGas;
+	if (quote.source !== "adaptive_hedge" || !feePolicy.marketPriorityFees || gasLimit <= 0n || feePolicy.maxTransactionGasCost <= 0n || baseFee === void 0 || baseFee < 0n || floor === void 0 || floor < 0n || floor > quote.maxPriorityFeePerGas) throw new Error("Incomplete budgeted hedge fee authority");
+	const bump = (value) => (value * REPLACEMENT_FEE_BUMP_NUMERATOR + REPLACEMENT_FEE_BUMP_DENOMINATOR - 1n) / REPLACEMENT_FEE_BUMP_DENOMINATOR;
+	const hardMaximum = feePolicy.maxTransactionGasCost / gasLimit;
+	const maximumAffordableFeePerGas = originalQuote === void 0 ? hardMaximum * REPLACEMENT_FEE_BUMP_DENOMINATOR / REPLACEMENT_FEE_BUMP_NUMERATOR : hardMaximum;
+	const minimumPriorityFeePerGas = originalQuote === void 0 || floor >= bump(originalQuote.maxPriorityFeePerGas) ? floor : bump(originalQuote.maxPriorityFeePerGas);
+	const minimumRequiredFeePerGas = originalQuote === void 0 || baseFee * 2n + minimumPriorityFeePerGas >= bump(originalQuote.maxFeePerGas) ? baseFee * 2n + minimumPriorityFeePerGas : bump(originalQuote.maxFeePerGas);
+	if (minimumRequiredFeePerGas > maximumAffordableFeePerGas) return {
+		status: "wait",
+		maximumAffordableFeePerGas,
+		minimumRequiredFeePerGas,
+		minimumPriorityFeePerGas
+	};
+	const target = quote.maxPriorityFeePerGas > minimumPriorityFeePerGas ? quote.maxPriorityFeePerGas : minimumPriorityFeePerGas;
+	const tipRoom = maximumAffordableFeePerGas - 2n * baseFee;
+	const selectedTip = target < tipRoom ? target : tipRoom;
+	const desiredMaxFee = 2n * baseFee + selectedTip;
+	const maxFeePerGas = desiredMaxFee >= minimumRequiredFeePerGas ? desiredMaxFee : minimumRequiredFeePerGas;
+	return {
+		status: "ready",
+		quote: {
+			...quote,
+			maxFeePerGas,
+			maxPriorityFeePerGas: selectedTip,
+			minimumMaxFeePerGas: baseFee + selectedTip,
+			minimumPriorityFeePerGas: selectedTip
+		},
+		feePolicy: Object.freeze({
+			...feePolicy,
+			maxTransactionGasCost: originalQuote === void 0 ? gasLimit * maximumAffordableFeePerGas : feePolicy.maxTransactionGasCost
+		})
+	};
+}
+
+//#endregion
+//#region src/hypoVault/hedgeGain.ts
+const D = Decimal.clone({ precision: 110 });
+const Q192$1 = new D(2).pow(192);
+const decimal = (value) => new D(value.toString());
+function priceAt(sqrtPriceX96, numeraireIndex) {
+	if (sqrtPriceX96 <= 0n) throw new RangeError("Hedge valuation requires a positive price");
+	const squared = decimal(sqrtPriceX96).pow(2);
+	return numeraireIndex === 0n ? Q192$1.div(squared) : squared.div(Q192$1);
+}
+function prepareBook(book) {
+	const quoteIndex = Number(book.numeraireIndex);
+	const assetIndex = 1 - quoteIndex;
+	const points = book.curve.filter(({ tick }) => tick > -887272n && tick < 887272n).map(({ tick, value0, value1 }) => {
+		const values = [value0 + book.balances[0], value1 + book.balances[1]];
+		return {
+			price: priceAt(tickToSqrtPriceX96(tick), book.numeraireIndex),
+			quote: decimal(values[quoteIndex]),
+			asset: decimal(values[assetIndex])
+		};
+	}).sort((a, b) => a.price.cmp(b.price));
+	if (points.length < 2) throw new RangeError("Incomplete option value curve");
+	const first = points[0];
+	const last = points[points.length - 1];
+	if (first === void 0 || last === void 0) throw new RangeError("Missing curve endpoints");
+	const segments = points.slice(1).map((right, index) => {
+		const left = points[index];
+		if (left === void 0 || !left.price.lt(right.price)) throw new RangeError("Invalid option value curve");
+		const lo = left.price.sqrt();
+		const hi = right.price.sqrt();
+		const quoteSlope = right.quote.minus(left.quote).div(hi.minus(lo));
+		const assetSlope = right.asset.minus(left.asset).div(new D(1).div(hi).minus(new D(1).div(lo)));
+		return {
+			lo,
+			hi,
+			a: left.quote.minus(quoteSlope.mul(lo)),
+			b: quoteSlope.plus(assetSlope),
+			c: left.asset.minus(assetSlope.div(lo))
+		};
+	});
+	const valueAt = (sqrtPriceX96) => {
+		const price = priceAt(sqrtPriceX96, book.numeraireIndex);
+		const x = price.sqrt();
+		const segment = segments.find((candidate) => x.gte(candidate.lo) && x.lte(candidate.hi));
+		if (segment !== void 0) return segment.a.plus(segment.b.mul(x)).plus(segment.c.mul(price));
+		const endpoint = price.lt(first.price) ? first : last;
+		return endpoint.quote.plus(endpoint.asset.mul(price));
+	};
+	const minimum = () => {
+		if (last.asset.lt(0)) return void 0;
+		let value = first.quote;
+		for (const point of points) value = D.min(value, point.quote.plus(point.asset.mul(point.price)));
+		for (const segment of segments) {
+			if (segment.c.lte(0)) continue;
+			const x = segment.b.neg().div(segment.c.mul(2));
+			if (x.gt(segment.lo) && x.lt(segment.hi)) value = D.min(value, segment.a.plus(segment.b.mul(x)).plus(segment.c.mul(x.pow(2))));
+		}
+		return value;
+	};
+	return {
+		valueAt,
+		minimum
+	};
+}
+function valueFrozenHedgeBook(book, sqrtPriceX96 = book.sqrtPriceX96) {
+	return BigInt(prepareBook(book).valueAt(sqrtPriceX96).floor().toFixed(0));
+}
+/** Current price protection; future interest, liquidation and execution are not guaranteed. */
+function estimateProtectedHedgeGain({ before, after, anchor, roundingReserve }) {
+	if (roundingReserve < 0n) throw new RangeError("Negative hedge rounding reserve");
+	if (before.numeraireIndex !== after.numeraireIndex) throw new RangeError("Hedge books must use the same numeraire");
+	if (anchor === void 0) return {
+		valid: false,
+		protectedGain: 0n,
+		reason: "Missing confirmed gain anchor"
+	};
+	const current = prepareBook(before);
+	const proposed = prepareBook(after);
+	const beforeFloor = current.minimum();
+	const afterFloor = proposed.minimum();
+	if (beforeFloor === void 0 || afterFloor === void 0) return {
+		valid: false,
+		protectedGain: 0n,
+		reason: "Unbounded hedge price tail"
+	};
+	if (proposed.valueAt(before.sqrtPriceX96).gt(current.valueAt(before.sqrtPriceX96).plus(decimal(roundingReserve)))) return {
+		valid: false,
+		protectedGain: 0n,
+		reason: "Unfunded post-hedge value increase"
+	};
+	const anchorMark = current.valueAt(anchor.sqrtPriceX96);
+	const basis = D.max(beforeFloor, anchorMark, decimal(anchor.actualValue));
+	const gain = D.max(0, afterFloor.minus(basis).minus(decimal(roundingReserve)));
+	return {
+		valid: true,
+		protectedGain: BigInt(gain.floor().toFixed(0)),
+		floorAfter: BigInt(afterFloor.floor().toFixed(0)),
+		basis: BigInt(basis.ceil().toFixed(0)),
+		negativeCarry: BigInt(D.max(0, decimal(anchor.actualValue).minus(anchorMark)).ceil().toFixed(0))
+	};
+}
+/** Round the two-thirds allowance down and convert at the most expensive allowed gas-asset price. */
+function getProtectedHedgeGasBudget({ protectedGain, gasAlreadyPaid, numeraireIndex, gasAssetIndex, sqrtPriceLowerX96, sqrtPriceUpperX96 }) {
+	if (protectedGain < 0n || gasAlreadyPaid < 0n || sqrtPriceLowerX96 <= 0n || sqrtPriceUpperX96 < sqrtPriceLowerX96) throw new RangeError("Invalid protected hedge gas budget");
+	const allowance = protectedGain * 2n / 3n;
+	const remaining = allowance > gasAlreadyPaid ? allowance - gasAlreadyPaid : 0n;
+	const budget = numeraireIndex === gasAssetIndex ? remaining : numeraireIndex === 0n ? remaining * sqrtPriceLowerX96 ** 2n / (1n << 192n) : remaining * (1n << 192n) / sqrtPriceUpperX96 ** 2n;
+	const maximum = VOLUSDC_HEDGE_FEE_POLICY.maxTransactionGasCost;
+	return {
+		allowance,
+		remaining,
+		maxTransactionGasCost: budget < maximum ? budget : maximum
+	};
+}
+
+//#endregion
+//#region src/panoptic/v2/simulations/tokenFlow.ts
+/**
+* PanopticPool getAssetsOf ABI.
+* Returns collateral assets (shares converted to underlying) for an account.
+*/
+const getAssetsOfAbi = [{
+	type: "function",
+	name: "getAssetsOf",
+	inputs: [{
+		name: "account",
+		type: "address"
+	}],
+	outputs: [{
+		name: "assets0",
+		type: "uint256"
+	}, {
+		name: "assets1",
+		type: "uint256"
+	}],
+	stateMutability: "view"
+}];
+/**
+* PanopticPool multicall ABI (inherited from Uniswap).
+* Uses delegatecall, preserving msg.sender throughout the chain.
+*/
+const multicallAbi = [{
+	type: "function",
+	name: "multicall",
+	inputs: [{
+		name: "data",
+		type: "bytes[]"
+	}],
+	outputs: [{
+		name: "results",
+		type: "bytes[]"
+	}],
+	stateMutability: "nonpayable"
+}, ...panopticErrorsAbi];
+const collateralTrackersByClient = new WeakMap();
+const readCollateralTrackers = (client, poolAddress) => {
+	const collateralTrackersByPool = collateralTrackersByClient.get(client) ?? new Map();
+	collateralTrackersByClient.set(client, collateralTrackersByPool);
+	const cached = collateralTrackersByPool.get(poolAddress);
+	if (cached) return cached;
+	const trackers = client.multicall({
+		contracts: [{
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "collateralToken0"
+		}, {
+			address: poolAddress,
+			abi: panopticPoolV2Abi,
+			functionName: "collateralToken1"
+		}],
+		allowFailure: false
+	});
+	collateralTrackersByPool.set(poolAddress, trackers);
+	trackers.catch(() => collateralTrackersByPool.delete(poolAddress));
+	return trackers;
+};
+const readInterestOwed = async (client, poolAddress, user, blockNumber) => {
+	try {
+		const [tracker0, tracker1] = await readCollateralTrackers(client, poolAddress);
+		const read = {
+			abi: collateralTrackerV2Abi,
+			functionName: "owedInterest",
+			args: [user]
+		};
+		const [interestOwed0, interestOwed1] = await client.multicall({
+			contracts: [{
+				...read,
+				address: tracker0
+			}, {
+				...read,
+				address: tracker1
+			}],
+			allowFailure: false,
+			blockNumber
+		});
+		return {
+			interestOwed0,
+			interestOwed1
+		};
+	} catch {
+		return void 0;
+	}
+};
+/**
+* Simulate a contract call and measure token flow using PanopticPool.multicall.
+*
+* This function uses PanopticPool's inherited multicall (delegatecall-based) to chain:
+* 1. getAssetsOf(user) - read collateral assets before
+* 2. getCurrentTick() - read pool tick before
+* 3. Execute the target call (e.g., dispatch)
+* 4. getCurrentTick() - read pool tick after
+* 5. getAssetsOf(user) - read collateral assets after
+*
+* ## Why PanopticPool.multicall instead of Multicall3?
+* - Measures **collateral assets** (shares → underlying), not raw wallet balances
+* - Uses **delegatecall**, preserving msg.sender throughout the chain
+* - Single contract interaction with PanopticPool
+* - Correctly reflects what happens during position operations
+*
+* ## Same-Block Guarantee
+* All operations execute within a single eth_call, ensuring atomic consistency.
+*
+* @param params - Simulation parameters
+* @returns Token flow result
+*
+* @example
+* ```typescript
+* const callData = encodeFunctionData({
+*   abi: panopticPoolV2Abi,
+*   functionName: 'dispatch',
+*   args: [positionIdList, finalPositionIdList, positionSizes, tickAndSpreadLimits, false, 0n],
+* })
+*
+* const result = await simulateWithTokenFlow({
+*   client,
+*   poolAddress,
+*   user: userAddress,
+*   callData,
+* })
+*
+* if (result.success) {
+*   console.log('Token 0 change:', result.tokenFlow.delta0)
+*   console.log('Token 1 change:', result.tokenFlow.delta1)
+* }
+* ```
+*/
+async function simulateWithTokenFlow(params) {
+	const { client, poolAddress, user, callData, blockNumber, postCallData, preCallData } = params;
+	const getAssetsOfCallData = encodeFunctionData({
+		abi: getAssetsOfAbi,
+		functionName: "getAssetsOf",
+		args: [user]
+	});
+	const getCurrentTickCallData = encodeFunctionData({
+		abi: panopticPoolV2Abi,
+		functionName: "getCurrentTick"
+	});
+	const preLen = preCallData?.length ?? 0;
+	const multicallData = [
+		getAssetsOfCallData,
+		getCurrentTickCallData,
+		...preCallData ?? [],
+		callData,
+		getCurrentTickCallData,
+		getAssetsOfCallData,
+		...postCallData ?? []
+	];
+	try {
+		const [{ result }, interestOwed] = await Promise.all([client.simulateContract({
+			address: poolAddress,
+			abi: multicallAbi,
+			functionName: "multicall",
+			args: [multicallData],
+			account: user,
+			blockNumber
+		}), readInterestOwed(client, poolAddress, user, blockNumber)]);
+		const decodeAssets = (data) => {
+			const decoded = decodeFunctionResult({
+				abi: getAssetsOfAbi,
+				functionName: "getAssetsOf",
+				data
+			});
+			return {
+				assets0: decoded[0],
+				assets1: decoded[1]
+			};
+		};
+		const decodeTick = (data) => {
+			return BigInt(decodeFunctionResult({
+				abi: panopticPoolV2Abi,
+				functionName: "getCurrentTick",
+				data
+			}));
+		};
+		const assetsBefore = decodeAssets(result[0]);
+		const tickBefore = decodeTick(result[1]);
+		const tickAfter = decodeTick(result[3 + preLen]);
+		const assetsAfter = decodeAssets(result[4 + preLen]);
+		const preCallResults = preLen > 0 ? result.slice(2, 2 + preLen) : void 0;
+		const postCallResults = postCallData && postCallData.length > 0 ? result.slice(5 + preLen) : void 0;
+		const delta0 = assetsAfter.assets0 - assetsBefore.assets0;
+		const delta1 = assetsAfter.assets1 - assetsBefore.assets1;
+		let gasEstimate = 0n;
+		try {
+			if (params.estimateGas !== false) gasEstimate = await client.estimateGas({
+				account: user,
+				to: poolAddress,
+				data: callData,
+				blockNumber
+			});
+		} catch {}
+		return {
+			success: true,
+			tokenFlow: {
+				delta0,
+				delta1,
+				balanceBefore0: assetsBefore.assets0,
+				balanceBefore1: assetsBefore.assets1,
+				balanceAfter0: assetsAfter.assets0,
+				balanceAfter1: assetsAfter.assets1,
+				tickBefore,
+				tickAfter,
+				...interestOwed
+			},
+			gasEstimate,
+			postCallResults,
+			preCallResults
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : "Simulation failed",
+			rawError: error instanceof Error ? error : void 0,
+			gasEstimate: 0n
+		};
+	}
+}
+
+//#endregion
+//#region src/hypoVault/hedgeGainQuote.ts
+const MASK128 = (1n << 128n) - 1n;
+const Q192 = 1n << 192n;
+const ceilDiv = (value, divisor) => (value + divisor - 1n) / divisor;
+const max = (a, b) => a > b ? a : b;
+const min = (a, b) => a < b ? a : b;
+const assetsAbi = [{
+	type: "function",
+	name: "getAssetsOf",
+	stateMutability: "view",
+	inputs: [{
+		name: "account",
+		type: "address"
+	}],
+	outputs: [{ type: "uint256" }, { type: "uint256" }]
+}];
+function fullPositions(data, ids) {
+	const [shortPremium, longPremium, balances] = decodeFunctionResult({
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		data
+	});
+	if (balances.length !== ids.length) throw new Error("Incomplete hedge position balances");
+	const positions = ids.map((tokenId, index) => {
+		const packed = balances[index];
+		if (packed === void 0 || (packed & MASK128) === 0n) throw new Error("Missing active hedge position");
+		return {
+			tokenId,
+			positionSize: packed & MASK128
+		};
+	});
+	return {
+		positions,
+		premium: [(shortPremium & MASK128) - (longPremium & MASK128), (shortPremium >> 128n) - (longPremium >> 128n)]
+	};
+}
+async function readVaultHedgeBook({ client, poolAddress, account, queryAddress, numeraire, fromBlock, blockNumber, metadata: prefetchedMetadata }) {
+	const block = await client.getBlock({ blockNumber });
+	const metadata = prefetchedMetadata ?? await getPoolMetadata({
+		client,
+		poolAddress
+	});
+	const gasAsset = getChainDeployment(client.chain?.id ?? 0)?.sfpmSwap?.weth;
+	const tokens = [metadata.token0Asset, metadata.token1Asset];
+	const quoteIndex = tokens.findIndex((token) => token.toLowerCase() === numeraire.toLowerCase());
+	const gasIndex = tokens.findIndex((token) => token.toLowerCase() === gasAsset?.toLowerCase());
+	if (metadata.isV4 || quoteIndex !== 0 && quoteIndex !== 1 || gasIndex !== 0 && gasIndex !== 1) throw new Error("Protected hedge fees require a supported native-gas v3 pair");
+	const numeraireIndex = quoteIndex === 0 ? 0n : 1n;
+	const gasAssetIndex = gasIndex === 0 ? 0n : 1n;
+	if (numeraireIndex === gasAssetIndex) throw new Error("Hedge numeraire must differ from gas asset");
+	if ((gasIndex === 0 ? metadata.token0Decimals : metadata.token1Decimals) !== 18n) throw new Error("Native gas conversion requires an eighteen-decimal wrapped asset");
+	const ids = await getOpenPositionIds({
+		client,
+		chainId: BigInt(client.chain?.id ?? 0),
+		poolAddress,
+		account,
+		fromBlock,
+		toBlock: block.number
+	});
+	if (ids === null || ids.length === 0 || new Set(ids).size !== ids.length) throw new Error("Missing complete option book");
+	const fullCall = encodeFunctionData({
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			account,
+			true,
+			ids
+		]
+	});
+	const [results, nativeBalance] = await Promise.all([client.multicall({
+		contracts: [
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "getFullPositionsData",
+				args: [
+					account,
+					true,
+					ids
+				]
+			},
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "numberOfLegs",
+				args: [account]
+			},
+			{
+				address: poolAddress,
+				abi: assetsAbi,
+				functionName: "getAssetsOf",
+				args: [account]
+			},
+			{
+				address: metadata.underlyingPoolId,
+				abi: uniswapV3PoolAbi,
+				functionName: "slot0"
+			},
+			{
+				address: metadata.token0Asset,
+				abi: erc20Abi,
+				functionName: "balanceOf",
+				args: [account]
+			},
+			{
+				address: metadata.token1Asset,
+				abi: erc20Abi,
+				functionName: "balanceOf",
+				args: [account]
+			}
+		],
+		blockNumber: block.number,
+		allowFailure: false
+	}), client.getBalance({
+		address: account,
+		blockNumber: block.number
+	})]);
+	const [full, legCount, collateral, spot, wallet0, wallet1] = results;
+	const positions = ids.map((tokenId, index) => ({
+		tokenId,
+		positionSize: (full[2][index] ?? 0n) & MASK128
+	}));
+	if (full[2].length !== ids.length || positions.some((position) => position.positionSize === 0n) || positions.reduce((count, position) => count + BigInt(decodeTokenId(position.tokenId).legs.length), 0n) !== legCount) throw new Error("Incomplete hedge book leg count");
+	const premium = [(full[0] & MASK128) - (full[1] & MASK128), (full[0] >> 128n) - (full[1] >> 128n)];
+	const wallet = [wallet0 + (gasIndex === 0 ? nativeBalance : 0n), wallet1 + (gasIndex === 1 ? nativeBalance : 0n)];
+	const curve = await getPositionValueCurve({
+		client,
+		queryAddress,
+		positions
+	});
+	const book = {
+		curve,
+		balances: [collateral[0] + wallet[0] + premium[0], collateral[1] + wallet[1] + premium[1]],
+		sqrtPriceX96: spot[0],
+		numeraireIndex
+	};
+	return {
+		book,
+		blockNumber: block.number,
+		blockHash: block.hash,
+		timestamp: block.timestamp,
+		metadata,
+		account,
+		poolAddress,
+		queryAddress,
+		positions,
+		collateral,
+		wallet,
+		nativeBalance,
+		fullCall,
+		gasAssetIndex
+	};
+}
+async function quoteProtectedVaultHedge({ client, snapshot, dispatchData, anchor }) {
+	const decoded = decodeFunctionData({
+		abi: panopticPoolV2Abi,
+		data: dispatchData
+	});
+	if (decoded.functionName !== "dispatch") throw new Error("Protected gain requires a dispatch");
+	const [operations, finalIds, sizes, limits, usePremia] = decoded.args;
+	if (usePremia || new Set(operations).size !== operations.length || operations.length !== sizes.length || sizes.length !== limits.length) throw new Error("Unsupported protected hedge dispatch");
+	const existing = new Map(snapshot.positions.map((position) => [position.tokenId, position.positionSize]));
+	const expected = new Map(existing);
+	const reserve = [0n, 0n];
+	let lower = snapshot.book.sqrtPriceX96;
+	let upper = lower;
+	let direction;
+	let swapCount = 0;
+	for (const [index, tokenId] of operations.entries()) {
+		const size = sizes[index];
+		const limit = limits[index];
+		const { legs, tickSpacing } = decodeTokenId(tokenId);
+		const leg = legs[0];
+		if (size === void 0 || limit === void 0 || legs.length !== 1 || leg === void 0 || leg.width !== 0n || leg.isLong) throw new Error("Only standalone loan hedges can authorize protected gain");
+		const prior = existing.get(tokenId);
+		if (prior !== void 0 && size !== 0n || prior === void 0 && size === 0n) throw new Error("Unsupported hedge resize or missing burn");
+		if (size === 0n) expected.delete(tokenId);
+		else expected.set(tokenId, size);
+		if (limit[0] <= limit[1]) continue;
+		const lo = tickToSqrtPriceX96(BigInt(limit[1]));
+		const hi = tickToSqrtPriceX96(BigInt(limit[0]));
+		if (snapshot.book.sqrtPriceX96 < lo || snapshot.book.sqrtPriceX96 > hi) throw new Error("Hedge execution bounds are stale");
+		lower = min(lower, lo);
+		upper = max(upper, hi);
+		const borrowIndex = leg.tokenType === 0n ? 0n : 1n;
+		const counterIndex = borrowIndex === 0n ? 1n : 0n;
+		const outgoing = size === 0n ? counterIndex : borrowIndex;
+		if (direction !== void 0 && direction !== outgoing) throw new Error("Opposing swaps require a separate execution bound");
+		direction = outgoing;
+		const principal = -getLegTokenInventory({
+			...leg,
+			width: 2n
+		}, borrowIndex === 0n ? 887272n : -887272n, size === 0n ? prior ?? 0n : size, tickSpacing, borrowIndex) + 2n;
+		const convert = (sqrt) => borrowIndex === 0n ? ceilDiv(principal * sqrt ** 2n, Q192) : ceilDiv(principal * Q192, sqrt ** 2n);
+		const current = convert(snapshot.book.sqrtPriceX96);
+		const minimum = min(convert(lo), convert(hi));
+		const maximum = max(convert(lo), convert(hi));
+		const drift = size === 0n ? maximum - current : current - minimum;
+		reserve[Number(counterIndex)] += drift + ceilDiv(maximum * snapshot.metadata.fee, 1000000n - snapshot.metadata.fee) + 2n;
+		swapCount++;
+	}
+	if (swapCount === 0 || finalIds.length !== expected.size || new Set(finalIds).size !== finalIds.length || finalIds.some((id) => !expected.has(id))) throw new Error("Incomplete final protected hedge book");
+	const finalCall = encodeFunctionData({
+		abi: panopticPoolV2Abi,
+		functionName: "getFullPositionsData",
+		args: [
+			snapshot.account,
+			true,
+			finalIds
+		]
+	});
+	const result = await simulateWithTokenFlow({
+		client,
+		poolAddress: snapshot.poolAddress,
+		user: snapshot.account,
+		callData: dispatchData,
+		blockNumber: snapshot.blockNumber,
+		estimateGas: false,
+		preCallData: [snapshot.fullCall],
+		postCallData: [finalCall]
+	});
+	const flow = result.tokenFlow;
+	const pre = result.preCallResults?.[0];
+	const post = result.postCallResults?.[0];
+	if (!result.success || flow === void 0 || pre === void 0 || post === void 0) throw result.rawError ?? new Error(result.error ?? "Missing exact hedge cashflow quote");
+	if (flow.balanceBefore0 !== snapshot.collateral[0] || flow.balanceBefore1 !== snapshot.collateral[1]) throw new Error("Hedge quote does not match its confirmed snapshot");
+	const before = fullPositions(pre, snapshot.positions.map((position) => position.tokenId));
+	const after = fullPositions(post, finalIds);
+	if (after.positions.some((position) => expected.get(position.tokenId) !== position.positionSize)) throw new Error("Hedge quote changed an unexpected position");
+	const afterBook = {
+		...snapshot.book,
+		curve: await getPositionValueCurve({
+			client,
+			queryAddress: snapshot.queryAddress,
+			positions: after.positions
+		}),
+		balances: [flow.balanceAfter0 + snapshot.wallet[0] + after.premium[0] - reserve[0], flow.balanceAfter1 + snapshot.wallet[1] + after.premium[1] - reserve[1]]
+	};
+	const beforeBook = {
+		...snapshot.book,
+		balances: [flow.balanceBefore0 + snapshot.wallet[0] + before.premium[0], flow.balanceBefore1 + snapshot.wallet[1] + before.premium[1]]
+	};
+	const decimals = snapshot.book.numeraireIndex === 0n ? snapshot.metadata.token0Decimals : snapshot.metadata.token1Decimals;
+	const roundingReserve = 10n ** (decimals > 2n ? decimals - 2n : 0n);
+	return {
+		...estimateProtectedHedgeGain({
+			before: beforeBook,
+			after: afterBook,
+			anchor,
+			roundingReserve
+		}),
+		sqrtPriceLowerX96: lower,
+		sqrtPriceUpperX96: upper,
+		executionReserve: reserve
+	};
+}
+async function getVaultHedgeAccountActivity({ client, snapshot, fromBlock }) {
+	const addresses = [
+		snapshot.metadata.collateralToken0Address,
+		snapshot.metadata.collateralToken1Address,
+		snapshot.metadata.token0Asset,
+		snapshot.metadata.token1Asset
+	];
+	const [mints, burns, incoming, outgoing] = await Promise.all([
+		client.getContractEvents({
+			address: snapshot.poolAddress,
+			abi: panopticPoolV2Abi,
+			eventName: "OptionMinted",
+			args: { recipient: snapshot.account },
+			fromBlock,
+			toBlock: snapshot.blockNumber
+		}),
+		client.getContractEvents({
+			address: snapshot.poolAddress,
+			abi: panopticPoolV2Abi,
+			eventName: "OptionBurnt",
+			args: { recipient: snapshot.account },
+			fromBlock,
+			toBlock: snapshot.blockNumber
+		}),
+		client.getContractEvents({
+			address: addresses,
+			abi: erc20Abi,
+			eventName: "Transfer",
+			args: { to: snapshot.account },
+			fromBlock,
+			toBlock: snapshot.blockNumber
+		}),
+		client.getContractEvents({
+			address: addresses,
+			abi: erc20Abi,
+			eventName: "Transfer",
+			args: { from: snapshot.account },
+			fromBlock,
+			toBlock: snapshot.blockNumber
+		})
+	]);
+	return [
+		...mints,
+		...burns,
+		...incoming.filter((log) => (log.args.value ?? 0n) > 0n),
+		...outgoing.filter((log) => (log.args.value ?? 0n) > 0n)
+	].reduce((latest, log) => log.blockNumber !== null && (latest === void 0 || log.blockNumber > latest) ? log.blockNumber : latest, void 0);
+}
+async function valueVaultHedgeGas({ client, snapshot, blockNumber, gasCost }) {
+	const spot = await client.readContract({
+		address: snapshot.metadata.underlyingPoolId,
+		abi: uniswapV3PoolAbi,
+		functionName: "slot0",
+		blockNumber
+	});
+	return snapshot.gasAssetIndex === 0n ? ceilDiv(gasCost * spot[0] ** 2n, Q192) : ceilDiv(gasCost * Q192, spot[0] ** 2n);
+}
+
+//#endregion
+//#region src/hypoVault/signingFeePolicy.ts
+function authorizationIdentity(list = []) {
+	return list.map((authorization) => [
+		authorization.address.toLowerCase(),
+		authorization.chainId,
+		authorization.nonce,
+		authorization.yParity ?? (authorization.v === 27n ? 0 : authorization.v === 28n ? 1 : void 0),
+		authorization.r.toLowerCase(),
+		authorization.s.toLowerCase()
+	].join(":")).join("|");
+}
+/** Enforce an immutable intent budget on the actual serialized transaction before broadcast. */
+function withVaultTransactionFeePolicy(account, policy, intent) {
+	if (account.type !== "local") throw new Error("Adaptive vault fees require a local transaction signer");
+	const authority = Object.freeze({ ...policy });
+	const expected = intent === void 0 ? void 0 : Object.freeze({
+		...intent,
+		authorization: authorizationIdentity(intent.authorizationList)
+	});
+	const signTransaction = async (transaction, options) => {
+		const serialized = await account.signTransaction(transaction, options);
+		const signed = parseTransaction(serialized);
+		if (signed.gas === void 0 || signed.gas <= 0n) throw new Error("Vault signed transaction is missing a positive gas limit");
+		if (expected !== void 0 && (signed.chainId !== expected.chainId || signed.to?.toLowerCase() !== expected.to.toLowerCase() || (signed.data ?? "0x").toLowerCase() !== expected.data.toLowerCase() || (signed.value ?? 0n) !== expected.value || signed.gas !== expected.gasLimit || expected.nonce !== void 0 && signed.nonce !== expected.nonce || expected.maxFeePerGas !== void 0 && signed.maxFeePerGas !== expected.maxFeePerGas || expected.maxPriorityFeePerGas !== void 0 && signed.maxPriorityFeePerGas !== expected.maxPriorityFeePerGas || authorizationIdentity(signed.authorizationList) !== expected.authorization)) throw new Error("Vault signed transaction does not match its gas-budget intent");
+		const validation = validateVaultSignedTransactionFeeCaps({
+			chainId: signed.chainId,
+			gasLimit: signed.gas,
+			maxFeePerGas: signed.maxFeePerGas ?? null,
+			maxPriorityFeePerGas: signed.maxPriorityFeePerGas ?? null
+		}, void 0, authority);
+		if (!validation.valid) throw new Error(validation.reason);
+		return serialized;
+	};
+	return {
+		...account,
+		signTransaction
+	};
+}
+
+//#endregion
+//#region src/hypoVault/signingPreflight.ts
+/** Validate execution after signing, before the signed bytes can be broadcast. */
+function withVaultTransactionPreflight(account, preflight) {
+	if (account.type !== "local") throw new Error("Post-sign vault preflight requires a local transaction signer");
+	const signTransaction = async (transaction, options) => {
+		const serialized = await account.signTransaction(transaction, options);
+		await preflight();
+		return serialized;
+	};
+	return {
+		...account,
+		signTransaction
+	};
+}
+
 //#endregion
 //#region src/panoptic/v2/reads/irm.ts
 const WAD = 10n ** 18n;
@@ -37644,5 +38515,5 @@ async function getIrmCurve(params) {
 }
 
 //#endregion
-export { BASE_CHAIN_ID, BASE_DEPLOYMENT, BASE_ETH_USDC_5BPS_MARKET, BASE_HYPOVAULT_ADDRESSES, BASE_HYPOVAULT_CORE_ADDRESSES, BASE_HYPOVAULT_MANAGER_ADDRESSES, BASE_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, BASE_PANOPTIC_POOL_ADDRESSES, BASE_PANOPTIC_V2_ADDRESSES, BORROW_INDEX_BITS, BPS_SCALE, BaseUSDCPLPStrategistLeaves, BaseUSDCPLPVaultPoolInfos, BaseWETHPLPStrategistLeaves, BaseWETHPLPVaultPoolInfos, CHAIN_DEPLOYMENTS, CollateralTrackerAbi, CollateralTrackerV1_1Abi, Erc1155Abi, Erc20Abi, HypoVaultAbi, HypoVaultManagerConfigSchema, HypoVaultManagerWithMerkleVerificationAbi, MAINNET_CHAIN_ID, MAINNET_DEPLOYMENT, MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES, MAINNET_PANOPTIC_V2_ADDRESSES, MAINNET_RISK_ENGINES, MAINNET_USDC_PLP_COMPILED_POOL_POLICY, MAINNET_USDC_PLP_POOL_POLICY, MAINNET_USDC_REPLACEMENT_ARTIFACTS, MAINNET_V3_AUTHORIZATION_BLOCK, MAINNET_WETH_PLP_COMPILED_POOL_POLICY, MAINNET_WETH_PLP_POOL_POLICY, MAINNET_WETH_REPLACEMENT_ARTIFACTS, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS, MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, MainnetLegacyUSDCPLPStrategistLeaves, MainnetLegacyWETHPLPStrategistLeaves, MainnetUSDCPLPLegacyVaultPoolInfos, MainnetUSDCPLPPreviousStrategistLeaves, MainnetUSDCPLPPreviousVaultPoolInfos, MainnetUSDCPLPStrategistLeaves, MainnetUSDCPLPV3AuthorizedStrategistLeaves, MainnetUSDCPLPV3AuthorizedVaultPoolInfos, MainnetUSDCPLPVaultPoolInfos, MainnetWETHPLPLegacyVaultPoolInfos, MainnetWETHPLPPreviousStrategistLeaves, MainnetWETHPLPPreviousVaultPoolInfos, MainnetWETHPLPStrategistLeaves, MainnetWETHPLPV3AuthorizedStrategistLeaves, MainnetWETHPLPV3AuthorizedVaultPoolInfos, MainnetWETHPLPVaultPoolInfos, Multicall3Abi, NonFungiblePositionManagerAbi, PanopticFactoryV3Abi, PanopticFactoryV4Abi, PanopticHelperAbi, PanopticPoolAbi, PanopticPoolV1_1Abi, PanopticQueryV1_1Abi, PanopticVaultAccountantAbi, PanopticVaultAccountantManagerInputAbi, PoolManagerAbi, RATE_AT_TARGET_BITS, ROBINHOOD_CHAIN_ID, ROBINHOOD_DEPLOYMENT, ROBINHOOD_HYPOVAULT_ADDRESSES, ROBINHOOD_HYPOVAULT_CORE_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, ROBINHOOD_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_PANOPTIC_V2_ADDRESSES, ROBINHOOD_RISK_ENGINES, ROBINHOOD_SPY_USDG_30BPS_MARKET, ROBINHOOD_SPY_USDG_30BPS_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_SPY_USDG_30BPS_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_30BPS_POOL_INFO, ROBINHOOD_SPY_USDG_5BPS_MARKET, ROBINHOOD_SPY_USDG_5BPS_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_SPY_USDG_5BPS_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_5BPS_POOL_INFO, ROBINHOOD_SPY_USDG_MARKET, ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_POOL_INFO, ROBINHOOD_USDG_30BPS_MANAGE_ROOT, ROBINHOOD_USDG_30BPS_POOL_HASH, ROBINHOOD_USDG_5BPS_POOL_HASH, ROBINHOOD_USDG_PLP_30BPS_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_30BPS_POOL_POLICY, ROBINHOOD_USDG_PLP_5BPS_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_5BPS_POOL_POLICY, ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_POOL_POLICY, ROBINHOOD_USDG_REPLACEMENT_ARTIFACTS, ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK, RescueDistributorAbi, RobinhoodUSDGPLP30bpsStrategistLeaves, RobinhoodUSDGPLP30bpsVaultPoolInfos, RobinhoodUSDGPLP5bpsStrategistLeaves, RobinhoodUSDGPLP5bpsVaultPoolInfos, RobinhoodUSDGPLPStrategistLeaves, RobinhoodUSDGPLPVaultPoolInfos, SECONDS_PER_YEAR, SEPOLIA_CHAIN_ID, SEPOLIA_DEPLOYMENT, SEPOLIA_ETH_USDC_5BPS_MARKET, SEPOLIA_HYPOVAULT_ADDRESSES, SEPOLIA_HYPOVAULT_CORE_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, SEPOLIA_PANOPTIC_POOL_ADDRESSES, SEPOLIA_PANOPTIC_V2_ADDRESSES, SemiFungiblePositionManagerAbi, SemiFungiblePositionManagerV1_1Abi, SepoliaUSDCPLPStrategistLeaves, SepoliaUSDCPLPVaultPoolInfos, SepoliaWETHPLPStrategistLeaves, SepoliaWETHPLPVaultPoolInfos, Simple7702AccountAbi, StateViewAbi, TRUSTED_VAULT_SHARE_PRICE_STATUSES, UNREALIZED_INTEREST_BITS, UniswapHelperAbi, UniswapHelperV1_1Abi, UniswapMigratorAbi, UniswapV3FactoryAbi, UniswapV3PoolAbi, UsdcPlpVaultBaseProdConfig, UsdcPlpVaultMainnetLegacyConfig, UsdcPlpVaultMainnetProdConfig, UsdcPlpVaultSepoliaDevConfig, UsdcPlpVaultSepoliaProdConfig, UsdgPlpVaultRobinhoodProdConfig, VAULT_DISPLAY_NAMES_PER_CHAIN, VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN, VaultApyPreInceptionBlockError, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, WAD, WETHAbi, WethPlpVaultBaseProdConfig, WethPlpVaultMainnetLegacyConfig, WethPlpVaultMainnetProdConfig, WethPlpVaultSepoliaDevConfig, WethPlpVaultSepoliaProdConfig, adjustUnderlyingIdleBalance, adjustVaultSharePricesForDonations, annualizePerSecondRateWad, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, buildClaimVaultShareCalldatas, buildExecuteDepositCalldatas, buildExecuteWithdrawalCalldatas, buildManageArgs, buildManagerInput, buildManagerInputAtBlock, buildRequestWithdrawalCalldatas, buildVaultManagerInput, buildVaultManagerInputAtBlock, buildWeeklyVaultReturnHistogram, builderFactoryAbi, builderWalletAbi, calculateAnnualizedApyPct, calculateAssetsFromShares, calculateAvailableShares, calculateClaimableAssetsFromQueuedWithdrawals, calculateClaimableSharesFromQueuedDeposits, calculateFixedPortfolioScenarios, calculateLongOptionNotionalPct, calculateMaxSignedPriceChanges, calculateMeanMaxAbsolutePriceChange, calculateSharesFromAssets, calculateVaultNetLendingApyPctFromTrackerInputs, calculateVaultNetLendingYieldUnderlyingFromTrackerInputs, calculateWeeklyVaultReturns, cancelDeposit, chainToHypoVaultGraphQlAPI, clearVaultApyStrategyOverride, collateralTrackerV2Abi as collateralTrackerAbi, collateralTrackerV2Abi, computeSharePriceFromNavSnapshot, convertJsonTreeToArray, createVaultSharePriceProcessor, deriveSupplyRatePerSecWad, deriveVaultApyTimeseriesFromSharePrices, donationRetainedFactor, encodeApproveFunctionData, encodeCancelDepositFunctionData, encodeDepositFunctionData, encodeExecuteDepositFunctionData, encodeExecuteWithdrawalFunctionData, encodeExecuteWithdrawalMulticallFunctionData, encodeFulfillDepositsFunctionData, encodeFulfillWithdrawalsFunctionData, encodeRequestDepositFunctionData, encodeRequestWithdrawalFunctionData, encodeRequestWithdrawalMulticallFunctionData, encodeWithdrawFunctionData, estimateFixedPortfolioPremium, executeWithdrawal, executeWithdrawalMulticall, fetchFirstDepositTimestampByVaultId, fetchFixedVaultPortfolio, fetchHypoVaultRoles, fetchVaultLendingAllocation, fetchVaultNetLendingApyPct, fetchVaultNetLendingApyTrackerInputs, fetchVaultNetLendingYieldUnderlying, fetchVaultPositionActivity, fetchVaultPositionExposureHistory, fetchVaultSharePriceSnapshot, fetchVaultSharePriceSnapshotWithCandidateRecovery, filterActiveVaultWeeks, findLeaf, findLeafForTarget, findLeafForTargetAndSignature, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, generateProof, getAaveHoldings, getAlchemyRpcUrl, getAlchemyWsRpcUrl, getCancelDepositContractConfig, getChainDeployment, getEthUsdcMarket, getExecuteWithdrawalContractConfig, getExecuteWithdrawalMulticallContractConfig, getHypoVaultConfigForVault, getHypoVaultGraphQLClient, getIrmCurrent, getIrmCurve, getLendingAllocationRows, getMainnetV3AuthorizationArtifactsAtBlock, getMainnetV3AuthorizationGenerations, getMainnetVaultManagerRootAtBlock, getMainnetVaultManagerRootHistory, getMainnetVaultPoolConfigurationAtBlock, getMainnetVaultPoolConfigurationHistory, getMinQueuedDepositEpoch, getMorphoHoldings, getProofsFromDigests, getProofsUsingTree, getRequestDepositContractConfig, getRequestWithdrawalContractConfig, getRequestWithdrawalMulticallContractConfig, getRobinhoodSpyUsdgAuthorizationGenerations, getSpyUsdgMarket, getStaleOracleOverrideBytecodeForAccountant, getStaleOracleStateOverrideForAccountant, getStkAaveHoldings, getVaultApyErrorMessage, getVaultApyStrategy, getVaultCandidatePoolInfos, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultDonationSources, getVaultDonationTransfers, getVaultManagerRootAtBlock, getVaultManagerRootHistory, getVaultPoolConfigurationAtBlock, getVaultPoolConfigurationHistory, getVaultPoolInfos, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, hashRobinhoodSpyUsdgPoolInfos, isExpectedHistoricalReadMiss, isIncorrectPositionListReadError, isStaleOraclePriceError, isStaleOraclePriceReadError, isSupportedChain, isTrustedVaultSharePriceStatus, packMarketState, panopticFactoryV4Abi as panopticFactoryAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticLiquidatorAbi, panopticPoolV2Abi as panopticPoolAbi, panopticPoolV2Abi, panopticQueryAbi, parseCustomError, parseMinimalProxyImplementation, prepareFixedPoolValue, qualifyVaultWeeks, ratePerSecWadToAprPct, recoverVaultCandidateTokenIdsByPool, requestDeposit, requestWithdrawal, requestWithdrawalMulticall, requireChainDeployment, resolveMainnetV3AuthorizationArtifacts, resolvePositionScanFromBlock, resolveRobinhoodSpyUsdgAuthorizationArtifacts, resolveRobinhoodSpyUsdgAuthorizationState, resolveVaultDisplayName, resolveVaultHistoricalCandidatesByPool, resolveVaultPoolInfosAtBlock, resolveVaultTokenIdsByPool, riskEngineAbi, semiFungiblePositionManagerV4Abi as semiFungiblePositionManagerAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, setVaultApyStrategyOverride, simulateCancelDeposit, simulateExecuteWithdrawal, simulateExecuteWithdrawalMulticall, simulateRequestDeposit, simulateRequestWithdrawal, simulateRequestWithdrawalMulticall, statusForVaultSharePriceSnapshot, updatePositionSnapshot, useCancelDeposit, useClaimVaultShares, useErc20Balance, useExecuteWithdrawal, useRequestDeposit, useRequestWithdrawal, utilizationBpsToWad, utilizationPctToWad, validateVaultSignedTransactionFeeCaps, valueDonationInUnderlying, valueVaultDonationBlock, verifyVaultOpenTokenIdsAtBlock };
+export { BASE_CHAIN_ID, BASE_DEPLOYMENT, BASE_ETH_USDC_5BPS_MARKET, BASE_HYPOVAULT_ADDRESSES, BASE_HYPOVAULT_CORE_ADDRESSES, BASE_HYPOVAULT_MANAGER_ADDRESSES, BASE_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, BASE_PANOPTIC_POOL_ADDRESSES, BASE_PANOPTIC_V2_ADDRESSES, BORROW_INDEX_BITS, BPS_SCALE, BaseUSDCPLPStrategistLeaves, BaseUSDCPLPVaultPoolInfos, BaseWETHPLPStrategistLeaves, BaseWETHPLPVaultPoolInfos, CHAIN_DEPLOYMENTS, CollateralTrackerAbi, CollateralTrackerV1_1Abi, Erc1155Abi, Erc20Abi, HypoVaultAbi, HypoVaultManagerConfigSchema, HypoVaultManagerWithMerkleVerificationAbi, MAINNET_CHAIN_ID, MAINNET_DEPLOYMENT, MAINNET_ETH_USDC_5BPS_V3_PANOPTIC_POOL_ADDRESSES, MAINNET_PANOPTIC_V2_ADDRESSES, MAINNET_RISK_ENGINES, MAINNET_USDC_PLP_COMPILED_POOL_POLICY, MAINNET_USDC_PLP_POOL_POLICY, MAINNET_USDC_REPLACEMENT_ARTIFACTS, MAINNET_V3_AUTHORIZATION_BLOCK, MAINNET_WETH_PLP_COMPILED_POOL_POLICY, MAINNET_WETH_PLP_POOL_POLICY, MAINNET_WETH_REPLACEMENT_ARTIFACTS, MARKET_EPOCH_BITS, MARKET_EPOCH_SHIFT, MAX_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS, MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, MainnetLegacyUSDCPLPStrategistLeaves, MainnetLegacyWETHPLPStrategistLeaves, MainnetUSDCPLPLegacyVaultPoolInfos, MainnetUSDCPLPPreviousStrategistLeaves, MainnetUSDCPLPPreviousVaultPoolInfos, MainnetUSDCPLPStrategistLeaves, MainnetUSDCPLPV3AuthorizedStrategistLeaves, MainnetUSDCPLPV3AuthorizedVaultPoolInfos, MainnetUSDCPLPVaultPoolInfos, MainnetWETHPLPLegacyVaultPoolInfos, MainnetWETHPLPPreviousStrategistLeaves, MainnetWETHPLPPreviousVaultPoolInfos, MainnetWETHPLPStrategistLeaves, MainnetWETHPLPV3AuthorizedStrategistLeaves, MainnetWETHPLPV3AuthorizedVaultPoolInfos, MainnetWETHPLPVaultPoolInfos, Multicall3Abi, NonFungiblePositionManagerAbi, PanopticFactoryV3Abi, PanopticFactoryV4Abi, PanopticHelperAbi, PanopticPoolAbi, PanopticPoolV1_1Abi, PanopticQueryV1_1Abi, PanopticVaultAccountantAbi, PanopticVaultAccountantManagerInputAbi, PoolManagerAbi, RATE_AT_TARGET_BITS, ROBINHOOD_CHAIN_ID, ROBINHOOD_DEPLOYMENT, ROBINHOOD_HYPOVAULT_ADDRESSES, ROBINHOOD_HYPOVAULT_CORE_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_ADDRESSES, ROBINHOOD_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, ROBINHOOD_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_PANOPTIC_V2_ADDRESSES, ROBINHOOD_RISK_ENGINES, ROBINHOOD_SPY_USDG_30BPS_MARKET, ROBINHOOD_SPY_USDG_30BPS_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_SPY_USDG_30BPS_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_30BPS_POOL_INFO, ROBINHOOD_SPY_USDG_5BPS_MARKET, ROBINHOOD_SPY_USDG_5BPS_PANOPTIC_POOL_ADDRESSES, ROBINHOOD_SPY_USDG_5BPS_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_5BPS_POOL_INFO, ROBINHOOD_SPY_USDG_MARKET, ROBINHOOD_SPY_USDG_POOL_DEPLOYMENT_BLOCK, ROBINHOOD_SPY_USDG_POOL_INFO, ROBINHOOD_USDG_30BPS_MANAGE_ROOT, ROBINHOOD_USDG_30BPS_POOL_HASH, ROBINHOOD_USDG_5BPS_POOL_HASH, ROBINHOOD_USDG_PLP_30BPS_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_30BPS_POOL_POLICY, ROBINHOOD_USDG_PLP_5BPS_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_5BPS_POOL_POLICY, ROBINHOOD_USDG_PLP_COMPILED_POOL_POLICY, ROBINHOOD_USDG_PLP_POOL_POLICY, ROBINHOOD_USDG_REPLACEMENT_ARTIFACTS, ROBINHOOD_USDG_VAULT_DEPLOYMENT_BLOCK, RescueDistributorAbi, RobinhoodUSDGPLP30bpsStrategistLeaves, RobinhoodUSDGPLP30bpsVaultPoolInfos, RobinhoodUSDGPLP5bpsStrategistLeaves, RobinhoodUSDGPLP5bpsVaultPoolInfos, RobinhoodUSDGPLPStrategistLeaves, RobinhoodUSDGPLPVaultPoolInfos, SECONDS_PER_YEAR, SEPOLIA_CHAIN_ID, SEPOLIA_DEPLOYMENT, SEPOLIA_ETH_USDC_5BPS_MARKET, SEPOLIA_HYPOVAULT_ADDRESSES, SEPOLIA_HYPOVAULT_CORE_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_ADDRESSES, SEPOLIA_HYPOVAULT_MANAGER_TURNKEY_SIGNERS, SEPOLIA_PANOPTIC_POOL_ADDRESSES, SEPOLIA_PANOPTIC_V2_ADDRESSES, SemiFungiblePositionManagerAbi, SemiFungiblePositionManagerV1_1Abi, SepoliaUSDCPLPStrategistLeaves, SepoliaUSDCPLPVaultPoolInfos, SepoliaWETHPLPStrategistLeaves, SepoliaWETHPLPVaultPoolInfos, Simple7702AccountAbi, StateViewAbi, TRUSTED_VAULT_SHARE_PRICE_STATUSES, UNREALIZED_INTEREST_BITS, UniswapHelperAbi, UniswapHelperV1_1Abi, UniswapMigratorAbi, UniswapV3FactoryAbi, UniswapV3PoolAbi, UsdcPlpVaultBaseProdConfig, UsdcPlpVaultMainnetLegacyConfig, UsdcPlpVaultMainnetProdConfig, UsdcPlpVaultSepoliaDevConfig, UsdcPlpVaultSepoliaProdConfig, UsdgPlpVaultRobinhoodProdConfig, VAULT_DISPLAY_NAMES_PER_CHAIN, VAULT_DISPLAY_NAME_RESOLVERS_PER_CHAIN, VOLUSDC_HEDGE_FEE_POLICY, VOLUSDC_INCIDENT_GAS_ENVELOPE, VaultApyPreInceptionBlockError, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, WAD, WETHAbi, WethPlpVaultBaseProdConfig, WethPlpVaultMainnetLegacyConfig, WethPlpVaultMainnetProdConfig, WethPlpVaultSepoliaDevConfig, WethPlpVaultSepoliaProdConfig, adjustUnderlyingIdleBalance, adjustVaultSharePricesForDonations, annualizePerSecondRateWad, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, buildClaimVaultShareCalldatas, buildExecuteDepositCalldatas, buildExecuteWithdrawalCalldatas, buildManageArgs, buildManagerInput, buildManagerInputAtBlock, buildRequestWithdrawalCalldatas, buildVaultManagerInput, buildVaultManagerInputAtBlock, buildWeeklyVaultReturnHistogram, builderFactoryAbi, builderWalletAbi, calculateAnnualizedApyPct, calculateAssetsFromShares, calculateAvailableShares, calculateClaimableAssetsFromQueuedWithdrawals, calculateClaimableSharesFromQueuedDeposits, calculateFixedPortfolioScenarios, calculateLongOptionNotionalPct, calculateMaxSignedPriceChanges, calculateMeanMaxAbsolutePriceChange, calculateSharesFromAssets, calculateVaultNetLendingApyPctFromTrackerInputs, calculateVaultNetLendingYieldUnderlyingFromTrackerInputs, calculateWeeklyVaultReturns, cancelDeposit, chainToHypoVaultGraphQlAPI, clearVaultApyStrategyOverride, collateralTrackerV2Abi as collateralTrackerAbi, collateralTrackerV2Abi, computeSharePriceFromNavSnapshot, convertJsonTreeToArray, createVaultSharePriceProcessor, deriveSupplyRatePerSecWad, deriveVaultApyTimeseriesFromSharePrices, donationRetainedFactor, encodeApproveFunctionData, encodeCancelDepositFunctionData, encodeDepositFunctionData, encodeExecuteDepositFunctionData, encodeExecuteWithdrawalFunctionData, encodeExecuteWithdrawalMulticallFunctionData, encodeFulfillDepositsFunctionData, encodeFulfillWithdrawalsFunctionData, encodeRequestDepositFunctionData, encodeRequestWithdrawalFunctionData, encodeRequestWithdrawalMulticallFunctionData, encodeWithdrawFunctionData, estimateFixedPortfolioPremium, estimateProtectedHedgeGain, executeWithdrawal, executeWithdrawalMulticall, fetchFirstDepositTimestampByVaultId, fetchFixedVaultPortfolio, fetchHypoVaultRoles, fetchVaultLendingAllocation, fetchVaultNetLendingApyPct, fetchVaultNetLendingApyTrackerInputs, fetchVaultNetLendingYieldUnderlying, fetchVaultPositionActivity, fetchVaultPositionExposureHistory, fetchVaultSharePriceSnapshot, fetchVaultSharePriceSnapshotWithCandidateRecovery, filterActiveVaultWeeks, findLeaf, findLeafForTarget, findLeafForTargetAndSignature, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, generateProof, getAaveHoldings, getAdaptiveHedgeFeeQuote, getAlchemyRpcUrl, getAlchemyWsRpcUrl, getCancelDepositContractConfig, getChainDeployment, getEthUsdcMarket, getExecuteWithdrawalContractConfig, getExecuteWithdrawalMulticallContractConfig, getHedgeShock, getHypoVaultConfigForVault, getHypoVaultGraphQLClient, getIrmCurrent, getIrmCurve, getLendingAllocationRows, getMainnetV3AuthorizationArtifactsAtBlock, getMainnetV3AuthorizationGenerations, getMainnetVaultManagerRootAtBlock, getMainnetVaultManagerRootHistory, getMainnetVaultPoolConfigurationAtBlock, getMainnetVaultPoolConfigurationHistory, getMinQueuedDepositEpoch, getMorphoHoldings, getProofsFromDigests, getProofsUsingTree, getProtectedHedgeGasBudget, getRequestDepositContractConfig, getRequestWithdrawalContractConfig, getRequestWithdrawalMulticallContractConfig, getRobinhoodSpyUsdgAuthorizationGenerations, getSpyUsdgMarket, getStaleOracleOverrideBytecodeForAccountant, getStaleOracleStateOverrideForAccountant, getStkAaveHoldings, getVaultApyErrorMessage, getVaultApyStrategy, getVaultCandidatePoolInfos, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultDonationSources, getVaultDonationTransfers, getVaultHedgeAccountActivity, getVaultManagerRootAtBlock, getVaultManagerRootHistory, getVaultPoolConfigurationAtBlock, getVaultPoolConfigurationHistory, getVaultPoolInfos, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, hashRobinhoodSpyUsdgPoolInfos, isExpectedHistoricalReadMiss, isIncorrectPositionListReadError, isStaleOraclePriceError, isStaleOraclePriceReadError, isSupportedChain, isTrustedVaultSharePriceStatus, packMarketState, panopticFactoryV4Abi as panopticFactoryAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticLiquidatorAbi, panopticPoolV2Abi as panopticPoolAbi, panopticPoolV2Abi, panopticQueryAbi, parseCustomError, parseMinimalProxyImplementation, prepareFixedPoolValue, qualifyVaultWeeks, quoteProtectedVaultHedge, ratePerSecWadToAprPct, readVaultHedgeBook, recoverVaultCandidateTokenIdsByPool, requestDeposit, requestWithdrawal, requestWithdrawalMulticall, requireChainDeployment, resolveAdaptiveHedgeFeeQuote, resolveHedgeShock, resolveMainnetV3AuthorizationArtifacts, resolvePositionScanFromBlock, resolveRobinhoodSpyUsdgAuthorizationArtifacts, resolveRobinhoodSpyUsdgAuthorizationState, resolveVaultDisplayName, resolveVaultHistoricalCandidatesByPool, resolveVaultPoolInfosAtBlock, resolveVaultTokenIdsByPool, riskEngineAbi, selectBudgetedHedgeFees, semiFungiblePositionManagerV4Abi as semiFungiblePositionManagerAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, setVaultApyStrategyOverride, simulateCancelDeposit, simulateExecuteWithdrawal, simulateExecuteWithdrawalMulticall, simulateRequestDeposit, simulateRequestWithdrawal, simulateRequestWithdrawalMulticall, statusForVaultSharePriceSnapshot, updatePositionSnapshot, useCancelDeposit, useClaimVaultShares, useErc20Balance, useExecuteWithdrawal, useRequestDeposit, useRequestWithdrawal, utilizationBpsToWad, utilizationPctToWad, validateVaultSignedTransactionFeeCaps, valueDonationInUnderlying, valueFrozenHedgeBook, valueVaultDonationBlock, valueVaultHedgeGas, verifyVaultOpenTokenIdsAtBlock, withVaultTransactionFeePolicy, withVaultTransactionPreflight };
 //# sourceMappingURL=index.js.map