@panoptic-eng/sdk 1.0.61 → 1.0.63

package/dist/providers-1WdiaRbY.js

@@ -0,0 +1,54 @@
+//#region src/rpc/providers.ts
+const alchemyChains = {
+	1: "eth-mainnet",
+	137: "polygon-mainnet",
+	42161: "arb-mainnet",
+	8453: "base-mainnet",
+	10: "opt-mainnet",
+	130: "unichain-mainnet",
+	4663: "robinhood-mainnet",
+	11155111: "eth-sepolia"
+};
+function isAlchemyChainId(chainId) {
+	return chainId in alchemyChains;
+}
+const infuraChains = {
+	1: "mainnet",
+	10: "optimism-mainnet",
+	137: "polygon-mainnet",
+	8453: "base-mainnet",
+	42161: "arbitrum-mainnet",
+	43114: "avalanche-mainnet",
+	11155111: "sepolia"
+};
+const RPC_PROVIDER_PRESETS = {
+	alchemy: {
+		apiKeyEnv: () => ["ALCHEMY_API_KEY"],
+		endpoint: (chainId, apiKey) => isAlchemyChainId(chainId) ? { url: `https://${alchemyChains[chainId]}.g.alchemy.com/v2/${apiKey}` } : void 0
+	},
+	infura: {
+		apiKeyEnv: () => ["INFURA_API_KEY"],
+		endpoint: (chainId, apiKey) => infuraChains[chainId] ? { url: `https://${infuraChains[chainId]}.infura.io/v3/${apiKey}` } : void 0
+	},
+	uniblock: {
+		apiKeyEnv: () => ["UNIBLOCK_API_KEY"],
+		endpoint: (chainId, apiKey) => ({
+			url: `https://api.uniblock.dev/uni/v1/json-rpc?chainId=${chainId}`,
+			headers: { "x-api-key": apiKey }
+		})
+	}
+};
+function isRpcProviderName(name) {
+	return Object.prototype.hasOwnProperty.call(RPC_PROVIDER_PRESETS, name);
+}
+function getAlchemyRpcUrl(chainId, alchemyApiKey) {
+	if (alchemyChains[chainId]) return `https://${alchemyChains[chainId]}.g.alchemy.com/v2/${alchemyApiKey}`;
+	else throw new Error(`Unsupported chainId: ${chainId}`);
+}
+function getAlchemyWsRpcUrl(chainId, alchemyApiKey) {
+	if (alchemyChains[chainId]) return `wss://${alchemyChains[chainId]}.g.alchemy.com/v2/${alchemyApiKey}`;
+	else throw new Error(`Unsupported chainId: ${chainId}`);
+}
+
+//#endregion
+export { RPC_PROVIDER_PRESETS, getAlchemyRpcUrl, getAlchemyWsRpcUrl, isRpcProviderName };

package/dist/{rates-CPHxWqpT.js → rates-BwZnK0tG.js}

@@ -11964,4 +11964,4 @@ 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, STRIKE_CONVERSION_FACTOR, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, WrongPoolIdError, WrongUniswapPoolError, ZeroAddressError, ZeroCollateralRequirementError, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, availableToBorrow, clearTrackedPositions, collateralTrackerV2Abi, createFileStorage, createMemoryStorage, createTxResult, decodeAllDispatchCalldata, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePosition, decodePositionBalance$1 as decodePositionBalance, decodeTickSpacing, diagnoseOracleSafeMode, fetchPoolId, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getBlockMeta, getClosedPositionsKey, getOpenPositionIds, getOracleRiskParameters, getOracleState, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPosition, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getRiskParameters, getSchemaVersionKey, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, getUtilization, isPanopticErrorType, isPositionTracked, jsonSerializer, mintableAfterBuffer, oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parsePanopticError, parseTokenAmount, parseWad, recoverSnapshot, recoverSnapshotFromTx, riskEngineAbi, selectDispatchForAccount, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode };
+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, STRIKE_CONVERSION_FACTOR, SafeModeError, StaleDataError, StaleOracleError, StorageDataNotFoundError, SwapTokenMismatchError, SyncTimeoutError, TOKEN_ID_BITS, TokenIdHasZeroLegsError, TooManyLegsOpenError, TransferFailedError, UnauthorizedUniswapCallbackError, UnderOverFlowError, UnhealthyPoolError, UnsafePremiumSettlementError, WrongPoolIdError, WrongUniswapPoolError, ZeroAddressError, ZeroCollateralRequirementError, annualizePerSecondRateWad, applyMintBuffer, applyMintBufferPerToken, availableToBorrow, clearTrackedPositions, collateralTrackerV2Abi, createFileStorage, createMemoryStorage, createTxResult, decodeAllDispatchCalldata, decodeDispatchCalldata, decodeLeftRightSigned, decodeLeftRightUnsigned, decodeOraclePack, decodeOracleRiskParameters, decodeOracleTiming, decodePosition, decodePositionBalance$1 as decodePositionBalance, decodeTickSpacing as decodeTickSpacing$1, diagnoseOracleSafeMode, fetchPoolId, formatPerSecondRateWadAsAprPct, formatPerSecondRateWadAsApyPct, formatRateWad, formatTokenAmount, formatTokenAmountSigned, formatTokenDelta, formatTokenFlow, formatWad, formatWadPercent, formatWadSigned, getBlockMeta, getClosedPositionsKey, getOpenPositionIds, getOracleRiskParameters, getOracleState, getPendingPositionsKey, getPool, getPoolCurrentTick, getPoolMetaKey, getPoolMetadata, getPoolPrefix, getPosition, getPositionGreeks, getPositionMetaKey, getPositions, getPositionsKey, getRiskParameters, getSchemaVersionKey, getSyncCheckpointKey, getTrackedChunksKey, getTrackedPositionIds, getUtilization, isPanopticErrorType, isPositionTracked, jsonSerializer, mintableAfterBuffer, oracleEpochAt, panopticErrorsAbi, panopticFactoryV3Abi, panopticFactoryV4Abi, panopticGuardianAbi, panopticLiquidatorAbi, panopticPoolV2Abi, panopticQueryAbi, parsePanopticError, parseTokenAmount, parseWad, recoverSnapshot, recoverSnapshotFromTx, riskEngineAbi, selectDispatchForAccount, semiFungiblePositionManagerV3Abi, semiFungiblePositionManagerV4Abi, stateViewAbi, submitWrite, uniswapV3PoolAbi, validateBuilderCode };

