@panoptic-eng/sdk 1.0.75 → 1.0.76

package/dist/{router-lUA1kp8A.js → router-DL_cDCzG.js}

@@ -1,5 +1,5 @@
 import { StateViewAbi } from "./StateView-q4yMpBY6.js";
-import { PanopticError, decodeAllLegs, decodeTokenId, getBlockMeta, getPool, getPoolMetadata, stateViewAbi, submitWrite, uniswapV3PoolAbi } from "./rates-c9XVKm3m.js";
+import { PanopticError, decodeAllLegs, decodeTokenId, getBlockMeta, getPool, getPoolMetadata, stateViewAbi, submitWrite, uniswapV3PoolAbi } from "./tokenFlow-6Ec9Hz48.js";
 import { getLegLiquidityRange, tickToSqrtPriceX96 } from "./greeks-CEv-Uex1.js";
 import { BaseError, ContractFunctionRevertedError, ExecutionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, isAddressEqual, maxUint256, toHex, zeroAddress } from "viem";
 import Decimal from "decimal.js";

package/dist/{rates-c9XVKm3m.js → tokenFlow-6Ec9Hz48.js}

@@ -1,5 +1,5 @@
 import { ORACLE_EPOCH_SECONDS, SCHEMA_VERSION, STORAGE_PREFIX, calculatePositionGreeks, tickToSqrtPriceX96 } from "./greeks-CEv-Uex1.js";
