@panoptic-eng/sdk 1.0.39 → 1.0.41

package/dist/{v2-DG7qG6di.js → v2-ChGyiigb.js}

@@ -1,7 +1,7 @@
 import { StateViewAbi, formatTokenAmount, getAccountCollateral, panopticQueryAbi$1 as panopticQueryAbi, parseTokenAmount, readBlockAndAggregate, requireReturnData } from "./irm-SPC2KxLA.js";
-import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePosition, decodePositionBalance, decodeTickSpacing, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./getTrackedPositionIds-ms3W9dYB.js";
+import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, LEG_LIMITS, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, TOKEN_ID_BITS, UnhealthyPoolError, WrongUniswapPoolError, collateralTrackerV2Abi, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePosition, decodePositionBalance, decodeTickSpacing, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./getTrackedPositionIds-ms3W9dYB.js";
 import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, WAD, calculatePositionDelta, calculatePositionGamma, calculatePositionValue, priceToTick, sqrtPriceX96ToTick, tickLimits, tickToPrice, tickToPriceDecimalScaled, tickToSqrtPriceX96 } from "./greeks-GysWXct-.js";
-import { addLegToTokenId, buildBatchDispatchArgs, buildUniqueCredit, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateOpenPosition, simulateWithTokenFlow } from "./writes-Xp9Wa8GQ.js";
+import { addLegToTokenId, buildBatchDispatchArgs, buildUniqueCredit, countLegs, createTokenIdBuilder, decodeAllLegs, decodeTokenId, getCurrentPositionSizes, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateOpenPosition, simulateWithTokenFlow } from "./writes-_gfkBizf.js";
 import { BaseError, ContractFunctionExecutionError, ContractFunctionRevertedError, ExecutionRevertedError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, keccak256, toHex, zeroAddress } from "viem";
 import { multicall } from "viem/actions";
 
@@ -203,6 +203,165 @@ function interpolateBlocks(startBlock, endBlock, points) {
 	return Array.from({ length: points }, (_, i) => startBlock + range * BigInt(i) / BigInt(points - 1));
 }
 
