@panoptic-eng/sdk 1.0.63 → 1.0.65

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

@@ -1,4 +1,4 @@
-import { ORACLE_EPOCH_SECONDS, SCHEMA_VERSION, STORAGE_PREFIX, calculatePositionGreeks, tickToSqrtPriceX96 } from "./greeks-CNi1-cnp.js";
+import { ORACLE_EPOCH_SECONDS, SCHEMA_VERSION, STORAGE_PREFIX, calculatePositionGreeks, tickToSqrtPriceX96 } from "./greeks-CGtgLUyh.js";
 import { BaseError, decodeAbiParameters, decodeErrorResult, decodeEventLog, decodeFunctionData, encodeFunctionData, getAddress, keccak256, parseAbi, toFunctionSelector, zeroAddress } from "viem";
 
 //#region src/generated.ts
@@ -7945,7 +7945,7 @@ var NoLegsExercisableError = class extends PanopticError {
 var NotALongLegError = class extends PanopticError {
 	name = "NotALongLegError";
 	constructor(cause) {
-		super("Cannot settle premium for non-long leg", cause);
+		super("Cannot settle streamia for non-long leg", cause);
 	}
 };
 /**
@@ -8414,7 +8414,7 @@ var UnsafePremiumSettlementError = class extends PanopticError {
 	name = "UnsafePremiumSettlementError";
 	constructor(remainingForfeit, failedBuyerCount, cause) {
 		const [token0, token1] = remainingForfeit;
-		super(failedBuyerCount > 0 ? `Premium settlement blocked: ${failedBuyerCount} buyer settlement${failedBuyerCount === 1 ? "" : "s"} would fail` : `Premium settlement blocked: uncollectable premium remains (${token0}, ${token1})`, cause);
+		super(failedBuyerCount > 0 ? `Streamia settlement blocked: ${failedBuyerCount} buyer settlement${failedBuyerCount === 1 ? "" : "s"} would fail` : `Streamia settlement blocked: uncollectable streamia remains (${token0}, ${token1})`, cause);
 		this.remainingForfeit = remainingForfeit;
 		this.failedBuyerCount = failedBuyerCount;
 	}
@@ -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 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 };
+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 };

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

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

package/dist/{router-Dejb6MWu.js → router-DxE-iwYF.js}

@@ -1,9 +1,297 @@
-import { PanopticError, getBlockMeta, getPoolMetadata, submitWrite } from "./rates-BwZnK0tG.js";
-import { tickToSqrtPriceX96 } from "./greeks-CNi1-cnp.js";
-import { decodeAllLegs, decodeTokenId } from "./writes--fM_8ggw.js";
-import { BaseError, ContractFunctionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, isAddressEqual, zeroAddress } from "viem";
+import { StateViewAbi } from "./StateView-q4yMpBY6.js";
+import { PanopticError, getBlockMeta, getPoolMetadata, stateViewAbi, submitWrite, uniswapV3PoolAbi } from "./rates-Y0Pbv1_x.js";
+import { tickToSqrtPriceX96 } from "./greeks-CGtgLUyh.js";
+import { decodeAllLegs, decodeTokenId } from "./writes-BA21eyGF.js";
+import { BaseError, ContractFunctionRevertedError, ExecutionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, isAddressEqual, toHex, zeroAddress } from "viem";
 import Decimal from "decimal.js";
 
+//#region src/panoptic/v2/reads/priceHistory.ts
+/**
+* Get historical price data (tick + sqrtPriceX96) for a pool across multiple blocks.
+*
+* @param params - The parameters
+* @returns Price snapshots at each block
+*
+* @example
+* ```typescript
+* const { snapshots } = await getPriceHistory({
+*   client,
+*   blockNumbers: [18000000n, 18000100n, 18000200n],
+*   poolConfig: { version: 'v3', poolAddress: '0x...' },
+* })
+*
+* for (const snap of snapshots) {
+*   console.log(`Block ${snap.blockNumber}: tick=${snap.tick}`)
+* }
+* ```
+*/
+async function getPriceHistory(params) {
+	const { client, blockNumbers, poolConfig } = params;
+	if (blockNumbers.length === 0) {
+		const _meta$1 = params._meta ?? await getBlockMeta({ client });
+		return {
+			snapshots: [],
+			_meta: _meta$1
+		};
+	}
+	const slot0Requests = blockNumbers.map((bn) => fetchSlot0(client, bn, poolConfig));
+	const [slot0Results, _meta] = await Promise.all([Promise.all(slot0Requests), params._meta ? Promise.resolve(params._meta) : getBlockMeta({ client })]);
+	const snapshots = slot0Results.map((result, i) => ({
+		blockNumber: blockNumbers[i],
+		tick: result.tick,
+		sqrtPriceX96: result.sqrtPriceX96
+	}));
+	return {
+		snapshots,
+		_meta
+	};
+}
+async function fetchSlot0(client, blockNumber, poolConfig) {
+	if (poolConfig.version === "v3") {
+		const result = await client.readContract({
+			address: poolConfig.poolAddress,
+			abi: uniswapV3PoolAbi,
+			functionName: "slot0",
+			blockNumber
+		});
+		return {
+			sqrtPriceX96: result[0],
+			tick: result[1]
+		};
+	} else {
+		const result = await client.readContract({
+			address: poolConfig.stateViewAddress,
+			abi: stateViewAbi,
+			functionName: "getSlot0",
+			args: [poolConfig.poolId],
+			blockNumber
+		});
+		return {
+			sqrtPriceX96: result[0],
+			tick: result[1]
+		};
+	}
+}
+
+//#endregion
+//#region src/panoptic/v2/reads/uniswapLpPosition.ts
+const nfpmAbi = [{
+	type: "function",
+	name: "positions",
+	inputs: [{
+		name: "tokenId",
+		type: "uint256"
+	}],
+	outputs: [
+		{
+			name: "nonce",
+			type: "uint96"
+		},
+		{
+			name: "operator",
+			type: "address"
+		},
+		{
+			name: "token0",
+			type: "address"
+		},
+		{
+			name: "token1",
+			type: "address"
+		},
+		{
+			name: "fee",
+			type: "uint24"
+		},
+		{
+			name: "tickLower",
+			type: "int24"
+		},
+		{
+			name: "tickUpper",
+			type: "int24"
+		},
+		{
+			name: "liquidity",
+			type: "uint128"
+		},
+		{
+			name: "feeGrowthInside0LastX128",
+			type: "uint256"
+		},
+		{
+			name: "feeGrowthInside1LastX128",
+			type: "uint256"
+		},
+		{
+			name: "tokensOwed0",
+			type: "uint128"
+		},
+		{
+			name: "tokensOwed1",
+			type: "uint128"
+		}
+	],
+	stateMutability: "view"
+}, {
+	type: "function",
+	name: "collect",
+	inputs: [{
+		name: "params",
+		type: "tuple",
+		components: [
+			{
+				name: "tokenId",
+				type: "uint256"
+			},
+			{
+				name: "recipient",
+				type: "address"
+			},
+			{
+				name: "amount0Max",
+				type: "uint128"
+			},
+			{
+				name: "amount1Max",
+				type: "uint128"
+			}
+		]
+	}],
+	outputs: [{
+		name: "amount0",
+		type: "uint256"
+	}, {
+		name: "amount1",
+		type: "uint256"
+	}],
+	stateMutability: "payable"
+}];
+const MAX_UINT128 = 2n ** 128n - 1n;
+const MAX_UINT256 = 2n ** 256n - 1n;
+const Q128 = 2n ** 128n;
+/**
+* Whether an error thrown by a viem contract call is an on-chain revert (as
+* opposed to a transport/RPC failure such as a timeout or rate limit).
+*/
+function isContractRevert(error) {
+	return error instanceof BaseError && error.walk((err) => err instanceof ContractFunctionRevertedError || err instanceof ExecutionRevertedError) != null;
+}
+/**
+* Fetch a Uniswap V3 LP position's state and uncollected fees.
+*
+* Fees come from simulating `collect` with max amounts as the owner — one
+* eth_call returning the exact claimable amounts (tokensOwed + fee growth
+* since the last poke). The simulation is best-effort: if it reverts (e.g.
+* an empty position), fees fall back to 0.
+*/
+async function getUniswapV3LpPositionState(params) {
+	const { client, nfpmAddress, tokenId, owner, blockNumber } = params;
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber
+	});
+	const position = await client.readContract({
+		address: nfpmAddress,
+		abi: nfpmAbi,
+		functionName: "positions",
+		args: [tokenId],
+		blockNumber: _meta.blockNumber
+	});
+	const [, , token0, token1, fee, tickLower, tickUpper, liquidity] = position;
+	let fees0 = 0n;
+	let fees1 = 0n;
+	try {
+		const { result } = await client.simulateContract({
+			address: nfpmAddress,
+			abi: nfpmAbi,
+			functionName: "collect",
+			args: [{
+				tokenId,
+				recipient: owner,
+				amount0Max: MAX_UINT128,
+				amount1Max: MAX_UINT128
+			}],
+			account: owner,
+			blockNumber: _meta.blockNumber
+		});
+		[fees0, fees1] = result;
+	} catch (error) {
+		if (!isContractRevert(error)) throw error;
+	}
+	return {
+		token0,
+		token1,
+		fee: Number(fee),
+		tickLower: Number(tickLower),
+		tickUpper: Number(tickUpper),
+		liquidity,
+		fees0,
+		fees1,
+		_meta
+	};
+}
+/**
+* Uncollected fees from a feeGrowthInside delta, mirroring v4-core's
+* `Position.calculatePositionFeesAccrued`: the subtraction wraps around
+* uint256 (feeGrowthInside can legitimately underflow in-protocol).
+*/
+function feesFromFeeGrowthDelta(feeGrowthInsideCurrentX128, feeGrowthInsideLastX128, liquidity) {
+	const delta = feeGrowthInsideCurrentX128 - feeGrowthInsideLastX128 & MAX_UINT256;
+	return delta * liquidity / Q128;
+}
+/**
+* Fetch a Uniswap V4 LP position's state and uncollected fees via StateView.
+*
+* The position inside PoolManager is keyed by (positionManager, tickLower,
+* tickUpper, salt) where posm uses `bytes32(tokenId)` as the salt. Fees on
+* pools with fee-taking hooks may be approximate.
+*/
+async function getUniswapV4LpPositionState(params) {
+	const { client, stateViewAddress, positionManagerAddress, poolId, tokenId, tickLower, tickUpper, blockNumber } = params;
+	const salt = toHex(tokenId, { size: 32 });
+	const _meta = await getBlockMeta({
+		client,
+		blockNumber
+	});
+	const [positionInfo, feeGrowthInside] = await client.multicall({
+		allowFailure: false,
+		blockNumber: _meta.blockNumber,
+		contracts: [{
+			address: stateViewAddress,
+			abi: StateViewAbi,
+			functionName: "getPositionInfo",
+			args: [
+				poolId,
+				positionManagerAddress,
+				tickLower,
+				tickUpper,
+				salt
+			]
+		}, {
+			address: stateViewAddress,
+			abi: StateViewAbi,
+			functionName: "getFeeGrowthInside",
+			args: [
+				poolId,
+				tickLower,
+				tickUpper
+			]
+		}]
+	});
+	const [liquidity, feeGrowthInside0LastX128, feeGrowthInside1LastX128] = positionInfo;
+	const [feeGrowthInside0X128, feeGrowthInside1X128] = feeGrowthInside;
+	return {
+		liquidity,
+		tickLower,
+		tickUpper,
+		fees0: feesFromFeeGrowthDelta(feeGrowthInside0X128, feeGrowthInside0LastX128, liquidity),
+		fees1: feesFromFeeGrowthDelta(feeGrowthInside1X128, feeGrowthInside1LastX128, liquidity),
+		_meta
+	};
+}
+
+//#endregion
 //#region src/uniswap/lpDeposit.ts
 const Q96$1 = 1n << 96n;
 const ceilDiv = (n, d) => (n + d - 1n) / d;