-import { BaseError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, encodeFunctionData, getAddress, keccak256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
+import { BaseError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, decodeFunctionResult, encodeFunctionData, getAddress, keccak256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
 
 //#region src/generated.ts
 const collateralTrackerV2Abi = [
@@ -12694,4 +12694,288 @@ function formatPerSecondRateWadAsAprPct(ratePerSecondWad, precision) {
 }
 
 //#endregion
-export { AccountInsolventError, AlreadyInitializedError, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTickLimitsError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MaxRetriesExceededError, MissingPositionIdsError, MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NoLoanPositionsError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, ReentrancyError, RpcError, RpcResponseError, STANDARD_TICK_WIDTHS, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, WrongPoolIdError, WrongUniswapPoolError, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, availableToBorrow, clearTrackedPositions, collateralTrackerV2Abi, countLegs, createFileStorage, createMemoryStorage, createTxResult, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePoolId, decodePositionBalance$1 as decodePositionBalance, decodeSnapshotTransaction, decodeTickSpacing, decodeTokenId, decodeVegoid, diagnoseOracleSafeMode, encodeLeg, encodePoolId, encodeV4PoolId, fetchPoolId, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getAccountPremia, getAssetIndex, getBlockMeta, getClosedPositionsKey, getForfeitablePremium, getOpenPositionIds, getOracleRiskParameters, getOracleState, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPosition, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getRiskParameters, getSchemaVersionKey, getSimpleLoanTokenIndex, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, getUtilization, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isLoan, isLoanLeg, isPanopticErrorType, isPositionTracked, isShortOnly, isSpread, jsonSerializer, mintableAfterBuffer, oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parsePanopticError, parseTokenAmount, parseWad, recoverSnapshot, recoverSnapshotFromTx, riskEngineAbi, riskEngineMulticall, selectDispatchForAccount, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode, validatePoolId };
+//#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
+		};
+	}
+}
+/**
+* Get pool token addresses for reference.
+*
+* @param params - Parameters
+* @returns Pool token addresses
+*/
+async function getPoolTokensForSimulation(params) {
+	const { client, poolAddress, blockNumber } = params;
+	const poolAbi = [{
+		type: "function",
+		name: "collateralToken0",
+		inputs: [],
+		outputs: [{ type: "address" }],
+		stateMutability: "view"
+	}, {
+		type: "function",
+		name: "collateralToken1",
+		inputs: [],
+		outputs: [{ type: "address" }],
+		stateMutability: "view"
+	}];
+	const collateralAbi = [{
+		type: "function",
+		name: "asset",
+		inputs: [],
+		outputs: [{ type: "address" }],
+		stateMutability: "view"
+	}];
+	const [ct0, ct1] = await client.multicall({
+		contracts: [{
+			address: poolAddress,
+			abi: poolAbi,
+			functionName: "collateralToken0"
+		}, {
+			address: poolAddress,
+			abi: poolAbi,
+			functionName: "collateralToken1"
+		}],
+		blockNumber,
+		allowFailure: false
+	});
+	const [token0, token1] = await client.multicall({
+		contracts: [{
+			address: ct0,
+			abi: collateralAbi,
+			functionName: "asset"
+		}, {
+			address: ct1,
+			abi: collateralAbi,
+			functionName: "asset"
+		}],
+		blockNumber,
+		allowFailure: false
+	});
+	return {
+		token0,
+		token1,
+		collateralTracker0: ct0,
+		collateralTracker1: ct1
+	};
+}
+
+//#endregion
+export { AccountInsolventError, AlreadyInitializedError, BatchValidationError, BelowMinimumRedemptionError, CastingError, ChunkHasZeroLiquidityError, ChunkLimitError, CrossPoolError, DEFAULT_MAX_SPREAD, DEFAULT_MINT_BUFFER, DEFAULT_VEGOID, DepositTooLargeError, DuplicateTokenIdError, EffectiveLiquidityAboveThresholdError, ExceedsMaximumRedemptionError, InputListFailError, InsufficientCreditLiquidityError, InvalidBuilderCodeError, InvalidHistoryRangeError, InvalidTickBoundError, InvalidTickError, InvalidTickLimitsError, InvalidTokenIdParameterError, InvalidUniswapCallbackError, LEG_BITS, LEG_LIMITS, LEG_MASKS, LengthMismatchError, LiquidityTooHighError, LoanSlotExhaustedError, MINT_BUFFER, MINT_BUFFER_DENOMINATOR, MaxRetriesExceededError, MissingPositionIdsError, MulticallNoDataError, MulticallResultFailedError, MulticallResultMissingError, NetLiquidityZeroError, NetworkMismatchError, NoLegsExercisableError, NoLoanPositionsError, NotALongLegError, NotBuilderError, NotEnoughLiquidityInChunkError, NotEnoughTokensError, NotGuardianError, NotMarginCalledError, NotPanopticPoolError, OracleRateLimitedError, PanopticError, PanopticHelperNotDeployedError, PanopticValidationError, PoolNotInitializedError, PositionCountNotZeroError, PositionNotOwnedError, PositionSnapshotNotFoundError, PositionTooLargeError, PriceBoundFailError, PriceImpactTooLargeError, ProviderLagError, ReentrancyError, RpcError, RpcResponseError, STANDARD_TICK_WIDTHS, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, WrongPoolIdError, WrongUniswapPoolError, ZeroAddressError, ZeroCollateralRequirementError, addLegToTokenId, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, availableToBorrow, clearTrackedPositions, collateralTrackerV2Abi, countLegs, createFileStorage, createMemoryStorage, createTxResult, decodeAllDispatchCalldata, decodeAllLegs, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeLeg, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePoolId, decodePositionBalance$1 as decodePositionBalance, decodeSnapshotTransaction, decodeTickSpacing, decodeTokenId, decodeVegoid, diagnoseOracleSafeMode, encodeLeg, encodePoolId, encodeV4PoolId, fetchPoolId, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getAccountPremia, getAssetIndex, getBlockMeta, getClosedPositionsKey, getForfeitablePremium, getOpenPositionIds, getOracleRiskParameters, getOracleState, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPoolTokensForSimulation, getPosition, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getPositionsWithPremia, getRiskParameters, getSchemaVersionKey, getSimpleLoanTokenIndex, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, getUtilization, hasLoanOrCredit, hasLongLeg, isCredit, isCreditLeg, isLoan, isLoanLeg, isPanopticErrorType, isPositionTracked, isShortOnly, isSpread, jsonSerializer, mintableAfterBuffer, oracleEpochAt, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parsePanopticError, parseTokenAmount, parseWad, recoverSnapshot, recoverSnapshotFromTx, riskEngineAbi, riskEngineMulticall, selectDispatchForAccount, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, simulateWithTokenFlow, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode, validatePoolId };

package/dist/{transactionFees-CqaoQFF-.js → transactionFees-DtoFzBvZ.js}

@@ -33,8 +33,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;
@@ -55,6 +55,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;
 }
@@ -129,30 +134,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
 	});