+//#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$2 = 1n << 192n;
+/**
+* Floor integer square root for bigints (Newton's method). Mirrors the isqrt
+* used in reads/collateralEstimate.ts (buildNeutralLeg).
+*/
+function isqrt$1(value) {
+	if (value < 0n) throw new PanopticError("isqrt of negative number");
+	if (value < 2n) return value;
+	let x = value;
+	let y = x + 1n >> 1n;
+	while (y < x) {
+		x = y;
+		y = x + value / x >> 1n;
+	}
+	return x;
+}
+const DEFAULT_TICK_SPACING = 200n;
+/**
+* Target notional (in wei of the tokenType-side asset) for the appended
+* tiny credit leg. Chosen at 10 wei — small enough to be economically
+* meaningless against any real position size, large enough to safely
+* clear rounding on the SFPM's width-2 internal chunk math without any
+* risk of underflowing to zero (which would revert ChunkHasZeroLiquidity).
+*/
+const TINY_CREDIT_TARGET_NOTIONAL_WEI = 10n;
+/**
+* Pick a signedStrike for the appended width=0 credit leg such that:
+*   1. positionSize · 1.0001^signedStrike ≈ TINY_CREDIT_TARGET_NOTIONAL_WEI
+*      (~10 wei — economically meaningless but comfortably above any
+*      SFPM width-2 chunk rounding);
+*   2. the leg's tick range (SFPM internally treats width=0 as width=2, so
+*      the range is `strike ± tickSpacing`) stays strictly inside
+*      `[MIN_POOL_TICK, MAX_POOL_TICK]` — otherwise the getSqrtRatioAtTick
+*      call reverts with `InvalidTick`.
+*
+* Closed form: `1.0001^signedStrike = target/positionSize`, so
+* `sqrtKrawX96 = isqrt(target · 2^192 / positionSize)` and
+* `signedStrike = sqrtPriceX96ToTick(sqrtKrawX96)`. If the notional-optimal
+* strike falls outside the safe range, we clamp inward. Clamping raises the
+* notional but keeps it << position size for any reasonable strike.
+*/
+function computeTinyCreditSignedStrike(positionSize, tickSpacing) {
+	if (positionSize <= 0n) throw new PanopticError("computeTinyCreditSignedStrike: positionSize must be > 0");
+	const minSafe = MIN_TICK + tickSpacing + 1n;
+	const maxSafe = MAX_TICK - tickSpacing - 1n;
+	let signedStrike;
+	try {
+		const sqrtKrawX96 = isqrt$1(TINY_CREDIT_TARGET_NOTIONAL_WEI * Q192$2 / positionSize);
+		signedStrike = sqrtPriceX96ToTick(sqrtKrawX96);
+	} catch {
+		signedStrike = minSafe;
+	}
+	if (signedStrike < minSafe) return minSafe;
+	if (signedStrike > maxSafe) return maxSafe;
+	return signedStrike;
+}
+/**
+* Assemble the tiny credit leg struct, picking a strike that avoids
+* colliding with any existing width=0 credit leg on the same (asset,
+* tokenType) pair.
+*
+* The encoded strike stored in the tokenId is
+* `asset === 0 ? signedStrike : -signedStrike` (mirrors
+* {@link buildNeutralLeg} in reads/collateralEstimate.ts).
+*/
+function pickUniqueTinyCreditLeg(baseTokenId, legIndex, positionSize, tickSpacing) {
+	const asset = 1n;
+	const tokenType = 0n;
+	const existingLegs = decodeAllLegs(baseTokenId);
+	const maxSafe = MAX_TICK - tickSpacing - 1n;
+	let signedStrike = computeTinyCreditSignedStrike(positionSize, tickSpacing);
+	while (signedStrike <= maxSafe) {
+		const candidate = asset === 0n ? signedStrike : -signedStrike;
+		let collides = false;
+		for (const leg of existingLegs) if (leg.width === 0n && leg.isLong && leg.asset === asset && leg.tokenType === tokenType && leg.strike === candidate) {
+			collides = true;
+			break;
+		}
+		if (!collides) break;
+		signedStrike += 1n;
+	}
+	if (signedStrike > maxSafe) throw new PanopticError("deriveUniqueTokenId: exhausted strike space picking a unique tiny credit leg");
+	const encodedStrike = asset === 0n ? signedStrike : -signedStrike;
+	return {
+		index: legIndex,
+		asset,
+		tokenType,
+		optionRatio: 1n,
+		isLong: 1n,
+		riskPartner: legIndex,
+		strike: encodedStrike,
+		width: 0n
+	};
+}
+function appendTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing) {
+	const newLeg = pickUniqueTinyCreditLeg(baseTokenId, baseLegCount, positionSize, tickSpacing);
+	return addLegToTokenId(baseTokenId, newLeg);
+}
+function scaleRatios(baseTokenId, targetPositionSize) {
+	const legs = decodeAllLegs(baseTokenId);
+	const maxRatio = legs.reduce((m, leg) => leg.optionRatio > m ? leg.optionRatio : m, 0n);
+	const N = MAX_OPTION_RATIO / maxRatio;
+	if (N < 2n) throw new PanopticError("deriveUniqueTokenId: cannot derive a unique tokenId — all 4 leg slots used and optionRatios already near the 127 ceiling");
+	const newPositionSize = (targetPositionSize + N - 1n) / N;
+	const poolId = baseTokenId & POOL_ID_MASK$2;
+	let out = poolId;
+	for (const leg of legs) out = addLegToTokenId(out, {
+		index: leg.index,
+		asset: leg.asset,
+		tokenType: leg.tokenType,
+		optionRatio: leg.optionRatio * N,
+		isLong: leg.isLong ? 1n : 0n,
+		riskPartner: leg.riskPartner,
+		strike: leg.strike,
+		width: leg.width
+	});
+	return {
+		newTokenId: out,
+		newPositionSize,
+		effectivePositionSize: newPositionSize * N,
+		strategy: "ratio-scale"
+	};
+}
+/**
+* Derive a tokenId unique from `baseTokenId` for a partial reduction.
+*
+* Prefers a tiny-credit-leg extension (arbitrary new size). Falls back to
+* optionRatio scaling only when the base tokenId already occupies all 4 leg
+* slots.
+*/
+function deriveUniqueTokenId(params) {
+	const { baseTokenId, targetPositionSize, tickSpacing = DEFAULT_TICK_SPACING } = params;
+	if (targetPositionSize <= 0n) throw new PanopticError("deriveUniqueTokenId: targetPositionSize must be > 0");
+	const legCount = countLegs(baseTokenId);
+	if (legCount === 0n) throw new PanopticError("deriveUniqueTokenId: baseTokenId has no legs");
+	if (legCount < MAX_LEGS) {
+		const newTokenId = appendTinyCreditLeg(baseTokenId, legCount, targetPositionSize, tickSpacing);
+		return {
+			newTokenId,
+			newPositionSize: targetPositionSize,
+			effectivePositionSize: targetPositionSize,
+			strategy: "tiny-credit"
+		};
+	}
+	return scaleRatios(baseTokenId, targetPositionSize);
+}
+/**
+* Re-export decoded leg count so callers can gate UI on the strategy that
+* would be chosen (e.g. show a divisibility hint on ratio-scale positions).
+*/
+function planDeriveStrategy(baseTokenId) {
+	return countLegs(baseTokenId) < MAX_LEGS ? "tiny-credit" : "ratio-scale";
+}
+
 //#endregion
 //#region src/panoptic/v2/sfpmSwap/calldata.ts
 /**
@@ -1703,8 +1862,9 @@ async function quoteTokenShortfallRecovery(params) {
 			error: new PanopticError("Could not size the prefixed recovery swap")
 		};
 	};
+	let creditOutSize = amountOut;
 	for (let attempt = 0; attempt < MAX_RECOVERY_QUOTE_ATTEMPTS; attempt++) {
-		const credit = buildUniqueCredit(pool.poolId, tokenOutIndex, tokenOutIndex, pool.currentTick, pool.tickSpacing, collisionIds, amountOut);
+		const credit = buildUniqueCredit(pool.poolId, tokenOutIndex, tokenOutIndex, pool.currentTick, pool.tickSpacing, collisionIds, creditOutSize);
 		const recoveredDispatch = buildTokenShortfallRecoveryDispatch({
 			dispatch: params.dispatch,
 			creditTokenId: credit.tokenId,
@@ -1748,10 +1908,14 @@ async function quoteTokenShortfallRecovery(params) {
 		const maxAmountIn = maximumAmountIn(estimatedAmountIn, params.slippageBps);
 		const swapOutput = getOutputAmount(swapSimulation.tokenFlow, tokenOutIndex);
 		const sourceBalance = getBalanceBefore(swapSimulation.tokenFlow, tokenInIndex);
-		if (swapOutput < amountOut || sourceBalance < maxAmountIn) return {
+		if (swapOutput < amountOut) {
+			creditOutSize = swapOutput > 0n ? ceilDiv(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
+			continue;
+		}
+		if (sourceBalance < maxAmountIn) return {
 			available: false,
 			reason: "swap-unavailable",
-			detail: swapOutput < amountOut ? `swap output ${swapOutput} < required ${amountOut}` : `source balance ${sourceBalance} < maximumAmountIn ${maxAmountIn} (estimated ${estimatedAmountIn}, slippageBps ${params.slippageBps})`,
+			detail: `source balance ${sourceBalance} < maximumAmountIn ${maxAmountIn} (estimated ${estimatedAmountIn}, slippageBps ${params.slippageBps})`,
 			error: new PanopticError("Insufficient source collateral for the recovery swap")
 		};
 		const recoverySimulation = await simulateDispatch({
@@ -1803,6 +1967,7 @@ async function quoteTokenShortfallRecovery(params) {
 		const decodedShortfall = remainingShortfall.assetsRequested - remainingShortfall.assetBalance;
 		const additionalAmountOut = decodedShortfall > 0n ? decodedShortfall : amountOut;
 		amountOut += additionalAmountOut;
+		creditOutSize = swapOutput > 0n ? ceilDiv(creditOutSize * amountOut, swapOutput) + 1n : creditOutSize * 2n;
 	}
 	return {
 		available: false,
@@ -1829,6 +1994,7 @@ const MAX_EFFECTIVE_LIQUIDITY_LIMIT = 8388607;
 * returned value must be scaled down to the caller's actual `positionSize`.
 */
 const MAX_UINT64$1 = 2n ** 64n - 1n;
