@steerprotocol/sdk 3.3.1 → 3.4.0

package/dist/index.cjs

@@ -8911,7 +8911,7 @@ const networks = {
 		...bittensorAddresses
 	},
 	[Chain.Robinhood]: {
-		address: "0x0000000000000000000000000000000000000000",
+		address: "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
 		name: Chain.Robinhood,
 		wrappedNativeToken: "WETH",
 		isWrappingEnabled: false,
@@ -14458,7 +14458,10 @@ const pancakeSwapConfig = (theGraphApiKey) => ({
 		[Chain.Arbitrum]: "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865"
 	},
 	swapRouterAddress: { [Chain.BSC]: "0x13f4EA83D0bd40E75C8222255bc855a974568Dd4" },
-	NFTManagerAddress: { [Chain.BSC]: "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364" },
+	NFTManagerAddress: {
+		[Chain.BSC]: "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364",
+		[Chain.Arbitrum]: "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364"
+	},
 	TickLensAddress: {
 		[Chain.BSC]: "0x9a489505a00cE272eAa5e07Dba6491314CaE3796",
 		[Chain.Arbitrum]: "0x9a489505a00cE272eAa5e07Dba6491314CaE3796"
@@ -14655,7 +14658,24 @@ const sushiConfig = (theGraphApiKey) => ({
 		[Chain.Robinhood]: "0xe51960f1b45f1c9fb6d166e6a884f866fc70433b",
 		[Chain.Mainnet]: "0xbaceb8ec6b9355dfc0269c18bac9d6e2bdc29c4f"
 	},
-	NFTManagerAddress: { [Chain.Robinhood]: "0x51d0e5188afe12d502e29d982d20c190e7816107" },
+	NFTManagerAddress: {
+		[Chain.Polygon]: "0xb7402ee99f0a008e461098ac3a27f4957df89a40",
+		[Chain.Arbitrum]: "0xf0cbce1942a68beb3d1b73f0dd86c8dcc363ef49",
+		[Chain.Optimism]: "0x1af415a1eba07a4986a52b6f2e7de7003d82231e",
+		[Chain.BSC]: "0xf70c086618dcf2b1a461311275e00d6b722ef914",
+		[Chain.Avalanche]: "0x18350b048ab366ed601ffdbc669110ecb36016f3",
+		[Chain.Thundercore]: "0xf4d73326c13a4fc5fd7a064217e12780e9bd62c3",
+		[Chain.PolygonzkEVM]: "0xf4d73326c13a4fc5fd7a064217e12780e9bd62c3",
+		[Chain.Base]: "0x80c7dd17b01855a6d2347444a0fcc36136a314de",
+		[Chain.Linea]: "0x80c7dd17b01855a6d2347444a0fcc36136a314de",
+		[Chain.Blast]: "0x51edb3e5bce8618b77b60215f84ad3db14709051",
+		[Chain.Rootstock]: "0x0389879e0156033202c44bf784ac18fc02edee4f",
+		[Chain.Filecoin]: "0xf4d73326c13a4fc5fd7a064217e12780e9bd62c3",
+		[Chain.Hemi]: "0xe43ca1dee3f0fc1e2df73a0745674545f11a59f5",
+		[Chain.Katana]: "0x2659c6085d26144117d904c46b48b6d180393d27",
+		[Chain.Robinhood]: "0x51d0e5188afe12d502e29d982d20c190e7816107",
+		[Chain.Mainnet]: "0x2214a42d8e2a1d20635c2cb0664422c528b6a432"
+	},
 	TickLensAddress: {
 		[Chain.Polygon]: "0x9fdeA1412e50D78B25aCE4f96d35801647Fdf7dA",
 		[Chain.Arbitrum]: "0x8516944E89f296eb6473d79aED1Ba12088016c9e",
@@ -14680,8 +14700,22 @@ const sushiConfig = (theGraphApiKey) => ({
 		[Chain.Linea]: "0xc14Ee6B248787847527e11b8d7Cf257b212f7a9F"
 	},
 	initCodeHash: {
+		[Chain.Polygon]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Arbitrum]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Optimism]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.BSC]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Avalanche]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Thundercore]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.PolygonzkEVM]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Base]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Linea]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
 		[Chain.Blast]: "0x8e13daee7f5a62e37e71bf852bcd44e7d16b90617ed2b17c24c2ee62411c5bae",