@@ -175,13 +182,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);
@@ -196,8 +205,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,
@@ -214,15 +224,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";
@@ -322,4 +332,4 @@ async function getVaultDeltaHedgeInitialFeeQuote(client) {
 }
 
 //#endregion
-export { 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, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, validateVaultSignedTransactionFeeCaps };
+export { 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, REPLACEMENT_FEE_BUMP_DENOMINATOR, REPLACEMENT_FEE_BUMP_NUMERATOR, VaultTransactionFeeEstimationError, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, validateVaultSignedTransactionFeeCaps };

package/dist/{v2-C0vQkjxc.js → v2-t8LiEkav.js}

@@ -1,8 +1,8 @@
-import { UniswapV3PoolAbi, applyOwedInterest, getAccountBuyingPower, getAccountCollateral, getNetLiquidationValue, panopticQueryAbi$1 as panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-BntFNP1P.js";
-import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, MulticallResultMissingError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, addLegToTokenId, applyMintBufferPerToken, availableToBorrow, collateralTrackerV2Abi, countLegs, decodeAllLegs, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePositionBalance, decodeTokenId, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPoolMetadata, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, isPanopticErrorType, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, riskEngineMulticall, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, uniswapV3PoolAbi } from "./rates-c9XVKm3m.js";
+import { UniswapV3PoolAbi, applyOwedInterest, getAccountBuyingPower, getAccountCollateral, getNetLiquidationValue, panopticQueryAbi$1 as panopticQueryAbi, readBlockAndAggregate, requireReturnData } from "./irm-CGuYhr-C.js";
+import { AccountInsolventError, ChunkLimitError, DEFAULT_VEGOID, InvalidHistoryRangeError, MulticallResultMissingError, NotEnoughTokensError, PanopticError, PanopticValidationError, SafeModeError, StaleDataError, StorageDataNotFoundError, UnhealthyPoolError, WrongUniswapPoolError, addLegToTokenId, applyMintBufferPerToken, availableToBorrow, collateralTrackerV2Abi, countLegs, decodeAllLegs, decodeLeftRightSigned, decodeLeftRightUnsigned, decodePositionBalance, decodeTokenId, getBlockMeta, getClosedPositionsKey, getPendingPositionsKey, getPool, getPoolMetaKey, getPoolMetadata, getPoolTokensForSimulation, getPositionMetaKey, getPositionsKey, getTrackedChunksKey, getTrackedPositionIds, isPanopticErrorType, jsonSerializer, mintableAfterBuffer, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi as panopticQueryAbi$1, parsePanopticError, riskEngineAbi, riskEngineMulticall, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, simulateWithTokenFlow, stateViewAbi, uniswapV3PoolAbi } from "./tokenFlow-6Ec9Hz48.js";
 import { MAX_TICK, MAX_TRACKED_CHUNKS, MIN_TICK, NO_LOWER_LIQUIDATION_TICK, NO_UPPER_LIQUIDATION_TICK, WAD, calculatePositionDelta, calculatePositionDeltaDebtOnly, calculatePositionGamma, calculatePositionValue, getLegLiquidityRange, priceToTick, sqrtPriceX96ToTick, tickLimits, tickToPriceDecimalScaled, tickToSqrtPriceX96, toVaultFrameAtTick } from "./greeks-CEv-Uex1.js";
-import { buildBatchDispatchArgs, buildProtectedSettlePlan, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, createTokenIdBuilder, ensureUniqueTokenId, getCurrentPositionSizes, getPoolTokensForSimulation, loadCheckpoint, resolveTokenIndex, simulateDispatch, simulateOpenPosition, simulateWithTokenFlow } from "./writes-CDTpO4OY.js";
-import { feesFromFeeGrowthDelta, getLpPositionFunding, getMaxLpPositionSize, getPriceHistory, preparePositionGamma, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router } from "./router-lUA1kp8A.js";
+import { buildBatchDispatchArgs, buildProtectedSettlePlan, buildSettleSequenceCalls, buildUniqueCredit, buildUniqueLoan, createTokenIdBuilder, ensureUniqueTokenId, getCurrentPositionSizes, loadCheckpoint, resolveTokenIndex, simulateDispatch, simulateOpenPosition } from "./writes-DKpVWZkE.js";
+import { feesFromFeeGrowthDelta, getLpPositionFunding, getMaxLpPositionSize, getPriceHistory, preparePositionGamma, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router } from "./router-DL_cDCzG.js";
 import { ContractFunctionExecutionError, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, getAddress, hexToString, isAddress, isAddressEqual, isHex, keccak256, parseEventLogs, trim, zeroAddress } from "viem";
 import Decimal from "decimal.js";
 import { multicall } from "viem/actions";