@@ -129,7 +417,7 @@ function getMaxLpPositionSize(params) {
 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. */
+/** The streamia-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");
@@ -152,6 +440,16 @@ function preparePositionGamma({ tokenId, positionSize, quoteIsToken0, quoteDecim
 			isLong: leg.isLong
 		}];
 	});
+	return prepareLiquidityGamma({
+		chunks,
+		quoteIsToken0,
+		quoteDecimals
+	});
+}
+/** Signed dollar-gamma for fixed liquidity ranges in one quote frame. */
+function prepareLiquidityGamma({ chunks, quoteIsToken0, quoteDecimals }) {
+	if (!Number.isInteger(quoteDecimals) || quoteDecimals < 0 || quoteDecimals > 255) throw new RangeError("Invalid quote decimals");
+	for (const chunk of chunks) if (!Number.isInteger(chunk.lowerTick) || !Number.isInteger(chunk.upperTick) || chunk.lowerTick < -887272 || chunk.upperTick > 887272 || chunk.lowerTick >= chunk.upperTick || chunk.liquidity < 0n || chunk.liquidity >= 1n << 128n) throw new RangeError("Invalid liquidity range");
 	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);
@@ -970,4 +1268,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, calculatePositionVolatilityMetrics, encodeV3Path, getLpDepositAmounts, getLpDepositBreakdown, getLpFundingDeposit, getLpPositionFunding, getMaxLpPositionSize, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV4Addresses, preparePositionGamma, quoteSwapExactInViaV3Router, quoteSwapExactOutViaV3Router, quoteV3ExactIn, quoteV3ExactOut, resolveV3SwapRoute, swapExactInViaV3Router, swapExactOutViaV3Router, universalRouterAbi, valuePositionAccrual };
+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, feesFromFeeGrowthDelta, getLpDepositAmounts, getLpDepositBreakdown, getLpFundingDeposit, getLpPositionFunding, getMaxLpPositionSize, getPriceHistory, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV3LpPositionState, getUniswapV4Addresses, getUniswapV4LpPositionState, prepareLiquidityGamma, preparePositionGamma, quoteSwapExactInViaV3Router, quoteSwapExactOutViaV3Router, quoteV3ExactIn, quoteV3ExactOut, resolveV3SwapRoute, swapExactInViaV3Router, swapExactOutViaV3Router, universalRouterAbi, valuePositionAccrual };