-		[Chain.Robinhood]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54"
+		[Chain.Rootstock]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Filecoin]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Hemi]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Katana]: "0xe040f12c7cee3904b78f24f8fc395629c2e69525c2815da7a659f7483e378ecb",
+		[Chain.Robinhood]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54",
+		[Chain.Mainnet]: "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54"
 	},
 	QuoterV2Address: {
 		[Chain.Polygon]: "0xb1E835Dc2785b52265711e17fCCb0fd018226a6e",
@@ -14773,7 +14807,8 @@ const uniswapConfig = (theGraphApiKey) => ({
 		[Chain.Arbitrum]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
 		[Chain.BSC]: "0x7b8A01B39D58278b5DE7e48c8449c9f4F5170613",
 		[Chain.Celo]: "0x3d79EdAaBC0EaB6F08ED885C05Fc0B014290D95A",
-		[Chain.Base]: "0x4f225937EDc33EFD6109c4ceF7b560B2D6401009",
+		[Chain.Rootstock]: "0x9d9386c042F194B460Ec424a1e57ACDE25f5C4b1",
+		[Chain.Base]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
 		[Chain.Filecoin]: "0x4cd986dD509fbB6A695aE971d5C56c8795f640ee",
 		[Chain.Sonic]: "0x743E03cceB4af2efA3CC76838f6E8B50B63F184c",
 		[Chain.Unichain]: "0x943e6e07a7e8e791dafc44083e54041d743c46e9",
@@ -15119,6 +15154,7 @@ const uniswapV4Config = (theGraphApiKey) => ({
 		[Chain.Robinhood]: "0x9639443158e8c5efa35bd45287bf2effd3d8dc06"
 	},
 	PositionManager: {
+		[Chain.Unichain]: "0x4529A01c7A0410167c5740C487A8DE60232617bf",
 		[Chain.BSC]: "0x7a4a5c919ae2541aed11041a1aeee68f1287f95b",
 		[Chain.Base]: "0x7c5f5a4bbd8fd63184577525326123b519429bdc",
 		[Chain.Arbitrum]: "0xd88f38f930b7952f2db2432cb002e7abbf3dd869",
@@ -19647,6 +19683,320 @@ 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)([
@@ -19684,19 +20034,6 @@ const ALGEBRA_DIRECTIONAL_POOL_ABI = (0, viem.parseAbi)([
 	"function globalState() view returns (uint160 price,int24 tick,uint16 feeZto,uint16 feeOtz,uint16 timepointIndex,uint8 communityFeeToken0,uint8 communityFeeToken1,bool unlocked)",
 	"function tickSpacing() view returns (int24)"
 ]);
-const STATE_VIEW_ABI = (0, viem.parseAbi)(["function getSlot0(bytes32 poolId) view returns (uint160 sqrtPriceX96,int24 tick,uint24 protocolFee,uint24 lpFee)"]);
-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_BEFORE_SWAP_FLAG = 1n << 7n;
-const V4_AFTER_SWAP_FLAG = 1n << 6n;
-const V4_AFTER_ADD_LIQUIDITY_FLAG = 1n << 10n;
-const V4_AFTER_REMOVE_LIQUIDITY_FLAG = 1n << 8n;
-const V4_BEFORE_SWAP_RETURNS_DELTA_FLAG = 1n << 3n;
-const V4_AFTER_SWAP_RETURNS_DELTA_FLAG = 1n << 2n;
-const V4_AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG = 1n << 1n;
-const V4_AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG = 1n;
 var ExecutionContextError = class extends Error {
 	constructor(status, message) {
 		super(message);
@@ -19713,23 +20050,11 @@ function resolvePoolFamily(protocol) {
 	return "uniswap-v3-compatible";
 }
 function assertPoolKey(poolKey, invalidStatus = 400) {
-	if (!(0, viem.isAddress)(poolKey.currency0) || !(0, viem.isAddress)(poolKey.currency1) || !(0, viem.isAddress)(poolKey.hooks)) throw new ExecutionContextError(invalidStatus, "Uniswap v4 poolKey contains an invalid address.");
-	if (!Number.isInteger(poolKey.fee) || poolKey.fee < 0 || poolKey.fee > V4_MAX_STATIC_FEE && poolKey.fee !== V4_DYNAMIC_FEE_FLAG) throw new ExecutionContextError(invalidStatus, "Uniswap v4 poolKey fee must be at most 1000000 or the dynamic fee flag 0x800000.");
-	if (!Number.isInteger(poolKey.tickSpacing) || poolKey.tickSpacing <= 0 || poolKey.tickSpacing > V4_MAX_TICK_SPACING) throw new ExecutionContextError(invalidStatus, "Uniswap v4 poolKey tickSpacing must be between 1 and 32767.");
-	const normalized = {
-		currency0: (0, viem.getAddress)(poolKey.currency0),
-		currency1: (0, viem.getAddress)(poolKey.currency1),
-		fee: poolKey.fee,
-		tickSpacing: poolKey.tickSpacing,
-		hooks: (0, viem.getAddress)(poolKey.hooks)
-	};
-	if (BigInt(normalized.currency0) >= BigInt(normalized.currency1)) throw new ExecutionContextError(invalidStatus, "Uniswap v4 poolKey currencies are not canonically ordered.");
-	const hooks = BigInt(normalized.hooks);
-	const isDynamicFee = normalized.fee === V4_DYNAMIC_FEE_FLAG;
-	const hasFlag = (flag) => (hooks & flag) !== 0n;
-	if (!hasFlag(V4_BEFORE_SWAP_FLAG) && hasFlag(V4_BEFORE_SWAP_RETURNS_DELTA_FLAG) || !hasFlag(V4_AFTER_SWAP_FLAG) && hasFlag(V4_AFTER_SWAP_RETURNS_DELTA_FLAG) || !hasFlag(V4_AFTER_ADD_LIQUIDITY_FLAG) && hasFlag(V4_AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG) || !hasFlag(V4_AFTER_REMOVE_LIQUIDITY_FLAG) && hasFlag(V4_AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG)) throw new ExecutionContextError(invalidStatus, "Uniswap v4 poolKey hook return-delta flags require their corresponding action flags.");
-	if (!(hooks === 0n ? !isDynamicFee : (hooks & V4_ALL_HOOK_MASK) !== 0n || isDynamicFee)) throw new ExecutionContextError(invalidStatus, "Uniswap v4 poolKey hook address is incompatible with its fee and permission flags.");
-	return normalized;
+	try {
+		return validateV4PoolKey(poolKey);
+	} catch (error) {
+		throw new ExecutionContextError(invalidStatus, error instanceof Error ? error.message : "Uniswap v4 poolKey is invalid.");
+	}
 }
 function normalizeRawPoolKey(raw) {
 	return assertPoolKey({
@@ -19741,34 +20066,10 @@ function normalizeRawPoolKey(raw) {
 	}, 422);
 }
 function poolKeysEqual(a, b) {
-	return (0, viem.getAddress)(a.currency0) === (0, viem.getAddress)(b.currency0) && (0, viem.getAddress)(a.currency1) === (0, viem.getAddress)(b.currency1) && a.fee === b.fee && a.tickSpacing === b.tickSpacing && (0, viem.getAddress)(a.hooks) === (0, viem.getAddress)(b.hooks);
+	return v4PoolKeysEqual(a, b);
 }
 function getPoolId(poolKey) {
-	return (0, viem.keccak256)((0, viem.encodeAbiParameters)([{
-		type: "tuple",
-		components: [
-			{
-				name: "currency0",
-				type: "address"
-			},
-			{
-				name: "currency1",
-				type: "address"
-			},
-			{
-				name: "fee",
-				type: "uint24"
-			},
-			{
-				name: "tickSpacing",
-				type: "int24"
-			},
-			{
-				name: "hooks",
-				type: "address"
-			}
-		]
-	}], [poolKey]));
+	return getV4PoolId(poolKey);
 }
 function normalizePositions(raw) {
 	const [lowerTicks, upperTicks, relativeWeights] = raw;
@@ -19911,13 +20212,19 @@ async function getVaultExecutionContext(params) {
 			const stateView = v4Config?.StateView?.[chain];
 			if (!poolManager || !stateView || !(0, viem.isAddress)(poolManager) || !(0, viem.isAddress)(stateView)) throw new ExecutionContextError(422, "Uniswap v4 PoolManager or StateView is missing from SDK config.");
 			poolManagerAddress = (0, viem.getAddress)(poolManager);
-			const slot0 = await publicClient.readContract({
+			const [stateViewPoolManager, slot0] = await Promise.all([publicClient.readContract({
+				address: (0, viem.getAddress)(stateView),
+				abi: v4StateViewAbi,
+				functionName: "poolManager",
+				blockNumber
+			}), publicClient.readContract({
 				address: (0, viem.getAddress)(stateView),
-				abi: STATE_VIEW_ABI,
+				abi: v4StateViewAbi,
 				functionName: "getSlot0",
 				args: [poolId],
 				blockNumber
-			});
+			})]);
+			if ((0, viem.getAddress)(stateViewPoolManager) !== poolManagerAddress) throw new ExecutionContextError(422, "Configured Uniswap v4 StateView is bound to a different PoolManager.");
 			if (slot0[0] === 0n) throw new ExecutionContextError(422, `Uniswap v4 pool ${poolId} is not initialized in the configured PoolManager.`);
 			currentTick = Number(slot0[1]);
 			tickSpacing = poolKey.tickSpacing;
@@ -22366,19 +22673,19 @@ const getPoolDetailsQuery = (isAlgebraPool, protocol) => {
 * 
 * @example
 * ```typescript
-* import { createPublicClient, createWalletClient, http } from 'viem';
+* import { createPublicClient, http } from 'viem';
 * import { mainnet } from 'viem/chains';
 * import { PoolClient } from '@steerprotocol/sdk';
 * 
 * const client = createPublicClient({
 *   chain: mainnet,
 *   transport: http()
-* }) as PublicClient & WalletClient;
+* });
 * 
 * const poolClient = new PoolClient(client, 'your-subgraph-studio-key');
 * 
 * // Fetch top pools
-* const topPools = await poolClient.getTopPools(100, Protocol.UniswapV3, 1);
+* const topPools = await poolClient.getTopPools(100, Protocol.Uniswap, 1);
 * ```
 * 
 * @extends SubgraphClient
@@ -22388,7 +22695,7 @@ var PoolClient = class extends SubgraphClient {
 	/**
 	* Creates a new PoolClient instance
 	* 
-	* @param client - Combined public and wallet client for blockchain interactions
+	* @param client - Public client for read-only blockchain interactions
 	* @param subgraphStudioKey - Optional Subgraph Studio API key for higher rate limits
 	* 
 	* @example
@@ -22544,7 +22851,7 @@ var PoolClient = class extends SubgraphClient {
 	* @example
 	* ```typescript
 	* // Get top 100 Uniswap V3 pools on Ethereum
-	* const topPools = await poolClient.getTopPools(100, Protocol.UniswapV3, 1);
+	* const topPools = await poolClient.getTopPools(100, Protocol.Uniswap, 1);
 	* if (topPools.success) {
 	*   console.log(`Found ${topPools.data.length} pools`);
 	* }
@@ -22593,7 +22900,7 @@ var PoolClient = class extends SubgraphClient {
 	* // Get specific pool details
 	* const poolDetails = await poolClient.getPoolById(
 	*   '0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640',
-	*   Protocol.UniswapV3,
+	*   Protocol.Uniswap,
 	*   1
 	* );
 	* if (poolDetails.success && poolDetails.data) {
@@ -22641,7 +22948,7 @@ var PoolClient = class extends SubgraphClient {
 	* ];
 	* const pools = await poolClient.fetchPoolsForTokensBatch(
 	*   tokenAddresses,
-	*   Protocol.UniswapV3,
+	*   Protocol.Uniswap,
 	*   1,
 	*   5
 	* );
@@ -22723,7 +23030,7 @@ var PoolClient = class extends SubgraphClient {
 	* // Get all USDC pools on Uniswap V3
 	* const usdcPools = await poolClient.fetchPoolsForToken(
 	*   '0xa0b86a33e6f8b07b71c3a39ef77a6b6e8f1b7b7e',
-	*   Protocol.UniswapV3,
+	*   Protocol.Uniswap,
 	*   1
 	* );
 	* if (usdcPools.success) {
@@ -23453,8 +23760,8 @@ var StakingClient = class extends SubgraphClient {
 * const summary = await steerClient.rewards.getRewardSummary(userAddress, chainId);
 * 
 * // Use pool data functionality
-* const topPools = await steerClient.pools.getTopPools(100, Protocol.UniswapV3, 1);
-* const poolDetails = await steerClient.pools.getPoolById(poolId, Protocol.UniswapV3, 1);
+* const topPools = await steerClient.pools.getTopPools(100, Protocol.Uniswap, 1);
+* const poolDetails = await steerClient.pools.getPoolById(poolId, Protocol.Uniswap, 1);
 * 
 * // Use staking functionality
 * const stakingPools = await steerClient.staking.getStakingPools(1);
@@ -23493,10 +23800,7 @@ var SteerClient = class extends SubgraphClient {
 			...publicClient,
 			...walletClient
 		} : publicClient);
-		this.pools = new PoolClient(walletClient ? {
-			...publicClient,
-			...walletClient
-		} : publicClient, subgraphStudioKey);
+		this.pools = new PoolClient(publicClient, subgraphStudioKey);
 		if (walletClient) this.rewards = new SmartRewardsClient(publicClient, walletClient, this.environment === "production" ? "production" : "development");
 		else this.rewards = new SmartRewardsClient(publicClient, publicClient, this.environment === "production" ? "production" : "development");
 	}
@@ -24048,6 +24352,3623 @@ var FeeManagerClient = class extends SubgraphClient {
 	}
 };
 //#endregion
+//#region src/pool-lifecycle/types.ts
+const PREPARED_POOL_ACTION_SERIALIZATION_VERSION = 1;
+const BIGINT_TAG = "__steer_pool_lifecycle_bigint__";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Serialize a prepared action in a versioned JSON envelope. Bigints use an
+* explicit tag so ordinary decimal strings remain distinguishable on decode.
+*/
+function serializePreparedPoolAction(action, space = 2) {
+	if (!isRecord(action) || action.schemaVersion !== 1 || typeof action.kind !== "string") throw new TypeError("Prepared pool action must be a schema-version-1 object");
+	return JSON.stringify({
+		serializationVersion: 1,
+		action
+	}, (_key, value) => {
+		if (typeof value === "bigint") return { [BIGINT_TAG]: value.toString() };
+		if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") throw new TypeError("Prepared pool action contains a non-JSON value");
+		if (typeof value === "number" && !Number.isFinite(value)) throw new TypeError("Prepared pool action contains a non-finite number");
+		return value;
+	}, space);
+}
+/** Parse a versioned serialized action; protocol adapters must validate its shape. */
+function deserializePreparedPoolAction(serialized) {
+	if (typeof serialized !== "string") throw new TypeError("Serialized prepared pool action must be a string");
+	const envelope = JSON.parse(serialized, (_key, value) => {
+		if (isRecord(value) && Object.keys(value).length === 1 && BIGINT_TAG in value) {
+			const encoded = value[BIGINT_TAG];
+			if (typeof encoded !== "string" || !/^-?(0|[1-9][0-9]*)$/.test(encoded)) throw new TypeError("Serialized prepared pool action contains an invalid bigint");
+			return BigInt(encoded);
+		}
+		return value;
+	});
+	if (!isRecord(envelope) || envelope.serializationVersion !== 1 || !isRecord(envelope.action)) throw new TypeError("Serialized prepared pool action envelope is invalid or unsupported");
+	return envelope.action;
+}
+//#endregion
+//#region src/pool-lifecycle/capabilities/registry.ts
+/** Build a frozen string-keyed index and fail closed on every duplicate key. */
+function buildCheckedRegistry(values, keyOf, duplicateLabel) {
+	const registry = Object.create(null);
+	for (const value of values) {
+		const key = keyOf(value);
+		if (Object.prototype.hasOwnProperty.call(registry, key)) throw new Error(`Duplicate ${duplicateLabel}: ${key}`);
+		registry[key] = value;
+	}
+	return Object.freeze(registry);
+}
+//#endregion
+//#region src/pool-lifecycle/capabilities/algebra.ts
+const SDK_CONFIG_URL = "https://github.com/SteerProtocol/sdk/tree/2dfaa0ee00bb80be684206f73e67b8d35f8ce9ff/src/const/amm/configs/protocols";
+function provenance$1(...urls) {
+	return Object.freeze({
+		source: "sdk-config",
+		urls: Object.freeze(urls)
+	});
+}
+const PROVENANCE_BY_VARIANT = Object.freeze({
+	legacy: provenance$1(SDK_CONFIG_URL, "https://github.com/cryptoalgebra/Algebra/blob/11fff534a351d92b816f81953d0ad70de4ef35e9/src/core/contracts/interfaces/IAlgebraFactory.sol"),
+	directional: provenance$1(SDK_CONFIG_URL, "https://github.com/cryptoalgebra/Algebra/blob/ab8ea842204839802524f762b751ef835eb79ec3/src/core/contracts/interfaces/IAlgebraFactory.sol", "https://github.com/cryptoalgebra/Algebra/blob/ab8ea842204839802524f762b751ef835eb79ec3/src/core/contracts/interfaces/pool/IAlgebraPoolState.sol"),
+	"integral-v1": provenance$1(SDK_CONFIG_URL, "https://github.com/cryptoalgebra/Algebra/blob/3eae63f432a889fca5b000e9bd61078c6f923995/src/core/contracts/interfaces/IAlgebraFactory.sol"),
+	"integral-v2": provenance$1(SDK_CONFIG_URL, "https://github.com/cryptoalgebra/Algebra/blob/62f01348af24b96d7d16f6b56fbaa61e512ba1c5/src/core/contracts/interfaces/IAlgebraFactory.sol", "https://github.com/cryptoalgebra/Algebra/blob/62f01348af24b96d7d16f6b56fbaa61e512ba1c5/src/periphery/contracts/interfaces/IAlgebraCustomPoolEntryPoint.sol")
+});
+function deployment$1(input) {
+	const shape = input.variant === "directional" ? {
+		adapter: "algebra-directional-pair-v1",
+		version: 1,
+		createPool: "pair",
+		state: "directional-global-state"
+	} : input.variant === "integral-v1" ? {
+		adapter: "algebra-integral-pair-v1",
+		version: 1,
+		createPool: "pair",
+		state: "integral-global-state"
+	} : input.variant === "integral-v2" ? {
+		adapter: "algebra-integral-plugin-data-v2",
+		version: 2,
+		createPool: "pair-with-plugin-data",
+		state: "integral-global-state"
+	} : {
+		adapter: "algebra-legacy-pair-v1",
+		version: 1,
+		createPool: "pair",
+		state: "legacy-global-state"
+	};
+	return Object.freeze({
+		supported: true,
+		schemaVersion: 1,
+		family: "algebra",
+		chainId: input.chainId,
+		protocol: input.protocol,
+		variant: input.variant,
+		...shape,
+		factory: (0, viem.getAddress)(input.factory),
+		...input.customPoolEntryPoint ? { customPoolEntryPoint: (0, viem.getAddress)(input.customPoolEntryPoint) } : {},
+		customPoolCreation: input.customPoolEntryPoint ? "adapter-specific-deployer-required" : "not-configured",
+		provenance: PROVENANCE_BY_VARIANT[input.variant]
+	});
+}
+/**
+* Explicit lifecycle capabilities for every Algebra-family protocol/chain pair
+* currently present in the SDK AMM registry. Subgraph presence is never used as
+* a runtime fallback.
+*/
+const ALGEBRA_LIFECYCLE_DEPLOYMENTS = Object.freeze([
+	deployment$1({
+		chainId: ChainId.Polygon,
+		protocol: Protocol.QuickSwap,
+		variant: "legacy",
+		factory: "0x411b0fAcC3489691f28ad58c47006AF5E3Ab3A28"
+	}),
+	deployment$1({
+		chainId: ChainId.PolygonzkEVM,
+		protocol: Protocol.QuickSwap,
+		variant: "legacy",
+		factory: "0x4B9f4d2435Ef65559567e5DbFC1BbB37abC43B57"
+	}),
+	deployment$1({
+		chainId: ChainId.Zircuit,
+		protocol: Protocol.Ocelex,
+		variant: "legacy",
+		factory: "0x03057ae6294292b299a1863420edD65e0197AFEf"
+	}),
+	deployment$1({
+		chainId: ChainId.Arbitrum,
+		protocol: Protocol.Camelot,
+		variant: "directional",
+		factory: "0x1a3c9B1d2F0529D97f2afC5136Cc23e58f1FD35B"
+	}),
+	deployment$1({
+		chainId: ChainId.Apechain,
+		protocol: Protocol.Camelot,
+		variant: "directional",
+		factory: "0x1a3c9B1d2F0529D97f2afC5136Cc23e58f1FD35B"
+	}),
+	deployment$1({
+		chainId: ChainId.Linea,
+		protocol: Protocol.Lynex,
+		variant: "legacy",
+		factory: "0x622b2c98123D303ae067DB4925CD6282B3A08D0F"
+	}),
+	deployment$1({
+		chainId: ChainId.BSC,
+		protocol: Protocol.Thena,
+		variant: "legacy",
+		factory: "0x306F06C147f064A010530292A1EB6737c3e378e4"
+	}),
+	deployment$1({
+		chainId: ChainId.Metis,
+		protocol: Protocol.Hercules,
+		variant: "directional",
+		factory: "0xC5BfA92f27dF36d268422EE314a1387bB5ffB06A"
+	}),
+	deployment$1({
+		chainId: ChainId.XLayer,
+		protocol: Protocol.QuickSwapAlgebra,
+		variant: "legacy",
+		factory: "0xd2480162Aa7F02Ead7BF4C127465446150D58452"
+	}),
+	deployment$1({
+		chainId: ChainId.Moonbeam,
+		protocol: Protocol.StellaSwap,
+		variant: "legacy",
+		factory: "0xabE1655110112D0E45EF91e94f8d757e4ddBA59C"
+	}),
+	deployment$1({
+		chainId: ChainId.Mode,
+		protocol: Protocol.Kim,
+		variant: "integral-v1",
+		factory: "0xB5F00c2C5f8821155D8ed27E31932CFD9DB3C5D5"
+	}),
+	deployment$1({
+		chainId: ChainId.Base,
+		protocol: Protocol.Kim,
+		variant: "integral-v1",
+		factory: "0x2F0d41f94d5D1550b79A83D2fe85C82d68c5a3ca"
+	}),
+	deployment$1({
+		chainId: ChainId.Telos,
+		protocol: Protocol.Swapsicle,
+		variant: "integral-v1",
+		factory: "0xA09BAbf9A48003ae9b9333966a8Bda94d820D0d9"
+	}),
+	deployment$1({
+		chainId: ChainId.Blast,
+		protocol: Protocol.Fenix,
+		variant: "integral-v1",
+		factory: "0x7a44CD060afC1B6F4c80A2B9b37f4473E74E25Df"
+	}),
+	deployment$1({
+		chainId: ChainId.Taiko,
+		protocol: Protocol.Henjin,
+		variant: "integral-v1",
+		factory: "0x42B08e7a9211482d3643a126a7dF1895448d3509",
+		customPoolEntryPoint: "0x441013A52DDedc8D02eB9B90F7A555F6848188b5"
+	}),
+	deployment$1({
+		chainId: ChainId.Sonic,
+		protocol: Protocol.SilverSwap,
+		variant: "integral-v1",
+		factory: "0xb860200BD68dc39cEAfd6ebb82883f189f4CdA76"
+	}),
+	deployment$1({
+		chainId: ChainId.Nibiru,
+		protocol: Protocol.SilverSwap,
+		variant: "integral-v1",
+		factory: "0xb860200BD68dc39cEAfd6ebb82883f189f4CdA76"
+	}),
+	deployment$1({
+		chainId: ChainId.Zeta,
+		protocol: Protocol.Beam,
+		variant: "integral-v1",
+		factory: "0x28b5244B6CA7Cb07f2f7F40edE944c07C2395603"
+	}),
+	deployment$1({
+		chainId: ChainId.Core,
+		protocol: Protocol.Glyph,
+		variant: "integral-v1",
+		factory: "0x74EfE55beA4988e7D92D03EFd8ddB8BF8b7bD597"
+	}),
+	deployment$1({
+		chainId: ChainId.Hyperevm,
+		protocol: Protocol.Nest,
+		variant: "integral-v1",
+		factory: "0xF77Bd082c627aA54591cF2f2EaA811fd1AB3b1F3"
+	}),
+	deployment$1({
+		chainId: ChainId.Soneium,
+		protocol: Protocol.QuickSwapIntegral,
+		variant: "integral-v2",
+		factory: "0x8Ff309F68F6Caf77a78E9C20d2Af7Ed4bE2D7093"
+	}),
+	deployment$1({
+		chainId: ChainId.Base,
+		protocol: Protocol.QuickSwapIntegral,
+		variant: "integral-v2",
+		factory: "0xC5396866754799B9720125B104AE01d935Ab9C7b",
+		customPoolEntryPoint: "0xb9ce7698cE3dCf21cc88bf7dCc1fE20C85E4226E"
+	}),
+	deployment$1({
+		chainId: ChainId.Polygon,
+		protocol: Protocol.QuickSwapIntegral,
+		variant: "integral-v2",
+		factory: "0x134c1dBE4860A9cAaf89002574fFe814772D9904",
+		customPoolEntryPoint: "0xfcfE065bc131Fa8Bb31A227b2fF4F0EC47D3F1a2"
+	}),
+	deployment$1({
+		chainId: ChainId.Bera,
+		protocol: Protocol.Wasabee,
+		variant: "integral-v2",
+		factory: "0x7d53327D78EFD0b463bd8d7dc938C52402323b95"
+	}),
+	deployment$1({
+		chainId: ChainId.Ronin,
+		protocol: Protocol.KatanaIntegral,
+		variant: "integral-v2",
+		factory: "0x7ecaf729C6FFb04448aA89A722cA370724BF70De"
+	}),
+	deployment$1({
+		chainId: ChainId.Avalanche,
+		protocol: Protocol.Blackhole,
+		variant: "integral-v2",
+		factory: "0x512eb749541B7cf294be882D636218c84a5e9E5F"
+	}),
+	deployment$1({
+		chainId: ChainId.Mainnet,
+		protocol: Protocol.Cypher,
+		variant: "integral-v2",
+		factory: "0xfb8Ed3485EfA29a0e4bed93351dD51B59fC4b0f0",
+		customPoolEntryPoint: "0x79616564DB0294ecBa5912f1cE985FD1c11eeF51"
+	}),
+	deployment$1({
+		chainId: ChainId.Flare,
+		protocol: Protocol.SparkIntegral,
+		variant: "integral-v2",
+		factory: "0x805488DaA81c1b9e7C5cE3f1DCeA28F21448EC6A"
+	}),
+	deployment$1({
+		chainId: ChainId.Base,
+		protocol: Protocol.Hydrex,
+		variant: "integral-v2",
+		factory: "0x36077D39cdC65E1e3FB65810430E5b2c4D5fA29E"
+	})
+]);
+function key$1(chainId, protocol) {
+	return `${chainId}:${protocol}`;
+}
+const BY_KEY = buildCheckedRegistry(ALGEBRA_LIFECYCLE_DEPLOYMENTS, (item) => key$1(item.chainId, item.protocol), "Algebra lifecycle deployment");
+function resolveAlgebraLifecycleDeployment(params) {
+	return BY_KEY[key$1(params.chainId, params.protocol)];
+}
+/** Validate external capability metadata and return its canonical frozen entry. */
+function validateAlgebraLifecycleDeployment(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", "Algebra lifecycle deployment must be an object.");
+	const candidate = value;
+	if (!Number.isSafeInteger(candidate.chainId) || typeof candidate.protocol !== "string") throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", "Algebra lifecycle deployment chainId and protocol are invalid.");
+	const configured = resolveAlgebraLifecycleDeployment({
+		chainId: Number(candidate.chainId),
+		protocol: candidate.protocol
+	});
+	let matches = false;
+	try {
+		const candidateEntryPoint = candidate.customPoolEntryPoint ? (0, viem.getAddress)(candidate.customPoolEntryPoint) : void 0;
+		const configuredEntryPoint = configured?.customPoolEntryPoint;
+		matches = configured !== void 0 && candidate.supported === true && candidate.schemaVersion === configured.schemaVersion && candidate.family === configured.family && candidate.variant === configured.variant && candidate.adapter === configured.adapter && candidate.version === configured.version && (0, viem.getAddress)(candidate.factory) === configured.factory && candidate.createPool === configured.createPool && candidate.state === configured.state && candidateEntryPoint === configuredEntryPoint && candidate.customPoolCreation === configured.customPoolCreation;
+	} catch {}
+	if (!matches || !configured) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `Algebra lifecycle deployment is not configured for chain ${String(candidate.chainId)} and protocol ${String(candidate.protocol)}.`);
+	return configured;
+}
+//#endregion
+//#region src/pool-lifecycle/capabilities/v3.ts
+const STANDARD_V3_POOL_INIT_CODE_HASH = "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54";
+const SDK_CONFIG_ROOT = "https://github.com/SteerProtocol/sdk/blob/2dfaa0ee00bb80be684206f73e67b8d35f8ce9ff/src/const/amm/configs/protocols";
+const UNISWAP_DEPLOYMENTS = "https://developers.uniswap.org/docs/protocols/v3/deployments";
+const UNISWAP_GOVERNANCE_DEPLOYMENTS = "https://gov.uniswap.org/t/official-uniswap-v3-deployments-list/24323";
+const SUSHI_DEPLOYMENTS = "https://unpkg.com/sushi@6.5.1/_esm/evm/config/features/sushiswap-v3.js";
+const PANCAKE_DEPLOYMENTS = "https://developer.pancakeswap.finance/contracts/v3/addresses";
+function deploymentKey$2(chainId, protocol) {
+	return `${chainId}:${protocol}`;
+}
+function provenance(source, ...urls) {
+	return Object.freeze({
+		source,
+		urls: Object.freeze(urls)
+	});
+}
+function sdkConfigUrl(file) {
+	return `${SDK_CONFIG_ROOT}/${file}.ts`;
+}
+function atomic(params) {
+	return Object.freeze({
+		supported: true,
+		schemaVersion: 1,
+		family: "uniswap-v3-compatible",
+		adapter: "pool-initializer-v1",
+		version: 1,
+		atomicCreateAndInitialize: true,
+		...params,
+		factory: (0, viem.getAddress)(params.factory.toLowerCase()),
+		initializer: (0, viem.getAddress)(params.initializer.toLowerCase())
+	});
+}
+function factoryOnly(params) {
+	return Object.freeze({
+		supported: true,
+		schemaVersion: 1,
+		family: "uniswap-v3-compatible",
+		adapter: "v3-factory-v1",
+		version: 1,
+		atomicCreateAndInitialize: false,
+		initializer: null,
+		...params,
+		factory: (0, viem.getAddress)(params.factory.toLowerCase())
+	});
+}
+const uniswapProvenance = provenance("official-deployment", UNISWAP_DEPLOYMENTS, UNISWAP_GOVERNANCE_DEPLOYMENTS);
+const sushiProvenance = provenance("official-deployment", SUSHI_DEPLOYMENTS);
+const pancakeProvenance = provenance("official-deployment", PANCAKE_DEPLOYMENTS);
+/** Explicit, fail-closed V3 create/initialize deployment allowlist. */
+const V3_LIFECYCLE_DEPLOYMENTS = buildCheckedRegistry([
+	atomic({
+		chainId: ChainId.Mainnet,
+		protocol: Protocol.Uniswap,
+		factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+		initializer: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Polygon,
+		protocol: Protocol.Uniswap,
+		factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+		initializer: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Optimism,
+		protocol: Protocol.Uniswap,
+		factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+		initializer: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Arbitrum,
+		protocol: Protocol.Uniswap,
+		factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+		initializer: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.BSC,
+		protocol: Protocol.Uniswap,
+		factory: "0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7",
+		initializer: "0x7b8A01B39D58278b5DE7e48c8449c9f4F5170613",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Celo,
+		protocol: Protocol.Uniswap,
+		factory: "0xAfE208a311B21f13EF87E33A90049fC17A7acDEc",
+		initializer: "0x3d79EdAaBC0EaB6F08ED885C05Fc0B014290D95A",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Rootstock,
+		protocol: Protocol.Uniswap,
+		factory: "0xaF37EC98A00FD63689CF3060BF3B6784E00caD82",
+		initializer: "0x9d9386c042F194B460Ec424a1e57ACDE25f5C4b1",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Base,
+		protocol: Protocol.Uniswap,
+		factory: "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
+		initializer: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Filecoin,
+		protocol: Protocol.Uniswap,
+		factory: "0xB4C47eD546Fc31E26470a186eC2C5F19eF09BA41",
+		initializer: "0x4cd986dD509fbB6A695aE971d5C56c8795f640ee",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Sonic,
+		protocol: Protocol.Uniswap,
+		factory: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D",
+		initializer: "0x743E03cceB4af2efA3CC76838f6E8B50B63F184c",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Unichain,
+		protocol: Protocol.Uniswap,
+		factory: "0x1f98400000000000000000000000000000000003",
+		initializer: "0x943e6e07a7e8e791dafc44083e54041d743c46e9",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Telos,
+		protocol: Protocol.Uniswap,
+		factory: "0xcb2436774C3e191c85056d248EF4260ce5f27A9D",
+		initializer: "0x743E03cceB4af2efA3CC76838f6E8B50B63F184c",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Saga,
+		protocol: Protocol.Uniswap,
+		factory: "0x454050C4c9190390981Ac4b8d5AFcd7aC65eEffa",
+		initializer: "0xdD489C75be1039ec7d843A6aC2Fd658350B067Cf",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Nibiru,
+		protocol: Protocol.Uniswap,
+		factory: "0x346239972d1fa486FC4a521031BC81bFB7D6e8a4",
+		initializer: "0xEFdE184f4b5d79f7c3b7Efc0388d829ff9af0050",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Robinhood,
+		protocol: Protocol.Uniswap,
+		factory: "0x1f7d7550b1b028f7571e69a784071f0205fd2efa",
+		initializer: "0x73991a25c818bf1f1128deaab1492d45638de0d3",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: uniswapProvenance
+	}),
+	atomic({
+		chainId: ChainId.Polygon,
+		protocol: Protocol.Sushi,
+		factory: "0x917933899c6a5F8E37F31E19f92CdBFF7e8FF0e2",
+		initializer: "0xb7402ee99f0a008e461098ac3a27f4957df89a40",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Arbitrum,
+		protocol: Protocol.Sushi,
+		factory: "0x1af415a1EbA07a4986a52B6f2e7dE7003D82231e",
+		initializer: "0xf0cbce1942a68beb3d1b73f0dd86c8dcc363ef49",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Optimism,
+		protocol: Protocol.Sushi,
+		factory: "0x9c6522117e2ed1fE5bdb72bb0eD5E3f2bdE7DBe0",
+		initializer: "0x1af415a1eba07a4986a52b6f2e7de7003d82231e",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.BSC,
+		protocol: Protocol.Sushi,
+		factory: "0x126555dd55a39328F69400d6aE4F782Bd4C34ABb",
+		initializer: "0xf70c086618dcf2b1a461311275e00d6b722ef914",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Avalanche,
+		protocol: Protocol.Sushi,
+		factory: "0x3e603C14aF37EBdaD31709C4f848Fc6aD5BEc715",
+		initializer: "0x18350b048ab366ed601ffdbc669110ecb36016f3",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Thundercore,
+		protocol: Protocol.Sushi,
+		factory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+		initializer: "0xf4d73326c13a4fc5fd7a064217e12780e9bd62c3",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.PolygonzkEVM,
+		protocol: Protocol.Sushi,
+		factory: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
+		initializer: "0xf4d73326c13a4fc5fd7a064217e12780e9bd62c3",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Base,
+		protocol: Protocol.Sushi,
+		factory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+		initializer: "0x80c7dd17b01855a6d2347444a0fcc36136a314de",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Linea,
+		protocol: Protocol.Sushi,
+		factory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+		initializer: "0x80c7dd17b01855a6d2347444a0fcc36136a314de",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Blast,
+		protocol: Protocol.Sushi,
+		factory: "0x7680D4B43f3d1d54d6cfEeB2169463bFa7a6cf0d",
+		initializer: "0x51edb3e5bce8618b77b60215f84ad3db14709051",
+		poolInitCodeHash: "0x8e13daee7f5a62e37e71bf852bcd44e7d16b90617ed2b17c24c2ee62411c5bae",
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Rootstock,
+		protocol: Protocol.Sushi,
+		factory: "0x46B3fDF7b5CDe91Ac049936bF0bDb12c5d22202e",
+		initializer: "0x0389879e0156033202c44bf784ac18fc02edee4f",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Filecoin,
+		protocol: Protocol.Sushi,
+		factory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+		initializer: "0xf4d73326c13a4fc5fd7a064217e12780e9bd62c3",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Hemi,
+		protocol: Protocol.Sushi,
+		factory: "0xCdBCd51a5E8728E0AF4895ce5771b7d17fF71959",
+		initializer: "0xe43ca1dee3f0fc1e2df73a0745674545f11a59f5",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Katana,
+		protocol: Protocol.Sushi,
+		factory: "0x203e8740894c8955cB8950759876d7E7E45E04c1",
+		initializer: "0x2659c6085d26144117d904c46b48b6d180393d27",
+		poolInitCodeHash: "0xe040f12c7cee3904b78f24f8fc395629c2e69525c2815da7a659f7483e378ecb",
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.Robinhood,
+		protocol: Protocol.Sushi,
+		factory: "0xe51960f1b45f1c9fb6d166e6a884f866fc70433b",
+		initializer: "0x51d0e5188afe12d502e29d982d20c190e7816107",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: provenance("verified-explorer", "https://robinhoodchain.blockscout.com/address/0xe51960f1b45f1c9fb6d166e6a884f866fc70433b", "https://robinhoodchain.blockscout.com/address/0x51d0e5188afe12d502e29d982d20c190e7816107"),
+		startBlock: 6292626n
+	}),
+	atomic({
+		chainId: ChainId.Mainnet,
+		protocol: Protocol.Sushi,
+		factory: "0xbaceb8ec6b9355dfc0269c18bac9d6e2bdc29c4f",
+		initializer: "0x2214a42d8e2a1d20635c2cb0664422c528b6a432",
+		poolInitCodeHash: STANDARD_V3_POOL_INIT_CODE_HASH,
+		provenance: sushiProvenance
+	}),
+	atomic({
+		chainId: ChainId.BSC,
+		protocol: Protocol.PancakeSwap,
+		factory: "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865",
+		initializer: "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364",
+		provenance: pancakeProvenance
+	}),
+	atomic({
+		chainId: ChainId.Arbitrum,
+		protocol: Protocol.PancakeSwap,
+		factory: "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865",
+		initializer: "0x46A15B0b27311cedF172AB29E4f4766fbE7F4364",
+		provenance: pancakeProvenance
+	}),
+	atomic({
+		chainId: ChainId.Evmos,
+		protocol: Protocol.Forge,
+		factory: "0xf544365e7065966f190155F629cE0182fC68Eaa2",
+		initializer: "0x5fE5dAAa011673289847dA4f76d63246DDB2965d",
+		provenance: provenance("sdk-config", sdkConfigUrl("forge"))
+	}),
+	atomic({
+		chainId: ChainId.Arbitrum,
+		protocol: Protocol.Horiza,
+		factory: "0x5b1C257B88537d1Ce2AF55a1760336288CcD28B6",
+		initializer: "0x39f16045432dc7cb6160269724821459b35938f9",
+		provenance: provenance("sdk-config", sdkConfigUrl("horiza"))
+	}),
+	atomic({
+		chainId: ChainId.Metis,
+		protocol: Protocol.Maia,
+		factory: "0xf5fd18Cd5325904cC7141cB9Daca1F2F964B9927",
+		initializer: "0x1fc37a909cB3997f96cE395B3Ee9ac268C9bCcdb",
+		provenance: provenance("sdk-config", sdkConfigUrl("maia"))
+	}),
+	atomic({
+		chainId: ChainId.Linea,
+		protocol: Protocol.MetaVault,
+		factory: "0x9367c561915f9D062aFE3b57B18e30dEC62b8488",
+		initializer: "0x5979C5315625276ff99a56f95eE5cC44293e7b36",
+		provenance: provenance("sdk-config", sdkConfigUrl("metavault"))
+	}),
+	atomic({
+		chainId: ChainId.Scroll,
+		protocol: Protocol.MetaVault,
+		factory: "0x9367c561915f9D062aFE3b57B18e30dEC62b8488",
+		initializer: "0x5979C5315625276ff99a56f95eE5cC44293e7b36",
+		provenance: provenance("sdk-config", sdkConfigUrl("metavault"))
+	}),
+	atomic({
+		chainId: ChainId.Manta,
+		protocol: Protocol.QuickSwapUniv3,
+		factory: "0x56c2162254b0E4417288786eE402c2B41d4e181e",
+		initializer: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff",
+		provenance: provenance("sdk-config", sdkConfigUrl("quickswap-univ3"))
+	}),
+	atomic({
+		chainId: ChainId.AstarZkevm,
+		protocol: Protocol.QuickSwapUniv3,
+		factory: "0x56c2162254b0E4417288786eE402c2B41d4e181e",
+		initializer: "0xF6Ad3CcF71Abb3E12beCf6b3D2a74C963859ADCd",
+		provenance: provenance("sdk-config", sdkConfigUrl("quickswap-univ3"))
+	}),
+	atomic({
+		chainId: ChainId.Bittensor,
+		protocol: Protocol.BittensorUniV3,
+		factory: "0xfB30AE7542a5E8A5BC134128c0c9dEb4646a2508",
+		initializer: "0x32aF22F550bB1E9dd1382BEaBb0E3e6bb12fA549",
+		provenance: provenance("sdk-config", sdkConfigUrl("bittensor-univ3"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Astar,
+		protocol: Protocol.ArthSwap,
+		factory: "0x69E92b56e4BF4C0FFa2cFB087c7EA47E846a7244",
+		provenance: provenance("sdk-config", sdkConfigUrl("arthswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.AstarZkevm,
+		protocol: Protocol.ArthSwap,
+		factory: "0xAeaaf0e2c81Af264101B9129C00F4440cCF0F720",
+		provenance: provenance("sdk-config", sdkConfigUrl("arthswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Base,
+		protocol: Protocol.BaseSwap,
+		factory: "0x38015D05f4fEC8AFe15D7cc0386a126574e8077B",
+		provenance: provenance("sdk-config", sdkConfigUrl("baseswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Base,
+		protocol: Protocol.BaseX,
+		factory: "0xdC323d16C451819890805737997F4Ede96b95e3e",
+		provenance: provenance("sdk-config", sdkConfigUrl("basex"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Moonbeam,
+		protocol: Protocol.BeamSwap,
+		factory: "0xD118fa707147c54387B738F54838Ea5dD4196E71",
+		provenance: provenance("sdk-config", sdkConfigUrl("beamswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Mantle,
+		protocol: Protocol.Crust,
+		factory: "0xe67a97d7e55256F33fA0B1465d31E6CED36065d0",
+		provenance: provenance("sdk-config", sdkConfigUrl("crust"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Taiko,
+		protocol: Protocol.Dodo,
+		factory: "0x78172691DD3B8ADa7aEbd9bFfB487FB11D735DB2",
+		provenance: provenance("sdk-config", sdkConfigUrl("dodo"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Sei,
+		protocol: Protocol.DragonSwap,
+		factory: "0x179D9a5592Bc77050796F7be28058c51cA575df4",
+		provenance: provenance("sdk-config", sdkConfigUrl("dragonswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Zeta,
+		protocol: Protocol.Eddy,
+		factory: "0x67AA6B2b715937Edc1Eb4D3b7B5d5dCD1fd93E8C",
+		provenance: provenance("sdk-config", sdkConfigUrl("eddy"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Scroll,
+		protocol: Protocol.Equilibre,
+		factory: "0x952aC46B2586737df679e836d9B980E43E12B2d8",
+		provenance: provenance("sdk-config", sdkConfigUrl("equilibre"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Mantle,
+		protocol: Protocol.FusionX,
+		factory: "0x530d2766D1988CC1c000C8b7d00334c14B69AD71",
+		poolInitCodeHash: "0x1bce652aaa6528355d7a339037433a20cd28410e3967635ba8d2ddb037440dbf",
+		provenance: provenance("sdk-config", sdkConfigUrl("fusionx"))
+	}),
+	factoryOnly({
+		chainId: ChainId.TataraTestnet,
+		protocol: Protocol.Katana,
+		factory: "0x9B3336186a38E1b6c21955d112dbb0343Ee061eE",
+		provenance: provenance("sdk-config", sdkConfigUrl("katana"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Kava,
+		protocol: Protocol.Kinetix,
+		factory: "0x2dBB6254231C5569B6A4313c6C1F5Fe1340b35C2",
+		provenance: provenance("sdk-config", sdkConfigUrl("kinetix"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Base,
+		protocol: Protocol.Kinetix,
+		factory: "0xdDF5a3259a88Ab79D5530eB3eB14c1C92CD97FCf",
+		provenance: provenance("sdk-config", sdkConfigUrl("kinetix"))
+	}),
+	factoryOnly({
+		chainId: ChainId.BeraChainBartio,
+		protocol: Protocol.Kodiak,
+		factory: "0x217Cd80795EfCa5025d47023da5c03a24fA95356",
+		provenance: provenance("sdk-config", sdkConfigUrl("kodiak"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Bera,
+		protocol: Protocol.Kodiak,
+		factory: "0xD84CBf0B02636E7f53dB9E5e45A616E05d710990",
+		provenance: provenance("sdk-config", sdkConfigUrl("kodiak"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Soneium,
+		protocol: Protocol.Kyo,
+		factory: "0x137841043180BBA8EF52828F9030D1b7fE065F95",
+		provenance: provenance("sdk-config", sdkConfigUrl("kyo"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Linea,
+		protocol: Protocol.LineHub,
+		factory: "0x6c379d538F2F7cb642851e154A8E572D63238DF4",
+		provenance: provenance("sdk-config", sdkConfigUrl("linehub"))
+	}),
+	factoryOnly({
+		chainId: ChainId.ZklinkNova,
+		protocol: Protocol.NovaSwap,
+		factory: "0x9f94c91b178F5bc9fCcA3e5428b09A3d01CE5AC6",
+		provenance: provenance("sdk-config", sdkConfigUrl("novaswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.OkxTestnet,
+		protocol: Protocol.QuickSwapUniv3,
+		factory: "0x56c2162254b0E4417288786eE402c2B41d4e181e",
+		provenance: provenance("sdk-config", sdkConfigUrl("quickswap-univ3"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Sei,
+		protocol: Protocol.Sailor,
+		factory: "0x137841043180BBA8EF52828F9030D1b7fE065F95",
+		provenance: provenance("sdk-config", sdkConfigUrl("sailor"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Flare,
+		protocol: Protocol.Spark,
+		factory: "0xb3fB4f96175f6f9D716c17744e5A6d4BA9da8176",
+		provenance: provenance("sdk-config", sdkConfigUrl("spark"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Flare,
+		protocol: Protocol.Spark32,
+		factory: "0x8A2578d23d4C532cC9A98FaD91C0523f5efDE652",
+		provenance: provenance("sdk-config", sdkConfigUrl("spark32"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Sonic,
+		protocol: Protocol.SpookySwap,
+		factory: "0x3D91B700252e0E3eE7805d12e048a988Ab69C8ad",
+		provenance: provenance("sdk-config", sdkConfigUrl("spookyswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Mode,
+		protocol: Protocol.SupSwap,
+		factory: "0xa0b018Fe0d00ed075fb9b0eEe26d25cf72e1F693",
+		provenance: provenance("sdk-config", sdkConfigUrl("supswap"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Mode,
+		protocol: Protocol.SwapMode,
+		factory: "0x6E36FC34eA123044F278d3a9F3819027B21c9c32",
+		provenance: provenance("sdk-config", sdkConfigUrl("swapmode"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Fantom,
+		protocol: Protocol.Thick,
+		factory: "0xE6dA85feb3B4E0d6AEd95c41a125fba859bB9d24",
+		provenance: provenance("sdk-config", sdkConfigUrl("thick"))
+	}),
+	factoryOnly({
+		chainId: ChainId.Blast,
+		protocol: Protocol.Thruster,
+		factory: "0x71b08f13B3c3aF35aAdEb3949AFEb1ded1016127",
+		poolInitCodeHash: "0xd0c3a51b16dbc778f000c620eaabeecd33b33a80bd145e1f7cbc0d4de335193d",
+		provenance: provenance("sdk-config", sdkConfigUrl("thruster"))
+	})
+], (entry) => deploymentKey$2(entry.chainId, entry.protocol), "V3 lifecycle deployment");
+/**
+* Protocols whose current SDK configuration is intentionally inventoried by
+* the V3 lifecycle registry. Adding a factory for one of these protocols must
+* also add an explicit lifecycle capability entry.
+*/
+const V3_CONFIG_PROTOCOLS = Object.freeze([
+	Protocol.ArthSwap,
+	Protocol.BaseSwap,
+	Protocol.BaseX,
+	Protocol.BeamSwap,
+	Protocol.BittensorUniV3,
+	Protocol.Crust,
+	Protocol.Dodo,
+	Protocol.DragonSwap,
+	Protocol.Eddy,
+	Protocol.Equilibre,
+	Protocol.Forge,
+	Protocol.FusionX,
+	Protocol.Horiza,
+	Protocol.Katana,
+	Protocol.Kinetix,
+	Protocol.Kodiak,
+	Protocol.Kyo,
+	Protocol.LineHub,
+	Protocol.Maia,
+	Protocol.MetaVault,
+	Protocol.NovaSwap,
+	Protocol.PancakeSwap,
+	Protocol.QuickSwapUniv3,
+	Protocol.Sailor,
+	Protocol.Spark,
+	Protocol.Spark32,
+	Protocol.SpookySwap,
+	Protocol.SupSwap,
+	Protocol.Sushi,
+	Protocol.SwapMode,
+	Protocol.Thick,
+	Protocol.Thruster,
+	Protocol.Uniswap
+]);
+function resolveV3LifecycleDeployment(params) {
+	return V3_LIFECYCLE_DEPLOYMENTS[deploymentKey$2(params.chainId, params.protocol)];
+}
+//#endregion
+//#region src/pool-lifecycle/capabilities/v4.ts
+const OFFICIAL_DEPLOYMENTS_URL = "https://developers.uniswap.org/deployments.json";
+function getV4LifecycleDeploymentId(params) {
+	const poolManager = (0, viem.getAddress)(params.poolManager).toLowerCase();
+	const stateView = (0, viem.getAddress)(params.stateView).toLowerCase();
+	return `uniswap-v4:${params.chainId}:${params.protocol}:${poolManager}:${stateView}:${params.adapter}:v${params.version}`;
+}
+function deployment(chainId, poolManager, stateView, startBlock) {
+	const poolManagerAddress = (0, viem.getAddress)(poolManager);
+	const stateViewAddress = (0, viem.getAddress)(stateView);
+	const identity = {
+		chainId,
+		protocol: Protocol.UniswapV4,
+		poolManager: poolManagerAddress,
+		stateView: stateViewAddress,
+		adapter: "pool-manager-initialize-v1",
+		version: 1
+	};
+	return Object.freeze({
+		supported: true,
+		schemaVersion: 1,
+		deploymentId: getV4LifecycleDeploymentId(identity),
+		chainId,
+		protocol: Protocol.UniswapV4,
+		family: "uniswap-v4",
+		adapter: identity.adapter,
+		version: identity.version,
+		poolManager: poolManagerAddress,
+		stateView: stateViewAddress,
+		startBlock,
+		provenance: Object.freeze({
+			source: "official-deployment",
+			urls: Object.freeze([OFFICIAL_DEPLOYMENTS_URL])
+		})
+	});
+}
+/**
+* Explicit lifecycle-write registry. Entries are not inferred from discovery
+* configuration so a newly discovered deployment remains unsupported until it
+* is deliberately reviewed and versioned here.
+*/
+const CURRENT_V4_LIFECYCLE_DEPLOYMENTS = Object.freeze([
+	deployment(ChainId.Mainnet, "0x000000000004444c5dc75cB358380D2e3dE08A90", "0x7ffe42c4a5deea5b0fec41c94c136cf115597227", 21688329n),
+	deployment(ChainId.BSC, "0x28e2ea090877bf75740558f6bfb36a5ffee9e9df", "0xd13dd3d6e93f276fafc9db9e6bb47c1180aee0c4", 45970610n),
+	deployment(ChainId.Unichain, "0x1f98400000000000000000000000000000000004", "0x86e8631a016f9068c3f085faf484ee3f5fdee8f2", 25500n),
+	deployment(ChainId.Robinhood, "0x8366a39cc670b4001a1121b8f6a443a643e40951", "0xf3334192d15450cdd385c8b70e03f9a6bd9e673b", 9070n),
+	deployment(ChainId.Base, "0x498581ff718922c3f8e6a244956af099b2652b2b", "0xa3c0c9b65bad0b08107aa264b0f3db444b867a71", 25350988n),
+	deployment(ChainId.Arbitrum, "0x360e68faccca8ca495c1b759fd9eee466db9fb32", "0x76fd297e2d437cd7f76d50f01afe6160f86e9990", 297842872n)
+]);
+/**
+* Every approved V4 deployment, including historical managers. When a current
+* deployment changes, retain the former entry here so existing plans remain
+* independently resolvable by deploymentId.
+*/
+const V4_LIFECYCLE_DEPLOYMENTS = Object.freeze([...CURRENT_V4_LIFECYCLE_DEPLOYMENTS]);
+function deploymentKey$1(chainId, protocol) {
+	return `${chainId}:${protocol}`;
+}
+const V4_LIFECYCLE_DEPLOYMENTS_BY_ID = buildCheckedRegistry(V4_LIFECYCLE_DEPLOYMENTS, (entry) => entry.deploymentId, "V4 lifecycle deployment id");
+const CURRENT_DEPLOYMENTS_BY_KEY = buildCheckedRegistry(CURRENT_V4_LIFECYCLE_DEPLOYMENTS, (entry) => deploymentKey$1(entry.chainId, entry.protocol), "current V4 lifecycle deployment");
+/** Resolve the explicitly selected current-default deployment for a chain/protocol pair. */
+function resolveCurrentV4LifecycleDeployment(params) {
+	return CURRENT_DEPLOYMENTS_BY_KEY[deploymentKey$1(params.chainId, params.protocol)];
+}
+/** Backwards-compatible alias; prefer the name that makes current-default semantics explicit. */
+const resolveV4LifecycleDeployment = resolveCurrentV4LifecycleDeployment;
+/** Resolve an exact current or historical deployment without consulting defaults. */
+function resolveV4LifecycleDeploymentById(deploymentId) {
+	return V4_LIFECYCLE_DEPLOYMENTS_BY_ID[deploymentId];
+}
+/**
+* Validate capability metadata supplied across a UI/CLI boundary and return
+* the canonical frozen registry entry.
+*/
+function validateV4LifecycleDeployment(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", "V4 deployment must be an object.");
+	const candidate = value;
+	if (typeof candidate.deploymentId !== "string" || !Number.isSafeInteger(candidate.chainId) || typeof candidate.protocol !== "string") throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", "V4 deployment id, chainId, and protocol are invalid.");
+	const configured = resolveV4LifecycleDeploymentById(candidate.deploymentId);
+	let matches = false;
+	try {
+		matches = configured !== void 0 && candidate.supported === true && candidate.deploymentId === configured.deploymentId && candidate.schemaVersion === configured.schemaVersion && candidate.chainId === configured.chainId && candidate.protocol === configured.protocol && candidate.family === configured.family && candidate.adapter === configured.adapter && candidate.version === configured.version && (0, viem.getAddress)(candidate.poolManager) === configured.poolManager && (0, viem.getAddress)(candidate.stateView) === configured.stateView && candidate.startBlock === configured.startBlock;
+	} catch {}
+	if (!matches || !configured) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `V4 lifecycle deployment ${String(candidate.deploymentId)} is not configured.`);
+	return configured;
+}
+//#endregion
+//#region src/pool-lifecycle/capabilities.ts
+function deploymentKey(deployment) {
+	return `${deployment.chainId}:${deployment.protocol}`;
+}
+function buildLifecycleRegistry() {
+	return buildCheckedRegistry([
+		...Object.values(V3_LIFECYCLE_DEPLOYMENTS).filter((deployment) => deployment !== void 0),
+		...CURRENT_V4_LIFECYCLE_DEPLOYMENTS,
+		...ALGEBRA_LIFECYCLE_DEPLOYMENTS
+	], deploymentKey, "pool lifecycle deployment");
+}
+/**
+* Collision-checked current-default deployments, independent of discovery.
+* Historical V4 entries remain available through V4_LIFECYCLE_DEPLOYMENTS and
+* its deployment-id resolver instead of competing for this chain/protocol key.
+*/
+const POOL_LIFECYCLE_DEPLOYMENTS = buildLifecycleRegistry();
+/**
+* Resolve only explicitly versioned lifecycle capabilities. Discovery and
+* subgraph metadata are never an implicit fallback for transaction building.
+*/
+function resolvePoolLifecycleDeployment(params) {
+	const deployment = POOL_LIFECYCLE_DEPLOYMENTS[deploymentKey(params)];
+	if (deployment) return deployment;
+	return Object.freeze({
+		supported: false,
+		schemaVersion: 1,
+		family: "unsupported",
+		chainId: params.chainId,
+		protocol: params.protocol,
+		reason: "deployment-not-configured"
+	});
+}
+//#endregion
+//#region src/pool-lifecycle/abis/algebra.ts
+const algebraPairFactoryAbi = (0, viem.parseAbi)([
+	"event Pool(address indexed token0,address indexed token1,address pool)",
+	"function poolDeployer() view returns (address)",
+	"function poolByPair(address tokenA,address tokenB) view returns (address pool)",
+	"function createPool(address tokenA,address tokenB) returns (address pool)"
+]);
+const algebraIntegralPluginDataFactoryAbi = (0, viem.parseAbi)([
+	"event Pool(address indexed token0,address indexed token1,address pool)",
+	"event CustomPool(address indexed deployer,address indexed token0,address indexed token1,address pool)",
+	"function poolDeployer() view returns (address)",
+	"function poolByPair(address tokenA,address tokenB) view returns (address pool)",
+	"function createPool(address tokenA,address tokenB,bytes data) returns (address pool)",
+	"function defaultConfigurationForPool() view returns (uint16 communityFee,int24 tickSpacing,uint16 fee)",
+	"function defaultPluginFactory() view returns (address)"
+]);
+const algebraIntegralPairFactoryAbi = (0, viem.parseAbi)([
+	"event Pool(address indexed token0,address indexed token1,address pool)",
+	"event CustomPool(address indexed deployer,address indexed token0,address indexed token1,address pool)",
+	"function poolDeployer() view returns (address)",
+	"function poolByPair(address tokenA,address tokenB) view returns (address pool)",
+	"function createPool(address tokenA,address tokenB) returns (address pool)",
+	"function defaultTickspacing() view returns (int24)",
+	"function defaultFee() view returns (uint16)",
+	"function defaultPluginFactory() view returns (address)"
+]);
+const algebraPoolBaseAbi = (0, viem.parseAbi)([
+	"event Initialize(uint160 price,int24 tick)",
+	"function factory() view returns (address)",
+	"function token0() view returns (address)",
+	"function token1() view returns (address)",
+	"function tickSpacing() view returns (int24)",
+	"function initialize(uint160 initialPrice)"
+]);
+const algebraLegacyPoolStateAbi = (0, viem.parseAbi)(["function globalState() view returns (uint160 price,int24 tick,int24 prevInitializedTick,uint16 fee,uint16 timepointIndex,uint8 communityFee,bool unlocked)"]);
+const algebraDirectionalPoolStateAbi = (0, viem.parseAbi)(["function globalState() view returns (uint160 price,int24 tick,uint16 feeZto,uint16 feeOtz,uint16 timepointIndex,uint8 communityFeeToken0,uint8 communityFeeToken1,bool unlocked)"]);
+const algebraIntegralPoolStateAbi = (0, viem.parseAbi)(["function globalState() view returns (uint160 price,int24 tick,uint16 lastFee,uint8 pluginConfig,uint16 communityFee,bool unlocked)", "function plugin() view returns (address)"]);
+/**
+* Kept separate from standard pool creation. Calling this directly from an EOA
+* is invalid because the entry point requires msg.sender == deployer.
+*/
+const algebraCustomPoolEntryPointAbi = (0, viem.parseAbi)(["function factory() view returns (address)", "function createCustomPool(address deployer,address creator,address tokenA,address tokenB,bytes data) returns (address customPool)"]);
+//#endregion
+//#region src/pool-lifecycle/abis/v3.ts
+/** Minimal canonical Uniswap V3-compatible factory ABI used by pool lifecycle flows. */
+const v3FactoryAbi = [
+	{
+		type: "function",
+		name: "createPool",
+		stateMutability: "nonpayable",
+		inputs: [
+			{
+				name: "tokenA",
+				type: "address"
+			},
+			{
+				name: "tokenB",
+				type: "address"
+			},
+			{
+				name: "fee",
+				type: "uint24"
+			}
+		],
+		outputs: [{
+			name: "pool",
+			type: "address"
+		}]
+	},
+	{
+		type: "function",
+		name: "getPool",
+		stateMutability: "view",
+		inputs: [
+			{
+				name: "tokenA",
+				type: "address"
+			},
+			{
+				name: "tokenB",
+				type: "address"
+			},
+			{
+				name: "fee",
+				type: "uint24"
+			}
+		],
+		outputs: [{
+			name: "pool",
+			type: "address"
+		}]
+	},
+	{
+		type: "function",
+		name: "feeAmountTickSpacing",
+		stateMutability: "view",
+		inputs: [{
+			name: "fee",
+			type: "uint24"
+		}],
+		outputs: [{
+			name: "tickSpacing",
+			type: "int24"
+		}]
+	},
+	{
+		type: "event",
+		name: "PoolCreated",
+		inputs: [
+			{
+				name: "token0",
+				type: "address",
+				indexed: true
+			},
+			{
+				name: "token1",
+				type: "address",
+				indexed: true
+			},
+			{
+				name: "fee",
+				type: "uint24",
+				indexed: true
+			},
+			{
+				name: "tickSpacing",
+				type: "int24",
+				indexed: false
+			},
+			{
+				name: "pool",
+				type: "address",
+				indexed: false
+			}
+		]
+	}
+];
+/** Minimal PoolInitializer/NonfungiblePositionManager ABI used for atomic V3 setup. */
+const v3PoolInitializerAbi = [{
+	type: "function",
+	name: "createAndInitializePoolIfNecessary",
+	stateMutability: "payable",
+	inputs: [
+		{
+			name: "token0",
+			type: "address"
+		},
+		{
+			name: "token1",
+			type: "address"
+		},
+		{
+			name: "fee",
+			type: "uint24"
+		},
+		{
+			name: "sqrtPriceX96",
+			type: "uint160"
+		}
+	],
+	outputs: [{
+		name: "pool",
+		type: "address"
+	}]
+}, {
+	type: "function",
+	name: "factory",
+	stateMutability: "view",
+	inputs: [],
+	outputs: [{
+		name: "",
+		type: "address"
+	}]
+}];
+/** Minimal canonical V3 pool ABI needed to initialize and verify a deployment. */
+const v3PoolAbi = [
+	{
+		type: "function",
+		name: "initialize",
+		stateMutability: "nonpayable",
+		inputs: [{
+			name: "sqrtPriceX96",
+			type: "uint160"
+		}],
+		outputs: []
+	},
+	{
+		type: "function",
+		name: "factory",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "address"
+		}]
+	},
+	{
+		type: "function",
+		name: "token0",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "address"
+		}]
+	},
+	{
+		type: "function",
+		name: "token1",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "address"
+		}]
+	},
+	{
+		type: "function",
+		name: "fee",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "uint24"
+		}]
+	},
+	{
+		type: "function",
+		name: "tickSpacing",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "int24"
+		}]
+	},
+	{
+		type: "function",
+		name: "slot0",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [
+			{
+				name: "sqrtPriceX96",
+				type: "uint160"
+			},
+			{
+				name: "tick",
+				type: "int24"
+			},
+			{
+				name: "observationIndex",
+				type: "uint16"
+			},
+			{
+				name: "observationCardinality",
+				type: "uint16"
+			},
+			{
+				name: "observationCardinalityNext",
+				type: "uint16"
+			},
+			{
+				name: "feeProtocol",
+				type: "uint8"
+			},
+			{
+				name: "unlocked",
+				type: "bool"
+			}
+		]
+	},
+	{
+		type: "event",
+		name: "Initialize",
+		inputs: [{
+			name: "sqrtPriceX96",
+			type: "uint160",
+			indexed: false
+		}, {
+			name: "tick",
+			type: "int24",
+			indexed: false
+		}]
+	}
+];
+//#endregion
+//#region src/pool-lifecycle/algebra/key.ts
+function canonicalizeAlgebraPoolKey(input) {
+	if (!(0, viem.isAddress)(input.tokenA, { strict: true }) || !(0, viem.isAddress)(input.tokenB, { strict: true })) throw new PoolLifecycleError("INVALID_INPUT", "Algebra tokens must be valid EVM addresses.");
+	const tokenA = (0, viem.getAddress)(input.tokenA);
+	const tokenB = (0, viem.getAddress)(input.tokenB);
+	if (tokenA === "0x0000000000000000000000000000000000000000" || tokenB === "0x0000000000000000000000000000000000000000" || tokenA === tokenB) throw new PoolLifecycleError("INVALID_INPUT", "Algebra tokens must be distinct and non-zero.");
+	return BigInt(tokenA) < BigInt(tokenB) ? {
+		token0: tokenA,
+		token1: tokenB
+	} : {
+		token0: tokenB,
+		token1: tokenA
+	};
+}
+function assertAlgebraInitialPrice(key, price) {
+	const priceKey = canonicalizeAlgebraPoolKey({
+		tokenA: price.token0,
+		tokenB: price.token1
+	});
+	if (priceKey.token0 !== key.token0 || priceKey.token1 !== key.token1) throw new PoolLifecycleError("INVALID_INPUT", "Algebra price tokens do not match the pool key.");
+	validateSqrtPriceX96(price.sqrtPriceX96);
+	return {
+		token0: key.token0,
+		token1: key.token1,
+		sqrtPriceX96: price.sqrtPriceX96
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/algebra/inspect.ts
+const ZERO = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+async function requireCode(client, address, label, blockNumber) {
+	const code = await client.getCode({
+		address,
+		blockNumber
+	});
+	if (!code || code === "0x") throw new PoolLifecycleError("CONTRACT_NOT_DEPLOYED", `${label} ${address} has no bytecode at block ${blockNumber}.`);
+}
+/** Verify configured custom-pool routing without claiming a generic deployer ABI. */
+async function inspectAlgebraCustomPoolEntryPoint(params) {
+	const deployment = validateAlgebraLifecycleDeployment(params.deployment);
+	if (!deployment.customPoolEntryPoint) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `No custom Algebra entry point is configured for chain ${deployment.chainId} and protocol ${deployment.protocol}.`);
+	const chainId = await params.publicClient.getChainId();
+	if (chainId !== deployment.chainId) throw new PoolLifecycleError("CHAIN_MISMATCH", `Public client chain ${chainId} does not match Algebra deployment chain ${deployment.chainId}.`);
+	const blockNumber = params.blockNumber ?? await params.publicClient.getBlockNumber();
+	const entryPoint = deployment.customPoolEntryPoint;
+	const factory = deployment.factory;
+	await requireCode(params.publicClient, entryPoint, "Algebra custom pool entry point", blockNumber);
+	const entryFactory = (0, viem.getAddress)(await params.publicClient.readContract({
+		address: entryPoint,
+		abi: algebraCustomPoolEntryPointAbi,
+		functionName: "factory",
+		blockNumber
+	}));
+	if (entryFactory !== factory) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Algebra entry point factory ${entryFactory} does not match ${factory}.`);
+	return {
+		blockNumber,
+		entryPoint,
+		factory
+	};
+}
+async function inspectAlgebraPool(params) {
+	const { publicClient } = params;
+	const deployment = validateAlgebraLifecycleDeployment(params.deployment);
+	const key = canonicalizeAlgebraPoolKey(params.key);
+	const chainId = await publicClient.getChainId();
+	if (chainId !== deployment.chainId) throw new PoolLifecycleError("CHAIN_MISMATCH", `Public client chain ${chainId} does not match Algebra deployment chain ${deployment.chainId}.`);
+	const blockNumber = params.blockNumber ?? await publicClient.getBlockNumber();
+	const factory = (0, viem.getAddress)(deployment.factory);
+	await Promise.all([
+		requireCode(publicClient, factory, "Algebra factory", blockNumber),
+		requireCode(publicClient, key.token0, "token0", blockNumber),
+		requireCode(publicClient, key.token1, "token1", blockNumber)
+	]);
+	const factoryAbi = deployment.createPool === "pair-with-plugin-data" ? algebraIntegralPluginDataFactoryAbi : deployment.variant === "integral-v1" ? algebraIntegralPairFactoryAbi : algebraPairFactoryAbi;
+	const [poolRaw, poolDeployerRaw] = await Promise.all([publicClient.readContract({
+		address: factory,
+		abi: factoryAbi,
+		functionName: "poolByPair",
+		args: [key.token0, key.token1],
+		blockNumber
+	}), publicClient.readContract({
+		address: factory,
+		abi: factoryAbi,
+		functionName: "poolDeployer",
+		blockNumber
+	})]);
+	const poolDeployer = (0, viem.getAddress)(poolDeployerRaw);
+	if (poolDeployer === ZERO) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Algebra factory ${factory} reports a zero pool deployer.`);
+	await requireCode(publicClient, poolDeployer, "Algebra pool deployer", blockNumber);
+	let defaultTickSpacing = null;
+	let defaultFee = null;
+	if (deployment.variant === "integral-v1") {
+		const [tickSpacing, fee] = await Promise.all([publicClient.readContract({
+			address: factory,
+			abi: algebraIntegralPairFactoryAbi,
+			functionName: "defaultTickspacing",
+			blockNumber
+		}), publicClient.readContract({
+			address: factory,
+			abi: algebraIntegralPairFactoryAbi,
+			functionName: "defaultFee",
+			blockNumber
+		})]);
+		defaultTickSpacing = Number(tickSpacing);
+		defaultFee = Number(fee);
+	} else if (deployment.variant === "integral-v2") {
+		const configuration = await publicClient.readContract({
+			address: factory,
+			abi: algebraIntegralPluginDataFactoryAbi,
+			functionName: "defaultConfigurationForPool",
+			blockNumber
+		});
+		defaultTickSpacing = Number(configuration[1]);
+		defaultFee = Number(configuration[2]);
+	}
+	if (defaultTickSpacing !== null && (!Number.isInteger(defaultTickSpacing) || defaultTickSpacing <= 0)) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Algebra factory ${factory} reports invalid default tick spacing.`);
+	const poolAddress = (0, viem.getAddress)(poolRaw);
+	if (poolAddress === ZERO) return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		status: "absent",
+		poolAddress: null,
+		sqrtPriceX96: 0n,
+		tick: null,
+		tickSpacing: defaultTickSpacing,
+		fee: defaultFee,
+		directionalFee: null,
+		plugin: null,
+		pluginConfig: null,
+		unlocked: null
+	};
+	await requireCode(publicClient, poolAddress, "Algebra pool", blockNumber);
+	const [actualFactoryRaw, token0Raw, token1Raw, tickSpacingRaw] = await Promise.all([
+		publicClient.readContract({
+			address: poolAddress,
+			abi: algebraPoolBaseAbi,
+			functionName: "factory",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: algebraPoolBaseAbi,
+			functionName: "token0",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: algebraPoolBaseAbi,
+			functionName: "token1",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: algebraPoolBaseAbi,
+			functionName: "tickSpacing",
+			blockNumber
+		})
+	]);
+	if ((0, viem.getAddress)(actualFactoryRaw) !== factory || (0, viem.getAddress)(token0Raw) !== key.token0 || (0, viem.getAddress)(token1Raw) !== key.token1) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Pool ${poolAddress} does not match the configured Algebra deployment and token pair.`);
+	const tickSpacing = Number(tickSpacingRaw);
+	let sqrtPriceX96;
+	let tick;
+	let fee = null;
+	let directionalFee = null;
+	let plugin = null;
+	let pluginConfig = null;
+	let unlocked;
+	if (deployment.state === "directional-global-state") {
+		const state = await publicClient.readContract({
+			address: poolAddress,
+			abi: algebraDirectionalPoolStateAbi,
+			functionName: "globalState",
+			blockNumber
+		});
+		sqrtPriceX96 = state[0];
+		tick = Number(state[1]);
+		directionalFee = {
+			zeroToOne: Number(state[2]),
+			oneToZero: Number(state[3])
+		};
+		unlocked = state[7];
+	} else if (deployment.state === "integral-global-state") {
+		const [state, pluginRaw] = await Promise.all([publicClient.readContract({
+			address: poolAddress,
+			abi: algebraIntegralPoolStateAbi,
+			functionName: "globalState",
+			blockNumber
+		}), publicClient.readContract({
+			address: poolAddress,
+			abi: algebraIntegralPoolStateAbi,
+			functionName: "plugin",
+			blockNumber
+		})]);
+		sqrtPriceX96 = state[0];
+		tick = Number(state[1]);
+		fee = Number(state[2]);
+		pluginConfig = Number(state[3]);
+		unlocked = state[5];
+		const pluginAddress = (0, viem.getAddress)(pluginRaw);
+		plugin = pluginAddress === ZERO ? null : pluginAddress;
+	} else {
+		const state = await publicClient.readContract({
+			address: poolAddress,
+			abi: algebraLegacyPoolStateAbi,
+			functionName: "globalState",
+			blockNumber
+		});
+		sqrtPriceX96 = state[0];
+		tick = Number(state[1]);
+		fee = Number(state[3]);
+		unlocked = state[6];
+	}
+	const uninitializedIntegralPool = deployment.variant.startsWith("integral") && sqrtPriceX96 === 0n && tickSpacing === 0;
+	if (!Number.isInteger(tickSpacing) || tickSpacing <= 0 && !uninitializedIntegralPool) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Pool ${poolAddress} reports invalid tick spacing.`);
+	return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		status: sqrtPriceX96 === 0n ? "uninitialized" : "initialized",
+		poolAddress,
+		sqrtPriceX96,
+		tick,
+		tickSpacing,
+		fee,
+		directionalFee,
+		plugin,
+		pluginConfig,
+		unlocked
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/algebra/actions.ts
+const ZERO_ADDRESS$2 = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+function assertPreflight(deployment, key, snapshot) {
+	let matches = false;
+	try {
+		const snapshotDeployment = validateAlgebraLifecycleDeployment(snapshot.deployment);
+		matches = snapshot.schemaVersion === 1 && typeof snapshot.blockNumber === "bigint" && snapshot.blockNumber >= 0n && snapshotDeployment === deployment && snapshot.key.token0 === key.token0 && snapshot.key.token1 === key.token1 && (snapshot.status === "absent" || snapshot.status === "uninitialized" || snapshot.status === "initialized");
+	} catch {}
+	if (!matches) throw new PoolLifecycleError("INVALID_INPUT", "Algebra preflight does not match the requested deployment and token pair.");
+	if (snapshot.status === "absent") {
+		if (snapshot.poolAddress !== null || snapshot.sqrtPriceX96 !== 0n || snapshot.tick !== null) throw new PoolLifecycleError("INVALID_INPUT", "Absent Algebra preflight is inconsistent.");
+		return;
+	}
+	if (!snapshot.poolAddress || (0, viem.getAddress)(snapshot.poolAddress) === ZERO_ADDRESS$2) throw new PoolLifecycleError("INVALID_INPUT", "Algebra preflight pool address is invalid.");
+	if (snapshot.status === "uninitialized" && snapshot.sqrtPriceX96 !== 0n) throw new PoolLifecycleError("INVALID_INPUT", "Uninitialized Algebra preflight must have zero sqrtPriceX96.");
+}
+function summary(snapshot) {
+	return {
+		blockNumber: snapshot.blockNumber,
+		status: snapshot.status,
+		poolAddress: snapshot.poolAddress,
+		sqrtPriceX96: snapshot.sqrtPriceX96
+	};
+}
+function identity$1(deployment, key, poolAddress) {
+	return {
+		family: "algebra",
+		adapter: deployment.adapter,
+		version: deployment.version,
+		variant: deployment.variant,
+		chainId: deployment.chainId,
+		factory: (0, viem.getAddress)(deployment.factory),
+		key,
+		poolAddress
+	};
+}
+/** Build the version-specific standard-pool factory call without signing it. */
+function buildAlgebraCreatePoolTransaction(params) {
+	const deployment = validateAlgebraLifecycleDeployment(params.deployment);
+	const key = canonicalizeAlgebraPoolKey(params.key);
+	assertPreflight(deployment, key, params.preflight);
+	if (params.preflight.status !== "absent") throw new PoolLifecycleError("POOL_STATE_MISMATCH", `Algebra pool already exists at ${params.preflight.poolAddress}.`);
+	const pluginData = params.pluginData ?? "0x";
+	if (deployment.createPool === "pair" && pluginData !== "0x") throw new PoolLifecycleError("INVALID_INPUT", `${deployment.variant} pool creation does not accept plugin data.`);
+	const data = deployment.createPool === "pair-with-plugin-data" ? (0, viem.encodeFunctionData)({
+		abi: algebraIntegralPluginDataFactoryAbi,
+		functionName: "createPool",
+		args: [
+			key.token0,
+			key.token1,
+			pluginData
+		]
+	}) : (0, viem.encodeFunctionData)({
+		abi: deployment.variant === "integral-v1" ? algebraIntegralPairFactoryAbi : algebraPairFactoryAbi,
+		functionName: "createPool",
+		args: [key.token0, key.token1]
+	});
+	return {
+		schemaVersion: 1,
+		kind: "algebra-create",
+		protocol: deployment.protocol,
+		transaction: {
+			chainId: deployment.chainId,
+			to: deployment.factory,
+			data,
+			value: 0n
+		},
+		identity: identity$1(deployment, key, null),
+		expected: {
+			sqrtPriceX96: null,
+			pluginData
+		},
+		preflight: summary(params.preflight)
+	};
+}
+/** Build a direct initialization call bound to an inspected, uninitialized pool. */
+function buildAlgebraInitializePoolTransaction(params) {
+	const deployment = validateAlgebraLifecycleDeployment(params.deployment);
+	const key = canonicalizeAlgebraPoolKey(params.key);
+	const price = assertAlgebraInitialPrice(key, params.initialPrice);
+	assertPreflight(deployment, key, params.preflight);
+	if (params.preflight.status !== "uninitialized" || !params.preflight.poolAddress) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Algebra initialization requires an inspected, uninitialized factory pool.");
+	const poolAddress = (0, viem.getAddress)(params.preflight.poolAddress);
+	return {
+		schemaVersion: 1,
+		kind: "algebra-initialize",
+		protocol: deployment.protocol,
+		transaction: {
+			chainId: deployment.chainId,
+			to: poolAddress,
+			data: (0, viem.encodeFunctionData)({
+				abi: algebraPoolBaseAbi,
+				functionName: "initialize",
+				args: [price.sqrtPriceX96]
+			}),
+			value: 0n
+		},
+		identity: identity$1(deployment, key, poolAddress),
+		expected: {
+			sqrtPriceX96: price.sqrtPriceX96,
+			pluginData: null
+		},
+		preflight: summary(params.preflight)
+	};
+}
+/**
+* Prepare the next honest lifecycle step. Creation and initialization remain
+* separate when the SDK has no proven atomic initializer deployment.
+*/
+async function prepareAlgebraPool(params) {
+	const snapshot = await inspectAlgebraPool(params);
+	if (snapshot.status === "absent") return {
+		status: "ready-create",
+		snapshot,
+		action: buildAlgebraCreatePoolTransaction({
+			deployment: snapshot.deployment,
+			key: params.key,
+			preflight: snapshot,
+			pluginData: params.pluginData
+		})
+	};
+	if (snapshot.status === "uninitialized") return {
+		status: "ready-initialize",
+		snapshot,
+		action: buildAlgebraInitializePoolTransaction({
+			deployment: snapshot.deployment,
+			key: params.key,
+			preflight: snapshot,
+			initialPrice: params.initialPrice
+		})
+	};
+	const expected = assertAlgebraInitialPrice(snapshot.key, params.initialPrice);
+	if (snapshot.sqrtPriceX96 !== expected.sqrtPriceX96) throw new PoolLifecycleError("POOL_STATE_MISMATCH", `Algebra pool ${snapshot.poolAddress} is already initialized at a different price.`);
+	return {
+		status: "already-initialized-matching",
+		snapshot,
+		action: null
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/algebra/types.ts
+function invalid$1(message) {
+	throw new PoolLifecycleError("INVALID_INPUT", message);
+}
+function record$1(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return invalid$1(`${label} must be an object.`);
+	return value;
+}
+function address$1(value, label, nullable = false) {
+	if (nullable && value === null) return null;
+	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) return invalid$1(`${label} must be a valid address.`);
+	const result = (0, viem.getAddress)(value);
+	if (result === "0x0000000000000000000000000000000000000000") return invalid$1(`${label} must not be zero.`);
+	return result;
+}
+function hex(value, label) {
+	if (typeof value !== "string" || !/^0x(?:[0-9a-fA-F]{2})*$/.test(value)) return invalid$1(`${label} must be hex bytes.`);
+	return value;
+}
+function key(value) {
+	const item = record$1(value, "Algebra key");
+	const token0 = address$1(item.token0, "Algebra token0");
+	const token1 = address$1(item.token1, "Algebra token1");
+	if (BigInt(token0) >= BigInt(token1)) return invalid$1("Algebra tokens must be canonically ordered and distinct.");
+	return {
+		token0,
+		token1
+	};
+}
+/** Re-derive target and calldata after a plan crosses a UI/CLI/JSON boundary. */
+function validatePreparedAlgebraPoolAction(value) {
+	const action = record$1(value, "Prepared Algebra action");
+	if (action.schemaVersion !== 1 || action.kind !== "algebra-create" && action.kind !== "algebra-initialize") return invalid$1("Prepared Algebra action kind or schema version is unsupported.");
+	if (typeof action.protocol !== "string") return invalid$1("Algebra action protocol must be a string.");
+	const tx = record$1(action.transaction, "Algebra transaction");
+	if (!Number.isSafeInteger(tx.chainId) || Number(tx.chainId) <= 0) return invalid$1("Algebra chainId must be a positive safe integer.");
+	if (tx.value !== 0n) return invalid$1("Algebra lifecycle transactions must have zero value.");
+	const to = address$1(tx.to, "Algebra transaction target");
+	const data = hex(tx.data, "Algebra calldata");
+	const deployment = resolveAlgebraLifecycleDeployment({
+		chainId: Number(tx.chainId),
+		protocol: action.protocol
+	});
+	if (!deployment) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `No Algebra lifecycle deployment is configured for chain ${tx.chainId} and protocol ${action.protocol}.`);
+	const identity = record$1(action.identity, "Algebra identity");
+	const poolKey = key(identity.key);
+	if (identity.family !== "algebra" || identity.adapter !== deployment.adapter || identity.version !== deployment.version || identity.variant !== deployment.variant || identity.chainId !== deployment.chainId || address$1(identity.factory, "Algebra identity factory") !== (0, viem.getAddress)(deployment.factory)) return invalid$1("Algebra identity does not match the configured deployment.");
+	const expected = record$1(action.expected, "Algebra expectation");
+	const preflight = record$1(action.preflight, "Algebra preflight");
+	if (typeof preflight.blockNumber !== "bigint" || preflight.blockNumber < 0n) return invalid$1("Algebra preflight blockNumber must be a non-negative bigint.");
+	let expectedTo;
+	let expectedData;
+	if (action.kind === "algebra-create") {
+		if (identity.poolAddress !== null || expected.sqrtPriceX96 !== null || preflight.status !== "absent" || preflight.poolAddress !== null || preflight.sqrtPriceX96 !== 0n) return invalid$1("Algebra create cannot bind an existing pool or price.");
+		const pluginData = hex(expected.pluginData, "Algebra plugin data");
+		expectedTo = (0, viem.getAddress)(deployment.factory);
+		expectedData = deployment.createPool === "pair-with-plugin-data" ? (0, viem.encodeFunctionData)({
+			abi: algebraIntegralPluginDataFactoryAbi,
+			functionName: "createPool",
+			args: [
+				poolKey.token0,
+				poolKey.token1,
+				pluginData
+			]
+		}) : (0, viem.encodeFunctionData)({
+			abi: deployment.variant === "integral-v1" ? algebraIntegralPairFactoryAbi : algebraPairFactoryAbi,
+			functionName: "createPool",
+			args: [poolKey.token0, poolKey.token1]
+		});
+	} else {
+		const pool = address$1(identity.poolAddress, "Algebra pool address");
+		if (expected.pluginData !== null || typeof expected.sqrtPriceX96 !== "bigint" || preflight.status !== "uninitialized" || address$1(preflight.poolAddress, "Algebra preflight pool") !== pool || preflight.sqrtPriceX96 !== 0n) return invalid$1("Algebra initialize expectation is invalid.");
+		try {
+			validateSqrtPriceX96(expected.sqrtPriceX96);
+		} catch (error) {
+			return invalid$1(error instanceof Error ? error.message : "Invalid Algebra price.");
+		}
+		expectedTo = pool;
+		expectedData = (0, viem.encodeFunctionData)({
+			abi: algebraPoolBaseAbi,
+			functionName: "initialize",
+			args: [expected.sqrtPriceX96]
+		});
+	}
+	if (to !== expectedTo || data.toLowerCase() !== expectedData.toLowerCase()) return invalid$1("Algebra transaction does not match its trusted deployment and expectation.");
+	return deployment;
+}
+function deserializePreparedAlgebraPoolAction(serialized) {
+	const action = deserializePreparedPoolAction(serialized);
+	validatePreparedAlgebraPoolAction(action);
+	return action;
+}
+//#endregion
+//#region src/pool-lifecycle/algebra/simulate.ts
+async function simulateAlgebraPoolAction(params) {
+	if (!(0, viem.isAddress)(params.account, { strict: true }) || (0, viem.getAddress)(params.account) === "0x0000000000000000000000000000000000000000") throw new PoolLifecycleError("INVALID_INPUT", "Simulation account must be a valid non-zero address.");
+	const deployment = validatePreparedAlgebraPoolAction(params.action);
+	const blockNumber = params.blockNumber ?? await params.publicClient.getBlockNumber();
+	const snapshot = await inspectAlgebraPool({
+		publicClient: params.publicClient,
+		deployment,
+		key: {
+			tokenA: params.action.identity.key.token0,
+			tokenB: params.action.identity.key.token1
+		},
+		blockNumber
+	});
+	if (params.action.kind === "algebra-create" && snapshot.status !== "absent") throw new PoolLifecycleError("POOL_STATE_MISMATCH", `Algebra pool already exists at ${snapshot.poolAddress}; refresh the action.`);
+	if (params.action.kind === "algebra-initialize" && (snapshot.status !== "uninitialized" || snapshot.poolAddress !== params.action.identity.poolAddress)) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Algebra pool is no longer the uninitialized factory pool bound to this action.");
+	const request = {
+		account: (0, viem.getAddress)(params.account),
+		to: params.action.transaction.to,
+		data: params.action.transaction.data,
+		value: params.action.transaction.value,
+		blockNumber
+	};
+	try {
+		const [call, gasEstimate] = await Promise.all([params.publicClient.call({
+			...request,
+			batch: false
+		}), params.publicClient.estimateGas(request)]);
+		let returnedPoolAddress = null;
+		if (params.action.kind === "algebra-create") {
+			if (!call.data || call.data === "0x") throw new PoolLifecycleError("SIMULATION_FAILED", "Algebra create returned no pool address.");
+			returnedPoolAddress = (0, viem.getAddress)((0, viem.decodeFunctionResult)({
+				abi: deployment.createPool === "pair-with-plugin-data" ? algebraIntegralPluginDataFactoryAbi : deployment.variant === "integral-v1" ? algebraIntegralPairFactoryAbi : algebraPairFactoryAbi,
+				functionName: "createPool",
+				data: call.data
+			}));
+			if (returnedPoolAddress === "0x0000000000000000000000000000000000000000") throw new PoolLifecycleError("SIMULATION_FAILED", "Algebra create simulation returned the zero pool address.");
+		}
+		return {
+			transaction: params.action.transaction,
+			blockNumber,
+			returnData: call.data ?? null,
+			returnedPoolAddress,
+			gasEstimate
+		};
+	} catch (error) {
+		if (error instanceof PoolLifecycleError) throw error;
+		throw new PoolLifecycleError("SIMULATION_FAILED", error instanceof Error ? error.message : "Algebra simulation failed.", error);
+	}
+}
+//#endregion
+//#region src/pool-lifecycle/algebra/verify.ts
+function assertReceiptLog(log, receipt) {
+	if (log.transactionHash !== receipt.transactionHash || log.blockHash !== receipt.blockHash || log.blockNumber !== receipt.blockNumber || log.transactionIndex !== receipt.transactionIndex || log.removed !== false) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Algebra lifecycle log does not belong to the canonical receipt.");
+}
+function decodeAlgebraPoolActionReceipt(action, receipt) {
+	validatePreparedAlgebraPoolAction(action);
+	const created = [];
+	const initialized = [];
+	for (const log of receipt.logs) {
+		if ((0, viem.getAddress)(log.address) === action.identity.factory) try {
+			const decoded = (0, viem.decodeEventLog)({
+				abi: algebraPairFactoryAbi,
+				eventName: "Pool",
+				data: log.data,
+				topics: log.topics
+			});
+			if ((0, viem.getAddress)(decoded.args.token0) === action.identity.key.token0 && (0, viem.getAddress)(decoded.args.token1) === action.identity.key.token1) {
+				assertReceiptLog(log, receipt);
+				created.push({
+					poolAddress: (0, viem.getAddress)(decoded.args.pool),
+					logIndex: log.logIndex
+				});
+			}
+		} catch (error) {
+			if (error instanceof PoolLifecycleError) throw error;
+		}
+		if (action.kind !== "algebra-initialize" || action.identity.poolAddress === null || (0, viem.getAddress)(log.address) !== action.identity.poolAddress) continue;
+		try {
+			const decoded = (0, viem.decodeEventLog)({
+				abi: algebraPoolBaseAbi,
+				eventName: "Initialize",
+				data: log.data,
+				topics: log.topics
+			});
+			assertReceiptLog(log, receipt);
+			initialized.push({
+				poolAddress: (0, viem.getAddress)(log.address),
+				sqrtPriceX96: decoded.args.price,
+				tick: Number(decoded.args.tick),
+				logIndex: log.logIndex
+			});
+		} catch (error) {
+			if (error instanceof PoolLifecycleError) throw error;
+		}
+	}
+	if (created.length > 1 || initialized.length > 1) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Receipt contains duplicate matching Algebra lifecycle events.");
+	return {
+		receiptStatus: receipt.status,
+		poolCreated: created[0] ?? null,
+		initialization: initialized[0] ?? null
+	};
+}
+function result(action, evidence, snapshot, blockNumber) {
+	const identity = {
+		...action.identity,
+		poolAddress: snapshot?.poolAddress ?? action.identity.poolAddress
+	};
+	if (evidence.receiptStatus === "reverted") return {
+		verified: false,
+		outcome: "reverted",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: []
+	};
+	if (!snapshot || snapshot.status === "absent" || !snapshot.poolAddress) return {
+		verified: false,
+		outcome: "not-initialized",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: []
+	};
+	if (action.kind === "algebra-create") {
+		if (!evidence.poolCreated || evidence.poolCreated.poolAddress !== snapshot.poolAddress) return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings: ["Pool event does not match the factory pool at the receipt block."]
+		};
+		return {
+			verified: true,
+			outcome: "created",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings: snapshot.status === "initialized" ? ["Pool was initialized by another call in the same block."] : []
+		};
+	}
+	const initialization = evidence.initialization;
+	if (!initialization || initialization.poolAddress !== snapshot.poolAddress) return {
+		verified: false,
+		outcome: "not-initialized",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Receipt contains no Initialize event for the expected Algebra pool."]
+	};
+	if (initialization.sqrtPriceX96 !== action.expected.sqrtPriceX96) return {
+		verified: false,
+		outcome: "already-initialized-different-price",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Initialize event used a different price."]
+	};
+	if (snapshot.status !== "initialized") return {
+		verified: false,
+		outcome: "not-initialized",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: []
+	};
+	if (snapshot.sqrtPriceX96 !== action.expected.sqrtPriceX96) return {
+		verified: true,
+		outcome: "initialized-then-price-moved",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Pool price moved after initialization in the receipt block."]
+	};
+	return {
+		verified: true,
+		outcome: "initialized-existing",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: []
+	};
+}
+function unavailable$1(action, receipt, warning) {
+	return {
+		verified: false,
+		outcome: "verification-unavailable",
+		blockNumber: receipt.blockNumber,
+		identity: action.identity,
+		state: null,
+		evidence: {
+			receiptStatus: receipt.status,
+			poolCreated: null,
+			initialization: null
+		},
+		warnings: [warning]
+	};
+}
+async function verifyAlgebraPoolAction(params) {
+	const deployment = validatePreparedAlgebraPoolAction(params.action);
+	let chainId;
+	let transaction;
+	let receipt;
+	try {
+		[chainId, transaction, receipt] = await Promise.all([
+			params.publicClient.getChainId(),
+			params.publicClient.getTransaction({ hash: params.receipt.transactionHash }),
+			params.publicClient.getTransactionReceipt({ hash: params.receipt.transactionHash })
+		]);
+	} catch (error) {
+		return unavailable$1(params.action, params.receipt, error instanceof Error ? error.message : "Could not load canonical transaction evidence.");
+	}
+	const expectedTarget = (0, viem.getAddress)(params.action.transaction.to);
+	if (!(chainId === params.action.transaction.chainId && params.receipt.transactionHash === receipt.transactionHash && params.receipt.blockHash === receipt.blockHash && params.receipt.blockNumber === receipt.blockNumber && params.receipt.transactionIndex === receipt.transactionIndex && params.receipt.status === receipt.status && receipt.to !== null && (0, viem.getAddress)(receipt.to) === expectedTarget && transaction.to !== null && (0, viem.getAddress)(transaction.to) === expectedTarget && transaction.hash === params.receipt.transactionHash && transaction.hash === receipt.transactionHash && transaction.input.toLowerCase() === params.action.transaction.data.toLowerCase() && transaction.value === params.action.transaction.value && transaction.blockHash === receipt.blockHash && transaction.blockNumber === receipt.blockNumber && transaction.transactionIndex === receipt.transactionIndex && (0, viem.getAddress)(transaction.from) === (0, viem.getAddress)(receipt.from))) return {
+		...unavailable$1(params.action, receipt, "Receipt, transaction, client, or prepared action do not match."),
+		outcome: "wrong-deployment"
+	};
+	let evidence;
+	try {
+		evidence = decodeAlgebraPoolActionReceipt(params.action, receipt);
+	} catch (error) {
+		return {
+			...unavailable$1(params.action, receipt, error instanceof Error ? error.message : "Receipt evidence is invalid."),
+			outcome: "wrong-deployment"
+		};
+	}
+	try {
+		if ((await params.publicClient.getBlock({
+			blockNumber: receipt.blockNumber,
+			includeTransactions: false
+		})).hash !== receipt.blockHash) return unavailable$1(params.action, receipt, "Receipt block is no longer canonical.");
+		if (receipt.status === "reverted") return result(params.action, evidence, null, receipt.blockNumber);
+		const snapshot = await inspectAlgebraPool({
+			publicClient: params.publicClient,
+			deployment,
+			key: {
+				tokenA: params.action.identity.key.token0,
+				tokenB: params.action.identity.key.token1
+			},
+			blockNumber: receipt.blockNumber
+		});
+		if ((await params.publicClient.getBlock({
+			blockNumber: receipt.blockNumber,
+			includeTransactions: false
+		})).hash !== receipt.blockHash) return unavailable$1(params.action, receipt, "Receipt block changed during verification.");
+		return result(params.action, evidence, snapshot, receipt.blockNumber);
+	} catch (error) {
+		if (error instanceof PoolLifecycleError) return {
+			...unavailable$1(params.action, receipt, error.message),
+			outcome: "wrong-deployment",
+			evidence
+		};
+		return {
+			...unavailable$1(params.action, receipt, error instanceof Error ? error.message : "Pool state verification failed."),
+			evidence
+		};
+	}
+}
+//#endregion
+//#region src/pool-lifecycle/v3/types.ts
+function invalidPreparedAction(message) {
+	throw new PoolLifecycleError("INVALID_INPUT", message);
+}
+function asRecord(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return invalidPreparedAction(`${label} must be an object.`);
+	return value;
+}
+function asAddress(value, label, allowZero = false) {
+	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) return invalidPreparedAction(`${label} must be a valid EVM address.`);
+	const address = (0, viem.getAddress)(value);
+	if (!allowZero && address === "0x0000000000000000000000000000000000000000") return invalidPreparedAction(`${label} must not be the zero address.`);
+	return address;
+}
+function asNullableAddress(value, label) {
+	return value === null ? null : asAddress(value, label);
+}
+function asNonNegativeBigInt(value, label) {
+	if (typeof value !== "bigint" || value < 0n) return invalidPreparedAction(`${label} must be a non-negative bigint.`);
+	return value;
+}
+function asPoolKey(value) {
+	const key = asRecord(value, "V3 action identity key");
+	const token0 = asAddress(key.token0, "V3 action token0");
+	const token1 = asAddress(key.token1, "V3 action token1");
+	if (BigInt(token0) >= BigInt(token1)) return invalidPreparedAction("V3 action tokens must be distinct and canonically ordered.");
+	if (!Number.isSafeInteger(key.fee) || Number(key.fee) < 0 || Number(key.fee) >= 1e6) return invalidPreparedAction("V3 action fee must be an integer from 0 through 999999.");
+	return {
+		token0,
+		token1,
+		fee: Number(key.fee)
+	};
+}
+function asExpectedSqrtPrice(value) {
+	const sqrtPriceX96 = asNonNegativeBigInt(value, "V3 action expected sqrtPriceX96");
+	try {
+		return validateSqrtPriceX96(sqrtPriceX96);
+	} catch (error) {
+		return invalidPreparedAction(error instanceof Error ? error.message : "V3 action expected sqrtPriceX96 is invalid.");
+	}
+}
+function validatePreflight(value) {
+	const preflight = asRecord(value, "V3 action preflight");
+	const blockNumber = asNonNegativeBigInt(preflight.blockNumber, "V3 preflight blockNumber");
+	const sqrtPriceX96 = asNonNegativeBigInt(preflight.sqrtPriceX96, "V3 preflight sqrtPriceX96");
+	if (preflight.status === "absent") {
+		if (preflight.poolAddress !== null || sqrtPriceX96 !== 0n) return invalidPreparedAction("An absent V3 preflight must have no pool and zero price.");
+		return {
+			blockNumber,
+			status: "absent",
+			poolAddress: null,
+			sqrtPriceX96: 0n
+		};
+	}
+	const poolAddress = asAddress(preflight.poolAddress, "V3 preflight poolAddress");
+	if (preflight.status === "uninitialized") {
+		if (sqrtPriceX96 !== 0n) return invalidPreparedAction("An uninitialized V3 preflight must have zero price.");
+		return {
+			blockNumber,
+			status: "uninitialized",
+			poolAddress,
+			sqrtPriceX96: 0n
+		};
+	}
+	if (preflight.status === "initialized") {
+		asExpectedSqrtPrice(sqrtPriceX96);
+		return {
+			blockNumber,
+			status: "initialized",
+			poolAddress,
+			sqrtPriceX96
+		};
+	}
+	return invalidPreparedAction("V3 action preflight status is unsupported.");
+}
+/**
+* Runtime validation for plans crossing JSON, UI/CLI, or signer boundaries.
+* It re-derives the exact target, value, and calldata from trusted capability
+* metadata plus the declared kind, key, and expectation.
+*/
+function validatePreparedV3PoolAction(value) {
+	const action = asRecord(value, "Prepared V3 pool action");
+	if (action.schemaVersion !== 1) return invalidPreparedAction("Prepared V3 pool action schemaVersion is unsupported.");
+	if (action.kind !== "v3-create" && action.kind !== "v3-initialize" && action.kind !== "v3-create-and-initialize") return invalidPreparedAction("Prepared V3 pool action kind is unsupported.");
+	const transaction = asRecord(action.transaction, "V3 action transaction");
+	if (!Number.isSafeInteger(transaction.chainId) || Number(transaction.chainId) <= 0) return invalidPreparedAction("V3 action chainId must be a positive safe integer.");
+	const chainId = Number(transaction.chainId);
+	const to = asAddress(transaction.to, "V3 action transaction target");
+	if (typeof transaction.data !== "string" || !/^0x(?:[0-9a-fA-F]{2})+$/.test(transaction.data)) return invalidPreparedAction("V3 action calldata must be non-empty hex bytes.");
+	if (transaction.value !== 0n) return invalidPreparedAction("V3 pool lifecycle transactions must have zero value.");
+	if (typeof action.protocol !== "string") return invalidPreparedAction("V3 action protocol must be a string.");
+	const deployment = resolveV3LifecycleDeployment({
+		chainId,
+		protocol: action.protocol
+	});
+	if (!deployment) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `No pool lifecycle deployment is configured for chain ${chainId} and protocol ${action.protocol}.`);
+	const identity = asRecord(action.identity, "V3 action identity");
+	const key = asPoolKey(identity.key);
+	if (identity.family !== deployment.family || identity.adapter !== deployment.adapter || identity.version !== deployment.version || identity.chainId !== chainId || asAddress(identity.factory, "V3 action factory") !== (0, viem.getAddress)(deployment.factory) || asNullableAddress(identity.initializer, "V3 action initializer") !== (deployment.initializer === null ? null : (0, viem.getAddress)(deployment.initializer))) return invalidPreparedAction("V3 action identity does not match the configured deployment.");
+	const expected = asRecord(action.expected, "V3 action expectation");
+	const preflight = validatePreflight(action.preflight);
+	let expectedTo;
+	let expectedData;
+	if (action.kind === "v3-create") {
+		if (expected.sqrtPriceX96 !== null || identity.poolAddress !== null) return invalidPreparedAction("A V3 create action must expect no price and no existing pool.");
+		if (preflight.status !== "absent") return invalidPreparedAction("A V3 create action requires an inspected absent-pool preflight.");
+		expectedTo = (0, viem.getAddress)(deployment.factory);
+		expectedData = (0, viem.encodeFunctionData)({
+			abi: v3FactoryAbi,
+			functionName: "createPool",
+			args: [
+				key.token0,
+				key.token1,
+				key.fee
+			]
+		});
+	} else {
+		const sqrtPriceX96 = asExpectedSqrtPrice(expected.sqrtPriceX96);
+		if (action.kind === "v3-initialize") {
+			const poolAddress = asAddress(identity.poolAddress, "V3 initialize poolAddress");
+			if (preflight.status !== "uninitialized" || preflight.poolAddress !== poolAddress) return invalidPreparedAction("A V3 initialize action requires a matching uninitialized preflight.");
+			expectedTo = poolAddress;
+			expectedData = (0, viem.encodeFunctionData)({
+				abi: v3PoolAbi,
+				functionName: "initialize",
+				args: [sqrtPriceX96]
+			});
+		} else {
+			if (!deployment.atomicCreateAndInitialize) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `V3 deployment ${chainId}:${action.protocol} has no configured atomic initializer.`);
+			const poolAddress = identity.poolAddress === null ? null : asAddress(identity.poolAddress, "V3 create-and-initialize poolAddress");
+			if (preflight.status === "initialized") return invalidPreparedAction("A V3 create-and-initialize action requires an absent or uninitialized preflight.");
+			if (preflight.status === "absent" && poolAddress !== null || preflight.status === "uninitialized" && preflight.poolAddress !== poolAddress) return invalidPreparedAction("V3 create-and-initialize identity does not match its preflight.");
+			expectedTo = (0, viem.getAddress)(deployment.initializer);
+			expectedData = (0, viem.encodeFunctionData)({
+				abi: v3PoolInitializerAbi,
+				functionName: "createAndInitializePoolIfNecessary",
+				args: [
+					key.token0,
+					key.token1,
+					key.fee,
+					sqrtPriceX96
+				]
+			});
+		}
+	}
+	if (to !== expectedTo || transaction.data.toLowerCase() !== expectedData.toLowerCase()) return invalidPreparedAction("V3 action transaction does not match its kind, identity, and expectation.");
+	return deployment;
+}
+/** Assertion-form companion for consumers that need TypeScript narrowing. */
+function assertPreparedV3PoolAction(value) {
+	validatePreparedV3PoolAction(value);
+}
+/** Deserialize and fully validate a versioned V3 prepared action. */
+function deserializePreparedV3PoolAction(serialized) {
+	let value;
+	try {
+		value = deserializePreparedPoolAction(serialized);
+	} catch (error) {
+		throw new PoolLifecycleError("INVALID_INPUT", error instanceof Error ? error.message : "Serialized V3 pool action is invalid.", error);
+	}
+	assertPreparedV3PoolAction(value);
+	return value;
+}
+//#endregion
+//#region src/pool-lifecycle/v3/key.ts
+const MAX_V3_FEE = 1e6;
+/** Validate and canonicalize a V3 key without assuming a hard-coded fee tier. */
+function canonicalizeV3PoolKey(input) {
+	if (!Number.isSafeInteger(input.fee) || input.fee < 0 || input.fee >= MAX_V3_FEE) throw new PoolLifecycleError("INVALID_INPUT", "V3 fee must be an integer from 0 through 999999; deployment support is checked onchain.");
+	let pair;
+	try {
+		pair = sortErc20Pair(input.tokenA, input.tokenB);
+	} catch (error) {
+		throw new PoolLifecycleError("INVALID_INPUT", error instanceof Error ? error.message : "Invalid V3 token pair.", error);
+	}
+	return {
+		...pair,
+		fee: input.fee
+	};
+}
+/** Ensure an initial price is bound to the same canonical token pair as a V3 key. */
+function assertV3InitialPrice(key, price) {
+	try {
+		if ((0, viem.getAddress)(price.token0) !== key.token0 || (0, viem.getAddress)(price.token1) !== key.token1) throw new Error("Initial price token order does not match the canonical V3 pool key.");
+		validateSqrtPriceX96(price.sqrtPriceX96);
+	} catch (error) {
+		throw new PoolLifecycleError("INVALID_INPUT", error instanceof Error ? error.message : "Invalid V3 initial price.", error);
+	}
+	return {
+		token0: key.token0,
+		token1: key.token1,
+		sqrtPriceX96: price.sqrtPriceX96
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/v3/inspect.ts
+const ZERO_ADDRESS$1 = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+function hasCode$1(bytecode) {
+	return bytecode !== void 0 && bytecode !== "0x";
+}
+async function requireContractCode$1(publicClient, address, label, blockNumber) {
+	if (!hasCode$1(await publicClient.getCode({
+		address,
+		blockNumber
+	}))) throw new PoolLifecycleError("CONTRACT_NOT_DEPLOYED", `${label} ${address} has no bytecode at block ${blockNumber}.`);
+}
+/**
+* Read a block-consistent V3 deployment and pool snapshot before building or
+* verifying a lifecycle transaction.
+*/
+async function inspectV3Pool(params) {
+	const { publicClient, deployment } = params;
+	const key = canonicalizeV3PoolKey(params.key);
+	const activeChainId = await publicClient.getChainId();
+	if (activeChainId !== deployment.chainId) throw new PoolLifecycleError("CHAIN_MISMATCH", `Public client chain ${activeChainId} does not match lifecycle deployment chain ${deployment.chainId}.`);
+	const blockNumber = params.blockNumber ?? await publicClient.getBlockNumber();
+	const factory = (0, viem.getAddress)(deployment.factory);
+	await Promise.all([
+		requireContractCode$1(publicClient, factory, "V3 factory", blockNumber),
+		...deployment.atomicCreateAndInitialize ? [requireContractCode$1(publicClient, (0, viem.getAddress)(deployment.initializer), "V3 initializer", blockNumber)] : [],
+		requireContractCode$1(publicClient, key.token0, "token0", blockNumber),
+		requireContractCode$1(publicClient, key.token1, "token1", blockNumber)
+	]);
+	const [initializerFactoryResult, feeTickSpacingResult, poolResult] = await Promise.all([
+		deployment.atomicCreateAndInitialize ? publicClient.readContract({
+			address: (0, viem.getAddress)(deployment.initializer),
+			abi: v3PoolInitializerAbi,
+			functionName: "factory",
+			blockNumber
+		}) : Promise.resolve(null),
+		publicClient.readContract({
+			address: factory,
+			abi: v3FactoryAbi,
+			functionName: "feeAmountTickSpacing",
+			args: [key.fee],
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: factory,
+			abi: v3FactoryAbi,
+			functionName: "getPool",
+			args: [
+				key.token0,
+				key.token1,
+				key.fee
+			],
+			blockNumber
+		})
+	]);
+	if (deployment.atomicCreateAndInitialize && (0, viem.getAddress)(initializerFactoryResult) !== factory) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `V3 initializer factory ${(0, viem.getAddress)(initializerFactoryResult)} does not match configured factory ${factory}.`);
+	const feeTickSpacing = Number(feeTickSpacingResult);
+	if (!Number.isInteger(feeTickSpacing) || feeTickSpacing <= 0) throw new PoolLifecycleError("DISABLED_FEE", `V3 fee ${key.fee} is not enabled by factory ${factory}.`);
+	const poolAddress = (0, viem.getAddress)(poolResult);
+	if (poolAddress === ZERO_ADDRESS$1) return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		feeTickSpacing,
+		status: "absent",
+		poolAddress: null,
+		sqrtPriceX96: 0n,
+		tick: null,
+		tickSpacing: feeTickSpacing
+	};
+	await requireContractCode$1(publicClient, poolAddress, "V3 pool", blockNumber);
+	const [actualFactoryResult, token0Result, token1Result, feeResult, tickSpacingResult, slot0] = await Promise.all([
+		publicClient.readContract({
+			address: poolAddress,
+			abi: v3PoolAbi,
+			functionName: "factory",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: v3PoolAbi,
+			functionName: "token0",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: v3PoolAbi,
+			functionName: "token1",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: v3PoolAbi,
+			functionName: "fee",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: v3PoolAbi,
+			functionName: "tickSpacing",
+			blockNumber
+		}),
+		publicClient.readContract({
+			address: poolAddress,
+			abi: v3PoolAbi,
+			functionName: "slot0",
+			blockNumber
+		})
+	]);
+	const actualFactory = (0, viem.getAddress)(actualFactoryResult);
+	const actualToken0 = (0, viem.getAddress)(token0Result);
+	const actualToken1 = (0, viem.getAddress)(token1Result);
+	const actualFee = Number(feeResult);
+	const tickSpacing = Number(tickSpacingResult);
+	if (actualFactory !== factory || actualToken0 !== key.token0 || actualToken1 !== key.token1 || actualFee !== key.fee || tickSpacing !== feeTickSpacing) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Pool ${poolAddress} immutables do not match the configured V3 deployment and key.`);
+	const sqrtPriceX96 = slot0[0];
+	const tick = Number(slot0[1]);
+	if (sqrtPriceX96 === 0n) return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		feeTickSpacing,
+		status: "uninitialized",
+		poolAddress,
+		sqrtPriceX96: 0n,
+		tick,
+		tickSpacing
+	};
+	return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		feeTickSpacing,
+		status: "initialized",
+		poolAddress,
+		sqrtPriceX96,
+		tick,
+		tickSpacing
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/v3/actions.ts
+function preflightSummary(preflight) {
+	if (preflight.status === "absent") return {
+		blockNumber: preflight.blockNumber,
+		status: "absent",
+		poolAddress: null,
+		sqrtPriceX96: 0n
+	};
+	if (preflight.status === "uninitialized") return {
+		blockNumber: preflight.blockNumber,
+		status: "uninitialized",
+		poolAddress: preflight.poolAddress,
+		sqrtPriceX96: 0n
+	};
+	return {
+		blockNumber: preflight.blockNumber,
+		status: "initialized",
+		poolAddress: preflight.poolAddress,
+		sqrtPriceX96: preflight.sqrtPriceX96
+	};
+}
+function assertConfiguredDeployment(deployment) {
+	let matches = false;
+	try {
+		const configured = resolveV3LifecycleDeployment({
+			chainId: deployment.chainId,
+			protocol: deployment.protocol
+		});
+		matches = configured !== void 0 && deployment.supported === true && deployment.schemaVersion === configured.schemaVersion && deployment.family === configured.family && deployment.adapter === configured.adapter && deployment.version === configured.version && (0, viem.getAddress)(deployment.factory) === (0, viem.getAddress)(configured.factory) && (deployment.initializer === null || configured.initializer === null ? deployment.initializer === configured.initializer : (0, viem.getAddress)(deployment.initializer) === (0, viem.getAddress)(configured.initializer)) && deployment.atomicCreateAndInitialize === configured.atomicCreateAndInitialize && deployment.poolInitCodeHash === configured.poolInitCodeHash;
+	} catch {}
+	if (!matches) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `Pool lifecycle deployment is not configured for chain ${deployment.chainId} and protocol ${deployment.protocol}.`);
+}
+function assertAtomicDeployment(deployment) {
+	if (!deployment.atomicCreateAndInitialize) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `V3 deployment ${deployment.chainId}:${deployment.protocol} has no configured atomic initializer.`);
+}
+function assertPreflightMatches$1(deployment, key, preflight) {
+	if (!preflight) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "V3 transaction building requires an inspected preflight snapshot.");
+	let matches = false;
+	try {
+		matches = preflight.schemaVersion === 1 && typeof preflight.blockNumber === "bigint" && preflight.blockNumber >= 0n && preflight.deployment.chainId === deployment.chainId && preflight.deployment.schemaVersion === deployment.schemaVersion && preflight.deployment.protocol === deployment.protocol && preflight.deployment.family === deployment.family && preflight.deployment.adapter === deployment.adapter && preflight.deployment.version === deployment.version && (0, viem.getAddress)(preflight.deployment.factory) === (0, viem.getAddress)(deployment.factory) && (preflight.deployment.initializer === null || deployment.initializer === null ? preflight.deployment.initializer === deployment.initializer : (0, viem.getAddress)(preflight.deployment.initializer) === (0, viem.getAddress)(deployment.initializer)) && preflight.deployment.atomicCreateAndInitialize === deployment.atomicCreateAndInitialize && preflight.deployment.poolInitCodeHash === deployment.poolInitCodeHash && preflight.key.token0 === key.token0 && preflight.key.token1 === key.token1 && preflight.key.fee === key.fee && Number.isSafeInteger(preflight.feeTickSpacing) && preflight.feeTickSpacing > 0 && preflight.feeTickSpacing <= 16383 && preflight.tickSpacing === preflight.feeTickSpacing;
+	} catch {}
+	if (!matches) throw new PoolLifecycleError("INVALID_INPUT", "V3 preflight snapshot does not match the requested deployment and pool key.");
+	if (preflight.status !== "absent" && preflight.status !== "uninitialized" && preflight.status !== "initialized") throw new PoolLifecycleError("INVALID_INPUT", "V3 preflight status is unsupported.");
+	if (preflight.status === "absent") {
+		if (preflight.poolAddress !== null || preflight.sqrtPriceX96 !== 0n || preflight.tick !== null) throw new PoolLifecycleError("INVALID_INPUT", "Absent V3 preflight state is inconsistent.");
+		return;
+	}
+	if (!(0, viem.isAddress)(preflight.poolAddress, { strict: true }) || (0, viem.getAddress)(preflight.poolAddress) === "0x0000000000000000000000000000000000000000") throw new PoolLifecycleError("INVALID_INPUT", "V3 preflight pool address is invalid.");
+	if (preflight.status === "uninitialized" && preflight.sqrtPriceX96 !== 0n) throw new PoolLifecycleError("INVALID_INPUT", "Uninitialized V3 preflight state must have zero sqrtPriceX96.");
+	if (!Number.isSafeInteger(preflight.tick) || preflight.tick < -887272 || preflight.tick > 887272) throw new PoolLifecycleError("INVALID_INPUT", "V3 preflight tick is invalid.");
+	if (preflight.status === "initialized") try {
+		validateSqrtPriceX96(preflight.sqrtPriceX96);
+	} catch (error) {
+		throw new PoolLifecycleError("INVALID_INPUT", error instanceof Error ? error.message : "Initialized V3 preflight price is invalid.", error);
+	}
+}
+function assertCreatePreflight(preflight) {
+	if (preflight.status !== "absent") throw new PoolLifecycleError("POOL_STATE_MISMATCH", "V3 factory creation requires an inspected, absent pool.");
+}
+function assertAtomicPreflight(preflight, sqrtPriceX96) {
+	if (preflight.status === "initialized") throw new PoolLifecycleError("POOL_STATE_MISMATCH", `V3 pool is already initialized at a ${preflight.sqrtPriceX96 === sqrtPriceX96 ? "matching" : "different"} price; no initialization transaction was built.`);
+}
+function buildIdentity(deployment, key, poolAddress) {
+	return {
+		family: "uniswap-v3-compatible",
+		adapter: deployment.adapter,
+		version: deployment.version,
+		chainId: deployment.chainId,
+		factory: (0, viem.getAddress)(deployment.factory),
+		initializer: deployment.initializer === null ? null : (0, viem.getAddress)(deployment.initializer),
+		key,
+		poolAddress
+	};
+}
+/** Build the low-level V3 factory create transaction without signing it. */
+function buildV3CreatePoolTransaction(params) {
+	assertConfiguredDeployment(params.deployment);
+	const key = canonicalizeV3PoolKey(params.key);
+	assertPreflightMatches$1(params.deployment, key, params.preflight);
+	assertCreatePreflight(params.preflight);
+	return {
+		schemaVersion: 1,
+		kind: "v3-create",
+		protocol: params.deployment.protocol,
+		transaction: {
+			chainId: params.deployment.chainId,
+			to: (0, viem.getAddress)(params.deployment.factory),
+			data: (0, viem.encodeFunctionData)({
+				abi: v3FactoryAbi,
+				functionName: "createPool",
+				args: [
+					key.token0,
+					key.token1,
+					key.fee
+				]
+			}),
+			value: 0n
+		},
+		identity: buildIdentity(params.deployment, key, null),
+		expected: { sqrtPriceX96: null },
+		preflight: preflightSummary(params.preflight)
+	};
+}
+/** Build a direct one-time V3 pool initialize transaction without signing it. */
+function buildV3InitializePoolTransaction(params) {
+	assertConfiguredDeployment(params.deployment);
+	const key = canonicalizeV3PoolKey(params.key);
+	const initialPrice = assertV3InitialPrice(key, params.initialPrice);
+	if (!params.preflight || params.preflight.status !== "uninitialized") throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Direct V3 initialize requires an inspected, uninitialized pool.");
+	assertPreflightMatches$1(params.deployment, key, params.preflight);
+	const poolAddress = (0, viem.getAddress)(params.preflight.poolAddress);
+	return {
+		schemaVersion: 1,
+		kind: "v3-initialize",
+		protocol: params.deployment.protocol,
+		transaction: {
+			chainId: params.deployment.chainId,
+			to: poolAddress,
+			data: (0, viem.encodeFunctionData)({
+				abi: v3PoolAbi,
+				functionName: "initialize",
+				args: [initialPrice.sqrtPriceX96]
+			}),
+			value: 0n
+		},
+		identity: buildIdentity(params.deployment, key, poolAddress),
+		expected: { sqrtPriceX96: initialPrice.sqrtPriceX96 },
+		preflight: preflightSummary(params.preflight)
+	};
+}
+/** Build the canonical atomic create-and-initialize V3 periphery transaction. */
+function buildV3CreateAndInitializeTransaction(params) {
+	assertConfiguredDeployment(params.deployment);
+	assertAtomicDeployment(params.deployment);
+	const key = canonicalizeV3PoolKey(params.key);
+	const initialPrice = assertV3InitialPrice(key, params.initialPrice);
+	assertPreflightMatches$1(params.deployment, key, params.preflight);
+	assertAtomicPreflight(params.preflight, initialPrice.sqrtPriceX96);
+	return {
+		schemaVersion: 1,
+		kind: "v3-create-and-initialize",
+		protocol: params.deployment.protocol,
+		transaction: {
+			chainId: params.deployment.chainId,
+			to: (0, viem.getAddress)(params.deployment.initializer),
+			data: (0, viem.encodeFunctionData)({
+				abi: v3PoolInitializerAbi,
+				functionName: "createAndInitializePoolIfNecessary",
+				args: [
+					key.token0,
+					key.token1,
+					key.fee,
+					initialPrice.sqrtPriceX96
+				]
+			}),
+			value: 0n
+		},
+		identity: buildIdentity(params.deployment, key, params.preflight.poolAddress),
+		expected: { sqrtPriceX96: initialPrice.sqrtPriceX96 },
+		preflight: preflightSummary(params.preflight)
+	};
+}
+/**
+* Prepare only the factory-creation step. This is the first stage for
+* deployments without a configured atomic initializer and deliberately does
+* not claim that the irreversible initial price has been set.
+*/
+async function prepareV3CreatePool(params) {
+	assertConfiguredDeployment(params.deployment);
+	const snapshot = await inspectV3Pool({
+		publicClient: params.publicClient,
+		deployment: params.deployment,
+		key: params.key,
+		blockNumber: params.blockNumber
+	});
+	if (snapshot.status !== "absent") return {
+		status: "already-exists",
+		snapshot,
+		action: null
+	};
+	return {
+		status: "ready",
+		snapshot,
+		action: buildV3CreatePoolTransaction({
+			deployment: params.deployment,
+			key: {
+				tokenA: snapshot.key.token0,
+				tokenB: snapshot.key.token1,
+				fee: snapshot.key.fee
+			},
+			preflight: snapshot
+		})
+	};
+}
+/**
+* Prepare only the direct, one-time pool initialization step. Callers using a
+* factory-only deployment must mine and verify creation, re-inspect the pool,
+* and then call this function; the SDK does not conceal the intervening race.
+*/
+async function prepareV3InitializePool(params) {
+	assertConfiguredDeployment(params.deployment);
+	const snapshot = await inspectV3Pool({
+		publicClient: params.publicClient,
+		deployment: params.deployment,
+		key: params.key,
+		blockNumber: params.blockNumber
+	});
+	const price = assertV3InitialPrice(snapshot.key, params.initialPrice);
+	if (snapshot.status === "absent") throw new PoolLifecycleError("POOL_STATE_MISMATCH", "V3 pool does not exist; create and verify it before preparing direct initialization.");
+	if (snapshot.status === "initialized") {
+		if (snapshot.sqrtPriceX96 === price.sqrtPriceX96) return {
+			status: "already-initialized-matching",
+			snapshot,
+			action: null
+		};
+		throw new PoolLifecycleError("POOL_STATE_MISMATCH", `V3 pool ${snapshot.poolAddress} is already initialized at a different price.`);
+	}
+	return {
+		status: "ready",
+		snapshot,
+		action: buildV3InitializePoolTransaction({
+			deployment: params.deployment,
+			key: {
+				tokenA: snapshot.key.token0,
+				tokenB: snapshot.key.token1,
+				fee: snapshot.key.fee
+			},
+			initialPrice: price,
+			preflight: snapshot
+		})
+	};
+}
+/**
+* Safe default preparation flow for UI and CLI consumers. It returns no
+* transaction for an already initialized pool only when the exact price
+* matches, and rejects a conflicting existing price.
+*/
+async function prepareV3CreateAndInitialize(params) {
+	assertConfiguredDeployment(params.deployment);
+	assertAtomicDeployment(params.deployment);
+	const snapshot = await inspectV3Pool({
+		publicClient: params.publicClient,
+		deployment: params.deployment,
+		key: params.key,
+		blockNumber: params.blockNumber
+	});
+	const price = assertV3InitialPrice(snapshot.key, params.initialPrice);
+	if (snapshot.status === "initialized") {
+		if (snapshot.sqrtPriceX96 === price.sqrtPriceX96) return {
+			status: "already-initialized-matching",
+			snapshot,
+			action: null
+		};
+		throw new PoolLifecycleError("POOL_STATE_MISMATCH", `V3 pool ${snapshot.poolAddress} is already initialized at a different price.`);
+	}
+	return {
+		status: "ready",
+		snapshot,
+		action: buildV3CreateAndInitializeTransaction({
+			deployment: params.deployment,
+			key: {
+				tokenA: snapshot.key.token0,
+				tokenB: snapshot.key.token1,
+				fee: snapshot.key.fee
+			},
+			initialPrice: price,
+			preflight: snapshot
+		})
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/v3/simulate.ts
+const ZERO_ADDRESS = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+function decodeReturnedPool(action, returnData) {
+	switch (action.kind) {
+		case "v3-initialize": return null;
+		case "v3-create":
+			if (!returnData || returnData === "0x") throw new PoolLifecycleError("SIMULATION_FAILED", "V3 create simulation returned no pool address.");
+			return (0, viem.getAddress)((0, viem.decodeFunctionResult)({
+				abi: v3FactoryAbi,
+				functionName: "createPool",
+				data: returnData
+			}));
+		case "v3-create-and-initialize":
+			if (!returnData || returnData === "0x") throw new PoolLifecycleError("SIMULATION_FAILED", "V3 create-and-initialize simulation returned no pool address.");
+			return (0, viem.getAddress)((0, viem.decodeFunctionResult)({
+				abi: v3PoolInitializerAbi,
+				functionName: "createAndInitializePoolIfNecessary",
+				data: returnData
+			}));
+	}
+}
+/** Simulate and estimate a prepared action with the exact eventual sender. */
+async function simulateV3PoolAction(params) {
+	if (!(0, viem.isAddress)(params.account, { strict: true }) || (0, viem.getAddress)(params.account) === ZERO_ADDRESS) throw new PoolLifecycleError("INVALID_INPUT", "Simulation account must be a valid non-zero EVM address.");
+	const { publicClient, action } = params;
+	const deployment = validatePreparedV3PoolAction(action);
+	const account = (0, viem.getAddress)(params.account);
+	const blockNumber = params.blockNumber ?? await publicClient.getBlockNumber();
+	const snapshot = await inspectV3Pool({
+		publicClient,
+		deployment,
+		key: {
+			tokenA: action.identity.key.token0,
+			tokenB: action.identity.key.token1,
+			fee: action.identity.key.fee
+		},
+		blockNumber
+	});
+	if (action.kind === "v3-create" && snapshot.status !== "absent") throw new PoolLifecycleError("POOL_STATE_MISMATCH", `V3 pool already exists at ${snapshot.poolAddress}; refresh the prepared action.`);
+	if (action.kind === "v3-initialize" && (snapshot.status !== "uninitialized" || snapshot.poolAddress !== action.identity.poolAddress)) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "V3 pool is no longer the uninitialized factory pool bound to this action.");
+	if (action.kind === "v3-create-and-initialize" && snapshot.status === "initialized") throw new PoolLifecycleError("POOL_STATE_MISMATCH", `V3 pool ${snapshot.poolAddress} is already initialized; refresh the prepared action.`);
+	const targetCode = await publicClient.getCode({
+		address: action.transaction.to,
+		blockNumber
+	});
+	if (!targetCode || targetCode === "0x") throw new PoolLifecycleError("CONTRACT_NOT_DEPLOYED", `Pool action target ${action.transaction.to} has no bytecode at block ${blockNumber}.`);
+	const baseRequest = {
+		account,
+		to: action.transaction.to,
+		data: action.transaction.data,
+		value: action.transaction.value
+	};
+	const callRequest = {
+		...baseRequest,
+		batch: false,
+		blockNumber
+	};
+	const estimateRequest = {
+		...baseRequest,
+		blockNumber
+	};
+	try {
+		const callResult = await publicClient.call(callRequest);
+		const gasEstimate = await publicClient.estimateGas(estimateRequest);
+		const returnedPoolAddress = decodeReturnedPool(action, callResult.data);
+		if (action.identity.poolAddress && returnedPoolAddress && returnedPoolAddress !== action.identity.poolAddress) throw new PoolLifecycleError("POOL_STATE_MISMATCH", `Simulation returned pool ${returnedPoolAddress}, expected ${action.identity.poolAddress}.`);
+		return {
+			transaction: action.transaction,
+			blockNumber,
+			returnData: callResult.data ?? null,
+			returnedPoolAddress,
+			gasEstimate
+		};
+	} catch (error) {
+		if (error instanceof PoolLifecycleError) throw error;
+		throw new PoolLifecycleError("SIMULATION_FAILED", error instanceof Error ? error.message : "V3 pool action simulation failed.", error);
+	}
+}
+//#endregion
+//#region src/pool-lifecycle/v3/verify.ts
+function assertLogBelongsToReceipt$1(log, receipt) {
+	if (log.transactionHash !== receipt.transactionHash || log.blockHash !== receipt.blockHash || log.blockNumber !== receipt.blockNumber || log.transactionIndex !== receipt.transactionIndex || log.removed !== false) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Decoded V3 lifecycle log does not belong to the supplied receipt.");
+}
+function decodeMatchingPoolCreated(action, receipt) {
+	const matches = [];
+	for (const log of receipt.logs) {
+		if ((0, viem.getAddress)(log.address) !== action.identity.factory) continue;
+		let decoded;
+		try {
+			decoded = (0, viem.decodeEventLog)({
+				abi: v3FactoryAbi,
+				eventName: "PoolCreated",
+				data: log.data,
+				topics: log.topics
+			});
+		} catch {
+			continue;
+		}
+		if ((0, viem.getAddress)(decoded.args.token0) !== action.identity.key.token0 || (0, viem.getAddress)(decoded.args.token1) !== action.identity.key.token1 || Number(decoded.args.fee) !== action.identity.key.fee) continue;
+		assertLogBelongsToReceipt$1(log, receipt);
+		matches.push({
+			poolAddress: (0, viem.getAddress)(decoded.args.pool),
+			token0: (0, viem.getAddress)(decoded.args.token0),
+			token1: (0, viem.getAddress)(decoded.args.token1),
+			fee: Number(decoded.args.fee),
+			tickSpacing: Number(decoded.args.tickSpacing),
+			logIndex: log.logIndex
+		});
+	}
+	if (matches.length > 1) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Receipt contains multiple matching V3 PoolCreated events.");
+	return matches[0] ?? null;
+}
+function decodeInitializations(receipt) {
+	const initializations = [];
+	for (const log of receipt.logs) {
+		let decoded;
+		try {
+			decoded = (0, viem.decodeEventLog)({
+				abi: v3PoolAbi,
+				eventName: "Initialize",
+				data: log.data,
+				topics: log.topics
+			});
+		} catch {
+			continue;
+		}
+		assertLogBelongsToReceipt$1(log, receipt);
+		initializations.push({
+			poolAddress: (0, viem.getAddress)(log.address),
+			sqrtPriceX96: decoded.args.sqrtPriceX96,
+			tick: Number(decoded.args.tick),
+			logIndex: log.logIndex
+		});
+	}
+	return initializations;
+}
+/** Decode receipt evidence without making any RPC reads. */
+function decodeV3PoolActionReceipt(action, receipt) {
+	validatePreparedV3PoolAction(action);
+	return {
+		receiptStatus: receipt.status,
+		poolCreated: decodeMatchingPoolCreated(action, receipt),
+		initializations: decodeInitializations(receipt)
+	};
+}
+function withFinalPoolAddress(action, snapshot) {
+	return {
+		...action.identity,
+		poolAddress: snapshot?.poolAddress ?? action.identity.poolAddress
+	};
+}
+/** Evaluate decoded receipt evidence against a block-pinned V3 snapshot. */
+function evaluateV3PoolAction(action, evidence, snapshot, blockNumber) {
+	const warnings = [];
+	const identity = withFinalPoolAddress(action, snapshot);
+	if (evidence.receiptStatus === "reverted") return {
+		verified: false,
+		outcome: "reverted",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings
+	};
+	if (!snapshot || snapshot.status === "absent" || !snapshot.poolAddress) return {
+		verified: false,
+		outcome: "not-initialized",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings
+	};
+	const created = evidence.poolCreated;
+	const createdMatchesState = created !== null && created.poolAddress === snapshot.poolAddress && created.tickSpacing === snapshot.tickSpacing;
+	const initializationsAtPool = evidence.initializations.filter((item) => item.poolAddress === snapshot.poolAddress);
+	if (initializationsAtPool.length > 1) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Receipt contains multiple Initialize events for the expected V3 pool."]
+	};
+	const initializationAtPool = initializationsAtPool[0];
+	const exactInitialization = initializationsAtPool.find((item) => item.poolAddress === snapshot.poolAddress && action.expected.sqrtPriceX96 !== null && item.sqrtPriceX96 === action.expected.sqrtPriceX96);
+	if (created && !createdMatchesState) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: ["PoolCreated evidence does not match the receipt-block pool state."]
+	};
+	if (action.kind === "v3-create") {
+		if (!createdMatchesState) return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings
+		};
+		if (snapshot.status === "initialized") warnings.push("The pool was initialized after creation in the same block.");
+		return {
+			verified: true,
+			outcome: "created",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings
+		};
+	}
+	if (exactInitialization) {
+		if (snapshot.status !== "initialized") return {
+			verified: false,
+			outcome: "not-initialized",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings
+		};
+		if (snapshot.sqrtPriceX96 !== action.expected.sqrtPriceX96) {
+			warnings.push("Pool price moved after the matching Initialize event in the receipt block.");
+			return {
+				verified: true,
+				outcome: "initialized-then-price-moved",
+				blockNumber,
+				identity,
+				state: snapshot,
+				evidence,
+				warnings
+			};
+		}
+		return {
+			verified: true,
+			outcome: action.kind === "v3-create-and-initialize" && createdMatchesState ? "created-and-initialized" : "initialized-existing",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings
+		};
+	}
+	if (initializationAtPool) {
+		warnings.push("Receipt initialized the expected pool at a different price.");
+		return {
+			verified: false,
+			outcome: "already-initialized-different-price",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings
+		};
+	}
+	if (action.kind === "v3-create-and-initialize" && createdMatchesState) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings: ["PoolCreated evidence is missing the required same-receipt Initialize event."]
+	};
+	if (action.kind === "v3-create-and-initialize" && snapshot.status === "initialized") {
+		if (snapshot.sqrtPriceX96 === action.expected.sqrtPriceX96) {
+			warnings.push("The receipt contains no matching Initialize event; another transaction set the price.");
+			return {
+				verified: true,
+				outcome: "already-initialized-matching",
+				blockNumber,
+				identity,
+				state: snapshot,
+				evidence,
+				warnings
+			};
+		}
+		return {
+			verified: false,
+			outcome: "already-initialized-different-price",
+			blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings
+		};
+	}
+	return {
+		verified: false,
+		outcome: "not-initialized",
+		blockNumber,
+		identity,
+		state: snapshot,
+		evidence,
+		warnings
+	};
+}
+/** Compose receipt decoding with receipt-block deployment and state verification. */
+async function verifyV3PoolAction(params) {
+	const { publicClient, action, receipt } = params;
+	const deployment = validatePreparedV3PoolAction(action);
+	const emptyEvidence = {
+		receiptStatus: receipt.status,
+		poolCreated: null,
+		initializations: []
+	};
+	let activeChainId;
+	let transaction;
+	let canonicalReceipt;
+	try {
+		[activeChainId, transaction, canonicalReceipt] = await Promise.all([
+			publicClient.getChainId(),
+			publicClient.getTransaction({ hash: receipt.transactionHash }),
+			publicClient.getTransactionReceipt({ hash: receipt.transactionHash })
+		]);
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "verification-unavailable",
+			blockNumber: receipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence: emptyEvidence,
+			warnings: [error instanceof Error ? error.message : "Failed to load the canonical receipt and transaction."]
+		};
+	}
+	const nullableAddressMatches = (left, right) => left === null || right === null ? left === right : (0, viem.getAddress)(left) === (0, viem.getAddress)(right);
+	const target = (0, viem.getAddress)(action.transaction.to);
+	const suppliedReceiptMatchesCanonical = receipt.transactionHash === canonicalReceipt.transactionHash && receipt.blockHash === canonicalReceipt.blockHash && receipt.blockNumber === canonicalReceipt.blockNumber && receipt.transactionIndex === canonicalReceipt.transactionIndex && receipt.status === canonicalReceipt.status && nullableAddressMatches(receipt.to, canonicalReceipt.to);
+	const receiptDestinationMatches = canonicalReceipt.to !== null && (0, viem.getAddress)(canonicalReceipt.to) === target;
+	const transactionDestinationMatches = transaction.to !== null && (0, viem.getAddress)(transaction.to) === target;
+	const transactionMatches = transaction.hash === canonicalReceipt.transactionHash && transactionDestinationMatches && transaction.input.toLowerCase() === action.transaction.data.toLowerCase() && transaction.value === action.transaction.value && transaction.blockHash === canonicalReceipt.blockHash && transaction.blockNumber === canonicalReceipt.blockNumber && transaction.transactionIndex === canonicalReceipt.transactionIndex && (0, viem.getAddress)(transaction.from) === (0, viem.getAddress)(canonicalReceipt.from);
+	if (activeChainId !== action.transaction.chainId || !suppliedReceiptMatchesCanonical || !receiptDestinationMatches || !transactionMatches) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber: canonicalReceipt.blockNumber,
+		identity: action.identity,
+		state: null,
+		evidence: emptyEvidence,
+		warnings: ["Receipt, client, or lifecycle deployment does not match the prepared action."]
+	};
+	let evidence;
+	try {
+		evidence = decodeV3PoolActionReceipt(action, canonicalReceipt);
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber: canonicalReceipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence: emptyEvidence,
+			warnings: [error instanceof Error ? error.message : "Receipt log attribution failed."]
+		};
+	}
+	let blockHashBefore;
+	try {
+		blockHashBefore = (await publicClient.getBlock({
+			blockNumber: canonicalReceipt.blockNumber,
+			includeTransactions: false
+		})).hash;
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "verification-unavailable",
+			blockNumber: canonicalReceipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence,
+			warnings: [error instanceof Error ? error.message : "Failed to load the receipt block."]
+		};
+	}
+	if (blockHashBefore !== canonicalReceipt.blockHash) return {
+		verified: false,
+		outcome: "verification-unavailable",
+		blockNumber: canonicalReceipt.blockNumber,
+		identity: action.identity,
+		state: null,
+		evidence,
+		warnings: ["Receipt block is no longer canonical; retry verification with a fresh receipt."]
+	};
+	if (canonicalReceipt.status === "reverted") return evaluateV3PoolAction(action, evidence, null, canonicalReceipt.blockNumber);
+	let snapshot;
+	try {
+		snapshot = await inspectV3Pool({
+			publicClient,
+			deployment,
+			key: {
+				tokenA: action.identity.key.token0,
+				tokenB: action.identity.key.token1,
+				fee: action.identity.key.fee
+			},
+			blockNumber: canonicalReceipt.blockNumber
+		});
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: error instanceof PoolLifecycleError ? "wrong-deployment" : "verification-unavailable",
+			blockNumber: canonicalReceipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence,
+			warnings: [error instanceof Error ? error.message : "Failed to verify V3 pool state."]
+		};
+	}
+	try {
+		if ((await publicClient.getBlock({
+			blockNumber: canonicalReceipt.blockNumber,
+			includeTransactions: false
+		})).hash !== canonicalReceipt.blockHash) return {
+			verified: false,
+			outcome: "verification-unavailable",
+			blockNumber: canonicalReceipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence,
+			warnings: ["Receipt block changed during verification; retry with a fresh receipt."]
+		};
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "verification-unavailable",
+			blockNumber: canonicalReceipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence,
+			warnings: [error instanceof Error ? error.message : "Failed to confirm the canonical receipt block."]
+		};
+	}
+	return evaluateV3PoolAction(action, evidence, snapshot, canonicalReceipt.blockNumber);
+}
+//#endregion
+//#region src/pool-lifecycle/v4/inspect.ts
+function hasCode(bytecode) {
+	return bytecode !== void 0 && bytecode !== "0x";
+}
+async function requireContractCode(publicClient, address, label, blockNumber) {
+	if (!hasCode(await publicClient.getCode({
+		address,
+		blockNumber
+	}))) throw new PoolLifecycleError("CONTRACT_NOT_DEPLOYED", `${label} ${address} has no bytecode at block ${blockNumber}.`);
+}
+function asUint24(value, label) {
+	const converted = Number(value);
+	if (!Number.isSafeInteger(converted) || converted < 0 || converted > 16777215) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `${label} returned by StateView is not a uint24.`);
+	return converted;
+}
+function asTick(value) {
+	const converted = Number(value);
+	if (!Number.isSafeInteger(converted) || converted < -887272 || converted > 887272) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", "Tick returned by StateView is outside the TickMath range.");
+	return converted;
+}
+/** Read PoolManager identity and pool state at one pinned block. */
+async function inspectV4Pool(params) {
+	const { publicClient } = params;
+	const deployment = validateV4LifecycleDeployment(params.deployment);
+	const key = canonicalizeV4PoolKey(params.key);
+	const activeChainId = await publicClient.getChainId();
+	if (activeChainId !== deployment.chainId) throw new PoolLifecycleError("CHAIN_MISMATCH", `Public client chain ${activeChainId} does not match V4 deployment chain ${deployment.chainId}.`);
+	const blockNumber = params.blockNumber ?? await publicClient.getBlockNumber();
+	if (typeof blockNumber !== "bigint" || blockNumber < 0n) throw new PoolLifecycleError("INVALID_INPUT", "V4 inspection blockNumber must be non-negative.");
+	const codeChecks = [requireContractCode(publicClient, deployment.poolManager, "V4 PoolManager", blockNumber), requireContractCode(publicClient, deployment.stateView, "V4 StateView", blockNumber)];
+	if (key.currency0 !== V4_ZERO_ADDRESS) codeChecks.push(requireContractCode(publicClient, key.currency0, "currency0", blockNumber));
+	codeChecks.push(requireContractCode(publicClient, key.currency1, "currency1", blockNumber));
+	if (key.hooks !== V4_ZERO_ADDRESS) codeChecks.push(requireContractCode(publicClient, key.hooks, "V4 hooks", blockNumber));
+	await Promise.all(codeChecks);
+	const poolId = getV4PoolId(key);
+	const [viewPoolManagerResult, slot0] = await Promise.all([publicClient.readContract({
+		address: deployment.stateView,
+		abi: v4StateViewAbi,
+		functionName: "poolManager",
+		blockNumber
+	}), publicClient.readContract({
+		address: deployment.stateView,
+		abi: v4StateViewAbi,
+		functionName: "getSlot0",
+		args: [poolId],
+		blockNumber
+	})]);
+	const viewPoolManager = (0, viem.getAddress)(viewPoolManagerResult);
+	if (viewPoolManager !== deployment.poolManager) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `V4 StateView is bound to ${viewPoolManager}, not configured PoolManager ${deployment.poolManager}.`);
+	const sqrtPriceX96 = slot0[0];
+	const tick = asTick(slot0[1]);
+	const protocolFee = asUint24(slot0[2], "protocolFee");
+	const lpFee = asUint24(slot0[3], "lpFee");
+	if (sqrtPriceX96 === 0n) {
+		if (tick !== 0 || protocolFee !== 0 || lpFee !== 0) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", "Uninitialized V4 StateView slot contains non-zero state.");
+		return {
+			schemaVersion: 1,
+			blockNumber,
+			deployment,
+			key,
+			poolId,
+			status: "uninitialized",
+			sqrtPriceX96: 0n,
+			tick: 0,
+			protocolFee: 0,
+			lpFee: 0
+		};
+	}
+	try {
+		validateSqrtPriceX96(sqrtPriceX96);
+	} catch (error) {
+		throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", error instanceof Error ? error.message : "StateView returned an invalid sqrtPriceX96.", error);
+	}
+	if (lpFee > 1e6) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", "StateView returned an invalid V4 LP fee.");
+	if (key.fee !== 8388608 && lpFee !== key.fee) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Static V4 pool LP fee ${lpFee} does not match PoolKey fee ${key.fee}.`);
+	return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		poolId,
+		status: "initialized",
+		sqrtPriceX96,
+		tick,
+		protocolFee,
+		lpFee
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/v4/actions.ts
+function assertPreflightMatches(deployment, key, preflight) {
+	let matches = false;
+	try {
+		const snapshotDeployment = validateV4LifecycleDeployment(preflight?.deployment);
+		matches = preflight.schemaVersion === 1 && preflight.status === "uninitialized" && typeof preflight.blockNumber === "bigint" && preflight.blockNumber >= 0n && snapshotDeployment === deployment && preflight.poolId === getV4PoolId(key) && v4PoolKeysEqual(preflight.key, key) && preflight.sqrtPriceX96 === 0n && preflight.tick === 0 && preflight.protocolFee === 0 && preflight.lpFee === 0;
+	} catch {}
+	if (!matches) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Direct V4 initialize requires a matching inspected, uninitialized PoolKey snapshot.");
+}
+function identity(deployment, key) {
+	return {
+		family: deployment.family,
+		adapter: deployment.adapter,
+		version: deployment.version,
+		deploymentId: deployment.deploymentId,
+		chainId: deployment.chainId,
+		poolManager: deployment.poolManager,
+		stateView: deployment.stateView,
+		poolId: getV4PoolId(key),
+		key
+	};
+}
+/** Build a direct PoolManager.initialize transaction without signing it. */
+function buildV4InitializePoolTransaction(params) {
+	const deployment = validateV4LifecycleDeployment(params.deployment);
+	const key = canonicalizeV4PoolKey(params.key);
+	const initialPrice = assertV4InitialPrice(key, params.initialPrice);
+	if (!params.preflight || params.preflight.status !== "uninitialized") throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Direct V4 initialize requires an inspected, uninitialized PoolKey.");
+	assertPreflightMatches(deployment, key, params.preflight);
+	const poolId = getV4PoolId(key);
+	return {
+		schemaVersion: 1,
+		kind: "v4-initialize",
+		protocol: deployment.protocol,
+		transaction: {
+			chainId: deployment.chainId,
+			to: deployment.poolManager,
+			data: (0, viem.encodeFunctionData)({
+				abi: v4PoolManagerAbi,
+				functionName: "initialize",
+				args: [key, initialPrice.sqrtPriceX96]
+			}),
+			value: 0n
+		},
+		identity: identity(deployment, key),
+		expected: initialPrice,
+		preflight: {
+			blockNumber: params.preflight.blockNumber,
+			deploymentId: deployment.deploymentId,
+			status: "uninitialized",
+			poolId,
+			sqrtPriceX96: 0n
+		}
+	};
+}
+/** Inspect first, then return either a safe unsigned plan or a matching no-op. */
+async function prepareV4Initialize(params) {
+	const snapshot = await inspectV4Pool(params);
+	const initialPrice = assertV4InitialPrice(snapshot.key, params.initialPrice);
+	if (snapshot.status === "initialized") {
+		if (snapshot.sqrtPriceX96 === initialPrice.sqrtPriceX96) return {
+			status: "already-initialized-matching",
+			snapshot,
+			action: null
+		};
+		throw new PoolLifecycleError("POOL_STATE_MISMATCH", `V4 pool ${snapshot.poolId} is already initialized at a different price.`);
+	}
+	return {
+		status: "ready",
+		snapshot,
+		action: buildV4InitializePoolTransaction({
+			deployment: snapshot.deployment,
+			key: {
+				currencyA: snapshot.key.currency0,
+				currencyB: snapshot.key.currency1,
+				fee: snapshot.key.fee,
+				tickSpacing: snapshot.key.tickSpacing,
+				hooks: snapshot.key.hooks
+			},
+			initialPrice,
+			preflight: snapshot
+		})
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/v4/integrity.ts
+function invalid(message, cause) {
+	throw new PoolLifecycleError("INVALID_INPUT", message, cause);
+}
+function record(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return invalid(`${label} must be an object.`);
+	return value;
+}
+function address(value, label) {
+	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) return invalid(`${label} must be a valid EVM address.`);
+	return (0, viem.getAddress)(value);
+}
+function poolId(value, label) {
+	if (typeof value !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value)) return invalid(`${label} must be 32-byte hex.`);
+	return value;
+}
+/**
+* Fully validate a signer-boundary V4 action and return its canonical frozen
+* capability. The target, value, PoolId, and calldata are all re-derived.
+*/
+function validatePreparedV4PoolAction(value) {
+	const action = record(value, "Prepared V4 pool action");
+	if (action.schemaVersion !== 1 || action.kind !== "v4-initialize") return invalid("Prepared V4 pool action schema or kind is unsupported.");
+	if (typeof action.protocol !== "string") return invalid("Prepared V4 pool action protocol must be a string.");
+	const transaction = record(action.transaction, "V4 action transaction");
+	if (!Number.isSafeInteger(transaction.chainId) || Number(transaction.chainId) <= 0) return invalid("V4 transaction chainId must be a positive safe integer.");
+	const chainId = Number(transaction.chainId);
+	const to = address(transaction.to, "V4 transaction target");
+	if (typeof transaction.data !== "string" || !/^0x(?:[0-9a-fA-F]{2})+$/.test(transaction.data)) return invalid("V4 transaction calldata must be non-empty hex bytes.");
+	if (transaction.value !== 0n) return invalid("V4 PoolManager.initialize transactions must have zero value.");
+	const identity = record(action.identity, "V4 action identity");
+	if (typeof identity.deploymentId !== "string") return invalid("V4 action identity deploymentId must be a string.");
+	const deployment = resolveV4LifecycleDeploymentById(identity.deploymentId);
+	if (!deployment) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `No V4 lifecycle deployment is configured for id ${identity.deploymentId}.`);
+	const key = validateV4PoolKey(record(identity.key, "V4 identity key"));
+	const expectedPoolId = getV4PoolId(key);
+	if (action.protocol !== deployment.protocol || identity.family !== deployment.family || identity.adapter !== deployment.adapter || identity.version !== deployment.version || identity.deploymentId !== deployment.deploymentId || identity.chainId !== chainId || chainId !== deployment.chainId || address(identity.poolManager, "V4 identity PoolManager") !== deployment.poolManager || address(identity.stateView, "V4 identity StateView") !== deployment.stateView || poolId(identity.poolId, "V4 identity PoolId").toLowerCase() !== expectedPoolId.toLowerCase()) return invalid("V4 action identity does not match the configured deployment and PoolKey.");
+	const expectationRecord = record(action.expected, "V4 action expectation");
+	let expectation;
+	try {
+		expectation = assertV4InitialPrice(key, expectationRecord);
+	} catch (error) {
+		if (error instanceof PoolLifecycleError) throw error;
+		return invalid("V4 action expectation is invalid.", error);
+	}
+	const preflight = record(action.preflight, "V4 action preflight");
+	if (preflight.status !== "uninitialized" || preflight.deploymentId !== deployment.deploymentId || typeof preflight.blockNumber !== "bigint" || preflight.blockNumber < 0n || poolId(preflight.poolId, "V4 preflight PoolId").toLowerCase() !== expectedPoolId.toLowerCase() || preflight.sqrtPriceX96 !== 0n) return invalid("V4 action requires a matching uninitialized preflight.");
+	const expectedData = (0, viem.encodeFunctionData)({
+		abi: v4PoolManagerAbi,
+		functionName: "initialize",
+		args: [key, expectation.sqrtPriceX96]
+	});
+	if (to !== deployment.poolManager || transaction.data.toLowerCase() !== expectedData.toLowerCase()) return invalid("V4 transaction does not match its identity and initialization expectation.");
+	return deployment;
+}
+function assertPreparedV4PoolAction(value) {
+	validatePreparedV4PoolAction(value);
+}
+/** Deserialize the shared versioned envelope, then perform adapter validation. */
+function deserializePreparedV4PoolAction(serialized) {
+	let value;
+	try {
+		value = deserializePreparedPoolAction(serialized);
+	} catch (error) {
+		throw new PoolLifecycleError("INVALID_INPUT", error instanceof Error ? error.message : "Serialized V4 pool action is invalid.", error);
+	}
+	assertPreparedV4PoolAction(value);
+	return value;
+}
+//#endregion
+//#region src/pool-lifecycle/v4/simulate.ts
+/** Re-inspect, call, and estimate with the exact eventual sender and envelope. */
+async function simulateV4PoolAction(params) {
+	if (!(0, viem.isAddress)(params.account, { strict: true }) || (0, viem.getAddress)(params.account) === V4_ZERO_ADDRESS) throw new PoolLifecycleError("INVALID_INPUT", "V4 simulation account must be a valid non-zero EVM address.");
+	const deployment = validatePreparedV4PoolAction(params.action);
+	const blockNumber = params.blockNumber ?? await params.publicClient.getBlockNumber();
+	if (typeof blockNumber !== "bigint" || blockNumber < 0n) throw new PoolLifecycleError("INVALID_INPUT", "V4 simulation blockNumber must be non-negative.");
+	const snapshot = await inspectV4Pool({
+		publicClient: params.publicClient,
+		deployment,
+		key: {
+			currencyA: params.action.identity.key.currency0,
+			currencyB: params.action.identity.key.currency1,
+			fee: params.action.identity.key.fee,
+			tickSpacing: params.action.identity.key.tickSpacing,
+			hooks: params.action.identity.key.hooks
+		},
+		blockNumber
+	});
+	if (snapshot.status !== "uninitialized") throw new PoolLifecycleError("POOL_STATE_MISMATCH", `V4 pool ${snapshot.poolId} is already initialized; refresh the action.`);
+	const baseRequest = {
+		account: (0, viem.getAddress)(params.account),
+		to: params.action.transaction.to,
+		data: params.action.transaction.data,
+		value: params.action.transaction.value
+	};
+	try {
+		const callResult = await params.publicClient.call({
+			...baseRequest,
+			batch: false,
+			blockNumber
+		});
+		if (!callResult.data || callResult.data === "0x") throw new PoolLifecycleError("SIMULATION_FAILED", "V4 PoolManager.initialize simulation returned no initial tick.");
+		const returnedTick = Number((0, viem.decodeFunctionResult)({
+			abi: v4PoolManagerAbi,
+			functionName: "initialize",
+			data: callResult.data
+		}));
+		if (!Number.isSafeInteger(returnedTick) || returnedTick < -887272 || returnedTick > 887272) throw new PoolLifecycleError("SIMULATION_FAILED", "V4 PoolManager.initialize returned an invalid tick.");
+		const gasEstimate = await params.publicClient.estimateGas({
+			...baseRequest,
+			blockNumber
+		});
+		return {
+			transaction: params.action.transaction,
+			blockNumber,
+			returnData: callResult.data,
+			returnedTick,
+			gasEstimate
+		};
+	} catch (error) {
+		if (error instanceof PoolLifecycleError) throw error;
+		throw new PoolLifecycleError("SIMULATION_FAILED", error instanceof Error ? error.message : "V4 pool initialization simulation failed.", error);
+	}
+}
+//#endregion
+//#region src/pool-lifecycle/v4/verify.ts
+function assertLogBelongsToReceipt(log, receipt) {
+	if (log.transactionHash !== receipt.transactionHash || log.blockHash !== receipt.blockHash || log.blockNumber !== receipt.blockNumber || log.transactionIndex !== receipt.transactionIndex || log.removed !== false) throw new PoolLifecycleError("POOL_STATE_MISMATCH", "Decoded V4 lifecycle log does not belong to the canonical receipt.");
+}
+/** Decode transaction-attributed PoolManager Initialize evidence without RPC reads. */
+function decodeV4PoolActionReceipt(action, receipt) {
+	validatePreparedV4PoolAction(action);
+	const initializations = [];
+	for (const log of receipt.logs) {
+		assertLogBelongsToReceipt(log, receipt);
+		if ((0, viem.getAddress)(log.address) !== action.identity.poolManager) continue;
+		let decoded;
+		try {
+			decoded = (0, viem.decodeEventLog)({
+				abi: v4PoolManagerAbi,
+				eventName: "Initialize",
+				data: log.data,
+				topics: log.topics
+			});
+		} catch {
+			continue;
+		}
+		if (decoded.args.id.toLowerCase() !== action.identity.poolId.toLowerCase()) continue;
+		initializations.push({
+			poolId: decoded.args.id,
+			currency0: (0, viem.getAddress)(decoded.args.currency0),
+			currency1: (0, viem.getAddress)(decoded.args.currency1),
+			fee: Number(decoded.args.fee),
+			tickSpacing: Number(decoded.args.tickSpacing),
+			hooks: (0, viem.getAddress)(decoded.args.hooks),
+			sqrtPriceX96: decoded.args.sqrtPriceX96,
+			tick: Number(decoded.args.tick),
+			logIndex: log.logIndex
+		});
+	}
+	return {
+		receiptStatus: receipt.status,
+		initializations
+	};
+}
+function unavailable(action, evidence, blockNumber, error, fallback) {
+	return {
+		verified: false,
+		outcome: "verification-unavailable",
+		blockNumber,
+		identity: action.identity,
+		state: null,
+		evidence,
+		warnings: [error instanceof Error ? error.message : fallback]
+	};
+}
+function evaluate(action, evidence, snapshot, blockNumber) {
+	if (evidence.receiptStatus === "reverted") return {
+		verified: false,
+		outcome: "reverted",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: []
+	};
+	if (!snapshot || snapshot.status !== "initialized") return {
+		verified: false,
+		outcome: "not-initialized",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: []
+	};
+	if (evidence.initializations.length !== 1) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: [evidence.initializations.length === 0 ? "Receipt contains no Initialize event for the expected V4 PoolId." : "Receipt contains multiple Initialize events for the expected V4 PoolId."]
+	};
+	const event = evidence.initializations[0];
+	const key = action.identity.key;
+	if (event.currency0 !== key.currency0 || event.currency1 !== key.currency1 || event.fee !== key.fee || event.tickSpacing !== key.tickSpacing || event.hooks !== key.hooks || event.poolId.toLowerCase() !== action.identity.poolId.toLowerCase()) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Initialize evidence does not match the complete prepared V4 PoolKey."]
+	};
+	if (event.sqrtPriceX96 !== action.expected.sqrtPriceX96) return {
+		verified: false,
+		outcome: "already-initialized-different-price",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Initialize evidence contains a different initial price."]
+	};
+	if (snapshot.poolId.toLowerCase() !== action.identity.poolId.toLowerCase()) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Receipt-block StateView state is for a different V4 PoolId."]
+	};
+	if (snapshot.sqrtPriceX96 !== action.expected.sqrtPriceX96) return {
+		verified: true,
+		outcome: "initialized-then-price-moved",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: ["V4 pool price moved after initialization in the receipt block."]
+	};
+	if (snapshot.tick !== event.tick) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: ["Initialize tick does not match the unchanged receipt-block V4 state."]
+	};
+	return {
+		verified: true,
+		outcome: "created-and-initialized",
+		blockNumber,
+		identity: action.identity,
+		state: snapshot,
+		evidence,
+		warnings: []
+	};
+}
+/** Verify exact calldata, canonical receipt/event, and receipt-block StateView state. */
+async function verifyV4PoolAction(params) {
+	const { publicClient, action, receipt } = params;
+	const deployment = validatePreparedV4PoolAction(action);
+	const emptyEvidence = {
+		receiptStatus: receipt.status,
+		initializations: []
+	};
+	let activeChainId;
+	let transaction;
+	let canonicalReceipt;
+	try {
+		[activeChainId, transaction, canonicalReceipt] = await Promise.all([
+			publicClient.getChainId(),
+			publicClient.getTransaction({ hash: receipt.transactionHash }),
+			publicClient.getTransactionReceipt({ hash: receipt.transactionHash })
+		]);
+	} catch (error) {
+		return unavailable(action, emptyEvidence, receipt.blockNumber, error, "Failed to load the canonical V4 transaction and receipt.");
+	}
+	const nullableAddressMatches = (left, right) => left === null || right === null ? left === right : (0, viem.getAddress)(left) === (0, viem.getAddress)(right);
+	const target = action.identity.poolManager;
+	const suppliedMatchesCanonical = receipt.transactionHash === canonicalReceipt.transactionHash && receipt.blockHash === canonicalReceipt.blockHash && receipt.blockNumber === canonicalReceipt.blockNumber && receipt.transactionIndex === canonicalReceipt.transactionIndex && receipt.status === canonicalReceipt.status && (0, viem.getAddress)(receipt.from) === (0, viem.getAddress)(canonicalReceipt.from) && nullableAddressMatches(receipt.to, canonicalReceipt.to);
+	const receiptDestinationMatches = canonicalReceipt.to !== null && (0, viem.getAddress)(canonicalReceipt.to) === target;
+	const transactionMatches = transaction.hash === canonicalReceipt.transactionHash && transaction.to !== null && (0, viem.getAddress)(transaction.to) === target && transaction.input.toLowerCase() === action.transaction.data.toLowerCase() && transaction.value === action.transaction.value && transaction.blockHash === canonicalReceipt.blockHash && transaction.blockNumber === canonicalReceipt.blockNumber && transaction.transactionIndex === canonicalReceipt.transactionIndex && (0, viem.getAddress)(transaction.from) === (0, viem.getAddress)(canonicalReceipt.from);
+	if (activeChainId !== action.transaction.chainId || !suppliedMatchesCanonical || !receiptDestinationMatches || !transactionMatches) return {
+		verified: false,
+		outcome: "wrong-deployment",
+		blockNumber: canonicalReceipt.blockNumber,
+		identity: action.identity,
+		state: null,
+		evidence: emptyEvidence,
+		warnings: ["Receipt, transaction, client, or V4 deployment does not match the action."]
+	};
+	let evidence;
+	try {
+		evidence = decodeV4PoolActionReceipt(action, canonicalReceipt);
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber: canonicalReceipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence: emptyEvidence,
+			warnings: [error instanceof Error ? error.message : "V4 receipt attribution failed."]
+		};
+	}
+	let blockHashBefore;
+	try {
+		blockHashBefore = (await publicClient.getBlock({
+			blockNumber: canonicalReceipt.blockNumber,
+			includeTransactions: false
+		})).hash;
+	} catch (error) {
+		return unavailable(action, evidence, canonicalReceipt.blockNumber, error, "Failed to load the V4 receipt block.");
+	}
+	if (blockHashBefore !== canonicalReceipt.blockHash) return unavailable(action, evidence, canonicalReceipt.blockNumber, /* @__PURE__ */ new Error("Receipt block is no longer canonical; retry with a fresh receipt."), "Receipt block is no longer canonical.");
+	if (canonicalReceipt.status === "reverted") return evaluate(action, evidence, null, canonicalReceipt.blockNumber);
+	let snapshot;
+	try {
+		snapshot = await inspectV4Pool({
+			publicClient,
+			deployment,
+			key: {
+				currencyA: action.identity.key.currency0,
+				currencyB: action.identity.key.currency1,
+				fee: action.identity.key.fee,
+				tickSpacing: action.identity.key.tickSpacing,
+				hooks: action.identity.key.hooks
+			},
+			blockNumber: canonicalReceipt.blockNumber
+		});
+	} catch (error) {
+		if (error instanceof PoolLifecycleError) return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber: canonicalReceipt.blockNumber,
+			identity: action.identity,
+			state: null,
+			evidence,
+			warnings: [error.message]
+		};
+		return unavailable(action, evidence, canonicalReceipt.blockNumber, error, "Failed to read receipt-block V4 state.");
+	}
+	try {
+		if ((await publicClient.getBlock({
+			blockNumber: canonicalReceipt.blockNumber,
+			includeTransactions: false
+		})).hash !== canonicalReceipt.blockHash) return unavailable(action, evidence, canonicalReceipt.blockNumber, /* @__PURE__ */ new Error("Receipt block changed during verification; retry with a fresh receipt."), "Receipt block changed during verification.");
+	} catch (error) {
+		return unavailable(action, evidence, canonicalReceipt.blockNumber, error, "Failed to reconfirm the canonical V4 receipt block.");
+	}
+	return evaluate(action, evidence, snapshot, canonicalReceipt.blockNumber);
+}
+//#endregion
 //#region src/index.ts
 /**
 * @packageDocumentation
@@ -24117,18 +28038,25 @@ var FeeManagerClient = class extends SubgraphClient {
 exports.AERODROME_PROTOCOLS = AERODROME_PROTOCOLS;
 exports.ALGEBRA_INTEGRAL_PROTOCOLS = ALGEBRA_INTEGRAL_PROTOCOLS;
 exports.ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS = ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS;
+exports.ALGEBRA_LIFECYCLE_DEPLOYMENTS = ALGEBRA_LIFECYCLE_DEPLOYMENTS;
 exports.ALGEBRA_PROTOCOLS = ALGEBRA_PROTOCOLS;
 exports.AMMType = AMMType;
 exports.API_URLS = API_URLS;
 exports.AlgebgraHookBeacons = AlgebgraHookBeacons;
+exports.CURRENT_V4_LIFECYCLE_DEPLOYMENTS = CURRENT_V4_LIFECYCLE_DEPLOYMENTS;
 exports.Chain = Chain;
 exports.ChainId = ChainId;
 exports.DIRECTIONAL_ALGEBRA_PROTOCOLS = DIRECTIONAL_ALGEBRA_PROTOCOLS;
 exports.FEE_MANAGER_ABI = FEE_MANAGER_ABI;
 exports.FeeManagerClient = FeeManagerClient;
+exports.MAX_SQRT_RATIO = MAX_SQRT_RATIO;
+exports.MIN_SQRT_RATIO = MIN_SQRT_RATIO;
 exports.MultiPositionManagers = MultiPositionManagers;
 exports.POOLSHARK_PROTOCOLS = POOLSHARK_PROTOCOLS;
+exports.POOL_LIFECYCLE_DEPLOYMENTS = POOL_LIFECYCLE_DEPLOYMENTS;
+exports.PREPARED_POOL_ACTION_SERIALIZATION_VERSION = PREPARED_POOL_ACTION_SERIALIZATION_VERSION;
 exports.PoolClient = PoolClient;
+exports.PoolLifecycleError = PoolLifecycleError;
 exports.Protocol = Protocol;
 exports.QuickSwapQuoterV2 = QuickSwapQuoterV2;
 exports.QuoterV2AlgebgraIntegral = QuoterV2AlgebgraIntegral;
@@ -24153,13 +28081,35 @@ exports.UniswapHookBeacons = UniswapHookBeacons;
 exports.UniswapV3PoolABI = UniswapV3PoolABI;
 exports.UniswapV3QuoterABI = UniswapV3QuoterABI;
 exports.UniswapV4Beacons = UniswapV4Beacons;
+exports.V3_CONFIG_PROTOCOLS = V3_CONFIG_PROTOCOLS;
+exports.V3_LIFECYCLE_DEPLOYMENTS = V3_LIFECYCLE_DEPLOYMENTS;
+exports.V4_ALL_HOOK_MASK = V4_ALL_HOOK_MASK;
+exports.V4_DYNAMIC_FEE_FLAG = V4_DYNAMIC_FEE_FLAG;
+exports.V4_LIFECYCLE_DEPLOYMENTS = V4_LIFECYCLE_DEPLOYMENTS;
+exports.V4_LIFECYCLE_DEPLOYMENTS_BY_ID = V4_LIFECYCLE_DEPLOYMENTS_BY_ID;
+exports.V4_MAX_STATIC_FEE = V4_MAX_STATIC_FEE;
+exports.V4_MAX_TICK_SPACING = V4_MAX_TICK_SPACING;
+exports.V4_ZERO_ADDRESS = V4_ZERO_ADDRESS;
 exports.VAULT_FEES_ABI = VAULT_FEES_ABI;
 exports.VaultClient = VaultClient;
 exports.abis = abis;
+exports.algebraCustomPoolEntryPointAbi = algebraCustomPoolEntryPointAbi;
+exports.algebraDirectionalPoolStateAbi = algebraDirectionalPoolStateAbi;
+exports.algebraIntegralPairFactoryAbi = algebraIntegralPairFactoryAbi;
+exports.algebraIntegralPluginDataFactoryAbi = algebraIntegralPluginDataFactoryAbi;
+exports.algebraIntegralPoolStateAbi = algebraIntegralPoolStateAbi;
+exports.algebraLegacyPoolStateAbi = algebraLegacyPoolStateAbi;
+exports.algebraPairFactoryAbi = algebraPairFactoryAbi;
+exports.algebraPoolBaseAbi = algebraPoolBaseAbi;
 exports.apechainAddresses = apechainAddresses;
 exports.arbitrumAddresses = arbitrumAddresses;
 exports.arbitrumgoerliAddresses = arbitrumgoerliAddresses;
 exports.arthswapConfig = arthswapConfig;
+exports.assertAlgebraInitialPrice = assertAlgebraInitialPrice;
+exports.assertPreparedV3PoolAction = assertPreparedV3PoolAction;
+exports.assertPreparedV4PoolAction = assertPreparedV4PoolAction;
+exports.assertV3InitialPrice = assertV3InitialPrice;
+exports.assertV4InitialPrice = assertV4InitialPrice;
 exports.astarAddresses = astarAddresses;
 exports.astarzkevmAddresses = astarzkevmAddresses;
 exports.avalancheAddresses = avalancheAddresses;
@@ -24172,15 +28122,34 @@ exports.bittensorAddresses = bittensorAddresses;
 exports.bittensorUniV3Config = bittensorUniV3Config;
 exports.blastAddresses = blastAddresses;
 exports.bscAddresses = bscAddresses;
+exports.buildAlgebraCreatePoolTransaction = buildAlgebraCreatePoolTransaction;
+exports.buildAlgebraInitializePoolTransaction = buildAlgebraInitializePoolTransaction;
+exports.buildV3CreateAndInitializeTransaction = buildV3CreateAndInitializeTransaction;
+exports.buildV3CreatePoolTransaction = buildV3CreatePoolTransaction;
+exports.buildV3InitializePoolTransaction = buildV3InitializePoolTransaction;
+exports.buildV4InitializePoolTransaction = buildV4InitializePoolTransaction;
 exports.calculateLimitPrice = calculateLimitPrice;
 exports.calculateSwapAmount = calculateSwapAmount;
 exports.camelotConfig = camelotConfig;
+exports.canonicalizeAlgebraPoolKey = canonicalizeAlgebraPoolKey;
+exports.canonicalizeV3PoolKey = canonicalizeV3PoolKey;
+exports.canonicalizeV4PoolKey = canonicalizeV4PoolKey;
 exports.celoAddresses = celoAddresses;
 exports.chainIdToName = chainIdToName;
 exports.chainNameToId = chainNameToId;
 exports.crustConfig = crustConfig;
+exports.decodeAlgebraPoolActionReceipt = decodeAlgebraPoolActionReceipt;
+exports.decodeV3PoolActionReceipt = decodeV3PoolActionReceipt;
+exports.decodeV4PoolActionReceipt = decodeV4PoolActionReceipt;
 exports.deprecatedBundlesURL = deprecatedBundlesURL;
+exports.deserializePreparedAlgebraPoolAction = deserializePreparedAlgebraPoolAction;
+exports.deserializePreparedPoolAction = deserializePreparedPoolAction;
+exports.deserializePreparedV3PoolAction = deserializePreparedV3PoolAction;
+exports.deserializePreparedV4PoolAction = deserializePreparedV4PoolAction;
 exports.determineSwapDirection = determineSwapDirection;
+exports.encodeCurrencyInitialSqrtPriceX96 = encodeCurrencyInitialSqrtPriceX96;
+exports.encodeInitialSqrtPriceX96 = encodeInitialSqrtPriceX96;
+exports.encodeSqrtRatioX96 = encodeSqrtRatioX96;
 exports.equilibreConfig = equilibreConfig;
 exports.erc1155Abi = erc1155Abi;
 exports.erc20Abi = erc20Abi;
@@ -24226,6 +28195,8 @@ exports.getSwapRouterAddress = getSwapRouterAddress;
 exports.getTheGraphResolverUrl = getTheGraphResolverUrl;
 exports.getTickLensAddress = getTickLensAddress;
 exports.getUniswapV4BeaconSupportedChains = getUniswapV4BeaconSupportedChains;
+exports.getV4LifecycleDeploymentId = getV4LifecycleDeploymentId;
+exports.getV4PoolId = getV4PoolId;
 exports.getVaultExecutionContext = getVaultExecutionContext;
 exports.getVaultReserves = getVaultReserves;
 exports.glyphConfig = glyphConfig;
@@ -24234,6 +28205,11 @@ exports.hemiAddresses = hemiAddresses;
 exports.henjinConfig = henjinConfig;
 exports.herculesConfig = herculesConfig;
 exports.horizaConfig = horizaConfig;
+exports.inspectAlgebraCustomPoolEntryPoint = inspectAlgebraCustomPoolEntryPoint;
+exports.inspectAlgebraPool = inspectAlgebraPool;
+exports.inspectV3Pool = inspectV3Pool;
+exports.inspectV4Pool = inspectV4Pool;
+exports.integerSqrt = integerSqrt;
 exports.isAerodromeVault = isAerodromeVault;
 exports.isAlgebraDirectionProtocol = isAlgebraDirectionProtocol;
 exports.isAlgebraIntegral21QuoteParams = isAlgebraIntegral21QuoteParams;
@@ -24278,25 +28254,43 @@ exports.okxtestnetAddresses = okxtestnetAddresses;
 exports.optimismAddresses = optimismAddresses;
 exports.optimismgoerliAddresses = optimismgoerliAddresses;
 exports.pancakeSwapConfig = pancakeSwapConfig;
+exports.parseExactDecimal = parseExactDecimal;
 exports.polygonAddresses = polygonAddresses;
 exports.polyzkevmAddresses = polyzkevmAddresses;
 exports.poolsharkConfig = poolsharkConfig;
+exports.prepareAlgebraPool = prepareAlgebraPool;
+exports.prepareV3CreateAndInitialize = prepareV3CreateAndInitialize;
+exports.prepareV3CreatePool = prepareV3CreatePool;
+exports.prepareV3InitializePool = prepareV3InitializePool;
+exports.prepareV4Initialize = prepareV4Initialize;
 exports.quickSwapAlgebraConfig = quickSwapAlgebraConfig;
 exports.quickSwapConfig = quickSwapConfig;
 exports.quickSwapIntegralConfig = quickSwapIntegralConfig;
 exports.quickSwapUniv3Config = quickSwapUniv3Config;
+exports.resolveAlgebraLifecycleDeployment = resolveAlgebraLifecycleDeployment;
+exports.resolveCurrentV4LifecycleDeployment = resolveCurrentV4LifecycleDeployment;
+exports.resolvePoolLifecycleDeployment = resolvePoolLifecycleDeployment;
+exports.resolveV3LifecycleDeployment = resolveV3LifecycleDeployment;
+exports.resolveV4LifecycleDeployment = resolveV4LifecycleDeployment;
+exports.resolveV4LifecycleDeploymentById = resolveV4LifecycleDeploymentById;
 exports.retroConfig = retroConfig;
 exports.robinhoodAddresses = robinhoodAddresses;
 exports.rootstockAddresses = rootstockAddresses;
 exports.sagaAddresses = sagaAddresses;
 exports.scrollAddresses = scrollAddresses;
 exports.seiAddresses = seiAddresses;
+exports.serializePreparedPoolAction = serializePreparedPoolAction;
 exports.shadowConfig = shadowConfig;
 exports.shouldValidateUniswapV4VaultHook = shouldValidateUniswapV4VaultHook;
+exports.simulateAlgebraPoolAction = simulateAlgebraPoolAction;
 exports.simulateSwap = simulateSwap;
+exports.simulateV3PoolAction = simulateV3PoolAction;
+exports.simulateV4PoolAction = simulateV4PoolAction;
 exports.singleTokenDepositAbi = singleTokenDepositAbi;
 exports.soneiumAddresses = soneiumAddresses;
 exports.sonicAddresses = sonicAddresses;
+exports.sortErc20Pair = sortErc20Pair;
+exports.sortEvmCurrencyPair = sortEvmCurrencyPair;
 exports.spark32Config = spark32Config;
 exports.sparkConfig = sparkConfig;
 exports.stabilityVaultsConfig = stabilityVaultsConfig;
@@ -24313,8 +28307,24 @@ exports.thrusterConfig = thrusterConfig;
 exports.thundercoreAddresses = thundercoreAddresses;
 exports.uniAddresses = uniAddresses;
 exports.uniswapConfig = uniswapConfig;
+exports.v3FactoryAbi = v3FactoryAbi;
+exports.v3PoolAbi = v3PoolAbi;
+exports.v3PoolInitializerAbi = v3PoolInitializerAbi;
+exports.v4PoolKeysEqual = v4PoolKeysEqual;
+exports.v4PoolManagerAbi = v4PoolManagerAbi;
+exports.v4StateViewAbi = v4StateViewAbi;
+exports.validateAlgebraLifecycleDeployment = validateAlgebraLifecycleDeployment;
+exports.validatePreparedAlgebraPoolAction = validatePreparedAlgebraPoolAction;
+exports.validatePreparedV3PoolAction = validatePreparedV3PoolAction;
+exports.validatePreparedV4PoolAction = validatePreparedV4PoolAction;
 exports.validateQuoteParams = validateQuoteParams;
+exports.validateSqrtPriceX96 = validateSqrtPriceX96;
 exports.validateSwapParams = validateSwapParams;
+exports.validateV4LifecycleDeployment = validateV4LifecycleDeployment;
+exports.validateV4PoolKey = validateV4PoolKey;
+exports.verifyAlgebraPoolAction = verifyAlgebraPoolAction;
+exports.verifyV3PoolAction = verifyV3PoolAction;
+exports.verifyV4PoolAction = verifyV4PoolAction;
 exports.xlayerAddresses = xlayerAddresses;
 exports.zetaAddresses = zetaAddresses;
 exports.zircuitAddresses = zircuitAddresses;