@@ -5546,6 +5546,72 @@ async function getHedgeLimits({ client, poolAddress, account, positionIds, asset
 	};
 }
 
+//#endregion
+//#region src/panoptic/v2/reads/legCapacity.ts
+async function getAccountLegCapacity({ client, poolAddress, account, positionIds, blockNumber }) {
+	if (new Set(positionIds).size !== positionIds.length) throw new Error("Leg capacity requires distinct open positions");
+	const metadata = await getPoolMetadata({
+		client,
+		poolAddress
+	});
+	const [maximumLegs, currentLegs, full] = await riskEngineMulticall(client, {
+		contracts: [
+			{
+				address: metadata.riskEngineAddress,
+				abi: riskEngineAbi,
+				functionName: "MAX_OPEN_LEGS"
+			},
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "numberOfLegs",
+				args: [account]
+			},
+			{
+				address: poolAddress,
+				abi: panopticPoolV2Abi,
+				functionName: "getFullPositionsData",
+				args: [
+					account,
+					false,
+					positionIds
+				]
+			}
+		],
+		allowFailure: false,
+		blockNumber
+	});
+	const decodedLegs = positionIds.reduce((sum$1, id) => sum$1 + BigInt(decodeTokenId(id).legs.length), 0n);
+	if (decodedLegs !== currentLegs || full[2].length !== positionIds.length || full[2].some((balance) => (balance & (1n << 128n) - 1n) === 0n)) throw new Error("Account leg snapshot does not match the complete open position list");
+	return {
+		maximumLegs: BigInt(maximumLegs),
+		currentLegs: BigInt(currentLegs),
+		positionIds,
+		blockNumber
+	};
+}
+/** Validate peak active legs in dispatch order, including existing-position resizes. */
+function fitsAccountLegCapacity({ capacity, tokenIds, positionSizes }) {
+	if (tokenIds.length !== positionSizes.length) return false;
+	const active = new Set(capacity.positionIds);
+	let count = capacity.currentLegs;
+	if (count > capacity.maximumLegs) return false;
+	for (let i = 0; i < tokenIds.length; i += 1) {
+		const id = tokenIds[i];
+		const size = positionSizes[i];
+		if (id === void 0 || size === void 0 || size < 0n) return false;
+		const legs = BigInt(decodeTokenId(id).legs.length);
+		if (legs === 0n) return false;
+		if (size === 0n && active.delete(id)) count -= legs;
+		if (size > 0n && !active.has(id)) {
+			active.add(id);
+			count += legs;
+		}
+		if (count > capacity.maximumLegs) return false;
+	}
+	return true;
+}
+
 //#endregion
 //#region src/panoptic/v2/reads/positionMintFunding.ts
 const Q96 = 1n << 96n;