+const FP96$1 = 1n << 96n;
 /**
 * `getRequiredBase` returns `type(uint128).max` as an error sentinel (invalid
 * tokenId or reverting `getMargin`). Detect it so we don't scale a garbage value.
@@ -1841,7 +2007,9 @@ const REQUIRED_BASE_ERROR_SENTINEL = 2n ** 128n - 1n;
 * computes the requirement at `type(uint64).max` size and 0% utilization. Since
 * the requirement is linear in size, the raw result is scaled by
 * `positionSize / type(uint64).max` to yield the requirement for the requested
-* size. Returns collateral requirement in terms of token0.
+* size. `PanopticQuery.getRequiredBase` returns the cross-margin requirement in
+* the higher-precision raw token at `atTick`; this function places that amount
+* in the matching `required0` or `required1` field.
 *
 * @param params - The parameters
 * @returns Estimated collateral requirements with block metadata
@@ -1860,7 +2028,7 @@ async function estimateCollateralRequired(params) {
 		});
 		effectiveTick = BigInt(currentTickResult);
 	}
-	const [required0, _meta] = await Promise.all([client.readContract({
+	const [requiredBase, _meta] = await Promise.all([client.readContract({
 		address: queryAddress,
 		abi: panopticQueryAbi,
 		functionName: "getRequiredBase",
@@ -1874,10 +2042,11 @@ async function estimateCollateralRequired(params) {
 		client,
 		blockNumber: targetBlockNumber
 	})]);
-	const scaled0 = required0 >= REQUIRED_BASE_ERROR_SENTINEL ? required0 : required0 * positionSize / MAX_UINT64$1;
+	const scaledRequirement = requiredBase >= REQUIRED_BASE_ERROR_SENTINEL ? requiredBase : requiredBase * positionSize / MAX_UINT64$1;
+	const denominatedInToken0 = tickToSqrtPriceX96(effectiveTick) < FP96$1;
 	return {
-		required0: scaled0,
-		required1: 0n,
+		required0: denominatedInToken0 ? scaledRequirement : 0n,
+		required1: denominatedInToken0 ? 0n : scaledRequirement,
 		_meta
 	};
 }
@@ -5089,7 +5258,9 @@ async function getStreamiaHistory(params) {
 			_meta: _meta$1
 		};
 	}
-	const premiaRequests = blockNumbers.map((bn) => client.readContract({
+	const _meta = params._meta ?? await getBlockMeta({ client });
+	const resolvedBlockNumbers = blockNumbers.map((blockNumber) => blockNumber ?? _meta.blockNumber);
+	const premiaRequests = resolvedBlockNumbers.map((blockNumber) => client.readContract({
 		address: panopticPoolAddress,
 		abi: panopticPoolV2Abi,
 		functionName: "getFullPositionsData",
@@ -5098,18 +5269,36 @@ async function getStreamiaHistory(params) {
 			true,
 			[tokenId]
 		],
-		blockNumber: bn
+		blockNumber
 	}));
-	const uniswapDataPromise = includeUniswapFees && legs.length > 0 ? fetchUniswapFeeData(client, blockNumbers, legs, poolConfig) : void 0;
-	const [premiaResults, uniswapData, _meta] = await Promise.all([
-		Promise.all(premiaRequests),
-		uniswapDataPromise ?? Promise.resolve(void 0),
-		params._meta ? Promise.resolve(params._meta) : getBlockMeta({ client })
-	]);
-	const sortedSettled = settledEvents ? [...settledEvents].sort((a, b) => a.blockNumber < b.blockNumber ? -1 : 1) : [];
+	const uniswapDataPromise = includeUniswapFees && legs.length > 0 ? fetchUniswapFeeData(client, resolvedBlockNumbers, legs, poolConfig) : void 0;
+	const [premiaResults, uniswapData] = await Promise.all([Promise.all(premiaRequests), uniswapDataPromise ?? Promise.resolve(void 0)]);
+	const sortedSettled = settledEvents ? [...settledEvents].sort((a, b) => a.blockNumber === b.blockNumber ? 0 : a.blockNumber < b.blockNumber ? -1 : 1) : [];
 	let settledIdx = 0;
 	let accSettled0 = 0n;
 	let accSettled1 = 0n;
+	const cumulativePremiaByInputIndex = Array.from({ length: blockNumbers.length }, () => ({
+		token0: 0n,
+		token1: 0n
+	}));
+	const chronologicalInputs = resolvedBlockNumbers.map((blockNumber, inputIndex) => ({
+		blockNumber,
+		inputIndex
+	})).sort((a, b) => a.blockNumber === b.blockNumber ? a.inputIndex - b.inputIndex : a.blockNumber < b.blockNumber ? -1 : 1);
+	for (const { blockNumber, inputIndex } of chronologicalInputs) {
+		while (settledIdx < sortedSettled.length && sortedSettled[settledIdx].blockNumber <= blockNumber) {
+			accSettled0 += sortedSettled[settledIdx].settled0;
+			accSettled1 += sortedSettled[settledIdx].settled1;
+			settledIdx++;
+		}
+		const result = premiaResults[inputIndex];
+		const premia0 = (result[0] & MASK_128) - (result[1] & MASK_128);
+		const premia1 = (result[0] >> 128n) - (result[1] >> 128n);
+		cumulativePremiaByInputIndex[inputIndex] = {
+			token0: premia0 + accSettled0,
+			token1: premia1 + accSettled1
+		};
+	}
 	let initialUniswapFees0 = null;
 	let initialUniswapFees1 = null;
 	const snapshots = premiaResults.map((result, i) => {
@@ -5120,14 +5309,8 @@ async function getStreamiaHistory(params) {
 		const short1 = shortPacked >> 128n;
 		const long0 = longPacked & MASK_128;
 		const long1 = longPacked >> 128n;
-		const effectiveBn = bn ?? BigInt(Number.MAX_SAFE_INTEGER);
-		while (settledIdx < sortedSettled.length && sortedSettled[settledIdx].blockNumber <= effectiveBn) {
-			accSettled0 += sortedSettled[settledIdx].settled0;
-			accSettled1 += sortedSettled[settledIdx].settled1;
-			settledIdx++;
-		}
-		const premia0 = short0 - long0 - accSettled0;
-		const premia1 = short1 - long1 - accSettled1;
+		const premia0 = short0 - long0;
+		const premia1 = short1 - long1;
 		let uniswapFees0 = 0n;
 		let uniswapFees1 = 0n;
 		if (uniswapData) {
@@ -5146,6 +5329,7 @@ async function getStreamiaHistory(params) {
 				token0: premia0,
 				token1: premia1
 			},
+			cumulativePanopticPremia: cumulativePremiaByInputIndex[i],
 			uniswapFees: {
 				token0: uniswapFees0,
 				token1: uniswapFees1
@@ -6932,14 +7116,21 @@ const multicallAbi = [{
 * @returns Simulation result with settlement data or error
 */
 async function simulateSettle(params) {
-	const { client, poolAddress, account, positionIdList, tokenId, blockNumber } = params;
+	const { client, poolAddress, account, positionIdList, finalPositionIdList, positionSizes: providedSizes, tokenId, blockNumber } = params;
 	const targetBlockNumber = blockNumber ?? await client.getBlockNumber();
 	const metaPromise = getBlockMeta({
 		client,
 		blockNumber: targetBlockNumber
 	});
 	try {
-		const positionSizes = positionIdList.map(() => 0n);
+		if (providedSizes && providedSizes.length !== positionIdList.length) throw new PanopticError("simulateSettle: positionSizes length must match positionIdList");
+		const positionSizes = providedSizes ?? await getCurrentPositionSizes({
+			client,
+			poolAddress,
+			account,
+			positionIdList,
+			blockNumber: targetBlockNumber
+		});
 		const tickAndSpreadLimits = positionIdList.map(() => [
 			-887272n,
 			887272n,
@@ -6950,7 +7141,7 @@ async function simulateSettle(params) {
 			functionName: "dispatch",
 			args: [
 				positionIdList,
-				positionIdList,
+				finalPositionIdList ?? positionIdList,
 				positionSizes.map((s) => BigInt(s)),
 				tickAndSpreadLimits.map((t) => [
 					Number(t[0]),
@@ -6982,8 +7173,8 @@ async function simulateSettle(params) {
 		});
 		const _meta = await metaPromise;
 		const data = {
-			premiaReceived0: tokenFlow.delta0 > 0n ? tokenFlow.delta0 : 0n,
-			premiaReceived1: tokenFlow.delta1 > 0n ? tokenFlow.delta1 : 0n,
+			premiaReceived0: tokenFlow.delta0,
+			premiaReceived1: tokenFlow.delta1,
 			postCollateral0: tokenFlow.balanceAfter0,
 			postCollateral1: tokenFlow.balanceAfter1,
 			forfeitAmounts
@@ -9100,4 +9291,4 @@ function isGasError(error) {
 }
 
 //#endregion
-export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, REQUIRED_BASE_ERROR_SENTINEL, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateSpreadWad, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, createPoolFormatters, decodePanopticTokenURI, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPoolIdHex, formatRatioPercent, formatTimestamp, formatTimestampLocale, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWei, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getAccountPremia, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolDisplayId, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionsWithPremia, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTokenListId, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseBps, parseCollateralLog, parsePoolLog, parseTokenListId, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteOneTokenFlow, quoteSfpmSwap, quoteTokenShortfallRecovery, removeTrackedChunks, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scanChunks, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, truncateAddress, watchEvents };
+export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, REQUIRED_BASE_ERROR_SENTINEL, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateSpreadWad, checkCollateralAcrossTicks, classifyStrategyGroups, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, createPoolFormatters, decodePanopticTokenURI, deriveUniqueTokenId, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feesFromFeeGrowthDelta, fetchSfpmV3PoolId, formatBlockNumber, formatBps, formatCompact, formatDatetime, formatDuration, formatDurationSeconds, formatFeeTier, formatGas, formatGwei, formatPoolIdHex, formatRatioPercent, formatTimestamp, formatTimestampLocale, formatTokenIdHex, formatTokenIdShort, formatTxHash, formatUtilization, formatWei, getAccountBuyingPower, getAccountGreeks, getAccountHistory, getAccountPremia, getChunkLiquidities, getChunkSpreads, getClosedPositions, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolDisplayId, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionsWithPremia, getPriceHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTokenListId, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3LpPositionState, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4LpPositionState, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, minePoolAddress, minePoolAddressLocalAsync, multicallRead, optimizeTokenIdRiskPartners, parseBps, parseCollateralLog, parsePoolLog, parseTokenListId, planDeriveStrategy, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteOneTokenFlow, quoteSfpmSwap, quoteTokenShortfallRecovery, removeTrackedChunks, resolveBlockNumbers, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scanChunks, simulateBatchDispatch, simulateClosePosition, simulateDeployNewPool, simulateDeposit, simulateDispatch, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSettle, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, truncateAddress, watchEvents };

package/dist/vault-transaction-fees.d.ts

@@ -8,7 +8,10 @@ type VaultTransactionFeeQuote = {
   maxFeePerGas: bigint;
   maxPriorityFeePerGas: bigint;
   minimumMaxFeePerGas: bigint;
-  source: 'fee_history' | 'viem_fallback';
+  source: 'fee_history' | 'viem_fallback' | 'rpc_priority_fee' | 'fee_history_p25';
+};
+type VaultDeltaHedgeFeeQuote = VaultTransactionFeeQuote & {
+  rawPriorityFeePerGas: bigint;
 };
 type VaultSignedTransactionFeeCaps = {
   gasLimit?: bigint | null;
@@ -47,6 +50,34 @@ declare class VaultTransactionGasCostLimitError extends Error {
     minimumRequiredFeePerGas: bigint;
   });
 }
+declare class VaultTransactionReplacementLimitError extends Error {
+  readonly code: 'GasCostCapExceeded';
+  readonly requiredMaxFeePerGas: bigint;
+  readonly requiredMaxPriorityFeePerGas: bigint;
+  readonly maximumAffordableFeePerGas: bigint;
+  constructor({
+    code,
+    gasLimit,
+    requiredMaxFeePerGas,
+    requiredMaxPriorityFeePerGas,
+    maximumAffordableFeePerGas
+  }: {
+    code: 'GasCostCapExceeded';
+    gasLimit: bigint;
+    requiredMaxFeePerGas: bigint;
+    requiredMaxPriorityFeePerGas: bigint;
+    maximumAffordableFeePerGas: bigint;
+  });
+}
+declare function getVaultTransactionReplacementFeeQuote({
+  originalQuote,
+  historicalQuote,
+  gasLimit
+}: {
+  originalQuote: Pick<VaultTransactionFeeQuote, 'maxFeePerGas' | 'maxPriorityFeePerGas'>;
+  historicalQuote: VaultDeltaHedgeFeeQuote;
+  gasLimit: bigint;
+}): VaultDeltaHedgeFeeQuote;
 declare function applyVaultTransactionGasCostLimit(quote: VaultTransactionFeeQuote, gasLimit: bigint): VaultTransactionFeeQuote;
 declare function bufferVaultTransactionGasEstimate(gasEstimate: bigint): bigint;
 declare function validateVaultSignedTransactionFeeCaps(feeCaps: VaultSignedTransactionFeeCaps, quote?: VaultTransactionFeeQuote): VaultSignedTransactionFeeValidationResult;
@@ -58,6 +89,13 @@ declare function validateVaultSignedTransactionFeeCaps(feeCaps: VaultSignedTrans
  * Viem's estimate is used while preserving those bounds and its original
  * base-fee allowance.
  */
-declare function getVaultTransactionFeeQuote<chain extends Chain | undefined>(client: Client<Transport, chain>): Promise<VaultTransactionFeeQuote>; //#endregion
-export { MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, VaultSignedTransactionFeeCaps, VaultSignedTransactionFeeValidationResult, VaultTransactionFeeEstimationError, VaultTransactionFeeQuote, VaultTransactionGasCostLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultTransactionFeeQuote, validateVaultSignedTransactionFeeCaps };
+declare function getVaultTransactionFeeQuote<chain extends Chain | undefined>(client: Client<Transport, chain>): Promise<VaultTransactionFeeQuote>;
+declare function getVaultDeltaHedgeHistoricalFeeQuote<chain extends Chain | undefined>(client: Client<Transport, chain>): Promise<VaultDeltaHedgeFeeQuote>;
+/**
+ * Resolve the first fee quote for a delta hedge from the connected RPC's
+ * eth_maxPriorityFeePerGas recommendation. A failed RPC recommendation falls
+ * back immediately to the rolling historical p25 quote.
+ */
+declare function getVaultDeltaHedgeInitialFeeQuote<chain extends Chain | undefined>(client: Client<Transport, chain>): Promise<VaultDeltaHedgeFeeQuote>; //#endregion
+export { MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, VaultDeltaHedgeFeeQuote, VaultSignedTransactionFeeCaps, VaultSignedTransactionFeeValidationResult, VaultTransactionFeeEstimationError, VaultTransactionFeeQuote, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, validateVaultSignedTransactionFeeCaps };
 //# sourceMappingURL=vault-transaction-fees.d.ts.map

package/dist/vault-transaction-fees.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vault-transaction-fees.d.ts","names":["Chain","Client","Transport","MIN_VAULT_PRIORITY_FEE_PER_GAS","MAX_VAULT_PRIORITY_FEE_PER_GAS","MAX_VAULT_TRANSACTION_GAS_COST","VaultTransactionFeeQuote","VaultSignedTransactionFeeCaps","VaultSignedTransactionFeeValidationResult","VaultTransactionFeeEstimationError","feeHistoryError","fallbackError","Error","VaultTransactionGasCostLimitError","gasLimit","maximumAffordableFeePerGas","minimumRequiredFeePerGas","FeeHistorySnapshot","FallbackFeeEstimate","resolveFeeHistoryQuote","baseFeePerGas","reward","resolveFallbackQuote","estimatedMaxFeePerGas","estimatedPriorityFeePerGas","applyVaultTransactionGasCostLimit","bufferVaultTransactionGasEstimate","validateVaultSignedTransactionFeeCaps","resolveVaultTransactionFeeQuote","readFeeHistory","readFallbackEstimate","Promise","getVaultTransactionFeeQuote","chain","__transactionFeeTestUtils"],"sources":["../src/hypoVault/transactionFees.d.ts"],"sourcesContent":null,"mappings":";;;cACqBG,8BAAAA;cACAC,8BAAAA;AADAD,cAEAE,8BAAAA,GAF8B,kBAAA;AAC9BD,KAETE,wBAAAA,GAFuC;EAC9BD,YAAAA,EAAAA,MAAAA;EACTC,oBAAAA,EAAAA,MAAwB;EAMxBC,mBAAAA,EAAAA,MAAAA;EAKAC,MAAAA,EAAAA,aAAAA,GAAAA,eAAAA;AAOZ,CAAA;AAAuD,KAZ3CD,6BAAAA,GAY2C;EAAA,QAGrCG,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;EAAe,YAAEC,EAAAA,MAAAA,GAAAA,IAAAA;EAAa,oBAHgBC,EAAAA,MAAAA,GAAAA,IAAAA;AAAK,CAAA;AAQhDC,KAfTL,yCAAAA,GAe0C;EAAA,KAAA,EAAA,IAAA;CAAA,GAAA;EAI5B,KAAEO,EAAAA,KAAAA;EAA0B,IAAEC,EAAAA,oBAAAA,GAAAA,gBAAAA,GAAAA,mBAAAA,GAAAA,oBAAAA,GAAAA,cAAAA,GAAAA,gBAAAA;EAAwB,MAJjBJ,EAAAA,MAAAA;AAAK,CAAA;AA0B5Ca,cAlCHhB,kCAAAA,SAA2CG,KAAAA,CAkCP;EAAA,SAAA,eAAA,EAAA,OAAA;EAAA,SAAQN,aAAAA,EAAAA,OAAAA;EAAwB,WAAqBA,CAAAA;IAAAA,eAAAA;IAAAA;EAEtFqB,CAFsFrB,EAAAA;IAAwB,eAAA,EAAA,OAAA;IAC9GoB,aAAAA,EAAAA,OAAAA;EACAC,CAAAA;;AAA+CpB,cA5BlDM,iCAAAA,SAA0CD,KAAAA,CA4BQL;EAA6B,SAAUD,QAAAA,EAAAA,MAAAA;EAAwB,SAAGE,0BAAAA,EAAAA,MAAAA;EAAyC,SAAA,wBAAA,EAAA,MAAA;;;;;;;;;;;iBAF1JiB,iCAAAA,QAAyCnB,6CAA6CA;iBACtFoB,iCAAAA;iBACAC,qCAAAA,UAA+CpB,uCAAuCD,2BAA2BE;;;;;;;;;iBAajHwB,0CAA0ChC,2BAA2BC,OAAOC,WAAW+B,SAASF,QAAQzB"}
+{"version":3,"file":"vault-transaction-fees.d.ts","names":["Chain","Client","Transport","MIN_VAULT_PRIORITY_FEE_PER_GAS","MAX_VAULT_PRIORITY_FEE_PER_GAS","MAX_VAULT_TRANSACTION_GAS_COST","VaultTransactionFeeQuote","VaultDeltaHedgeFeeQuote","VaultSignedTransactionFeeCaps","VaultSignedTransactionFeeValidationResult","VaultTransactionFeeEstimationError","feeHistoryError","fallbackError","Error","VaultTransactionGasCostLimitError","gasLimit","maximumAffordableFeePerGas","minimumRequiredFeePerGas","VaultTransactionReplacementLimitError","code","requiredMaxFeePerGas","requiredMaxPriorityFeePerGas","FeeHistorySnapshot","FallbackFeeEstimate","clampPriorityFee","resolveFeeHistoryQuote","baseFeePerGas","reward","resolveDeltaHedgeFeeHistoryQuote","resolveRpcPriorityFeeQuote","rawPriorityFeePerGas","getVaultTransactionReplacementFeeQuote","originalQuote","historicalQuote","Pick","resolveFallbackQuote","estimatedMaxFeePerGas","estimatedPriorityFeePerGas","applyVaultTransactionGasCostLimit","bufferVaultTransactionGasEstimate","validateVaultSignedTransactionFeeCaps","resolveVaultTransactionFeeQuote","readFeeHistory","readFallbackEstimate","Promise","getVaultTransactionFeeQuote","chain","getVaultDeltaHedgeHistoricalFeeQuote","resolveVaultDeltaHedgeInitialFeeQuote","readRpcQuote","readHistoricalQuote","getVaultDeltaHedgeInitialFeeQuote","__transactionFeeTestUtils"],"sources":["../src/hypoVault/transactionFees.d.ts"],"sourcesContent":null,"mappings":";;;cACqBG,8BAAAA;cACAC,8BAAAA;AADAD,cAEAE,8BAAAA,GAF8B,kBAAA;AAC9BD,KAETE,wBAAAA,GAFuC;EAC9BD,YAAAA,EAAAA,MAAAA;EACTC,oBAAAA,EAAAA,MAAwB;EAMxBC,mBAAAA,EAAAA,MAAuB;EAGvBC,MAAAA,EAAAA,aAAAA,GAAAA,eAA6B,GAAA,kBAAA,GAAA,iBAAA;AAKzC,CAAA;AAOqBE,KAfTH,uBAAAA,GAA0BD,wBAeiB,GAAA;EAAA,oBAAA,EAAA,MAAA;CAAA;AAGpBM,KAfvBJ,6BAAAA,GAeuBI;EAAa,QAHgBC,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;EAAK,YAAA,EAAA,MAAA,GAAA,IAAA;EAQhDC,oBAAAA,EAAAA,MAAAA,GAAAA,IAAAA;CAAiC;AAIpCC,KAnBNN,yCAAAA,GAmBMM;EAAQ,KAAEC,EAAAA,IAAAA;CAA0B,GAAA;EAA0B,KAJjBH,EAAAA,KAAAA;EAAK,IAAA,EAAA,oBAAA,GAAA,gBAAA,GAAA,mBAAA,GAAA,oBAAA,GAAA,cAAA,GAAA,gBAAA;EAU/CK,MAAAA,EAAAA,MAAAA;CAAqC;AAKxCC,cAvBGT,kCAAAA,SAA2CG,KAAAA,CAuB9CM;EAAI,SAAEJ,eAAAA,EAAAA,OAAAA;EAAQ,SAAEK,aAAAA,EAAAA,OAAAA;EAAoB,WAAEC,CAAAA;IAAAA,eAAAA;IAAAA;EALgB,CAKhBA,EAAAA;IAA8BL,eAAAA,EAAAA,OAAAA;IALnBH,aAAAA,EAAAA,OAAAA;EAAK,CAAA;AA+BxE;AAA8D,cAzCzCC,iCAAAA,SAA0CD,KAAAA,CAyCD;EAAA,SAAGmB,QAAAA,EAAAA,MAAAA;EAAa,SAAEC,0BAAAA,EAAAA,MAAAA;EAAe,SAAElB,wBAAAA,EAAAA,MAAAA;EAAQ,WACjFT,CAAAA;IAAAA,QAAAA;IAAAA,0BAAAA;IAAAA;EAGG,CAHHA,EAAAA;IAAL4B,QAAAA,EAAAA,MAAAA;IACE3B,0BAAAA,EAAAA,MAAAA;IAEjBA,wBAAAA,EAAAA,MAAAA;EAAuB,CAAA;AAK3B;AAAyD,cAxCpCW,qCAAAA,SAA8CL,KAAAA,CAwCV;EAAA,SAAQP,IAAAA,EAAAA,oBAAAA;EAAwB,SAAqBA,oBAAAA,EAAAA,MAAAA;EAAwB,SAAA,4BAAA,EAAA,MAAA;EAC9GiC,SAAAA,0BAAAA,EAAiC,MAAA;EACjCC,WAAAA,CAAAA;IAAAA,IAAAA;IAAAA,QAAAA;IAAAA,oBAAqC;IAAA,4BAAA;IAAA;GAAA,EAAA;IAAA,IAAA,EAAA,oBAAA;IAAUhC,QAAAA,EAAAA,MAAAA;IAAuCF,oBAAAA,EAAAA,MAAAA;IAA2BG,4BAAAA,EAAAA,MAAAA;IAAyC,0BAAA,EAAA,MAAA;;;AAcrEP,iBAzBrF6B,sCAAAA,CAyBqF7B;EAAAA,aAAAA;EAAAA,eAAAA;EAAAA;CAAAA,EAAAA;EAAS,aAAE4C,EAxBrGZ,IAwBqGY,CAxBhGxC,wBAwBgGwC,EAAAA,cAAAA,GAAAA,sBAAAA,CAAAA;EAAK,eAAvB7C,EAvBjFM,uBAuBiFN;EAAM,QAA6BM,EAAAA,MAAAA;CAAuB,CAAA,EArB5JA,uBAqB6HqC;iBAhBzGN,iCAAAA,QAAyChC,6CAA6CA;iBACtFiC,iCAAAA;AA4BAY,iBA3BAX,qCAAAA,CA2BiC,OAAA,EA3BchC,6BA2Bd,EAAA,KAAA,CAAA,EA3BqDF,wBA2BrD,CAAA,EA3BgFG,yCA2BhF;;;;AAA4E;;;;;iBAd7GoC,0CAA0C7C,2BAA2BC,OAAOC,WAAW4C,SAASF,QAAQtC;iBACxGyC,mDAAmD/C,2BAA2BC,OAAOC,WAAW4C,SAASF,QAAQrC;;;;;;iBAajH4C,gDAAgDnD,2BAA2BC,OAAOC,WAAW4C,SAASF,QAAQrC"}

package/dist/vault-transaction-fees.js

@@ -1,4 +1,5 @@
-import { estimateFeesPerGas, getFeeHistory } from "viem/actions";
+import { hexToBigInt } from "viem";
+import { estimateFeesPerGas, getBlock, getFeeHistory } from "viem/actions";
 
 //#region src/hypoVault/transactionFees.ts
 const MIN_VAULT_PRIORITY_FEE_PER_GAS = 100000000n;
@@ -6,8 +7,11 @@ const MAX_VAULT_PRIORITY_FEE_PER_GAS = 3000000000n;
 const MAX_VAULT_TRANSACTION_GAS_COST = 15000000000000000n;
 const FEE_HISTORY_BLOCK_COUNT = 20;
 const FEE_HISTORY_REWARD_PERCENTILES = [90];
+const DELTA_HEDGE_FEE_HISTORY_REWARD_PERCENTILES = [25];
 const BASE_FEE_BUFFER_NUMERATOR = 1125n;
 const BASE_FEE_BUFFER_DENOMINATOR = 1000n;
+const REPLACEMENT_FEE_BUMP_NUMERATOR = 1125n;
+const REPLACEMENT_FEE_BUMP_DENOMINATOR = 1000n;
 const GAS_ESTIMATE_BUFFER_NUMERATOR = 3n;
 const GAS_ESTIMATE_BUFFER_DENOMINATOR = 2n;
 var VaultTransactionFeeEstimationError = class extends Error {
@@ -32,6 +36,20 @@ var VaultTransactionGasCostLimitError = class extends Error {
 		this.minimumRequiredFeePerGas = minimumRequiredFeePerGas;
 	}
 };
+var VaultTransactionReplacementLimitError = class extends Error {
+	code;
+	requiredMaxFeePerGas;
+	requiredMaxPriorityFeePerGas;
+	maximumAffordableFeePerGas;
+	constructor({ code, gasLimit, requiredMaxFeePerGas, requiredMaxPriorityFeePerGas, maximumAffordableFeePerGas }) {
+		super(`Vault transaction replacement blocked by ${code}: gasLimit=${gasLimit.toString()}, requiredMaxFeePerGas=${requiredMaxFeePerGas.toString()}, requiredMaxPriorityFeePerGas=${requiredMaxPriorityFeePerGas.toString()}, maximumAffordableFeePerGas=${maximumAffordableFeePerGas.toString()}`);
+		this.name = "VaultTransactionReplacementLimitError";
+		this.code = code;
+		this.requiredMaxFeePerGas = requiredMaxFeePerGas;
+		this.requiredMaxPriorityFeePerGas = requiredMaxPriorityFeePerGas;
+		this.maximumAffordableFeePerGas = maximumAffordableFeePerGas;
+	}
+};
 function ceilMultiplyFraction(value, numerator, denominator) {
 	return (value * numerator + denominator - 1n) / denominator;
 }
@@ -68,6 +86,57 @@ function resolveFeeHistoryQuote({ baseFeePerGas, reward }) {
 		source: "fee_history"
 	};
 }
+function resolveDeltaHedgeFeeHistoryQuote({ baseFeePerGas, reward }) {
+	const latestBaseFeeIndex = baseFeePerGas.length - 2;
+	if (latestBaseFeeIndex < 0 || reward === void 0 || reward.length === 0) return null;
+	const p25Rewards = reward.flatMap((blockRewards) => {
+		const p25 = blockRewards[0];
+		return p25 === void 0 ? [] : [p25];
+	});
+	const rawPriorityFeePerGas = medianBigInt(p25Rewards);
+	if (rawPriorityFeePerGas === void 0) return null;
+	const maxPriorityFeePerGas = clampPriorityFee(rawPriorityFeePerGas);
+	const bufferedBaseFee = ceilMultiplyFraction(baseFeePerGas[latestBaseFeeIndex], BASE_FEE_BUFFER_NUMERATOR, BASE_FEE_BUFFER_DENOMINATOR);
+	return {
+		maxFeePerGas: bufferedBaseFee + maxPriorityFeePerGas,
+		maxPriorityFeePerGas,
+		minimumMaxFeePerGas: bufferedBaseFee + MIN_VAULT_PRIORITY_FEE_PER_GAS,
+		rawPriorityFeePerGas,
+		source: "fee_history_p25"
+	};
+}
+function resolveRpcPriorityFeeQuote({ baseFeePerGas, rawPriorityFeePerGas }) {
+	const bufferedBaseFee = ceilMultiplyFraction(baseFeePerGas, BASE_FEE_BUFFER_NUMERATOR, BASE_FEE_BUFFER_DENOMINATOR);
+	return {
+		maxFeePerGas: bufferedBaseFee + rawPriorityFeePerGas,
+		maxPriorityFeePerGas: rawPriorityFeePerGas,
+		minimumMaxFeePerGas: bufferedBaseFee + rawPriorityFeePerGas,
+		rawPriorityFeePerGas,
+		source: "rpc_priority_fee"
+	};
+}
+function getVaultTransactionReplacementFeeQuote({ originalQuote, historicalQuote, gasLimit }) {
+	if (gasLimit <= 0n) throw new Error(`Vault transaction gas limit must be positive, received ${gasLimit.toString()}`);
+	const bumpedPriorityFee = ceilMultiplyFraction(originalQuote.maxPriorityFeePerGas, REPLACEMENT_FEE_BUMP_NUMERATOR, REPLACEMENT_FEE_BUMP_DENOMINATOR);
+	const bumpedMaxFee = ceilMultiplyFraction(originalQuote.maxFeePerGas, REPLACEMENT_FEE_BUMP_NUMERATOR, REPLACEMENT_FEE_BUMP_DENOMINATOR);
+	const requiredMaxPriorityFeePerGas = historicalQuote.maxPriorityFeePerGas > bumpedPriorityFee ? historicalQuote.maxPriorityFeePerGas : bumpedPriorityFee;
+	const bufferedBaseFee = historicalQuote.minimumMaxFeePerGas - MIN_VAULT_PRIORITY_FEE_PER_GAS;
+	const currentMarketMaxFee = bufferedBaseFee + requiredMaxPriorityFeePerGas;
+	const requiredMaxFeePerGas = currentMarketMaxFee > bumpedMaxFee ? currentMarketMaxFee : bumpedMaxFee;
+	const maximumAffordableFeePerGas = MAX_VAULT_TRANSACTION_GAS_COST / gasLimit;
+	if (requiredMaxFeePerGas > maximumAffordableFeePerGas) throw new VaultTransactionReplacementLimitError({
+		code: "GasCostCapExceeded",
+		gasLimit,
+		requiredMaxFeePerGas,
+		requiredMaxPriorityFeePerGas,
+		maximumAffordableFeePerGas
+	});
+	return {
+		...historicalQuote,
+		maxFeePerGas: requiredMaxFeePerGas,
+		maxPriorityFeePerGas: requiredMaxPriorityFeePerGas
+	};
+}
 function resolveFallbackQuote({ maxFeePerGas: estimatedMaxFeePerGas, maxPriorityFeePerGas: estimatedPriorityFeePerGas }) {
 	const maxPriorityFeePerGas = clampPriorityFee(estimatedPriorityFeePerGas);
 	const estimatedBaseFeeAllowance = estimatedMaxFeePerGas > estimatedPriorityFeePerGas ? estimatedMaxFeePerGas - estimatedPriorityFeePerGas : 0n;
@@ -169,7 +238,42 @@ async function getVaultTransactionFeeQuote(client) {
 		readFallbackEstimate: () => estimateFeesPerGas(client)
 	});
 }
+async function getVaultDeltaHedgeHistoricalFeeQuote(client) {
+	const feeHistory = await getFeeHistory(client, {
+		blockCount: FEE_HISTORY_BLOCK_COUNT,
+		blockTag: "latest",
+		rewardPercentiles: DELTA_HEDGE_FEE_HISTORY_REWARD_PERCENTILES
+	});
+	const quote = resolveDeltaHedgeFeeHistoryQuote(feeHistory);
+	if (quote === null) throw new Error("eth_feeHistory returned incomplete p25 base fee or reward data");
+	return quote;
+}
+async function resolveVaultDeltaHedgeInitialFeeQuote({ readRpcQuote, readHistoricalQuote }) {
+	try {
+		return resolveRpcPriorityFeeQuote(await readRpcQuote());
+	} catch {
+		return readHistoricalQuote();
+	}
+}
+/**
+* Resolve the first fee quote for a delta hedge from the connected RPC's
+* eth_maxPriorityFeePerGas recommendation. A failed RPC recommendation falls
+* back immediately to the rolling historical p25 quote.
+*/
+async function getVaultDeltaHedgeInitialFeeQuote(client) {
+	return resolveVaultDeltaHedgeInitialFeeQuote({
+		readRpcQuote: async () => {
+			const [rawPriorityFee, latestBlock] = await Promise.all([client.request({ method: "eth_maxPriorityFeePerGas" }), getBlock(client, { blockTag: "latest" })]);
+			if (latestBlock.baseFeePerGas === null) throw new Error("Latest block does not include an EIP-1559 base fee");
+			return {
+				baseFeePerGas: latestBlock.baseFeePerGas,
+				rawPriorityFeePerGas: hexToBigInt(rawPriorityFee)
+			};
+		},
+		readHistoricalQuote: () => getVaultDeltaHedgeHistoricalFeeQuote(client)
+	});
+}
 
 //#endregion
-export { MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultTransactionFeeQuote, validateVaultSignedTransactionFeeCaps };
+export { MAX_VAULT_PRIORITY_FEE_PER_GAS, MAX_VAULT_TRANSACTION_GAS_COST, MIN_VAULT_PRIORITY_FEE_PER_GAS, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, validateVaultSignedTransactionFeeCaps };
 //# sourceMappingURL=vault-transaction-fees.js.map