package/dist/{transactionFees-aXQlx-lq.js → transactionFees-BF033Mob.js}

@@ -1,4 +1,4 @@
-import { ROBINHOOD_CHAIN_ID } from "./chainDeployments-BhXMBZ4B.js";
+import { ROBINHOOD_CHAIN_ID } from "./chainDeployments-Do4NaZA_.js";
 import { hexToBigInt } from "viem";
 import { estimateFeesPerGas, getBlock, getFeeHistory } from "viem/actions";
 

package/dist/uniswap/index.d.ts

@@ -1,5 +1,7 @@
+/// <reference types="node" />
 import Decimal from "decimal.js";
 import { Address, Hash, Hex, PublicClient, WalletClient } from "viem";
+import { z } from "zod";
 
 //#region src/uniswap/estimateLpFees.d.ts
 interface LpFeeCandle {
@@ -48,6 +50,181 @@ declare function estimateLpFees({
   skippedCandles: number;
   inferredCandles: number;
 }; //#endregion
+//#region src/uniswap/lpHistory.d.ts
+declare const changeSchema: z.ZodObject<{
+  eventType: z.ZodEnum<{
+    Mint: "Mint";
+    Burn: "Burn";
+  }>;
+  liquidity: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  amountSource: z.ZodNullable<z.ZodString>;
+  id: z.ZodString;
+  hash: z.ZodString;
+  blockNumber: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  logIndex: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  timestamp: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  amount0: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  amount1: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+}, z.core.$strip>;
+declare const collectSchema: z.ZodObject<{
+  recipient: z.ZodString;
+  id: z.ZodString;
+  hash: z.ZodString;
+  blockNumber: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  logIndex: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  timestamp: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  amount0: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+  amount1: z.ZodPipe<z.ZodString, z.ZodTransform<bigint, string>>;
+}, z.core.$strip>;
+type LpPositionHistoryEvent = z.infer<typeof changeSchema> | (z.infer<typeof collectSchema> & {
+  eventType: 'Collect';
+  amountSource: 'ExactEvent';
+});
+/** Complete NFT activity at one indexed block, sorted by block and log index. */
+declare function getLpPositionHistory({
+  url,
+  positionId,
+  signal
+}: {
+  url: string;
+  positionId: string;
+  signal?: AbortSignal;
+}): Promise<{
+  events: LpPositionHistoryEvent[];
+  positionId: string;
+  blockHash: string;
+  blockNumber: bigint;
+  version: 4 | 3;
+}>;
+/** Token flows; v3 collects may include principal already recorded in removals. */
+declare function summarizeLpPositionHistory(events: readonly LpPositionHistoryEvent[]): {
+  added: {
+    amount0: null;
+    amount1: null;
+    estimated: boolean;
+  } | {
+    amount0: bigint;
+    amount1: bigint;
+    estimated: boolean;
+  };
+  removed: {
+    amount0: null;
+    amount1: null;
+    estimated: boolean;
+  } | {
+    amount0: bigint;
+    amount1: bigint;
+    estimated: boolean;
+  };
+  collected: {
+    amount0: null;
+    amount1: null;
+    estimated: boolean;
+  } | {
+    amount0: bigint;
+    amount1: bigint;
+    estimated: boolean;
+  };
+};
+
+//#endregion
+//#region src/uniswap/lpAccounting.d.ts
+/** V3 NFT cash-flow returns, including withdrawn principal still awaiting collection. */
+declare function calculateV3LpAccounting({
+  events,
+  inventory,
+  claimable,
+  prices,
+  endBlock,
+  token0Decimals,
+  token1Decimals
+}: {
+  events: readonly LpPositionHistoryEvent[];
+  inventory: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  claimable: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  prices: readonly {
+    blockNumber: bigint;
+    sqrtPriceX96: bigint;
+  }[];
+  endBlock: bigint;
+  token0Decimals: number;
+  token1Decimals: number;
+}): {
+  fees0: bigint;
+  fees1: bigint;
+  claimable: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  quote0: {
+    pnl: string;
+    deposited: string;
+    pnlPercent: string | null;
+  };
+  quote1: {
+    pnl: string;
+    deposited: string;
+    pnlPercent: string | null;
+  };
+};
+/** Reconcile v3 activity and historical prices at the subgraph's indexed block. */
+declare function getV3LpHistoryAccounting({
+  client,
+  history,
+  nfpmAddress,
+  poolAddress,
+  tickLower,
+  tickUpper,
+  token0Decimals,
+  token1Decimals
+}: {
+  client: PublicClient;
+  history: Awaited<ReturnType<typeof getLpPositionHistory>>;
+  nfpmAddress: Address;
+  poolAddress: Address;
+  tickLower: bigint;
+  tickUpper: bigint;
+  token0Decimals: number;
+  token1Decimals: number;
+}): Promise<{
+  claimable: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  quote0: null;
+  quote1: null;
+  blockNumber: bigint;
+  timestamp: bigint;
+  fees0: bigint;
+  fees1: bigint;
+} | {
+  blockNumber: bigint;
+  timestamp: bigint;
+  fees0: bigint;
+  fees1: bigint;
+  claimable: {
+    amount0: bigint;
+    amount1: bigint;
+  };
+  quote0: {
+    pnl: string;
+    deposited: string;
+    pnlPercent: string | null;
+  };
+  quote1: {
+    pnl: string;
+    deposited: string;
+    pnlPercent: string | null;
+  };
+}>;
+
+//#endregion
 //#region src/uniswap/lpDeposit.d.ts
 /** Uniswap mint principal in raw token units, rounded up per leg, plus 5% headroom. */
 declare function getLpDepositAmounts(ranges: readonly LpFeeRange[], sqrtPriceX96: bigint): {
@@ -130,7 +307,9 @@ declare function getMaxLpPositionSize(params: Omit<LpPositionFundingParams, 'pos
     referenceSize: bigint;
     requiredInQuote: bigint;
   };
-}): bigint; //#endregion
+}): bigint;
+
+//#endregion
 //#region src/uniswap/lpFeeReturn.d.ts
 /** Simple fee APR over the full selected viewport, without compounding. */
 declare function annualizeLpFeeReturn(feeReturnPercent: Decimal, durationSeconds: bigint): Decimal;