@@ -10526,4 +10592,4 @@ async function getPositionVolatilityHistory({ client, poolAddress, account, toke
 }
 
 //#endregion
-export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, MARKET_INDICATOR_PERIODS, REQUIRED_BASE_ERROR_SENTINEL, STRIKE_LADDER_TARGET_STRIKES, VARIANCE_RATIO_LAG, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateMarketIndicator, calculateSpreadWad, calculateVarianceProfile, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralCurveTicks, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, emptyLiquidateParams, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCloseZapSwap, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feeGrowthInsideX128, fetchPoolSwaps, fetchSfpmV3PoolId, fetchUniswapFeeData, getAccountGreeks, getAccountHistory, getChunkLiquidities, getChunkSpreads, getClosePositionTransferEstimate, getClosedPositions, getCollateralCurve, getCollateralCurveInputs, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getHedgeLimits, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionMintFunding, getPositionVolatilityHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, minePoolAddressLocalAsync, multicallRead, netLiquidationValueInQuote, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, parseStreamedKey, parseStreamedSwap, parseSwapLog, prepareIndicatorCandles, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, realizedBeta, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, simulateBatchDispatch, simulateClosePosition, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, streamPoolSwaps, subscribePoolSwaps, watchEvents, watchPoolSwaps };
+export { DEFAULT_MIN_SWAP_RATIO_BPS, DEFAULT_RECONNECT_CONFIG, MARKET_INDICATOR_PERIODS, REQUIRED_BASE_ERROR_SENTINEL, STRIKE_LADDER_TARGET_STRIKES, VARIANCE_RATIO_LAG, addPendingPosition, addTrackedChunks, apportion, assertCanBurn, assertCanForceExercise, assertCanLiquidate, assertCanMint, assertFresh, assertHealthy, assertLpPositionFunded, assertTradeable, buildCreditWrappedDispatch, buildSfpmSwapCalldata, buildSfpmSwapPlan, buildTemporaryLoanRecoveryDispatch, buildTokenShortfallRecoveryDispatch, calculateAccountGreeksPure, calculateMarketIndicator, calculateSpreadWad, calculateVarianceProfile, checkCollateralAcrossTicks, classifyStrategyGroups, classifyStrike, cleanupStalePendingPositions, clearPendingPositions, clearTrackedChunks, clearTradeHistory, collateralCurveTicks, collateralRuleKindFor, computeV4PoolId, confirmPendingPosition, convertToAssets, convertToShares, createEventPoller, createEventSubscription, createFlowNeutralTokenId, decodePanopticTokenURI, emptyLiquidateParams, encodePoolKeyBytes, encodeV3PoolKeyBytes, ensureSfpmV3PoolInitialized, estimateBlockNumbers, estimateCloseZapSwap, estimateCollateralBreakdown, estimateCollateralRequired, failPendingPosition, feeGrowthInsideX128, fetchPoolSwaps, fetchSfpmV3PoolId, fetchUniswapFeeData, fitsAccountLegCapacity, getAccountGreeks, getAccountHistory, getAccountLegCapacity, getChunkLiquidities, getChunkSpreads, getClosePositionTransferEstimate, getClosedPositions, getCollateralCurve, getCollateralCurveInputs, getCollateralRequiredBase, getCollateralSharePrices, getCollateralTotalAssetsBatch, getDeltaHedgeParams, getEnforcedTickLimits, getExecutableLpMaxSize, getFactoryConstructMetadata, getFactoryOwnerOf, getFactoryTokenURI, getGuardianUnlockState, getHedgeLimits, getItmAmounts, getMarginBuffer, getMaxPositionSize, getMaxRedeem, getMaxWithdrawable, getNativeTokenPrice, getNotEnoughTokensError, getOpenPositionPreview, getPanopticPoolAddress, getPanopticPoolFromPoolId, getPendingPositions, getPoolLiquidities, getPortfolioValue, getPositionChunkData, getPositionEnrichmentData, getPositionMintFunding, getPositionVolatilityHistory, getRealizedPnL, getRequiredCreditForITM, getSafeMode, getStreamiaHistory, getSyncStatus, getTrackedChunks, getTradeHistory, getUniswapFeeHistory, getUniswapV3PoolFromId, getUniswapV3PoolInfo, getUniswapV3PoolLiquidities, getUniswapV4PoolBasicState, getUniswapV4PoolInfo, getUniswapV4PoolKeyFromId, getUniswapV4PoolLiquidities, interpolateBlocks, isGasError, isNonceError, isRetryableRpcError, isolateGroupTokenId, ladderStrikeSequence, logReturns, marketPnlInQuote, marketRiskFromValues, marketScenario, minePoolAddress, minePoolAddressLocalAsync, multicallRead, netLiquidationValueInQuote, optimizeTokenIdRiskPartners, parseCollateralLog, parsePoolLog, parseStreamedKey, parseStreamedSwap, parseSwapLog, prepareIndicatorCandles, previewDeposit, previewMint, previewRedeem, previewWithdraw, quoteLiquidation, quoteOneTokenFlow, quoteSfpmSwap, quoteTemporaryLoanRecovery, quoteTokenShortfallRecovery, quoteTokenShortfallSwap, realizedBeta, removeTrackedChunks, resolveBlockNumbers, resolveLadderStrike, resolvePanopticPoolFromPoolId, resolveUniswapV4PoolKey, saveClosedPosition, scaleCollateralRequired, scanChunks, screenAccountExact, simulateBatchDispatch, simulateClosePosition, simulateClosePremiumProtection, simulateDeployNewPool, simulateDeposit, simulateForceExercise, simulateLiquidate, simulateSFPMBurn, simulateSFPMMint, simulateSwapExactIn, simulateSwapExactOut, simulateWithdraw, slippageBpsToTickDistance, streamPoolSwaps, subscribePoolSwaps, watchEvents, watchPoolSwaps };

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