package/dist/{router-BZGHjEcU.js → router-Dejb6MWu.js}

@@ -1,10 +1,11 @@
-import { PanopticError, getBlockMeta, getPoolMetadata, submitWrite } from "./rates-CPHxWqpT.js";
+import { PanopticError, getBlockMeta, getPoolMetadata, submitWrite } from "./rates-BwZnK0tG.js";
 import { tickToSqrtPriceX96 } from "./greeks-CNi1-cnp.js";
-import { decodeAllLegs } from "./writes-gs0k0uoN.js";
+import { decodeAllLegs, decodeTokenId } from "./writes--fM_8ggw.js";
 import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, isAddressEqual, zeroAddress } from "viem";
+import Decimal from "decimal.js";
 
 //#region src/uniswap/lpDeposit.ts
-const Q96 = 1n << 96n;
+const Q96$1 = 1n << 96n;
 const ceilDiv = (n, d) => (n + d - 1n) / d;
 /** Uniswap mint principal in raw token units, rounded up per leg, plus 5% headroom. */
 function getLpDepositAmounts(ranges, sqrtPriceX96) {
@@ -20,8 +21,8 @@ function getLpDepositBreakdown(ranges, sqrtPriceX96) {
 		const lower = tickToSqrtPriceX96(BigInt(tickLower));
 		const upper = tickToSqrtPriceX96(BigInt(tickUpper));
 		const price = sqrtPriceX96 < lower ? lower : sqrtPriceX96 > upper ? upper : sqrtPriceX96;
-		amount0 += ceilDiv(liquidity * Q96 * (upper - price), upper * price);
-		amount1 += ceilDiv(liquidity * (price - lower), Q96);
+		amount0 += ceilDiv(liquidity * Q96$1 * (upper - price), upper * price);
+		amount1 += ceilDiv(liquidity * (price - lower), Q96$1);
 	}
 	const buffer = {
 		amount0: ceilDiv(amount0 * 5n, 100n),
@@ -49,7 +50,7 @@ function getUnhedgedLpRanges({ tokenId, positionSize, tickSpacing }) {
 		const lower = tickToSqrtPriceX96(tickLower);
 		const upper = tickToSqrtPriceX96(tickUpper);
 		const amount = positionSize * leg.optionRatio;
-		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96) / (upper - lower) : amount * Q96 / (upper - lower);
+		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96$1) / (upper - lower) : amount * Q96$1 / (upper - lower);
 		return liquidity <= 0n ? [] : [{
 			tickLower: Number(tickLower),
 			tickUpper: Number(tickUpper),
@@ -70,7 +71,7 @@ function getLpPositionFunding(params) {
 	});
 	const breakdown = getLpDepositBreakdown(ranges, sqrtPriceX96);
 	const priceSquared = valuationSqrtPriceX96 * valuationSqrtPriceX96;
-	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv(amount1 * Q96 * Q96, priceSquared) : amount1 + ceilDiv(amount0 * priceSquared, Q96 * Q96);
+	const value = ({ amount0, amount1 }) => quoteTokenIndex === 0 ? amount0 + ceilDiv(amount1 * Q96$1 * Q96$1, priceSquared) : amount1 + ceilDiv(amount0 * priceSquared, Q96$1 * Q96$1);
 	const principalInQuote = value(breakdown.principal);
 	const totalInQuote = value(breakdown.total);
 	return {
@@ -100,8 +101,8 @@ function getLpFundingDeposit({ funding, availableInQuote, minimumInQuote = 0n, q
 		requiredInQuote,
 		shortfallInQuote,
 		defaultQuotePercent,
-		amount0: quoteTokenIndex === 0 ? quoteAmount : ceilDiv(assetValue * Q96 * Q96, priceSquared),
-		amount1: quoteTokenIndex === 1 ? quoteAmount : ceilDiv(assetValue * priceSquared, Q96 * Q96)
+		amount0: quoteTokenIndex === 0 ? quoteAmount : ceilDiv(assetValue * Q96$1 * Q96$1, priceSquared),
+		amount1: quoteTokenIndex === 1 ? quoteAmount : ceilDiv(assetValue * priceSquared, Q96$1 * Q96$1)
 	};
 }
 /** Largest raw size funded by available collateral, including native-token rounding. */
@@ -123,6 +124,132 @@ function getMaxLpPositionSize(params) {
 	return low;
 }
 
+//#endregion
+//#region src/panoptic/v2/greeks/positionVolatility.ts
+const Precision = Decimal.clone({ precision: 80 });
+const Q96 = 1n << 96n;
+const YEAR_SECONDS = new Precision(31536e3);
+/** The premium-free position curve, expressed in one quote token's human units. */
+function preparePositionGamma({ tokenId, positionSize, quoteIsToken0, quoteDecimals }) {
+	if (positionSize <= 0n || positionSize >= 1n << 128n) throw new RangeError("Invalid position size");
+	if (!Number.isInteger(quoteDecimals) || quoteDecimals < 0 || quoteDecimals > 255) throw new RangeError("Invalid quote decimals");
+	const decoded = decodeTokenId(tokenId);
+	const chunks = decoded.legs.flatMap((leg) => {
+		if (leg.width === 0n) return [];
+		const width = leg.width * decoded.tickSpacing;
+		const lowerTick = leg.strike - width / 2n;
+		const upperTick = leg.strike + (width + 1n) / 2n;
+		if (lowerTick < -887272n || upperTick > 887272n || lowerTick >= upperTick) throw new RangeError("Invalid position range");
+		const lower = tickToSqrtPriceX96(lowerTick);
+		const upper = tickToSqrtPriceX96(upperTick);
+		const amount = positionSize * leg.optionRatio;
+		const liquidity = leg.asset === 0n ? amount * (lower * upper / Q96) / (upper - lower) : amount * Q96 / (upper - lower);
+		if (liquidity >= 1n << 128n) throw new RangeError("Liquidity exceeds uint128");
+		return [{
+			lowerTick: Number(lowerTick),
+			upperTick: Number(upperTick),
+			liquidity,
+			isLong: leg.isLong
+		}];
+	});
+	const scale = new Precision(10).pow(quoteDecimals);
+	const atTick = (tick) => {
+		const netLiquidity = chunks.reduce((sum, chunk) => tick >= BigInt(chunk.lowerTick) && tick < BigInt(chunk.upperTick) ? sum + (chunk.isLong ? -chunk.liquidity : chunk.liquidity) : sum, 0n);
+		const sqrt = new Precision(tickToSqrtPriceX96(tick).toString()).div(Q96.toString());
+		const gamma = new Precision(netLiquidity.toString()).neg().div(2).div(scale);
+		return quoteIsToken0 ? gamma.div(sqrt) : gamma.mul(sqrt);
+	};
+	const inRange = (low, high) => {
+		if (low > high) throw new RangeError("Invalid candle range");
+		const ticks = new Set([low, high]);
+		for (const chunk of chunks) for (const boundary of [BigInt(chunk.lowerTick), BigInt(chunk.upperTick)]) {
+			if (boundary >= low && boundary <= high) ticks.add(boundary);
+			if (boundary - 1n >= low && boundary - 1n <= high) ticks.add(boundary - 1n);
+		}
+		return [...ticks].map(atTick);
+	};
+	return {
+		chunks,
+		atTick,
+		inRange
+	};
+}
+/** Historical whole-position diagnostics, with signs retained independently of eligibility. */
+function calculatePositionVolatilityMetrics({ observations, netPremium, baseFees, quoteDecimals }) {
+	if (observations.length < 2) throw new RangeError("At least two price observations are required");
+	if (!Number.isInteger(quoteDecimals) || quoteDecimals < 0 || quoteDecimals > 255) throw new RangeError("Invalid quote decimals");
+	const points = observations.map((point) => ({
+		...point,
+		price: new Precision(point.price),
+		gamma: new Precision(point.gamma),
+		rangeGammas: (point.rangeGammas ?? []).map((gamma) => new Precision(gamma))
+	}));
+	for (const point of points) if (!point.price.isFinite() || point.price.lte(0) || !point.gamma.isFinite() || point.rangeGammas.some((gamma) => !gamma.isFinite())) throw new RangeError("Invalid price or gamma observation");
+	const quantum = new Precision(10).pow(-quoteDecimals);
+	const gammas = points.flatMap((point) => [point.gamma, ...point.rangeGammas]);
+	const peak = gammas.reduce((max, gamma) => Precision.max(max, gamma.abs()), new Precision(0));
+	const tolerance = Precision.max(quantum, peak.mul("1e-12"));
+	const positive = gammas.some((gamma) => gamma.gt(tolerance));
+	const negative = gammas.some((gamma) => gamma.lt(tolerance.neg()));
+	const gammaSign = positive && negative ? "changing" : positive ? "positive" : negative ? "negative" : "zero";
+	let exposure = new Precision(0);
+	let signedConvexity = new Precision(0);
+	let absoluteConvexity = new Precision(0);
+	let years = new Precision(0);
+	for (let i = 1; i < points.length; i++) {
+		const previous = points[i - 1];
+		const point = points[i];
+		const seconds = point.timestamp - previous.timestamp;
+		if (seconds <= 0n) throw new RangeError("Observations must have increasing timestamps");
+		const elapsed = new Precision(seconds.toString()).div(YEAR_SECONDS);
+		const squaredReturn = point.price.div(previous.price).ln().pow(2);
+		exposure = exposure.plus(previous.gamma.abs().mul(elapsed));
+		signedConvexity = signedConvexity.plus(previous.gamma.mul(squaredReturn).div(2));
+		absoluteConvexity = absoluteConvexity.plus(previous.gamma.abs().mul(squaredReturn).div(2));
+		years = years.plus(elapsed);
+	}
+	const sufficientExposure = exposure.gt(tolerance.mul(years).mul(100));
+	const premium = netPremium === null ? null : new Precision(netPremium);
+	const fees = baseFees == null ? null : new Precision(baseFees);
+	if (premium !== null && !premium.isFinite() || fees !== null && !fees.isFinite()) throw new RangeError("Invalid accounting amount");
+	const consistent = (amount) => gammaSign === "positive" ? amount.lte(quantum) : gammaSign === "negative" && amount.gte(quantum.neg());
+	const reason = !sufficientExposure ? "insufficient-exposure" : gammaSign === "changing" ? "changing-sign" : premium === null ? "premium-unavailable" : !consistent(premium) ? "inconsistent-premium-direction" : null;
+	const equivalent = (amount) => amount.abs().mul(2).div(exposure).sqrt().toString();
+	const coverage = (amount) => absoluteConvexity.gt(quantum) ? amount.abs().div(absoluteConvexity).toString() : null;
+	const eligibleFees = sufficientExposure && fees !== null && consistent(fees);
+	return {
+		gammaSign,
+		exposure: exposure.toString(),
+		signedConvexity: signedConvexity.toString(),
+		absoluteConvexity: absoluteConvexity.toString(),
+		netPremium: premium?.toString() ?? null,
+		estimatedHedgedResult: premium?.plus(signedConvexity).toString() ?? null,
+		weightedRealizedVolatility: sufficientExposure ? equivalent(absoluteConvexity) : null,
+		premiumEquivalentVolatility: reason === null && premium !== null ? equivalent(premium) : null,
+		premiumToConvexity: reason === null && premium !== null ? coverage(premium) : null,
+		baseFees: fees?.toString() ?? null,
+		feeEquivalentVolatility: eligibleFees ? equivalent(fees) : null,
+		feeToConvexity: eligibleFees ? coverage(fees) : null,
+		comparisonReason: reason
+	};
+}
+/** Quote-value signed cumulative token increments, excluding revaluation of previous accrual. */
+function valuePositionAccrual({ snapshots, quoteIsToken0, quoteDecimals }) {
+	let previous0 = 0n;
+	let previous1 = 0n;
+	let total = new Precision(0);
+	for (const snapshot of snapshots) {
+		const amount0 = new Precision((snapshot.token0 - previous0).toString());
+		const amount1 = new Precision((snapshot.token1 - previous1).toString());
+		if (snapshot.sqrtPriceX96 !== void 0 && snapshot.sqrtPriceX96 <= 0n) throw new RangeError("Invalid sqrt price");
+		const price = snapshot.sqrtPriceX96 === void 0 ? new Precision("1.0001").pow(snapshot.tick.toString()) : new Precision(snapshot.sqrtPriceX96.toString()).div(Q96.toString()).pow(2);
+		total = total.plus(quoteIsToken0 ? amount0.plus(amount1.div(price)) : amount1.plus(amount0.mul(price)));
+		previous0 = snapshot.token0;
+		previous1 = snapshot.token1;
+	}
+	return total.div(new Precision(10).pow(quoteDecimals));
+}
+
 //#endregion
 //#region src/uniswap/v4/router/errors.ts
 /**
@@ -843,4 +970,4 @@ async function swapExactOutViaV3Router(params) {
 }
 
 //#endregion
-export { AmountExceedsUint128Error, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, encodeV3Path, getLpDepositAmounts, getLpDepositBreakdown, getLpFundingDeposit, getLpPositionFunding, getMaxLpPositionSize, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV4Addresses, quoteSwapExactInViaV3Router, quoteSwapExactOutViaV3Router, quoteV3ExactIn, quoteV3ExactOut, resolveV3SwapRoute, swapExactInViaV3Router, swapExactOutViaV3Router, universalRouterAbi };
+export { AmountExceedsUint128Error, InvalidSwapTokenError, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoterUnavailableError, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UnsupportedChainError, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, calculatePositionVolatilityMetrics, encodeV3Path, getLpDepositAmounts, getLpDepositBreakdown, getLpFundingDeposit, getLpPositionFunding, getMaxLpPositionSize, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV4Addresses, preparePositionGamma, quoteSwapExactInViaV3Router, quoteSwapExactOutViaV3Router, quoteV3ExactIn, quoteV3ExactOut, resolveV3SwapRoute, swapExactInViaV3Router, swapExactOutViaV3Router, universalRouterAbi, valuePositionAccrual };

package/dist/{router-kTiatP_R.js → router-pm9PDlyH.js}

@@ -1,5 +1,5 @@
-import { PanopticError, getBlockMeta, getPool, submitWrite } from "./rates-CPHxWqpT.js";
-import { AmountExceedsUint128Error, InvalidSwapTokenError, MissingSweepRecipientError, QuoterUnavailableError, getUniswapV4Addresses, universalRouterAbi } from "./router-BZGHjEcU.js";
+import { PanopticError, getBlockMeta, getPool, submitWrite } from "./rates-BwZnK0tG.js";
+import { AmountExceedsUint128Error, InvalidSwapTokenError, MissingSweepRecipientError, QuoterUnavailableError, getUniswapV4Addresses, universalRouterAbi } from "./router-Dejb6MWu.js";
 import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, isAddressEqual, maxUint256, zeroAddress } from "viem";
 
 //#region src/uniswap/v4/router/encodeSwap.ts

package/dist/rpc/index.d.ts

@@ -0,0 +1,112 @@
+import * as viem0 from "viem";
+import * as viem1 from "viem";
+import { HttpTransportConfig, Transport } from "viem";
+
+//#region src/rpc/providers.d.ts
+/**
+* The only place that knows RPC vendor URL formats and credentials. Supporting
+* a new vendor means adding one preset here; services select it through env
+* (see `resolveRpcEndpoints`).
+*/
+/**
+ * The only place that knows RPC vendor URL formats and credentials. Supporting
+ * a new vendor means adding one preset here; services select it through env
+ * (see `resolveRpcEndpoints`).
+ */
+type RpcProviderPreset = {
+  /** Env vars holding the API key for `chainId`, highest precedence first. */
+  apiKeyEnv: (chainId: number) => readonly string[];
+  /** Endpoint for `chainId`, or undefined when the vendor does not serve it. */
+  endpoint: (chainId: number, apiKey: string) => {
+    url: string;
+    headers?: Record<string, string>;
+  } | undefined;
+};
+declare const alchemyChains: {
+  readonly 1: "eth-mainnet";
+  readonly 137: "polygon-mainnet";
+  readonly 42161: "arb-mainnet";
+  readonly 8453: "base-mainnet";
+  readonly 10: "opt-mainnet";
+  readonly 130: "unichain-mainnet";
+  readonly 4663: "robinhood-mainnet";
+  readonly 11155111: "eth-sepolia";
+};
+type AlchemyChainId = keyof typeof alchemyChains;
+type RpcProviderName = 'alchemy' | 'infura' | 'uniblock';
+declare const RPC_PROVIDER_PRESETS: Readonly<Record<RpcProviderName, RpcProviderPreset>>;
+declare function getAlchemyRpcUrl(chainId: AlchemyChainId, alchemyApiKey: string): string;
+declare function getAlchemyWsRpcUrl(chainId: AlchemyChainId, alchemyApiKey: string): string; //#endregion
+//#region src/rpc/redact.d.ts
+/**
+ * Strip RPC credentials from text before it is logged or shown. Providers
+ * embed keys in the URL path or query, so every URL keeps only its origin;
+ * credential header values are masked too.
+ */
+declare function redactRpcSecrets(text: string | undefined): string;
+
+//#endregion
+//#region src/rpc/resolve.d.ts
+type RpcEnv = Readonly<Record<string, string | undefined>>;
+type RpcEndpoint = {
+  /** Preset name, or `'url'` for an explicit URL entry. */
+  source: RpcProviderName | 'url';
+  url: string;
+  /** Credentials that must accompany every request to `url`, and only to `url`. */
+  headers: Record<string, string>;
+};
+type ResolveRpcEndpointsOptions = {
+  /** Service-specific URL variables honoured when `RPC_URL_<chainId>` is unset, in order. */
+  legacyUrlEnv?: readonly string[];
+  /** Presets tried, in order, when no URL is configured. Overridden by `RPC_PROVIDERS`. */
+  defaultProviders?: readonly RpcProviderName[];
+};
+declare const DEFAULT_RPC_PROVIDERS: readonly RpcProviderName[];
+/**
+ * Ordered RPC endpoints for `chainId` (primary first, the rest failover):
+ *
+ * 1. `RPC_URL_<chainId>` — comma-separated URLs and/or preset names; entry `n`
+ *    gets headers from `RPC_HEADERS_<chainId>_<n>` ("Name: value;Name: value").
+ * 2. Otherwise the service's legacy URL variables (`legacyUrlEnv`).
+ * 3. Otherwise the first preset in `RPC_PROVIDERS` (or `defaultProviders`)
+ *    that has an API key and serves the chain.
+ *
+ * Blank values count as unset. Throws when nothing resolves.
+ */
+declare function resolveRpcEndpoints(chainId: number, env: RpcEnv, options?: ResolveRpcEndpointsOptions): RpcEndpoint[];
+
+//#endregion
+//#region src/rpc/transport.d.ts
+type RpcHttpConfig = Omit<HttpTransportConfig, 'fetchOptions'>;
+/** viem HTTP transport for one endpoint, carrying its credential headers. */
+declare function rpcHttp(endpoint: RpcEndpoint, config?: RpcHttpConfig): viem1.HttpTransport<viem0.RpcSchema | undefined, boolean>;
+type RpcTransportOptions = RpcHttpConfig & {
+  /**
+   * Fail over to later endpoints. Disable for clients that submit
+   * transactions: a tx broadcast through one provider and retried through
+   * another surfaces as "already known" / "nonce too low" although it was sent.
+   */
+  failover?: boolean;
+};
+/**
+ * Transport over resolved endpoints: plain HTTP for one endpoint, otherwise an
+ * unranked viem `fallback` in configured order.
+ */
+declare function rpcTransport(endpoints: readonly RpcEndpoint[], {
+  failover,
+  ...config
+}?: RpcTransportOptions): Transport;
+/** anvil fork arguments for the primary endpoint (`--fork-header` only when it needs one). */
+declare function rpcForkArgs(endpoints: readonly RpcEndpoint[]): {
+  forkUrl: string;
+  forkHeader?: string;
+};
+/**
+ * Value for a Ponder chain's `rpc`. Header-free endpoints stay plain URLs so
+ * Ponder keeps its own load balancing; credential headers need a transport.
+ */
+declare function ponderRpc(endpoints: readonly RpcEndpoint[]): string | string[] | Transport;
+
+//#endregion
+export { AlchemyChainId, DEFAULT_RPC_PROVIDERS, RPC_PROVIDER_PRESETS, ResolveRpcEndpointsOptions, RpcEndpoint, RpcEnv, RpcHttpConfig, RpcProviderName, RpcProviderPreset, RpcTransportOptions, getAlchemyRpcUrl, getAlchemyWsRpcUrl, ponderRpc, redactRpcSecrets, resolveRpcEndpoints, rpcForkArgs, rpcHttp, rpcTransport };
+//# sourceMappingURL=index.d.ts.map

package/dist/rpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["RpcProviderPreset","Record","alchemyChains","AlchemyChainId","RpcProviderName","RPC_PROVIDER_PRESETS","Readonly","isRpcProviderName","getAlchemyRpcUrl","getAlchemyWsRpcUrl","redactRpcSecrets","RpcProviderName","RpcEnv","Record","Readonly","RpcEndpoint","ResolveRpcEndpointsOptions","DEFAULT_RPC_PROVIDERS","resolveRpcEndpoints","viem1","HttpTransportConfig","Transport","RpcEndpoint","RpcHttpConfig","Omit","rpcHttp","viem0","RpcSchema","HttpTransport","RpcTransportOptions","rpcTransport","failover","rpcForkArgs","ponderRpc"],"sources":["../../src/rpc/providers.d.ts","../../src/rpc/redact.d.ts","../../src/rpc/resolve.d.ts","../../src/rpc/transport.d.ts"],"sourcesContent":null,"mappings":";;;;;;;;;;;;;;;KAKYA,iBAAAA;;;;;IAAAA,GAAAA,EAAAA,MAAAA;IASEE,OAAAA,CAAAA,EAHIW,MAYjB,CAAA,MAAA,EAAA,MAAA,CAAA;EACWV,CAAAA,GAAAA,SAAAA;AACZ,CAAA;AACA,cAZcD,aAYiF,EAAA;EAAA,SAAA,CAAA,EAAA,aAAA;EAAA,SAApCS,GAAAA,EAAAA,iBAAAA;EAAe,SAAEX,KAAAA,EAAAA,aAAAA;EAAiB,SAAzCa,IAAAA,EAAAA,cAAAA;EAAM,SAAfC,EAAAA,EAAAA,aAAAA;EAAQ,SAAA,GAAA,EAAA,kBAAA;EAE3BN,SAAAA,IAAAA,EAAAA,mBAA0BL;EAC1BM,SAAAA,QAAAA,EAAAA,aAA4BN;;KALxCA,cAAAA,gBAA8BD;KAC9BS,eAAAA;cACSN,sBAAsBS,SAASD,OAAOF,iBAAiBX;iBAEpDQ,gBAAAA,UAA0BL;iBAC1BM,kBAAAA,UAA4BN;;;;;;;iBCxB5BO,gBAAAA;;;;KCJZE,MAAAA,GAASE,SAASD;KAClBS,WAAAA;;UAEAX;;;WAGCE;;KAEDG,0BAAAA;EFJAhB;EASEE,YAAAA,CAAAA,EAAAA,SASb,MAAA,EAAA;EACWC;EACAQ,gBAAAA,CAAAA,EAAe,SEZKA,eFYL,EAAA;AAC3B,CAAA;AAA+F,cEX1EM,qBFW0E,EAAA,SEX1CN,eFW0C,EAAA;;;;;AAA5C;AAEnD;AACA;;;;;iBEFwBO,mBAAAA,uBAA0CN,kBAAkBI,6BAA6BM;;;;KCzBrGC,aAAAA,GAAgBC,KAAKJ;;iBAETK,OAAAA,WAAkBH,sBAAsBC,gBAAqEJ,KAAAA,CAAtCS,cAAlBF,KAAAA,CAA+CC,SAAAA;KAChHE,mBAAAA,GAAsBN;;;;;AHAlC;EAScrB,QAAAA,CAAAA,EAAAA,OASb;AACD,CAAA;AACA;AACA;;;AAA4EF,iBGTpD8B,YAAAA,CHSoD9B,SAAAA,EAAAA,SGTnBsB,WHSmBtB,EAAAA,EAAAA;EAAAA,QAAAA;EAAAA,GAAAA;AAAAA,CAAAA,CAAAA,EGTsB6B,mBHStB7B,CAAAA,EGT4CqB,SHS5CrB;;AAAjCc,iBGPnBkB,WAAAA,CHOmBlB,SAAAA,EAAAA,SGPaQ,WHObR,EAAAA,CAAAA,EAAAA;EAAQ,OAAA,EAAA,MAAA;EAE3BN,UAAAA,CAAAA,EAAAA,MAAgB;AACxC,CAAA;;;;;iBGFwByB,SAAAA,qBAA8BX,oCAAoCD"}

package/dist/rpc/index.js

@@ -0,0 +1,242 @@
+import { fallback, http } from "viem";
+
+//#region src/rpc/providers.ts
+const alchemyChains = {
+	1: "eth-mainnet",
+	137: "polygon-mainnet",
+	42161: "arb-mainnet",
+	8453: "base-mainnet",
+	10: "opt-mainnet",
+	130: "unichain-mainnet",
+	4663: "robinhood-mainnet",
+	11155111: "eth-sepolia"
+};
+function isAlchemyChainId(chainId) {
+	return chainId in alchemyChains;
+}
+const infuraChains = {
+	1: "mainnet",
+	10: "optimism-mainnet",
+	137: "polygon-mainnet",
+	8453: "base-mainnet",
+	42161: "arbitrum-mainnet",
+	43114: "avalanche-mainnet",
+	11155111: "sepolia"
+};
+const RPC_PROVIDER_PRESETS = {
+	alchemy: {
+		apiKeyEnv: () => ["ALCHEMY_API_KEY"],
+		endpoint: (chainId, apiKey) => isAlchemyChainId(chainId) ? { url: `https://${alchemyChains[chainId]}.g.alchemy.com/v2/${apiKey}` } : void 0
+	},
+	infura: {
+		apiKeyEnv: () => ["INFURA_API_KEY"],
+		endpoint: (chainId, apiKey) => infuraChains[chainId] ? { url: `https://${infuraChains[chainId]}.infura.io/v3/${apiKey}` } : void 0
+	},
+	uniblock: {
+		apiKeyEnv: () => ["UNIBLOCK_API_KEY"],
+		endpoint: (chainId, apiKey) => ({
+			url: `https://api.uniblock.dev/uni/v1/json-rpc?chainId=${chainId}`,
+			headers: { "x-api-key": apiKey }
+		})
+	}
+};
+function isRpcProviderName(name) {
+	return Object.prototype.hasOwnProperty.call(RPC_PROVIDER_PRESETS, name);
+}
+function getAlchemyRpcUrl(chainId, alchemyApiKey) {
+	if (alchemyChains[chainId]) return `https://${alchemyChains[chainId]}.g.alchemy.com/v2/${alchemyApiKey}`;
+	else throw new Error(`Unsupported chainId: ${chainId}`);
+}
+function getAlchemyWsRpcUrl(chainId, alchemyApiKey) {
+	if (alchemyChains[chainId]) return `wss://${alchemyChains[chainId]}.g.alchemy.com/v2/${alchemyApiKey}`;
+	else throw new Error(`Unsupported chainId: ${chainId}`);
+}
+
+//#endregion
+//#region src/rpc/redact.ts
+const URL_PATTERN = /\b(?:https?|wss?):\/\/[^\s"'<>)]+/giu;
+const CREDENTIAL_HEADER_PATTERN = /\b(x-api-key|authorization|proxy-authorization)(["']?\s*[:=]\s*)(?:(["'])(?:\\.|(?!\3)[^\\\r\n])*\3|[^\r\n]+)/giu;
+function redactUrl(raw) {
+	try {
+		const url = new URL(raw);
+		const port = url.port ? `:${url.port}` : "";
+		return `${url.protocol}//${url.hostname}${port}/<redacted>`;
+	} catch {
+		return "<redacted-url>";
+	}
+}
+/**
+* Strip RPC credentials from text before it is logged or shown. Providers
+* embed keys in the URL path or query, so every URL keeps only its origin;
+* credential header values are masked too.
+*/
+function redactRpcSecrets(text) {
+	if (!text) return "";
+	return text.replace(CREDENTIAL_HEADER_PATTERN, "$1$2$3<redacted>$3").replace(URL_PATTERN, redactUrl);
+}
+
+//#endregion
+//#region src/rpc/resolve.ts
+const DEFAULT_RPC_PROVIDERS = ["alchemy", "uniblock"];
+function present(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function splitList(value) {
+	return (value ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+}
+function parseHeaders(value, envName) {
+	const headers = {};
+	for (const pair of splitHeaderPairs(value)) {
+		const separator = pair.indexOf(":");
+		const name = pair.slice(0, separator).trim();
+		if (separator <= 0 || name === "") throw new Error(`${envName} must be "Name: value" pairs separated by ";"`);
+		headers[name] = pair.slice(separator + 1).trim();
+	}
+	return headers;
+}
+function splitHeaderPairs(value) {
+	return (value ?? "").split(";").map((pair) => pair.trim()).filter((pair) => pair !== "");
+}
+function isHttpUrl(value) {
+	try {
+		const { protocol } = new URL(value);
+		return protocol === "http:" || protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function presetApiKey(name, chainId, env) {
+	for (const envName of RPC_PROVIDER_PRESETS[name].apiKeyEnv(chainId)) {
+		const key = present(env[envName]);
+		if (key !== void 0) return key;
+	}
+	return void 0;
+}
+function presetEndpoint(name, chainId, env) {
+	const apiKey = presetApiKey(name, chainId, env);
+	if (apiKey === void 0) return void 0;
+	const endpoint = RPC_PROVIDER_PRESETS[name].endpoint(chainId, apiKey);
+	return endpoint && {
+		source: name,
+		url: endpoint.url,
+		headers: endpoint.headers ?? {}
+	};
+}
+function explicitEndpoints(chainId, env) {
+	const listEnv = `RPC_URL_${chainId}`;
+	return splitList(env[listEnv]).map((entry, index) => {
+		if (isHttpUrl(entry)) {
+			const headersEnv = `RPC_HEADERS_${chainId}_${index}`;
+			return {
+				source: "url",
+				url: entry,
+				headers: parseHeaders(env[headersEnv], headersEnv)
+			};
+		}
+		if (!isRpcProviderName(entry)) throw new Error(`${listEnv} entry "${entry}" is neither an http(s) URL nor a known provider`);
+		const endpoint = presetEndpoint(entry, chainId, env);
+		if (endpoint === void 0) {
+			const keyEnv = RPC_PROVIDER_PRESETS[entry].apiKeyEnv(chainId).join(" or ");
+			throw new Error(`${listEnv} lists "${entry}", which needs ${keyEnv} and must serve chain ${chainId}`);
+		}
+		return endpoint;
+	});
+}
+function legacyEndpoints(env, legacyUrlEnv) {
+	return legacyUrlEnv.flatMap((envName) => splitList(env[envName]).map((url) => ({
+		source: "url",
+		url,
+		headers: {}
+	})));
+}
+function firstPresetEndpoint(chainId, env, providers) {
+	for (const name of providers) {
+		if (!isRpcProviderName(name)) throw new Error(`RPC_PROVIDERS entry "${name}" is not a known provider`);
+		const endpoint = presetEndpoint(name, chainId, env);
+		if (endpoint !== void 0) return endpoint;
+	}
+	return void 0;
+}
+function dedupe(endpoints) {
+	const seen = new Set();
+	return endpoints.filter((endpoint) => {
+		const key = `${endpoint.url}\n${JSON.stringify(endpoint.headers)}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+/**
+* Ordered RPC endpoints for `chainId` (primary first, the rest failover):
+*
+* 1. `RPC_URL_<chainId>` — comma-separated URLs and/or preset names; entry `n`
+*    gets headers from `RPC_HEADERS_<chainId>_<n>` ("Name: value;Name: value").
+* 2. Otherwise the service's legacy URL variables (`legacyUrlEnv`).
+* 3. Otherwise the first preset in `RPC_PROVIDERS` (or `defaultProviders`)
+*    that has an API key and serves the chain.
+*
+* Blank values count as unset. Throws when nothing resolves.
+*/
+function resolveRpcEndpoints(chainId, env, options = {}) {
+	const explicit = explicitEndpoints(chainId, env);
+	if (explicit.length > 0) return dedupe(explicit);
+	const legacyUrlEnv = options.legacyUrlEnv ?? [];
+	const legacy = legacyEndpoints(env, legacyUrlEnv);
+	if (legacy.length > 0) return dedupe(legacy);
+	const providers = present(env.RPC_PROVIDERS) ? splitList(env.RPC_PROVIDERS) : options.defaultProviders ?? DEFAULT_RPC_PROVIDERS;
+	const preset = firstPresetEndpoint(chainId, env, providers);
+	if (preset !== void 0) return [preset];
+	const keyEnv = [...new Set(providers.flatMap((name) => isRpcProviderName(name) ? RPC_PROVIDER_PRESETS[name].apiKeyEnv(chainId) : []))];
+	throw new Error(`No RPC configured for chain ${chainId}: set ${[
+		`RPC_URL_${chainId}`,
+		...legacyUrlEnv,
+		...keyEnv
+	].join(", ")}`);
+}
+
+//#endregion
+//#region src/rpc/transport.ts
+/** viem HTTP transport for one endpoint, carrying its credential headers. */
+function rpcHttp(endpoint, config = {}) {
+	return http(endpoint.url, {
+		...config,
+		fetchOptions: { headers: endpoint.headers }
+	});
+}
+/**
+* Transport over resolved endpoints: plain HTTP for one endpoint, otherwise an
+* unranked viem `fallback` in configured order.
+*/
+function rpcTransport(endpoints, { failover = true,...config } = {}) {
+	const [primary, ...rest] = endpoints;
+	if (primary === void 0) throw new Error("rpcTransport needs at least one endpoint");
+	if (!failover || rest.length === 0) return rpcHttp(primary, config);
+	return fallback(endpoints.map((endpoint) => rpcHttp(endpoint, config)), { rank: false });
+}
+/** anvil fork arguments for the primary endpoint (`--fork-header` only when it needs one). */
+function rpcForkArgs(endpoints) {
+	const [primary] = endpoints;
+	if (primary === void 0) throw new Error("rpcForkArgs needs at least one endpoint");
+	const headers = Object.entries(primary.headers);
+	if (headers.length === 0) return { forkUrl: primary.url };
+	if (headers.length > 1) throw new Error("anvil --fork-header supports one header per fork");
+	const [[name, value]] = headers;
+	return {
+		forkUrl: primary.url,
+		forkHeader: `${name}: ${value}`
+	};
+}
+/**
+* Value for a Ponder chain's `rpc`. Header-free endpoints stay plain URLs so
+* Ponder keeps its own load balancing; credential headers need a transport.
+*/
+function ponderRpc(endpoints) {
+	if (endpoints.some((endpoint) => Object.keys(endpoint.headers).length > 0)) return rpcTransport(endpoints);
+	const urls = endpoints.map((endpoint) => endpoint.url);
+	return urls.length === 1 ? urls[0] : urls;
+}
+
+//#endregion
+export { DEFAULT_RPC_PROVIDERS, RPC_PROVIDER_PRESETS, getAlchemyRpcUrl, getAlchemyWsRpcUrl, ponderRpc, redactRpcSecrets, resolveRpcEndpoints, rpcForkArgs, rpcHttp, rpcTransport };
+//# sourceMappingURL=index.js.map