@@ -230,6 +409,15 @@ declare function getLpGreeks(input: LpGreeksInput): LpGreeks;
 
 //#endregion
 //#region src/panoptic/v2/greeks/positionVolatility.d.ts
+interface PositionVolatilityObservation {
+  timestamp: bigint;
+  /** Any consistent positive price scale; only log price ratios are used. */
+  price: Decimal.Value;
+  /** Signed dollar-gamma in human quote units at this observation. */
+  gamma: Decimal.Value;
+  /** Whole-position gamma at price regions visited since the previous observation. */
+  rangeGammas?: readonly Decimal.Value[];
+}
 type VolatilityComparisonReason = 'insufficient-exposure' | 'changing-sign' | 'premium-unavailable' | 'inconsistent-premium-direction';
 
 //#endregion
@@ -331,7 +519,7 @@ interface OptionBurntEvent extends BaseEvent {
   tokenId: bigint;
   /** Position size that was burnt */
   positionSize: bigint;
-  /** Premia settled for each leg (token0 right, token1 left per leg) */
+  /** Streamia settled for each leg (token0 right, token1 left per leg) */
   premiaByLeg: readonly [bigint, bigint, bigint, bigint];
 }
 /**
@@ -694,7 +882,8 @@ declare function calculateLpPositionVolatility({
   tickUpper,
   quoteIsToken0,
   quoteDecimals,
-  snapshots
+  snapshots,
+  observations: priceObservations
 }: {
   liquidity: bigint;
   tickLower: bigint;
@@ -702,6 +891,7 @@ declare function calculateLpPositionVolatility({
   quoteIsToken0: boolean;
   quoteDecimals: number;
   snapshots: readonly UniswapFeeSnapshot[];
+  observations?: readonly PositionVolatilityObservation[];
 }): {
   gammaSign: string;
   exposure: string;
@@ -1591,5 +1781,5 @@ declare function swapExactOutViaRouter(params: SwapExactOutViaRouterParams): Pro
 declare function swapExactOutViaRouterAndWait(params: SwapExactOutViaRouterParams): Promise<TxReceipt>;
 
 //#endregion
-export { AmountExceedsUint128Error, ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, BuildV3ExactOutSwapCalldataArgs, BuildV3SwapCalldataArgs, BuildV4ExactOutSwapCalldataArgs, BuildV4SwapCalldataArgs, CheckRouterApprovalParams, ExpectedTimeInRangeInput, InvalidSwapTokenError, LP_RANGE_HORIZONS_DAYS, LP_RANGE_HORIZONS_YEARS, LpAmounts, LpFeeCandle, LpFeeRange, LpGreeks, LpGreeksInput, LpPositionFundingParams, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactInViaV3RouterParams, QuoteSwapExactOutViaRouterParams, QuoteSwapExactOutViaV3RouterParams, QuoteV3ExactInParams, QuoteV3ExactOutParams, QuoteV4ExactInByPoolKeyParams, QuoterUnavailableError, RangeProbabilityInput, RangeStats, RangeStatsInput, ResolveSwapRouteParams, ResolveV3SwapRouteParams, ResolvedSwapRoute, ResolvedV3SwapRoute, RouterApprovalStatus, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactInViaV3RouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, SwapExactOutViaV3RouterParams, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UniswapV3Addresses, UniswapV4Addresses, UnsupportedChainError, V3ExactInQuote, V3ExactOutQuote, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, V4ExactInQuote, V4_SWAP, annualizeLpFeeReturn, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, calculateLpPositionVolatility, checkRouterApproval, encodeV3Path, estimateLpFees, expectedTimeInRange, getAmountsForLiquidity, getLpDepositAmounts, getLpDepositBreakdown, getLpFeeReturnSeries, getLpFundingDeposit, getLpGreeks, getLpPositionFunding, getMaxLpPositionSize, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV3PoolBalances, getUniswapV4Addresses, normalCdf, pInRangeAt, quoteSwapExactInViaRouter, quoteSwapExactInViaV3Router, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router, quoteTokenPrices, quoteV3ExactIn, quoteV3ExactOut, quoteV4ExactInByPoolKey, rangeStats, resolveSwapRoute, resolveV3SwapRoute, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactInViaV3Router, swapExactOutViaRouter, swapExactOutViaRouterAndWait, swapExactOutViaV3Router };
+export { AmountExceedsUint128Error, ApproveErc20ForPermit2Params, ApproveRouterViaPermit2Params, BuildV3ExactOutSwapCalldataArgs, BuildV3SwapCalldataArgs, BuildV4ExactOutSwapCalldataArgs, BuildV4SwapCalldataArgs, CheckRouterApprovalParams, ExpectedTimeInRangeInput, InvalidSwapTokenError, LP_RANGE_HORIZONS_DAYS, LP_RANGE_HORIZONS_YEARS, LpAmounts, LpFeeCandle, LpFeeRange, LpGreeks, LpGreeksInput, LpPositionFundingParams, LpPositionHistoryEvent, MSG_SENDER, MissingSweepRecipientError, PERMIT2_ADDRESS, QuoteSwapExactInViaRouterParams, QuoteSwapExactInViaV3RouterParams, QuoteSwapExactOutViaRouterParams, QuoteSwapExactOutViaV3RouterParams, QuoteV3ExactInParams, QuoteV3ExactOutParams, QuoteV4ExactInByPoolKeyParams, QuoterUnavailableError, RangeProbabilityInput, RangeStats, RangeStatsInput, ResolveSwapRouteParams, ResolveV3SwapRouteParams, ResolvedSwapRoute, ResolvedV3SwapRoute, RouterApprovalStatus, SETTLE_ALL, SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, SWEEP, SwapExactInQuote, SwapExactInViaRouterParams, SwapExactInViaV3RouterParams, SwapExactOutQuote, SwapExactOutViaRouterParams, SwapExactOutViaV3RouterParams, TAKE_ALL, UNISWAP_V3_ADDRESSES, UNISWAP_V4_ADDRESSES, UniswapV3Addresses, UniswapV4Addresses, UnsupportedChainError, V3ExactInQuote, V3ExactOutQuote, V3_SWAP_EXACT_IN, V3_SWAP_EXACT_OUT, V4ExactInQuote, V4_SWAP, annualizeLpFeeReturn, approveErc20ForPermit2, approveErc20ForPermit2AndWait, approveRouterViaPermit2, approveRouterViaPermit2AndWait, buildV3ExactOutSwapExecuteArgs, buildV3ExactOutSwapExecuteCalldata, buildV3SwapExecuteArgs, buildV3SwapExecuteCalldata, buildV4ExactOutSwapExecuteArgs, buildV4ExactOutSwapExecuteCalldata, buildV4SwapExecuteArgs, buildV4SwapExecuteCalldata, calculateLpPositionVolatility, calculateV3LpAccounting, checkRouterApproval, encodeV3Path, estimateLpFees, expectedTimeInRange, getAmountsForLiquidity, getLpDepositAmounts, getLpDepositBreakdown, getLpFeeReturnSeries, getLpFundingDeposit, getLpGreeks, getLpPositionFunding, getLpPositionHistory, getMaxLpPositionSize, getUnhedgedLpRanges, getUniswapV3Addresses, getUniswapV3PoolBalances, getUniswapV4Addresses, getV3LpHistoryAccounting, normalCdf, pInRangeAt, quoteSwapExactInViaRouter, quoteSwapExactInViaV3Router, quoteSwapExactOutViaRouter, quoteSwapExactOutViaV3Router, quoteTokenPrices, quoteV3ExactIn, quoteV3ExactOut, quoteV4ExactInByPoolKey, rangeStats, resolveSwapRoute, resolveV3SwapRoute, summarizeLpPositionHistory, swapExactInViaRouter, swapExactInViaRouterAndWait, swapExactInViaV3Router, swapExactOutViaRouter, swapExactOutViaRouterAndWait, swapExactOutViaV3Router };
 //# sourceMappingURL=index.d.ts.map