@steerprotocol/sdk 3.7.2 → 3.7.4

package/dist/index.cjs

@@ -17327,58 +17327,420 @@ var SubgraphClient = class {
 	}
 };
 //#endregion
-//#region src/base/vault/utils.ts
-const GLOBAL_STATE_ABI = [{
-	inputs: [],
-	name: "globalState",
-	outputs: [
-		{
-			internalType: "uint160",
-			name: "price",
-			type: "uint160"
-		},
+//#region src/pool-lifecycle/abis/v4.ts
+/** Minimal authoritative IPoolManager surface used by the V4 lifecycle adapter. */
+const v4PoolManagerAbi = (0, viem.parseAbi)(["function initialize((address currency0,address currency1,uint24 fee,int24 tickSpacing,address hooks) key, uint160 sqrtPriceX96) returns (int24 tick)", "event Initialize(bytes32 indexed id, address indexed currency0, address indexed currency1, uint24 fee, int24 tickSpacing, address hooks, uint160 sqrtPriceX96, int24 tick)"]);
+/** Minimal StateView/ImmutableState surface used for deployment and state checks. */
+const v4StateViewAbi = (0, viem.parseAbi)(["function poolManager() view returns (address)", "function getSlot0(bytes32 poolId) view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)"]);
+//#endregion
+//#region src/pool-lifecycle/math.ts
+/** The smallest sqrt price accepted by Uniswap TickMath, inclusive. */
+const MIN_SQRT_RATIO = 4295128739n;
+/** The largest TickMath sqrt-price boundary, which is not itself valid. */
+const MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
+const ZERO_ADDRESS$3 = "0x0000000000000000000000000000000000000000";
+const MAX_ERC20_DECIMALS = 255;
+function greatestCommonDivisor(a, b) {
+	let left = a;
+	let right = b;
+	while (right !== 0n) {
+		const remainder = left % right;
+		left = right;
+		right = remainder;
+	}
+	return left;
+}
+function checksumAddress(value, label, allowZero) {
+	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) throw new TypeError(`${label} must be a valid EVM address`);
+	const address = (0, viem.getAddress)(value);
+	if (!allowZero && address === ZERO_ADDRESS$3) throw new RangeError(`${label} must not be the zero address`);
+	return address;
+}
+function assertErc20Decimals(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0 || value > MAX_ERC20_DECIMALS) throw new RangeError(`${label} must be an integer from 0 through 255`);
+}
+function assertPositiveFraction(value) {
+	if (typeof value?.numerator !== "bigint" || typeof value?.denominator !== "bigint") throw new TypeError("quotePerBase must contain bigint numerator and denominator values");
+	if (value.numerator <= 0n) throw new RangeError("quotePerBase numerator must be greater than zero");
+	if (value.denominator <= 0n) throw new RangeError("quotePerBase denominator must be greater than zero");
+}
+/**
+* Parses an unsigned, fixed-point decimal string without converting through a
+* JavaScript number. Signs, exponent notation, whitespace, and omitted whole
+* or fractional digits are rejected. The returned fraction is reduced.
+*/
+function parseExactDecimal(value) {
+	if (typeof value !== "string") throw new TypeError("Decimal value must be provided as a string");
+	const match = /^([0-9]+)(?:\.([0-9]+))?$/.exec(value);
+	if (match === null || match[0] !== value) throw new TypeError("Decimal value must use unsigned fixed-point notation, for example \"123.45\"");
+	const wholeDigits = match[1];
+	const fractionalDigits = match[2] ?? "";
+	const numerator = BigInt(`${wholeDigits}${fractionalDigits}`);
+	if (numerator === 0n) return {
+		numerator: 0n,
+		denominator: 1n
+	};
+	const denominator = 10n ** BigInt(fractionalDigits.length);
+	const divisor = greatestCommonDivisor(numerator, denominator);
+	return {
+		numerator: numerator / divisor,
+		denominator: denominator / divisor
+	};
+}
+/**
+* Validates, checksums, and sorts two distinct non-zero ERC20 addresses.
+*/
+function sortErc20Pair(tokenA, tokenB) {
+	const normalizedTokenA = checksumAddress(tokenA, "tokenA", false);
+	const normalizedTokenB = checksumAddress(tokenB, "tokenB", false);
+	if (normalizedTokenA === normalizedTokenB) throw new RangeError("ERC20 pair tokens must be different");
+	return BigInt(normalizedTokenA) < BigInt(normalizedTokenB) ? {
+		token0: normalizedTokenA,
+		token1: normalizedTokenB
+	} : {
+		token0: normalizedTokenB,
+		token1: normalizedTokenA
+	};
+}
+/**
+* Validates, checksums, and sorts two distinct EVM currencies. The zero
+* address is allowed and, when present, necessarily sorts as currency0.
+*/
+function sortEvmCurrencyPair(currencyA, currencyB) {
+	const normalizedCurrencyA = checksumAddress(currencyA, "currencyA", true);
+	const normalizedCurrencyB = checksumAddress(currencyB, "currencyB", true);
+	if (normalizedCurrencyA === normalizedCurrencyB) throw new RangeError("EVM pair currencies must be different");
+	return BigInt(normalizedCurrencyA) < BigInt(normalizedCurrencyB) ? {
+		currency0: normalizedCurrencyA,
+		currency1: normalizedCurrencyB
+	} : {
+		currency0: normalizedCurrencyB,
+		currency1: normalizedCurrencyA
+	};
+}
+/**
+* Returns floor(sqrt(value)) using bigint arithmetic only.
+*/
+function integerSqrt(value) {
+	if (typeof value !== "bigint") throw new TypeError("Square-root input must be a bigint");
+	if (value < 0n) throw new RangeError("Square-root input must not be negative");
+	if (value < 2n) return value;
+	let estimate = value;
+	let nextEstimate = estimate + 1n >> 1n;
+	while (nextEstimate < estimate) {
+		estimate = nextEstimate;
+		nextEstimate = estimate + value / estimate >> 1n;
+	}
+	return estimate;
+}
+/**
+* Enforces the Uniswap TickMath interval: MIN is inclusive and MAX exclusive.
+* Returns the input so it can be composed with transaction builders.
+*/
+function validateSqrtPriceX96(sqrtPriceX96) {
+	if (typeof sqrtPriceX96 !== "bigint") throw new TypeError("sqrtPriceX96 must be a bigint");
+	if (sqrtPriceX96 < 4295128739n || sqrtPriceX96 >= 1461446703485210103287273052203988822378723970342n) throw new RangeError(`sqrtPriceX96 must be in [${MIN_SQRT_RATIO}, ${MAX_SQRT_RATIO})`);
+	return sqrtPriceX96;
+}
+/**
+* Encode an exact raw token1/token0 amount ratio without token metadata.
+* The result matches the canonical V3 floor-rounding operation.
+*/
+function encodeSqrtRatioX96(amount1Raw, amount0Raw) {
+	if (typeof amount0Raw !== "bigint" || typeof amount1Raw !== "bigint") throw new TypeError("Raw ratio amounts must be bigint values");
+	if (amount0Raw <= 0n || amount1Raw <= 0n) throw new RangeError("Raw ratio amounts must be greater than zero");
+	return validateSqrtPriceX96(integerSqrt((amount1Raw << 192n) / amount0Raw));
+}
+/**
+* Converts an exact quote-per-base human price into the canonical raw-token
+* ratio and sqrtPriceX96 expected by concentrated-liquidity initializers.
+*
+* Address sorting and reciprocal orientation happen before the only lossy
+* operation. The final encoding is exactly:
+*
+*   floor(sqrt((amount1Raw << 192) / amount0Raw))
+*/
+function encodeInitialSqrtPriceX96(price) {
+	const pair = sortErc20Pair(price.baseToken, price.quoteToken);
+	const baseToken = checksumAddress(price.baseToken, "baseToken", false);
+	assertErc20Decimals(price.baseTokenDecimals, "baseTokenDecimals");
+	assertErc20Decimals(price.quoteTokenDecimals, "quoteTokenDecimals");
+	assertPositiveFraction(price.quotePerBase);
+	const baseScale = 10n ** BigInt(price.baseTokenDecimals);
+	const quoteScale = 10n ** BigInt(price.quoteTokenDecimals);
+	const baseTokenIsToken0 = baseToken === pair.token0;
+	const amount0Raw = baseTokenIsToken0 ? price.quotePerBase.denominator * baseScale : price.quotePerBase.numerator * quoteScale;
+	const amount1Raw = baseTokenIsToken0 ? price.quotePerBase.numerator * quoteScale : price.quotePerBase.denominator * baseScale;
+	const sqrtPriceX96 = encodeSqrtRatioX96(amount1Raw, amount0Raw);
+	return {
+		...pair,
+		amount0Raw,
+		amount1Raw,
+		sqrtPriceX96,
+		baseTokenIsToken0
+	};
+}
+/**
+* Currency-aware counterpart to {@link encodeInitialSqrtPriceX96}. It keeps
+* the same exact orientation and floor-rounding rules while permitting the
+* native zero-address currency required by Uniswap V4.
+*/
+function encodeCurrencyInitialSqrtPriceX96(price) {
+	const pair = sortEvmCurrencyPair(price.baseCurrency, price.quoteCurrency);
+	const baseCurrency = checksumAddress(price.baseCurrency, "baseCurrency", true);
+	assertErc20Decimals(price.baseCurrencyDecimals, "baseCurrencyDecimals");
+	assertErc20Decimals(price.quoteCurrencyDecimals, "quoteCurrencyDecimals");
+	assertPositiveFraction(price.quotePerBase);
+	const baseScale = 10n ** BigInt(price.baseCurrencyDecimals);
+	const quoteScale = 10n ** BigInt(price.quoteCurrencyDecimals);
+	const baseCurrencyIsCurrency0 = baseCurrency === pair.currency0;
+	const amount0Raw = baseCurrencyIsCurrency0 ? price.quotePerBase.denominator * baseScale : price.quotePerBase.numerator * quoteScale;
+	const amount1Raw = baseCurrencyIsCurrency0 ? price.quotePerBase.numerator * quoteScale : price.quotePerBase.denominator * baseScale;
+	return {
+		...pair,
+		amount0Raw,
+		amount1Raw,
+		sqrtPriceX96: encodeSqrtRatioX96(amount1Raw, amount0Raw),
+		baseCurrencyIsCurrency0
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/errors.ts
+/** Error thrown when a pool lifecycle primitive cannot safely continue. */
+var PoolLifecycleError = class extends Error {
+	constructor(code, message, causeValue) {
+		super(message);
+		this.name = "PoolLifecycleError";
+		this.code = code;
+		this.causeValue = causeValue;
+	}
+};
+//#endregion
+//#region src/pool-lifecycle/v4/key.ts
+const V4_DYNAMIC_FEE_FLAG = 8388608;
+const V4_MAX_STATIC_FEE = 1e6;
+const V4_MAX_TICK_SPACING = 32767;
+const V4_ALL_HOOK_MASK = (1n << 14n) - 1n;
+const V4_ZERO_ADDRESS = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+const BEFORE_SWAP_FLAG = 1n << 7n;
+const AFTER_SWAP_FLAG = 1n << 6n;
+const AFTER_ADD_LIQUIDITY_FLAG = 1n << 10n;
+const AFTER_REMOVE_LIQUIDITY_FLAG = 1n << 8n;
+const BEFORE_SWAP_RETURNS_DELTA_FLAG = 1n << 3n;
+const AFTER_SWAP_RETURNS_DELTA_FLAG = 1n << 2n;
+const AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG = 1n << 1n;
+const AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG = 1n;
+const POOL_KEY_ABI_PARAMETER = {
+	type: "tuple",
+	components: [
 		{
-			internalType: "int24",
-			name: "tick",
-			type: "int24"
+			name: "currency0",
+			type: "address"
 		},
 		{
-			internalType: "int24",
-			name: "prevInitializedTick",
-			type: "int24"
+			name: "currency1",
+			type: "address"
 		},
 		{
-			internalType: "uint16",
 			name: "fee",
-			type: "uint16"
-		},
-		{
-			internalType: "uint16",
-			name: "timepointIndex",
-			type: "uint16"
+			type: "uint24"
 		},
 		{
-			internalType: "uint8",
-			name: "communityFee",
-			type: "uint8"
+			name: "tickSpacing",
+			type: "int24"
 		},
 		{
-			internalType: "bool",
-			name: "unlocked",
-			type: "bool"
+			name: "hooks",
+			type: "address"
 		}
-	],
-	stateMutability: "view",
-	type: "function"
-}];
-const GLOBAL_STATE_ABI_INTEGRAL_V_1 = [{
-	inputs: [],
-	name: "globalState",
-	outputs: [
-		{
-			internalType: "uint160",
-			name: "price",
-			type: "uint160"
+	]
+};
+function invalidInput(message, cause) {
+	throw new PoolLifecycleError("INVALID_INPUT", message, cause);
+}
+function normalizeAddress(value, label) {
+	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) return invalidInput(`${label} must be a valid EVM address.`);
+	return (0, viem.getAddress)(value);
+}
+function validateFee(fee) {
+	if (!Number.isSafeInteger(fee) || Number(fee) < 0 || Number(fee) > 1e6 && Number(fee) !== 8388608) return invalidInput("V4 fee must be an integer from 0 through 1000000 or the dynamic fee flag 0x800000.");
+	return Number(fee);
+}
+function validateTickSpacing(tickSpacing) {
+	if (!Number.isSafeInteger(tickSpacing) || Number(tickSpacing) < 1 || Number(tickSpacing) > 32767) return invalidInput("V4 tickSpacing must be an integer from 1 through 32767.");
+	return Number(tickSpacing);
+}
+function validateHookAddress(hooksAddress, fee) {
+	const hooks = BigInt(hooksAddress);
+	const hasFlag = (flag) => (hooks & flag) !== 0n;
+	if (!hasFlag(BEFORE_SWAP_FLAG) && hasFlag(BEFORE_SWAP_RETURNS_DELTA_FLAG) || !hasFlag(AFTER_SWAP_FLAG) && hasFlag(AFTER_SWAP_RETURNS_DELTA_FLAG) || !hasFlag(AFTER_ADD_LIQUIDITY_FLAG) && hasFlag(AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG) || !hasFlag(AFTER_REMOVE_LIQUIDITY_FLAG) && hasFlag(AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG)) invalidInput("V4 hook return-delta flags require their corresponding action flags.");
+	const dynamicFee = fee === V4_DYNAMIC_FEE_FLAG;
+	if (!(hooks === 0n ? !dynamicFee : (hooks & V4_ALL_HOOK_MASK) !== 0n || dynamicFee)) invalidInput("V4 hooks address is incompatible with its fee and permission flags.");
+}
+/** Validate a complete PoolKey whose currencies are already canonically ordered. */
+function validateV4PoolKey(value) {
+	const currency0 = normalizeAddress(value?.currency0, "currency0");
+	const currency1 = normalizeAddress(value?.currency1, "currency1");
+	const fee = validateFee(value?.fee);
+	const tickSpacing = validateTickSpacing(value?.tickSpacing);
+	const hooks = normalizeAddress(value?.hooks, "hooks");
+	if (BigInt(currency0) >= BigInt(currency1)) invalidInput("V4 currencies must be distinct and canonically ordered.");
+	validateHookAddress(hooks, fee);
+	return {
+		currency0,
+		currency1,
+		fee,
+		tickSpacing,
+		hooks
+	};
+}
+/**
+* Validate and sort two currencies. Address zero is deliberately accepted and
+* sorts first because V4 represents the native currency as address(0).
+*/
+function canonicalizeV4PoolKey(value) {
+	const currencyA = normalizeAddress(value?.currencyA, "currencyA");
+	const currencyB = normalizeAddress(value?.currencyB, "currencyB");
+	if (currencyA === currencyB) return invalidInput("V4 pool currencies must be different.");
+	const [currency0, currency1] = BigInt(currencyA) < BigInt(currencyB) ? [currencyA, currencyB] : [currencyB, currencyA];
+	return validateV4PoolKey({
+		currency0,
+		currency1,
+		fee: value?.fee,
+		tickSpacing: value?.tickSpacing,
+		hooks: value?.hooks
+	});
+}
+/** Return the exact PoolId used by PoolIdLibrary.toId. */
+function getV4PoolId(key) {
+	const validated = validateV4PoolKey(key);
+	return (0, viem.keccak256)((0, viem.encodeAbiParameters)([POOL_KEY_ABI_PARAMETER], [validated]));
+}
+function v4PoolKeysEqual(left, right) {
+	try {
+		const a = validateV4PoolKey(left);
+		const b = validateV4PoolKey(right);
+		return a.currency0 === b.currency0 && a.currency1 === b.currency1 && a.fee === b.fee && a.tickSpacing === b.tickSpacing && a.hooks === b.hooks;
+	} catch {
+		return false;
+	}
+}
+/** Validate price bounds and bind the price to the canonical PoolKey order. */
+function assertV4InitialPrice(key, value) {
+	const currency0 = normalizeAddress(value?.currency0, "initialPrice.currency0");
+	const currency1 = normalizeAddress(value?.currency1, "initialPrice.currency1");
+	if (currency0 !== key.currency0 || currency1 !== key.currency1) return invalidInput("V4 initial price currencies must match the canonical PoolKey order.");
+	try {
+		return {
+			currency0,
+			currency1,
+			sqrtPriceX96: validateSqrtPriceX96(value?.sqrtPriceX96)
+		};
+	} catch (error) {
+		return invalidInput(error instanceof Error ? error.message : "V4 sqrtPriceX96 is invalid.", error);
+	}
+}
+//#endregion
+//#region src/base/vault/utils.ts
+function asV4Uint24(value, label) {
+	if (typeof value !== "number" && typeof value !== "bigint" || !Number.isSafeInteger(Number(value)) || Number(value) < 0 || Number(value) > 16777215) throw new Error(`V4 StateView returned an invalid ${label}.`);
+	return Number(value);
+}
+/** Read a V4 PoolId through its configured StateView at one block. */
+async function getV4PoolState(publicClient, params) {
+	if (!/^0x[0-9a-fA-F]{64}$/.test(params.poolId)) throw new Error("V4 poolId must be a bytes32 hex value.");
+	const chain = chainIdToName(params.chainId);
+	const config = getAmmConfig("")[Protocol.UniswapV4];
+	const manager = chain && config?.PoolManager?.[chain];
+	const view = chain && config?.StateView?.[chain];
+	if (!manager || !view || !(0, viem.isAddress)(manager) || !(0, viem.isAddress)(view)) throw new Error(`Uniswap V4 PoolManager or StateView is missing for chain ${params.chainId}.`);
+	const actualChainId = await publicClient.getChainId();
+	if (actualChainId !== params.chainId) throw new Error(`Public client chain ${actualChainId} does not match V4 chain ${params.chainId}.`);
+	const blockNumber = params.blockNumber ?? await publicClient.getBlockNumber();
+	if (typeof blockNumber !== "bigint" || blockNumber < 0n) throw new Error("V4 blockNumber must be a non-negative bigint.");
+	const stateView = (0, viem.getAddress)(view);
+	const [boundManager, slot0] = await Promise.all([publicClient.readContract({
+		address: stateView,
+		abi: v4StateViewAbi,
+		functionName: "poolManager",
+		blockNumber
+	}), publicClient.readContract({
+		address: stateView,
+		abi: v4StateViewAbi,
+		functionName: "getSlot0",
+		args: [params.poolId],
+		blockNumber
+	})]);
+	if ((0, viem.getAddress)(boundManager) !== (0, viem.getAddress)(manager)) throw new Error("Configured Uniswap V4 StateView is bound to a different PoolManager.");
+	if (!Array.isArray(slot0) || slot0.length !== 4) throw new Error("V4 StateView returned malformed slot0 state.");
+	const [sqrtPriceX96, rawTick, rawProtocolFee, rawLpFee] = slot0;
+	if (typeof sqrtPriceX96 !== "bigint" || sqrtPriceX96 === 0n) throw new Error(sqrtPriceX96 === 0n ? "Uniswap V4 pool is not initialized." : "V4 StateView returned malformed sqrtPriceX96.");
+	validateSqrtPriceX96(sqrtPriceX96);
+	const tick = Number(rawTick);
+	if (typeof rawTick !== "number" && typeof rawTick !== "bigint" || !Number.isSafeInteger(tick) || tick < -887272 || tick > 887272) throw new Error("V4 StateView returned an invalid tick.");
+	const protocolFee = asV4Uint24(rawProtocolFee, "protocol fee");
+	if (asV4Uint24(rawLpFee, "LP fee") > 1e6) throw new Error("V4 StateView returned an invalid LP fee.");
+	return {
+		sqrtPriceX96,
+		tick,
+		observationIndex: 0,
+		observationCardinality: 0,
+		observationCardinalityNext: 0,
+		feeProtocol: protocolFee,
+		unlocked: true
+	};
+}
+const GLOBAL_STATE_ABI = [{
+	inputs: [],
+	name: "globalState",
+	outputs: [
+		{
+			internalType: "uint160",
+			name: "price",
+			type: "uint160"
+		},
+		{
+			internalType: "int24",
+			name: "tick",
+			type: "int24"
+		},
+		{
+			internalType: "int24",
+			name: "prevInitializedTick",
+			type: "int24"
+		},
+		{
+			internalType: "uint16",
+			name: "fee",
+			type: "uint16"
+		},
+		{
+			internalType: "uint16",
+			name: "timepointIndex",
+			type: "uint16"
+		},
+		{
+			internalType: "uint8",
+			name: "communityFee",
+			type: "uint8"
+		},
+		{
+			internalType: "bool",
+			name: "unlocked",
+			type: "bool"
+		}
+	],
+	stateMutability: "view",
+	type: "function"
+}];
+const GLOBAL_STATE_ABI_INTEGRAL_V_1 = [{
+	inputs: [],
+	name: "globalState",
+	outputs: [
+		{
+			internalType: "uint160",
+			name: "price",
+			type: "uint160"
 		},
 		{
 			internalType: "int24",
@@ -17965,10 +18327,23 @@ async function getGlobalStateAlgebraIntegral(publicClient, poolAddress, isDirect
 *   poolAddress: '0x...',
 *   isPoolSharkPool: true
 * });
+*
+* // For Uniswap V4, supply the pool ID and the expected chain explicitly.
+* const v4State = await getPoolState(publicClient, {
+*   protocol: Protocol.UniswapV4,
+*   poolId: '0x...',
+*   chainId: 8453
+* });
 * ```
 */
 async function getPoolState(publicClient, params) {
 	try {
+		if (params.protocol === Protocol.UniswapV4) return {
+			data: await getV4PoolState(publicClient, params),
+			status: 200,
+			success: true
+		};
+		if ("protocol" in params || !/^0x[0-9a-fA-F]{40}$/.test(params.poolAddress)) throw new Error("An address-based pool read requires a valid pool address and supported protocol.");
 		let stateResponse;
 		if (params.isAlgebraIntegralPool) stateResponse = await getGlobalStateAlgebraIntegral(publicClient, params.poolAddress, params.isAlgebraDirectionPool || false);
 		else if (params.isPoolSharkPool) {
@@ -18077,7 +18452,7 @@ async function getPoolStateWithPrice(publicClient, params) {
 			success: false,
 			error: stateResponse.error || "Failed to get pool state"
 		};
-		const price = getPoolPrice(stateResponse.data, params);
+		const price = getPoolPrice(stateResponse.data, params.protocol === Protocol.UniswapV4 ? {} : params);
 		return {
 			data: {
 				state: stateResponse.data,
@@ -19830,320 +20205,6 @@ var VaultWithdrawClient = class {
 	}
 };
 //#endregion
-//#region src/pool-lifecycle/abis/v4.ts
-/** Minimal authoritative IPoolManager surface used by the V4 lifecycle adapter. */
-const v4PoolManagerAbi = (0, viem.parseAbi)(["function initialize((address currency0,address currency1,uint24 fee,int24 tickSpacing,address hooks) key, uint160 sqrtPriceX96) returns (int24 tick)", "event Initialize(bytes32 indexed id, address indexed currency0, address indexed currency1, uint24 fee, int24 tickSpacing, address hooks, uint160 sqrtPriceX96, int24 tick)"]);
-/** Minimal StateView/ImmutableState surface used for deployment and state checks. */
-const v4StateViewAbi = (0, viem.parseAbi)(["function poolManager() view returns (address)", "function getSlot0(bytes32 poolId) view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)"]);
-//#endregion
-//#region src/pool-lifecycle/errors.ts
-/** Error thrown when a pool lifecycle primitive cannot safely continue. */
-var PoolLifecycleError = class extends Error {
-	constructor(code, message, causeValue) {
-		super(message);
-		this.name = "PoolLifecycleError";
-		this.code = code;
-		this.causeValue = causeValue;
-	}
-};
-//#endregion
-//#region src/pool-lifecycle/math.ts
-/** The smallest sqrt price accepted by Uniswap TickMath, inclusive. */
-const MIN_SQRT_RATIO = 4295128739n;
-/** The largest TickMath sqrt-price boundary, which is not itself valid. */
-const MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
-const ZERO_ADDRESS$3 = "0x0000000000000000000000000000000000000000";
-const MAX_ERC20_DECIMALS = 255;
-function greatestCommonDivisor(a, b) {
-	let left = a;
-	let right = b;
-	while (right !== 0n) {
-		const remainder = left % right;
-		left = right;
-		right = remainder;
-	}
-	return left;
-}
-function checksumAddress(value, label, allowZero) {
-	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) throw new TypeError(`${label} must be a valid EVM address`);
-	const address = (0, viem.getAddress)(value);
-	if (!allowZero && address === ZERO_ADDRESS$3) throw new RangeError(`${label} must not be the zero address`);
-	return address;
-}
-function assertErc20Decimals(value, label) {
-	if (!Number.isSafeInteger(value) || value < 0 || value > MAX_ERC20_DECIMALS) throw new RangeError(`${label} must be an integer from 0 through 255`);
-}
-function assertPositiveFraction(value) {
-	if (typeof value?.numerator !== "bigint" || typeof value?.denominator !== "bigint") throw new TypeError("quotePerBase must contain bigint numerator and denominator values");
-	if (value.numerator <= 0n) throw new RangeError("quotePerBase numerator must be greater than zero");
-	if (value.denominator <= 0n) throw new RangeError("quotePerBase denominator must be greater than zero");
-}
-/**
-* Parses an unsigned, fixed-point decimal string without converting through a
-* JavaScript number. Signs, exponent notation, whitespace, and omitted whole
-* or fractional digits are rejected. The returned fraction is reduced.
-*/
-function parseExactDecimal(value) {
-	if (typeof value !== "string") throw new TypeError("Decimal value must be provided as a string");
-	const match = /^([0-9]+)(?:\.([0-9]+))?$/.exec(value);
-	if (match === null || match[0] !== value) throw new TypeError("Decimal value must use unsigned fixed-point notation, for example \"123.45\"");
-	const wholeDigits = match[1];
-	const fractionalDigits = match[2] ?? "";
-	const numerator = BigInt(`${wholeDigits}${fractionalDigits}`);
-	if (numerator === 0n) return {
-		numerator: 0n,
-		denominator: 1n
-	};
-	const denominator = 10n ** BigInt(fractionalDigits.length);
-	const divisor = greatestCommonDivisor(numerator, denominator);
-	return {
-		numerator: numerator / divisor,
-		denominator: denominator / divisor
-	};
-}
-/**
-* Validates, checksums, and sorts two distinct non-zero ERC20 addresses.
-*/
-function sortErc20Pair(tokenA, tokenB) {
-	const normalizedTokenA = checksumAddress(tokenA, "tokenA", false);
-	const normalizedTokenB = checksumAddress(tokenB, "tokenB", false);
-	if (normalizedTokenA === normalizedTokenB) throw new RangeError("ERC20 pair tokens must be different");
-	return BigInt(normalizedTokenA) < BigInt(normalizedTokenB) ? {
-		token0: normalizedTokenA,
-		token1: normalizedTokenB
-	} : {
-		token0: normalizedTokenB,
-		token1: normalizedTokenA
-	};
-}
-/**
-* Validates, checksums, and sorts two distinct EVM currencies. The zero
-* address is allowed and, when present, necessarily sorts as currency0.
-*/
-function sortEvmCurrencyPair(currencyA, currencyB) {
-	const normalizedCurrencyA = checksumAddress(currencyA, "currencyA", true);
-	const normalizedCurrencyB = checksumAddress(currencyB, "currencyB", true);
-	if (normalizedCurrencyA === normalizedCurrencyB) throw new RangeError("EVM pair currencies must be different");
-	return BigInt(normalizedCurrencyA) < BigInt(normalizedCurrencyB) ? {
-		currency0: normalizedCurrencyA,
-		currency1: normalizedCurrencyB
-	} : {
-		currency0: normalizedCurrencyB,
-		currency1: normalizedCurrencyA
-	};
-}
-/**
-* Returns floor(sqrt(value)) using bigint arithmetic only.
-*/
-function integerSqrt(value) {
-	if (typeof value !== "bigint") throw new TypeError("Square-root input must be a bigint");
-	if (value < 0n) throw new RangeError("Square-root input must not be negative");
-	if (value < 2n) return value;
-	let estimate = value;
-	let nextEstimate = estimate + 1n >> 1n;
-	while (nextEstimate < estimate) {
-		estimate = nextEstimate;
-		nextEstimate = estimate + value / estimate >> 1n;
-	}
-	return estimate;
-}
-/**
-* Enforces the Uniswap TickMath interval: MIN is inclusive and MAX exclusive.
-* Returns the input so it can be composed with transaction builders.
-*/
-function validateSqrtPriceX96(sqrtPriceX96) {
-	if (typeof sqrtPriceX96 !== "bigint") throw new TypeError("sqrtPriceX96 must be a bigint");
-	if (sqrtPriceX96 < 4295128739n || sqrtPriceX96 >= 1461446703485210103287273052203988822378723970342n) throw new RangeError(`sqrtPriceX96 must be in [${MIN_SQRT_RATIO}, ${MAX_SQRT_RATIO})`);
-	return sqrtPriceX96;
-}
-/**
-* Encode an exact raw token1/token0 amount ratio without token metadata.
-* The result matches the canonical V3 floor-rounding operation.
-*/
-function encodeSqrtRatioX96(amount1Raw, amount0Raw) {
-	if (typeof amount0Raw !== "bigint" || typeof amount1Raw !== "bigint") throw new TypeError("Raw ratio amounts must be bigint values");
-	if (amount0Raw <= 0n || amount1Raw <= 0n) throw new RangeError("Raw ratio amounts must be greater than zero");
-	return validateSqrtPriceX96(integerSqrt((amount1Raw << 192n) / amount0Raw));
-}
-/**
-* Converts an exact quote-per-base human price into the canonical raw-token
-* ratio and sqrtPriceX96 expected by concentrated-liquidity initializers.
-*
-* Address sorting and reciprocal orientation happen before the only lossy
-* operation. The final encoding is exactly:
-*
-*   floor(sqrt((amount1Raw << 192) / amount0Raw))
-*/
-function encodeInitialSqrtPriceX96(price) {
-	const pair = sortErc20Pair(price.baseToken, price.quoteToken);
-	const baseToken = checksumAddress(price.baseToken, "baseToken", false);
-	assertErc20Decimals(price.baseTokenDecimals, "baseTokenDecimals");
-	assertErc20Decimals(price.quoteTokenDecimals, "quoteTokenDecimals");
-	assertPositiveFraction(price.quotePerBase);
-	const baseScale = 10n ** BigInt(price.baseTokenDecimals);
-	const quoteScale = 10n ** BigInt(price.quoteTokenDecimals);
-	const baseTokenIsToken0 = baseToken === pair.token0;
-	const amount0Raw = baseTokenIsToken0 ? price.quotePerBase.denominator * baseScale : price.quotePerBase.numerator * quoteScale;
-	const amount1Raw = baseTokenIsToken0 ? price.quotePerBase.numerator * quoteScale : price.quotePerBase.denominator * baseScale;
-	const sqrtPriceX96 = encodeSqrtRatioX96(amount1Raw, amount0Raw);
-	return {
-		...pair,
-		amount0Raw,
-		amount1Raw,
-		sqrtPriceX96,
-		baseTokenIsToken0
-	};
-}
-/**
-* Currency-aware counterpart to {@link encodeInitialSqrtPriceX96}. It keeps
-* the same exact orientation and floor-rounding rules while permitting the
-* native zero-address currency required by Uniswap V4.
-*/
-function encodeCurrencyInitialSqrtPriceX96(price) {
-	const pair = sortEvmCurrencyPair(price.baseCurrency, price.quoteCurrency);
-	const baseCurrency = checksumAddress(price.baseCurrency, "baseCurrency", true);
-	assertErc20Decimals(price.baseCurrencyDecimals, "baseCurrencyDecimals");
-	assertErc20Decimals(price.quoteCurrencyDecimals, "quoteCurrencyDecimals");
-	assertPositiveFraction(price.quotePerBase);
-	const baseScale = 10n ** BigInt(price.baseCurrencyDecimals);
-	const quoteScale = 10n ** BigInt(price.quoteCurrencyDecimals);
-	const baseCurrencyIsCurrency0 = baseCurrency === pair.currency0;
-	const amount0Raw = baseCurrencyIsCurrency0 ? price.quotePerBase.denominator * baseScale : price.quotePerBase.numerator * quoteScale;
-	const amount1Raw = baseCurrencyIsCurrency0 ? price.quotePerBase.numerator * quoteScale : price.quotePerBase.denominator * baseScale;
-	return {
-		...pair,
-		amount0Raw,
-		amount1Raw,
-		sqrtPriceX96: encodeSqrtRatioX96(amount1Raw, amount0Raw),
-		baseCurrencyIsCurrency0
-	};
-}
-//#endregion
-//#region src/pool-lifecycle/v4/key.ts
-const V4_DYNAMIC_FEE_FLAG = 8388608;
-const V4_MAX_STATIC_FEE = 1e6;
-const V4_MAX_TICK_SPACING = 32767;
-const V4_ALL_HOOK_MASK = (1n << 14n) - 1n;
-const V4_ZERO_ADDRESS = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
-const BEFORE_SWAP_FLAG = 1n << 7n;
-const AFTER_SWAP_FLAG = 1n << 6n;
-const AFTER_ADD_LIQUIDITY_FLAG = 1n << 10n;
-const AFTER_REMOVE_LIQUIDITY_FLAG = 1n << 8n;
-const BEFORE_SWAP_RETURNS_DELTA_FLAG = 1n << 3n;
-const AFTER_SWAP_RETURNS_DELTA_FLAG = 1n << 2n;
-const AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG = 1n << 1n;
-const AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG = 1n;
-const POOL_KEY_ABI_PARAMETER = {
-	type: "tuple",
-	components: [
-		{
-			name: "currency0",
-			type: "address"
-		},
-		{
-			name: "currency1",
-			type: "address"
-		},
-		{
-			name: "fee",
-			type: "uint24"
-		},
-		{
-			name: "tickSpacing",
-			type: "int24"
-		},
-		{
-			name: "hooks",
-			type: "address"
-		}
-	]
-};
-function invalidInput(message, cause) {
-	throw new PoolLifecycleError("INVALID_INPUT", message, cause);
-}
-function normalizeAddress(value, label) {
-	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) return invalidInput(`${label} must be a valid EVM address.`);
-	return (0, viem.getAddress)(value);
-}
-function validateFee(fee) {
-	if (!Number.isSafeInteger(fee) || Number(fee) < 0 || Number(fee) > 1e6 && Number(fee) !== 8388608) return invalidInput("V4 fee must be an integer from 0 through 1000000 or the dynamic fee flag 0x800000.");
-	return Number(fee);
-}
-function validateTickSpacing(tickSpacing) {
-	if (!Number.isSafeInteger(tickSpacing) || Number(tickSpacing) < 1 || Number(tickSpacing) > 32767) return invalidInput("V4 tickSpacing must be an integer from 1 through 32767.");
-	return Number(tickSpacing);
-}
-function validateHookAddress(hooksAddress, fee) {
-	const hooks = BigInt(hooksAddress);
-	const hasFlag = (flag) => (hooks & flag) !== 0n;
-	if (!hasFlag(BEFORE_SWAP_FLAG) && hasFlag(BEFORE_SWAP_RETURNS_DELTA_FLAG) || !hasFlag(AFTER_SWAP_FLAG) && hasFlag(AFTER_SWAP_RETURNS_DELTA_FLAG) || !hasFlag(AFTER_ADD_LIQUIDITY_FLAG) && hasFlag(AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG) || !hasFlag(AFTER_REMOVE_LIQUIDITY_FLAG) && hasFlag(AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG)) invalidInput("V4 hook return-delta flags require their corresponding action flags.");
-	const dynamicFee = fee === V4_DYNAMIC_FEE_FLAG;
-	if (!(hooks === 0n ? !dynamicFee : (hooks & V4_ALL_HOOK_MASK) !== 0n || dynamicFee)) invalidInput("V4 hooks address is incompatible with its fee and permission flags.");
-}
-/** Validate a complete PoolKey whose currencies are already canonically ordered. */
-function validateV4PoolKey(value) {
-	const currency0 = normalizeAddress(value?.currency0, "currency0");
-	const currency1 = normalizeAddress(value?.currency1, "currency1");
-	const fee = validateFee(value?.fee);
-	const tickSpacing = validateTickSpacing(value?.tickSpacing);
-	const hooks = normalizeAddress(value?.hooks, "hooks");
-	if (BigInt(currency0) >= BigInt(currency1)) invalidInput("V4 currencies must be distinct and canonically ordered.");
-	validateHookAddress(hooks, fee);
-	return {
-		currency0,
-		currency1,
-		fee,
-		tickSpacing,
-		hooks
-	};
-}
-/**
-* Validate and sort two currencies. Address zero is deliberately accepted and
-* sorts first because V4 represents the native currency as address(0).
-*/
-function canonicalizeV4PoolKey(value) {
-	const currencyA = normalizeAddress(value?.currencyA, "currencyA");
-	const currencyB = normalizeAddress(value?.currencyB, "currencyB");
-	if (currencyA === currencyB) return invalidInput("V4 pool currencies must be different.");
-	const [currency0, currency1] = BigInt(currencyA) < BigInt(currencyB) ? [currencyA, currencyB] : [currencyB, currencyA];
-	return validateV4PoolKey({
-		currency0,
-		currency1,
-		fee: value?.fee,
-		tickSpacing: value?.tickSpacing,
-		hooks: value?.hooks
-	});
-}
-/** Return the exact PoolId used by PoolIdLibrary.toId. */
-function getV4PoolId(key) {
-	const validated = validateV4PoolKey(key);
-	return (0, viem.keccak256)((0, viem.encodeAbiParameters)([POOL_KEY_ABI_PARAMETER], [validated]));
-}
-function v4PoolKeysEqual(left, right) {
-	try {
-		const a = validateV4PoolKey(left);
-		const b = validateV4PoolKey(right);
-		return a.currency0 === b.currency0 && a.currency1 === b.currency1 && a.fee === b.fee && a.tickSpacing === b.tickSpacing && a.hooks === b.hooks;
-	} catch {
-		return false;
-	}
-}
-/** Validate price bounds and bind the price to the canonical PoolKey order. */
-function assertV4InitialPrice(key, value) {
-	const currency0 = normalizeAddress(value?.currency0, "initialPrice.currency0");
-	const currency1 = normalizeAddress(value?.currency1, "initialPrice.currency1");
-	if (currency0 !== key.currency0 || currency1 !== key.currency1) return invalidInput("V4 initial price currencies must match the canonical PoolKey order.");
-	try {
-		return {
-			currency0,
-			currency1,
-			sqrtPriceX96: validateSqrtPriceX96(value?.sqrtPriceX96)
-		};
-	} catch (error) {
-		return invalidInput(error instanceof Error ? error.message : "V4 sqrtPriceX96 is invalid.", error);
-	}
-}
-//#endregion
 //#region src/base/vault/execution-context.ts
 const VAULT_REGISTRY_ABI = (0, viem.parseAbi)(["function getVaultDetails(address vault) view returns ((uint8 state,uint256 tokenId,uint256 vaultID,string payloadIpfs,address vaultAddress,string beaconName) details)", "function beaconAddresses(string beaconName) view returns (address)"]);
 const VAULT_EXECUTION_ABI = (0, viem.parseAbi)([
@@ -23013,7 +23074,6 @@ var PoolClient = class extends SubgraphClient {
 				return data.data;
 			};
 			this.apiCallCount++;
-			console.log("Total API calls:", this.apiCallCount);
 			const timeoutPromise = new Promise((_, reject) => {
 				setTimeout(() => reject(/* @__PURE__ */ new Error("GraphQL query timeout")), this.defaultTimeout);
 			});
@@ -29082,6 +29142,8 @@ exports.getNFTManagerAddress = getNFTManagerAddress;
 exports.getNetworkByChainId = getNetworkByChainId;
 exports.getPoolHelperByChainId = getPoolHelperByChainId;
 exports.getPoolSlot0 = getPoolSlot0;
+exports.getPoolState = getPoolState;
+exports.getPoolStateWithPrice = getPoolStateWithPrice;
 exports.getProtcolTypeByAmmType = getProtcolTypeByAmmType;
 exports.getProtocolBySubgraph = getProtocolBySubgraph;
 exports.getProtocolConfigByBeacon = getProtocolConfigByBeacon;