@@ -5,16 +5,21 @@ declare const MIN_VAULT_PRIORITY_FEE_PER_GAS = 100000000n;
 declare const MAX_VAULT_PRIORITY_FEE_PER_GAS = 3000000000n;
 declare const MAX_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS = 8000000000n;
 declare const MAX_VAULT_TRANSACTION_GAS_COST = 15000000000000000n;
+type VaultTransactionFeePolicy = Readonly<{
+  maxTransactionGasCost: bigint;
+  marketPriorityFees: boolean;
+}>;
 type VaultTransactionFeeQuote = {
   currentBaseFeePerGas?: bigint;
   maxFeePerGas: bigint;
   maxPriorityFeePerGas: bigint;
   minimumMaxFeePerGas: bigint;
   minimumPriorityFeePerGas?: bigint;
-  source: 'fee_history' | 'viem_fallback' | 'rpc_priority_fee' | 'fee_history_p25';
+  source: 'fee_history' | 'viem_fallback' | 'rpc_priority_fee' | 'fee_history_p25' | 'adaptive_hedge';
 };
 type VaultDeltaHedgeFeeQuote = VaultTransactionFeeQuote & {
   rawPriorityFeePerGas: bigint;
+  competitivePriorityFeePerGas?: bigint;
 };
 type VaultSignedTransactionFeeCaps = {
   chainId?: number;
@@ -47,11 +52,13 @@ declare class VaultTransactionGasCostLimitError extends Error {
   constructor({
     gasLimit,
     maximumAffordableFeePerGas,
-    minimumRequiredFeePerGas
+    minimumRequiredFeePerGas,
+    maximumGasCost
   }: {
     gasLimit: bigint;
     maximumAffordableFeePerGas: bigint;
     minimumRequiredFeePerGas: bigint;
+    maximumGasCost?: bigint;
   });
 }
 declare class VaultTransactionReplacementLimitError extends Error {
@@ -78,17 +85,19 @@ declare function getVaultTransactionReplacementFeeQuote({
   historicalQuote,
   gasLimit,
   finalReplacement,
-  staleBoundsReplacement
+  staleBoundsReplacement,
+  feePolicy
 }: {
   originalQuote: Pick<VaultTransactionFeeQuote, 'maxFeePerGas' | 'maxPriorityFeePerGas'>;
   historicalQuote: VaultDeltaHedgeFeeQuote;
   gasLimit: bigint;
   finalReplacement?: boolean;
   staleBoundsReplacement?: boolean;
+  feePolicy?: VaultTransactionFeePolicy;
 }): VaultDeltaHedgeFeeQuote;
-declare function applyVaultTransactionGasCostLimit(quote: VaultTransactionFeeQuote, gasLimit: bigint): VaultTransactionFeeQuote;
+declare function applyVaultTransactionGasCostLimit(quote: VaultTransactionFeeQuote, gasLimit: bigint, feePolicy?: VaultTransactionFeePolicy): VaultTransactionFeeQuote;
 declare function bufferVaultTransactionGasEstimate(gasEstimate: bigint): bigint;
-declare function validateVaultSignedTransactionFeeCaps(feeCaps: VaultSignedTransactionFeeCaps, quote?: VaultTransactionFeeQuote): VaultSignedTransactionFeeValidationResult;
+declare function validateVaultSignedTransactionFeeCaps(feeCaps: VaultSignedTransactionFeeCaps, quote?: VaultTransactionFeeQuote, feePolicy?: VaultTransactionFeePolicy): VaultSignedTransactionFeeValidationResult;
 /**
  * Resolve explicit EIP-1559 fees for operator-controlled vault transactions.
  *
@@ -105,5 +114,5 @@ declare function getVaultDeltaHedgeHistoricalFeeQuote<chain extends Chain | unde
  * back immediately to the rolling historical p25 quote.
  */
 declare function getVaultDeltaHedgeInitialFeeQuote<chain extends Chain | undefined>(client: Client<Transport, chain>): Promise<VaultDeltaHedgeFeeQuote>; //#endregion
-export { 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, VaultDeltaHedgeFeeQuote, VaultSignedTransactionFeeCaps, VaultSignedTransactionFeeValidationResult, VaultTransactionFeeEstimationError, VaultTransactionFeeQuote, VaultTransactionGasCostLimitError, VaultTransactionReplacementLimitError, applyVaultTransactionGasCostLimit, bufferVaultTransactionGasEstimate, getVaultDeltaHedgeHistoricalFeeQuote, getVaultDeltaHedgeInitialFeeQuote, getVaultTransactionFeeQuote, getVaultTransactionReplacementFeeQuote, validateVaultSignedTransactionFeeCaps };
+export { 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, VaultDeltaHedgeFeeQuote, VaultSignedTransactionFeeCaps, VaultSignedTransactionFeeValidationResult, VaultTransactionFeeEstimationError, VaultTransactionFeePolicy, 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_STALE_DELTA_HEDGE_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","getChainPriorityFeeFloor","clampPriorityFee","resolveFeeHistoryQuote","baseFeePerGas","reward","minimumPriorityFeePerGas","resolveDeltaHedgeFeeHistoryQuote","resolveRpcPriorityFeeQuote","rawPriorityFeePerGas","getVaultTransactionReplacementFeeQuote","originalQuote","historicalQuote","finalReplacement","staleBoundsReplacement","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":"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"}
+{"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_STALE_DELTA_HEDGE_PRIORITY_FEE_PER_GAS","MAX_VAULT_TRANSACTION_GAS_COST","REPLACEMENT_FEE_BUMP_NUMERATOR","REPLACEMENT_FEE_BUMP_DENOMINATOR","VaultTransactionFeePolicy","Readonly","VaultTransactionFeeQuote","VaultDeltaHedgeFeeQuote","VaultSignedTransactionFeeCaps","VaultSignedTransactionFeeValidationResult","VaultTransactionFeeEstimationError","feeHistoryError","fallbackError","Error","VaultTransactionGasCostLimitError","gasLimit","maximumAffordableFeePerGas","minimumRequiredFeePerGas","maximumGasCost","VaultTransactionReplacementLimitError","code","requiredMaxFeePerGas","requiredMaxPriorityFeePerGas","FeeHistorySnapshot","FallbackFeeEstimate","getChainPriorityFeeFloor","clampPriorityFee","resolveFeeHistoryQuote","baseFeePerGas","reward","minimumPriorityFeePerGas","resolveDeltaHedgeFeeHistoryQuote","resolveRpcPriorityFeeQuote","rawPriorityFeePerGas","getVaultTransactionReplacementFeeQuote","originalQuote","historicalQuote","finalReplacement","staleBoundsReplacement","feePolicy","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,0CAAAA,GAF8B,WAAA;AAC9BD,cAEAE,8BAAAA,GAF8B,kBAAA;AAKvCG,KAAAA,yBAAAA,GAA4BC,QAAAA,CAAAA;EAI5BC,qBAAAA,EAAAA,MAAwB;EAQxBC,kBAAAA,EAAAA,OAAuB;AAInC,CAAA,CAAA;AAMYE,KAlBAH,wBAAAA,GAkBAG;EAOSC,oBAAAA,CAAAA,EAAAA,MAAAA;EAAkC,YAAA,EAAA,MAAA;EAAA,oBAGrCC,EAAAA,MAAAA;EAAe,mBAAEC,EAAAA,MAAAA;EAAa,wBAHgBC,CAAAA,EAAAA,MAAAA;EAAK,MAAA,EAAA,aAAA,GAAA,eAAA,GAAA,kBAAA,GAAA,iBAAA,GAAA,gBAAA;AAQrE,CAAA;AAAsD,KAzB1CN,uBAAAA,GAA0BD,wBAyBgB,GAAA;EAAA,oBAIpCS,EAAAA,MAAAA;EAAQ,4BAAEC,CAAAA,EAAAA,MAAAA;CAA0B;AAA4BE,KAzBtEV,6BAAAA,GAyBsEU;EAAc,OAJjCL,CAAAA,EAAAA,MAAAA;EAAK,QAAA,CAAA,EAAA,MAAA,GAAA,IAAA;EAW/CM,YAAAA,EAAAA,MAAAA,GAAAA,IAAAA;EAAqC,oBAAA,EAAA,MAAA,GAAA,IAAA;CAAA;AAKlCJ,KA/BZN,yCAAAA,GA+BYM;EAAQ,KAAEM,EAAAA,IAAAA;CAAoB,GAAA;EAA8B,KAAEL,EAAAA,KAAAA;EAA0B,IAL7CH,EAAAA,oBAAAA,GAAAA,gBAAAA,GAAAA,mBAAAA,GAAAA,oBAAAA,GAAAA,cAAAA,GAAAA,gBAAAA;EAAK,MAAA,EAAA,MAAA;AAmCxE,CAAA;AAA8D,cAtDzCH,kCAAAA,SAA2CG,KAAAA,CAsDF;EAAA,SAAGsB,eAAAA,EAAAA,OAAAA;EAAa,SAAEC,aAAAA,EAAAA,OAAAA;EAAe,WAAErB,CAAAA;IAAAA,eAAAA;IAAAA;EAAkD,CAAlDA,EAAAA;IAAUsB,eAAAA,EAAAA,OAAAA;IAAkBC,aAAAA,EAAAA,OAAAA;EAAsB,CAAA;;AAChIE,cA/CE1B,iCAAAA,SAA0CD,KAAAA,CA+C5C2B;EAAI,SACFjC,QAAAA,EAAAA,MAAAA;EAAuB,SAI5BH,0BAAAA,EAAAA,MAAAA;EAAyB,SACrCG,wBAAAA,EAAAA,MAAAA;EAAuB,WAAA,CAAA;IAAA,QAAA;IAAA,0BAAA;IAAA,wBAAA;IAAA;EAMuH,CANvH,EAAA;IAMHqC,QAAAA,EAAAA,MAAAA;IAAiC,0BAAA,EAAA,MAAA;IAAQtC,wBAAAA,EAAAA,MAAAA;IAAwDF,cAAAA,CAAAA,EAAAA,MAAAA;EAAyB,CAAA;AAA2B;AACrJyC,cAjDH1B,qCAAAA,SAA8CN,KAAAA,CAiDV;EACjCiC,SAAAA,IAAAA,EAAAA,oBAAAA,GAAAA,wBAAqC;EAAA,SAAA,oBAAA,EAAA,MAAA;EAAA,SAAUtC,4BAAAA,EAAAA,MAAAA;EAA6B,SAAUF,0BAAAA,EAAAA,MAAAA;EAAwB,WAAcF,CAAAA;IAAAA,IAAAA;IAAAA,QAAAA;IAAAA,oBAAAA;IAAAA,4BAAAA;IAAAA;GAAAA,EAAAA;IAA4BK,IAAAA,EAAAA,oBAAAA,GAAAA,wBAAAA;IAAyC,QAAA,EAAA,MAAA;;;;;;iBAfjMyB,sCAAAA;;;;;;;;iBACLM,KAAKlC;mBACHC;;EA0CGkD,gBAAAA,CAAAA,EAAAA,OAAAA;EAAiC,sBAAA,CAAA,EAAA,OAAA;EAAA,SAAe9D,CAAAA,EAtCxDS,yBAsCwDT;CAAK,CAAA,EArCzEY,uBAqCsGV;iBA/BlF+C,iCAAAA,QAAyCtC,wDAAwDF,4BAA4BE;iBAC7HuC,iCAAAA;iBACAC,qCAAAA,UAA+CtC,uCAAuCF,sCAAsCF,4BAA4BK;;;;;;;;;iBAcxJ0C,0CAA0CxD,2BAA2BC,OAAOC,WAAWuD,SAASF,QAAQ5C;iBACxG+C,mDAAmD1D,2BAA2BC,OAAOC,WAAWuD,SAASF,QAAQ3C;;;;;;iBAcjHkD,gDAAgD9D,2BAA2BC,OAAOC,WAAWuD,SAASF,QAAQ3C"}