@steerprotocol/sdk 3.4.3 → 3.5.0

package/dist/index.cjs

@@ -24415,7 +24415,7 @@ const PROVENANCE_BY_VARIANT = Object.freeze({
 	"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) {
+function deployment$2(input) {
 	const shape = input.variant === "directional" ? {
 		adapter: "algebra-directional-pair-v1",
 		version: 1,
@@ -24457,179 +24457,179 @@ function deployment$1(input) {
 * a runtime fallback.
 */
 const ALGEBRA_LIFECYCLE_DEPLOYMENTS = Object.freeze([
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Polygon,
 		protocol: Protocol.QuickSwap,
 		variant: "legacy",
 		factory: "0x411b0fAcC3489691f28ad58c47006AF5E3Ab3A28"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.PolygonzkEVM,
 		protocol: Protocol.QuickSwap,
 		variant: "legacy",
 		factory: "0x4B9f4d2435Ef65559567e5DbFC1BbB37abC43B57"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Zircuit,
 		protocol: Protocol.Ocelex,
 		variant: "legacy",
 		factory: "0x03057ae6294292b299a1863420edD65e0197AFEf"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Arbitrum,
 		protocol: Protocol.Camelot,
 		variant: "directional",
 		factory: "0x1a3c9B1d2F0529D97f2afC5136Cc23e58f1FD35B"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Apechain,
 		protocol: Protocol.Camelot,
 		variant: "directional",
 		factory: "0x1a3c9B1d2F0529D97f2afC5136Cc23e58f1FD35B"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Linea,
 		protocol: Protocol.Lynex,
 		variant: "legacy",
 		factory: "0x622b2c98123D303ae067DB4925CD6282B3A08D0F"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.BSC,
 		protocol: Protocol.Thena,
 		variant: "legacy",
 		factory: "0x306F06C147f064A010530292A1EB6737c3e378e4"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Metis,
 		protocol: Protocol.Hercules,
 		variant: "directional",
 		factory: "0xC5BfA92f27dF36d268422EE314a1387bB5ffB06A"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.XLayer,
 		protocol: Protocol.QuickSwapAlgebra,
 		variant: "legacy",
 		factory: "0xd2480162Aa7F02Ead7BF4C127465446150D58452"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Moonbeam,
 		protocol: Protocol.StellaSwap,
 		variant: "legacy",
 		factory: "0xabE1655110112D0E45EF91e94f8d757e4ddBA59C"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Mode,
 		protocol: Protocol.Kim,
 		variant: "integral-v1",
 		factory: "0xB5F00c2C5f8821155D8ed27E31932CFD9DB3C5D5"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Base,
 		protocol: Protocol.Kim,
 		variant: "integral-v1",
 		factory: "0x2F0d41f94d5D1550b79A83D2fe85C82d68c5a3ca"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Telos,
 		protocol: Protocol.Swapsicle,
 		variant: "integral-v1",
 		factory: "0xA09BAbf9A48003ae9b9333966a8Bda94d820D0d9"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Blast,
 		protocol: Protocol.Fenix,
 		variant: "integral-v1",
 		factory: "0x7a44CD060afC1B6F4c80A2B9b37f4473E74E25Df"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Taiko,
 		protocol: Protocol.Henjin,
 		variant: "integral-v1",
 		factory: "0x42B08e7a9211482d3643a126a7dF1895448d3509",
 		customPoolEntryPoint: "0x441013A52DDedc8D02eB9B90F7A555F6848188b5"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Sonic,
 		protocol: Protocol.SilverSwap,
 		variant: "integral-v1",
 		factory: "0xb860200BD68dc39cEAfd6ebb82883f189f4CdA76"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Nibiru,
 		protocol: Protocol.SilverSwap,
 		variant: "integral-v1",
 		factory: "0xb860200BD68dc39cEAfd6ebb82883f189f4CdA76"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Zeta,
 		protocol: Protocol.Beam,
 		variant: "integral-v1",
 		factory: "0x28b5244B6CA7Cb07f2f7F40edE944c07C2395603"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Core,
 		protocol: Protocol.Glyph,
 		variant: "integral-v1",
 		factory: "0x74EfE55beA4988e7D92D03EFd8ddB8BF8b7bD597"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Hyperevm,
 		protocol: Protocol.Nest,
 		variant: "integral-v1",
 		factory: "0xF77Bd082c627aA54591cF2f2EaA811fd1AB3b1F3"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Soneium,
 		protocol: Protocol.QuickSwapIntegral,
 		variant: "integral-v2",
 		factory: "0x8Ff309F68F6Caf77a78E9C20d2Af7Ed4bE2D7093"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Base,
 		protocol: Protocol.QuickSwapIntegral,
 		variant: "integral-v2",
 		factory: "0xC5396866754799B9720125B104AE01d935Ab9C7b",
 		customPoolEntryPoint: "0xb9ce7698cE3dCf21cc88bf7dCc1fE20C85E4226E"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Polygon,
 		protocol: Protocol.QuickSwapIntegral,
 		variant: "integral-v2",
 		factory: "0x134c1dBE4860A9cAaf89002574fFe814772D9904",
 		customPoolEntryPoint: "0xfcfE065bc131Fa8Bb31A227b2fF4F0EC47D3F1a2"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Bera,
 		protocol: Protocol.Wasabee,
 		variant: "integral-v2",
 		factory: "0x7d53327D78EFD0b463bd8d7dc938C52402323b95"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Ronin,
 		protocol: Protocol.KatanaIntegral,
 		variant: "integral-v2",
 		factory: "0x7ecaf729C6FFb04448aA89A722cA370724BF70De"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Avalanche,
 		protocol: Protocol.Blackhole,
 		variant: "integral-v2",
 		factory: "0x512eb749541B7cf294be882D636218c84a5e9E5F"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Mainnet,
 		protocol: Protocol.Cypher,
 		variant: "integral-v2",
 		factory: "0xfb8Ed3485EfA29a0e4bed93351dD51B59fC4b0f0",
 		customPoolEntryPoint: "0x79616564DB0294ecBa5912f1cE985FD1c11eeF51"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Flare,
 		protocol: Protocol.SparkIntegral,
 		variant: "integral-v2",
 		factory: "0x805488DaA81c1b9e7C5cE3f1DCeA28F21448EC6A"
 	}),
-	deployment$1({
+	deployment$2({
 		chainId: ChainId.Base,
 		protocol: Protocol.Hydrex,
 		variant: "integral-v2",
@@ -24662,6 +24662,164 @@ function validateAlgebraLifecycleDeployment(value) {
 	return configured;
 }
 //#endregion
+//#region src/pool-lifecycle/capabilities/aerodrome-slipstream.ts
+const factoryRegistry = (0, viem.getAddress)("0x5C3F18F06CC09CA1910767A34a20F771039E37C0");
+const voter = (0, viem.getAddress)("0x16613524e02aD97edfef371Bc883F2f5D6c480A5");
+const originalFactory = (0, viem.getAddress)("0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A");
+function deployment$1(input) {
+	return Object.freeze({
+		supported: true,
+		schemaVersion: 1,
+		family: "aerodrome-slipstream",
+		adapter: "aerodrome-slipstream-factory-v1",
+		version: 1,
+		...input
+	});
+}
+const AERODROME_SLIPSTREAM_LIFECYCLE_DEPLOYMENTS = Object.freeze([
+	deployment$1({
+		chainId: ChainId.Base,
+		protocol: Protocol.Aerodrome,
+		generation: 1,
+		latest: false,
+		factory: originalFactory,
+		factoryRuntimeCodeHash: "0x7340cf80843bd721bcaefbfc050e38304cb4174c239e6e914e3056f27f39b11c",
+		poolImplementation: (0, viem.getAddress)("0xeC8E5342B19977B4eF8892e02D8DAEcfa1315831"),
+		poolImplementationRuntimeCodeHash: "0x772fb5c610b40a122036f544e5b9b5bce6becb19db9524331289d1aaed2d5888",
+		poolProxyRuntimeCodeHash: "0xacd6710f7037ad095b1e4d5f8ee5b2681069cb4dd316e77e4e0cb8f85716a2a1",
+		factoryRegistry,
+		voter,
+		legacyCLFactory: null,
+		sourceVerification: Object.freeze({
+			sourceRevision: "0x4ef07edcf5aaac5c22bcef6718c77e0416e7e472",
+			compilerVersion: "0.7.6+commit.7338295f",
+			optimizer: Object.freeze({
+				enabled: true,
+				runs: 200
+			}),
+			executableRuntimeMatch: true,
+			immutableAnchors: Object.freeze({
+				factoryRegistry,
+				voter,
+				poolImplementation: (0, viem.getAddress)("0xeC8E5342B19977B4eF8892e02D8DAEcfa1315831"),
+				legacyCLFactory: null
+			})
+		}),
+		provenance: Object.freeze({
+			source: "official-deployment",
+			urls: Object.freeze([
+				"https://github.com/aerodrome-finance/slipstream/commit/37eead2c7e5302a204dec78bfa0775bbb8ff48a2",
+				"https://github.com/aerodrome-finance/slipstream/blob/4ef07edcf5aaac5c22bcef6718c77e0416e7e472/contracts/core/CLFactory.sol",
+				"https://github.com/aerodrome-finance/slipstream/blob/4ef07edcf5aaac5c22bcef6718c77e0416e7e472/contracts/core/CLPool.sol",
+				"https://basescan.org/address/0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A#code"
+			])
+		})
+	}),
+	deployment$1({
+		chainId: ChainId.Base,
+		protocol: Protocol.AerodromeV2,
+		generation: 2,
+		latest: false,
+		factory: (0, viem.getAddress)("0xaDe65c38CD4849aDBA595a4323a8C7DdfE89716a"),
+		factoryRuntimeCodeHash: "0x0e72100f63ce8e32c95370fa9636d38c8cf434a820f2a7a69985e50930d2cb85",
+		poolImplementation: (0, viem.getAddress)("0x942e97a4c6FdC38B4CD1c0298D37d81fDD8E5A16"),
+		poolImplementationRuntimeCodeHash: "0x916bc5496cc07ea86289bc3a08a90f93dcae34686be6634f6e89ef260c3df4fa",
+		poolProxyRuntimeCodeHash: "0x18308290b554b22918ea53c7e4e49eb871181d182749bf9e3a65ef949d3be808",
+		factoryRegistry,
+		voter,
+		legacyCLFactory: originalFactory,
+		sourceVerification: Object.freeze({
+			sourceRevision: "0xaa539f4cdb59212aaf846cce60f6ac5e9470c157",
+			compilerVersion: "0.7.6+commit.7338295f",
+			optimizer: Object.freeze({
+				enabled: true,
+				runs: 200
+			}),
+			executableRuntimeMatch: true,
+			immutableAnchors: Object.freeze({
+				factoryRegistry,
+				voter,
+				poolImplementation: (0, viem.getAddress)("0x942e97a4c6FdC38B4CD1c0298D37d81fDD8E5A16"),
+				legacyCLFactory: originalFactory
+			})
+		}),
+		provenance: Object.freeze({
+			source: "official-deployment",
+			urls: Object.freeze([
+				"https://github.com/aerodrome-finance/slipstream/commit/aa539f4cdb59212aaf846cce60f6ac5e9470c157",
+				"https://github.com/aerodrome-finance/slipstream/blob/aa539f4cdb59212aaf846cce60f6ac5e9470c157/contracts/core/CLFactory.sol",
+				"https://github.com/aerodrome-finance/slipstream/blob/aa539f4cdb59212aaf846cce60f6ac5e9470c157/contracts/core/CLPool.sol",
+				"https://github.com/aerodrome-finance/slipstream/blob/aa539f4cdb59212aaf846cce60f6ac5e9470c157/script/constants/output/DeployCL-Base-Gauge-Caps.json",
+				"https://basescan.org/address/0xaDe65c38CD4849aDBA595a4323a8C7DdfE89716a#code"
+			])
+		})
+	}),
+	deployment$1({
+		chainId: ChainId.Base,
+		protocol: Protocol.AerodromeV3,
+		generation: 3,
+		latest: true,
+		factory: (0, viem.getAddress)("0xf8f2eB4940CFE7d13603DDDD87f123820Fc061Ef"),
+		factoryRuntimeCodeHash: "0x4961963494e47f363617ab9a0f3999a28b33c519e51392952db06350cce700bd",
+		poolImplementation: (0, viem.getAddress)("0xc770898522D2A9c8Da7A10D63989b6b58305B665"),
+		poolImplementationRuntimeCodeHash: "0xe63484f408c701770737a3c40e435c8183c66b1663f3a8777ce44dd73aff339b",
+		poolProxyRuntimeCodeHash: "0xad8972486d67a48db1f32f254a4c2f4be28df0b5f399559d1e7cd8fbcfbedc96",
+		factoryRegistry,
+		voter,
+		legacyCLFactory: originalFactory,
+		sourceVerification: Object.freeze({
+			sourceRevision: "0x618c88df58f1fa271e9b3bc6bc476a4c37d068dd",
+			compilerVersion: "0.7.6+commit.7338295f",
+			optimizer: Object.freeze({
+				enabled: true,
+				runs: 200
+			}),
+			executableRuntimeMatch: true,
+			immutableAnchors: Object.freeze({
+				factoryRegistry,
+				voter,
+				poolImplementation: (0, viem.getAddress)("0xc770898522D2A9c8Da7A10D63989b6b58305B665"),
+				legacyCLFactory: originalFactory
+			})
+		}),
+		provenance: Object.freeze({
+			source: "official-deployment",
+			urls: Object.freeze([
+				"https://github.com/aerodrome-finance/slipstream/commit/618c88df58f1fa271e9b3bc6bc476a4c37d068dd",
+				"https://github.com/aerodrome-finance/slipstream/blob/618c88df58f1fa271e9b3bc6bc476a4c37d068dd/contracts/core/CLFactory.sol",
+				"https://github.com/aerodrome-finance/slipstream/blob/618c88df58f1fa271e9b3bc6bc476a4c37d068dd/contracts/core/CLPool.sol",
+				"https://github.com/aerodrome-finance/slipstream/blob/618c88df58f1fa271e9b3bc6bc476a4c37d068dd/script/constants/output/DeployCL-Base-MinUnstake.json",
+				"https://basescan.org/address/0xf8f2eB4940CFE7d13603DDDD87f123820Fc061Ef#code"
+			])
+		})
+	})
+]);
+const registry = buildCheckedRegistry(AERODROME_SLIPSTREAM_LIFECYCLE_DEPLOYMENTS, (item) => `${item.chainId}:${item.protocol}`, "Aerodrome Slipstream lifecycle deployment");
+function resolveAerodromeSlipstreamLifecycleDeployment(params) {
+	return registry[`${params.chainId}:${params.protocol}`];
+}
+/** Resolve the only factory generation that is eligible for a new pool deployment. */
+function resolveLatestAerodromeSlipstreamLifecycleDeployment(chainId) {
+	return AERODROME_SLIPSTREAM_LIFECYCLE_DEPLOYMENTS.find((item) => item.chainId === chainId && item.latest);
+}
+function assertLatestAerodromeSlipstreamLifecycleDeployment(value) {
+	const configured = validateAerodromeSlipstreamLifecycleDeployment(value);
+	if (!configured.latest) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `Aerodrome Slipstream generation ${configured.generation} is read/verification-only; new pools must use the latest generation.`);
+	return configured;
+}
+/** Reject mutable or forged deployment metadata at every public boundary. */
+function validateAerodromeSlipstreamLifecycleDeployment(value) {
+	const candidate = value;
+	const configured = typeof candidate?.chainId === "number" && typeof candidate.protocol === "string" ? resolveAerodromeSlipstreamLifecycleDeployment({
+		chainId: candidate.chainId,
+		protocol: candidate.protocol
+	}) : void 0;
+	try {
+		if (configured && candidate.supported === true && candidate.schemaVersion === configured.schemaVersion && candidate.family === configured.family && candidate.adapter === configured.adapter && candidate.version === configured.version && candidate.generation === configured.generation && candidate.latest === configured.latest && (0, viem.getAddress)(candidate.factory) === configured.factory && candidate.factoryRuntimeCodeHash === configured.factoryRuntimeCodeHash && (0, viem.getAddress)(candidate.poolImplementation) === configured.poolImplementation && candidate.poolImplementationRuntimeCodeHash === configured.poolImplementationRuntimeCodeHash && candidate.poolProxyRuntimeCodeHash === configured.poolProxyRuntimeCodeHash && (0, viem.getAddress)(candidate.factoryRegistry) === configured.factoryRegistry && (0, viem.getAddress)(candidate.voter) === configured.voter && (configured.legacyCLFactory === null ? candidate.legacyCLFactory === null : (0, viem.getAddress)(candidate.legacyCLFactory) === configured.legacyCLFactory)) return configured;
+	} catch {}
+	throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `Aerodrome Slipstream lifecycle deployment is not configured for chain ${String(candidate?.chainId)} and protocol ${String(candidate?.protocol)}.`);
+}
+//#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";
@@ -25341,7 +25499,8 @@ function buildLifecycleRegistry() {
 	return buildCheckedRegistry([
 		...Object.values(V3_LIFECYCLE_DEPLOYMENTS).filter((deployment) => deployment !== void 0),
 		...CURRENT_V4_LIFECYCLE_DEPLOYMENTS,
-		...ALGEBRA_LIFECYCLE_DEPLOYMENTS
+		...ALGEBRA_LIFECYCLE_DEPLOYMENTS,
+		...AERODROME_SLIPSTREAM_LIFECYCLE_DEPLOYMENTS
 	], deploymentKey, "pool lifecycle deployment");
 }
 /**
@@ -25410,6 +25569,29 @@ const algebraIntegralPoolStateAbi = (0, viem.parseAbi)(["function globalState()
 */
 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/aerodrome-slipstream.ts
+/** Exact Base Aerodrome Slipstream CLFactory lifecycle surface. */
+const aerodromeSlipstreamFactoryAbi = (0, viem.parseAbi)([
+	"event PoolCreated(address indexed token0,address indexed token1,int24 indexed tickSpacing,address pool)",
+	"function getPool(address tokenA,address tokenB,int24 tickSpacing) view returns (address pool)",
+	"function tickSpacingToFee(int24 tickSpacing) view returns (uint24 fee)",
+	"function poolImplementation() view returns (address)",
+	"function factoryRegistry() view returns (address)",
+	"function voter() view returns (address)",
+	"function legacyCLFactory() view returns (address)",
+	"function isPool(address pool) view returns (bool)",
+	"function createPool(address tokenA,address tokenB,int24 tickSpacing,uint160 sqrtPriceX96) returns (address pool)"
+]);
+/** Exact Aerodrome Slipstream CLPool lifecycle read and event surface. */
+const aerodromeSlipstreamPoolAbi = (0, viem.parseAbi)([
+	"event Initialize(uint160 sqrtPriceX96,int24 tick)",
+	"function factory() view returns (address)",
+	"function token0() view returns (address)",
+	"function token1() view returns (address)",
+	"function tickSpacing() view returns (int24)",
+	"function slot0() view returns (uint160 sqrtPriceX96,int24 tick,uint16 observationIndex,uint16 observationCardinality,uint16 observationCardinalityNext,bool unlocked)"
+]);
+//#endregion
 //#region src/pool-lifecycle/abis/v3.ts
 /** Minimal canonical Uniswap V3-compatible factory ABI used by pool lifecycle flows. */
 const v3FactoryAbi = [
@@ -25683,8 +25865,8 @@ function assertAlgebraInitialPrice(key, price) {
 }
 //#endregion
 //#region src/pool-lifecycle/algebra/inspect.ts
-const ZERO = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
-async function requireCode(client, address, label, blockNumber) {
+const ZERO$2 = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+async function requireCode$1(client, address, label, blockNumber) {
 	const code = await client.getCode({
 		address,
 		blockNumber
@@ -25700,7 +25882,7 @@ async function inspectAlgebraCustomPoolEntryPoint(params) {
 	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);
+	await requireCode$1(params.publicClient, entryPoint, "Algebra custom pool entry point", blockNumber);
 	const entryFactory = (0, viem.getAddress)(await params.publicClient.readContract({
 		address: entryPoint,
 		abi: algebraCustomPoolEntryPointAbi,
@@ -25723,9 +25905,9 @@ async function inspectAlgebraPool(params) {
 	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)
+		requireCode$1(publicClient, factory, "Algebra factory", blockNumber),
+		requireCode$1(publicClient, key.token0, "token0", blockNumber),
+		requireCode$1(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({
@@ -25741,8 +25923,8 @@ async function inspectAlgebraPool(params) {
 		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);
+	if (poolDeployer === ZERO$2) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Algebra factory ${factory} reports a zero pool deployer.`);
+	await requireCode$1(publicClient, poolDeployer, "Algebra pool deployer", blockNumber);
 	let defaultTickSpacing = null;
 	let defaultFee = null;
 	if (deployment.variant === "integral-v1") {
@@ -25771,7 +25953,7 @@ async function inspectAlgebraPool(params) {
 	}
 	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 {
+	if (poolAddress === ZERO$2) return {
 		schemaVersion: 1,
 		blockNumber,
 		deployment,
@@ -25787,7 +25969,7 @@ async function inspectAlgebraPool(params) {
 		pluginConfig: null,
 		unlocked: null
 	};
-	await requireCode(publicClient, poolAddress, "Algebra pool", blockNumber);
+	await requireCode$1(publicClient, poolAddress, "Algebra pool", blockNumber);
 	const [actualFactoryRaw, token0Raw, token1Raw, tickSpacingRaw] = await Promise.all([
 		publicClient.readContract({
 			address: poolAddress,
@@ -25855,7 +26037,7 @@ async function inspectAlgebraPool(params) {
 		pluginConfig = Number(state[3]);
 		unlocked = state[5];
 		const pluginAddress = (0, viem.getAddress)(pluginRaw);
-		plugin = pluginAddress === ZERO ? null : pluginAddress;
+		plugin = pluginAddress === ZERO$2 ? null : pluginAddress;
 	} else {
 		const state = await publicClient.readContract({
 			address: poolAddress,
@@ -26029,29 +26211,29 @@ async function prepareAlgebraPool(params) {
 }
 //#endregion
 //#region src/pool-lifecycle/algebra/types.ts
-function invalid$1(message) {
+function invalid$2(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.`);
+function record$2(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return invalid$2(`${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.`);
+	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) return invalid$2(`${label} must be a valid address.`);
 	const result = (0, viem.getAddress)(value);
-	if (result === "0x0000000000000000000000000000000000000000") return invalid$1(`${label} must not be zero.`);
+	if (result === "0x0000000000000000000000000000000000000000") return invalid$2(`${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.`);
+function hex$1(value, label) {
+	if (typeof value !== "string" || !/^0x(?:[0-9a-fA-F]{2})*$/.test(value)) return invalid$2(`${label} must be hex bytes.`);
 	return value;
 }
 function key(value) {
-	const item = record$1(value, "Algebra key");
+	const item = record$2(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.");
+	if (BigInt(token0) >= BigInt(token1)) return invalid$2("Algebra tokens must be canonically ordered and distinct.");
 	return {
 		token0,
 		token1
@@ -26059,30 +26241,30 @@ function key(value) {
 }
 /** 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 action = record$2(value, "Prepared Algebra action");
+	if (action.schemaVersion !== 1 || action.kind !== "algebra-create" && action.kind !== "algebra-initialize") return invalid$2("Prepared Algebra action kind or schema version is unsupported.");
+	if (typeof action.protocol !== "string") return invalid$2("Algebra action protocol must be a string.");
+	const tx = record$2(action.transaction, "Algebra transaction");
+	if (!Number.isSafeInteger(tx.chainId) || Number(tx.chainId) <= 0) return invalid$2("Algebra chainId must be a positive safe integer.");
+	if (tx.value !== 0n) return invalid$2("Algebra lifecycle transactions must have zero value.");
 	const to = address$1(tx.to, "Algebra transaction target");
-	const data = hex(tx.data, "Algebra calldata");
+	const data = hex$1(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 identity = record$2(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.");
+	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$2("Algebra identity does not match the configured deployment.");
+	const expected = record$2(action.expected, "Algebra expectation");
+	const preflight = record$2(action.preflight, "Algebra preflight");
+	if (typeof preflight.blockNumber !== "bigint" || preflight.blockNumber < 0n) return invalid$2("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");
+		if (identity.poolAddress !== null || expected.sqrtPriceX96 !== null || preflight.status !== "absent" || preflight.poolAddress !== null || preflight.sqrtPriceX96 !== 0n) return invalid$2("Algebra create cannot bind an existing pool or price.");
+		const pluginData = hex$1(expected.pluginData, "Algebra plugin data");
 		expectedTo = (0, viem.getAddress)(deployment.factory);
 		expectedData = deployment.createPool === "pair-with-plugin-data" ? (0, viem.encodeFunctionData)({
 			abi: algebraIntegralPluginDataFactoryAbi,
@@ -26099,11 +26281,11 @@ function validatePreparedAlgebraPoolAction(value) {
 		});
 	} 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.");
+		if (expected.pluginData !== null || typeof expected.sqrtPriceX96 !== "bigint" || preflight.status !== "uninitialized" || address$1(preflight.poolAddress, "Algebra preflight pool") !== pool || preflight.sqrtPriceX96 !== 0n) return invalid$2("Algebra initialize expectation is invalid.");
 		try {
 			validateSqrtPriceX96(expected.sqrtPriceX96);
 		} catch (error) {
-			return invalid$1(error instanceof Error ? error.message : "Invalid Algebra price.");
+			return invalid$2(error instanceof Error ? error.message : "Invalid Algebra price.");
 		}
 		expectedTo = pool;
 		expectedData = (0, viem.encodeFunctionData)({
@@ -26112,7 +26294,7 @@ function validatePreparedAlgebraPoolAction(value) {
 			args: [expected.sqrtPriceX96]
 		});
 	}
-	if (to !== expectedTo || data.toLowerCase() !== expectedData.toLowerCase()) return invalid$1("Algebra transaction does not match its trusted deployment and expectation.");
+	if (to !== expectedTo || data.toLowerCase() !== expectedData.toLowerCase()) return invalid$2("Algebra transaction does not match its trusted deployment and expectation.");
 	return deployment;
 }
 function deserializePreparedAlgebraPoolAction(serialized) {
@@ -26390,6 +26572,528 @@ async function verifyAlgebraPoolAction(params) {
 	}
 }
 //#endregion
+//#region src/pool-lifecycle/aerodrome-slipstream/key.ts
+function canonicalizeAerodromeSlipstreamPoolKey(key) {
+	let tokenA;
+	let tokenB;
+	try {
+		tokenA = (0, viem.getAddress)(key.tokenA);
+		tokenB = (0, viem.getAddress)(key.tokenB);
+	} catch {
+		throw new PoolLifecycleError("INVALID_INPUT", "Slipstream pool tokens must be valid addresses.");
+	}
+	if (tokenA === tokenB || tokenA === "0x0000000000000000000000000000000000000000" || tokenB === "0x0000000000000000000000000000000000000000") throw new PoolLifecycleError("INVALID_INPUT", "Slipstream pool tokens must be distinct non-zero addresses.");
+	if (!Number.isSafeInteger(key.tickSpacing) || key.tickSpacing <= 0 || key.tickSpacing >= 16384) throw new PoolLifecycleError("INVALID_INPUT", "Slipstream tick spacing must be an int24 between 1 and 16383.");
+	return BigInt(tokenA) < BigInt(tokenB) ? {
+		token0: tokenA,
+		token1: tokenB,
+		tickSpacing: key.tickSpacing
+	} : {
+		token0: tokenB,
+		token1: tokenA,
+		tickSpacing: key.tickSpacing
+	};
+}
+function assertAerodromeSlipstreamInitialPrice(value) {
+	if (typeof value !== "bigint" || value <= 0n || value >= 1n << 160n) throw new PoolLifecycleError("INVALID_INPUT", "Slipstream sqrtPriceX96 must be a non-zero uint160.");
+	return value;
+}
+//#endregion
+//#region src/pool-lifecycle/aerodrome-slipstream/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 nonZeroAddress(value, label) {
+	if (typeof value !== "string" || !(0, viem.isAddress)(value, { strict: true })) return invalid$1(`${label} must be a valid address.`);
+	const address = (0, viem.getAddress)(value);
+	if (address === "0x0000000000000000000000000000000000000000") return invalid$1(`${label} must not be zero.`);
+	return address;
+}
+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;
+}
+/** Re-derive all trusted calldata after a plan crosses a JSON boundary. */
+function validatePreparedAerodromeSlipstreamPoolAction(value) {
+	const action = record$1(value, "Prepared Slipstream action");
+	if (action.schemaVersion !== 1 || action.kind !== "aerodrome-slipstream-create-and-initialize" || typeof action.protocol !== "string") return invalid$1("Slipstream action kind, protocol, or schema version is unsupported.");
+	const transaction = record$1(action.transaction, "Slipstream transaction");
+	if (!Number.isSafeInteger(transaction.chainId) || Number(transaction.chainId) <= 0 || transaction.value !== 0n) return invalid$1("Slipstream transaction chainId or value is invalid.");
+	const deployment = resolveAerodromeSlipstreamLifecycleDeployment({
+		chainId: Number(transaction.chainId),
+		protocol: action.protocol
+	});
+	if (!deployment) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", "No Slipstream lifecycle deployment is configured for this action.");
+	const identity = record$1(action.identity, "Slipstream identity");
+	const key = canonicalizeAerodromeSlipstreamPoolKey({
+		tokenA: nonZeroAddress(record$1(identity.key, "Slipstream key").token0, "Slipstream token0"),
+		tokenB: nonZeroAddress(record$1(identity.key, "Slipstream key").token1, "Slipstream token1"),
+		tickSpacing: Number(record$1(identity.key, "Slipstream key").tickSpacing)
+	});
+	if (identity.family !== deployment.family || identity.adapter !== deployment.adapter || identity.version !== deployment.version || identity.chainId !== deployment.chainId || nonZeroAddress(identity.factory, "Slipstream factory") !== deployment.factory || identity.poolAddress !== null) return invalid$1("Slipstream identity does not match the configured deployment.");
+	const sqrtPriceX96 = assertAerodromeSlipstreamInitialPrice(record$1(action.expected, "Slipstream expectation").sqrtPriceX96);
+	const preflight = record$1(action.preflight, "Slipstream preflight");
+	if (typeof preflight.blockNumber !== "bigint" || preflight.blockNumber < 0n || preflight.status !== "absent" || preflight.poolAddress !== null) return invalid$1("Slipstream action must be bound to an absent pool preflight.");
+	const expectedData = (0, viem.encodeFunctionData)({
+		abi: aerodromeSlipstreamFactoryAbi,
+		functionName: "createPool",
+		args: [
+			key.token0,
+			key.token1,
+			key.tickSpacing,
+			sqrtPriceX96
+		]
+	});
+	if (nonZeroAddress(transaction.to, "Slipstream transaction target") !== deployment.factory || hex(transaction.data, "Slipstream transaction calldata").toLowerCase() !== expectedData.toLowerCase()) return invalid$1("Slipstream transaction does not match its trusted deployment and expectation.");
+	return deployment;
+}
+function deserializePreparedAerodromeSlipstreamPoolAction(serialized) {
+	const action = deserializePreparedPoolAction(serialized);
+	validatePreparedAerodromeSlipstreamPoolAction(action);
+	return action;
+}
+//#endregion
+//#region src/pool-lifecycle/aerodrome-slipstream/inspect.ts
+const ZERO$1 = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+async function requireRuntimeHash(client, address, expected, 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}.`);
+	if ((0, viem.keccak256)(code) !== expected) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `${label} ${address} runtime hash does not match the configured deployment.`);
+}
+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}.`);
+}
+async function inspectAerodromeSlipstreamPool(params) {
+	const deployment = validateAerodromeSlipstreamLifecycleDeployment(params.deployment);
+	const key = canonicalizeAerodromeSlipstreamPoolKey(params.key);
+	if (await params.publicClient.getChainId() !== deployment.chainId) throw new PoolLifecycleError("CHAIN_MISMATCH", `Public client chain does not match Slipstream deployment chain ${deployment.chainId}.`);
+	const blockNumber = params.blockNumber ?? await params.publicClient.getBlockNumber();
+	await Promise.all([
+		requireRuntimeHash(params.publicClient, deployment.factory, deployment.factoryRuntimeCodeHash, "Slipstream factory", blockNumber),
+		requireRuntimeHash(params.publicClient, deployment.poolImplementation, deployment.poolImplementationRuntimeCodeHash, "Slipstream pool implementation", blockNumber),
+		requireCode(params.publicClient, key.token0, "token0", blockNumber),
+		requireCode(params.publicClient, key.token1, "token1", blockNumber)
+	]);
+	const [implementation, factoryRegistry, voter, enabledFee, pool, legacyCLFactory] = await Promise.all([
+		params.publicClient.readContract({
+			address: deployment.factory,
+			abi: aerodromeSlipstreamFactoryAbi,
+			functionName: "poolImplementation",
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: deployment.factory,
+			abi: aerodromeSlipstreamFactoryAbi,
+			functionName: "factoryRegistry",
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: deployment.factory,
+			abi: aerodromeSlipstreamFactoryAbi,
+			functionName: "voter",
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: deployment.factory,
+			abi: aerodromeSlipstreamFactoryAbi,
+			functionName: "tickSpacingToFee",
+			args: [key.tickSpacing],
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: deployment.factory,
+			abi: aerodromeSlipstreamFactoryAbi,
+			functionName: "getPool",
+			args: [
+				key.token0,
+				key.token1,
+				key.tickSpacing
+			],
+			blockNumber
+		}),
+		deployment.legacyCLFactory === null ? Promise.resolve(null) : params.publicClient.readContract({
+			address: deployment.factory,
+			abi: aerodromeSlipstreamFactoryAbi,
+			functionName: "legacyCLFactory",
+			blockNumber
+		})
+	]);
+	if ((0, viem.getAddress)(implementation) !== deployment.poolImplementation || (0, viem.getAddress)(factoryRegistry) !== deployment.factoryRegistry || (0, viem.getAddress)(voter) !== deployment.voter || deployment.legacyCLFactory !== null && (0, viem.getAddress)(legacyCLFactory) !== deployment.legacyCLFactory) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", "Slipstream factory immutable deployment references do not match configuration.");
+	const fee = Number(enabledFee);
+	if (!Number.isSafeInteger(fee) || fee <= 0) throw new PoolLifecycleError("INVALID_INPUT", `Slipstream tick spacing ${key.tickSpacing} is not enabled.`);
+	const poolAddress = (0, viem.getAddress)(pool);
+	if (poolAddress === ZERO$1) return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		enabledFee: fee,
+		status: "absent",
+		poolAddress: null,
+		sqrtPriceX96: 0n,
+		tick: null
+	};
+	const [isPool, actualFactory, token0, token1, tickSpacing, slot0] = await Promise.all([
+		params.publicClient.readContract({
+			address: deployment.factory,
+			abi: aerodromeSlipstreamFactoryAbi,
+			functionName: "isPool",
+			args: [poolAddress],
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: poolAddress,
+			abi: aerodromeSlipstreamPoolAbi,
+			functionName: "factory",
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: poolAddress,
+			abi: aerodromeSlipstreamPoolAbi,
+			functionName: "token0",
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: poolAddress,
+			abi: aerodromeSlipstreamPoolAbi,
+			functionName: "token1",
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: poolAddress,
+			abi: aerodromeSlipstreamPoolAbi,
+			functionName: "tickSpacing",
+			blockNumber
+		}),
+		params.publicClient.readContract({
+			address: poolAddress,
+			abi: aerodromeSlipstreamPoolAbi,
+			functionName: "slot0",
+			blockNumber
+		})
+	]);
+	await requireRuntimeHash(params.publicClient, poolAddress, deployment.poolProxyRuntimeCodeHash, "Slipstream pool proxy", blockNumber);
+	if (!isPool || (0, viem.getAddress)(actualFactory) !== deployment.factory || (0, viem.getAddress)(token0) !== key.token0 || (0, viem.getAddress)(token1) !== key.token1 || Number(tickSpacing) !== key.tickSpacing || slot0[0] === 0n) throw new PoolLifecycleError("DEPLOYMENT_MISMATCH", `Slipstream pool ${poolAddress} does not match the configured factory, key, or initialized state.`);
+	return {
+		schemaVersion: 1,
+		blockNumber,
+		deployment,
+		key,
+		enabledFee: fee,
+		status: "initialized",
+		poolAddress,
+		sqrtPriceX96: slot0[0],
+		tick: Number(slot0[1])
+	};
+}
+//#endregion
+//#region src/pool-lifecycle/aerodrome-slipstream/actions.ts
+function assertAbsentPreflight(deployment, key, preflight) {
+	if (preflight.schemaVersion !== 1 || preflight.deployment !== deployment || preflight.key.token0 !== key.token0 || preflight.key.token1 !== key.token1 || preflight.key.tickSpacing !== key.tickSpacing || preflight.status !== "absent" || preflight.poolAddress !== null || preflight.sqrtPriceX96 !== 0n || preflight.tick !== null) throw new PoolLifecycleError("INVALID_INPUT", "Slipstream preflight does not prove this pool key is absent.");
+}
+function buildAerodromeSlipstreamCreateAndInitializeTransaction(params) {
+	const deployment = assertLatestAerodromeSlipstreamLifecycleDeployment(params.deployment);
+	const key = canonicalizeAerodromeSlipstreamPoolKey(params.key);
+	const sqrtPriceX96 = assertAerodromeSlipstreamInitialPrice(params.initialPrice);
+	assertAbsentPreflight(deployment, key, params.preflight);
+	return {
+		schemaVersion: 1,
+		kind: "aerodrome-slipstream-create-and-initialize",
+		protocol: deployment.protocol,
+		transaction: {
+			chainId: deployment.chainId,
+			to: deployment.factory,
+			data: (0, viem.encodeFunctionData)({
+				abi: aerodromeSlipstreamFactoryAbi,
+				functionName: "createPool",
+				args: [
+					key.token0,
+					key.token1,
+					key.tickSpacing,
+					sqrtPriceX96
+				]
+			}),
+			value: 0n
+		},
+		identity: {
+			family: deployment.family,
+			adapter: deployment.adapter,
+			version: deployment.version,
+			chainId: deployment.chainId,
+			factory: (0, viem.getAddress)(deployment.factory),
+			key,
+			poolAddress: null
+		},
+		expected: { sqrtPriceX96 },
+		preflight: {
+			blockNumber: params.preflight.blockNumber,
+			status: "absent",
+			poolAddress: null
+		}
+	};
+}
+async function prepareAerodromeSlipstreamPool(params) {
+	const deployment = assertLatestAerodromeSlipstreamLifecycleDeployment(params.deployment);
+	const snapshot = await inspectAerodromeSlipstreamPool({
+		...params,
+		deployment
+	});
+	const sqrtPriceX96 = assertAerodromeSlipstreamInitialPrice(params.initialPrice);
+	if (snapshot.status === "absent") return {
+		status: "ready",
+		snapshot,
+		action: buildAerodromeSlipstreamCreateAndInitializeTransaction({
+			deployment: snapshot.deployment,
+			key: params.key,
+			initialPrice: sqrtPriceX96,
+			preflight: snapshot
+		})
+	};
+	if (snapshot.sqrtPriceX96 !== sqrtPriceX96) throw new PoolLifecycleError("POOL_STATE_MISMATCH", `Slipstream pool ${snapshot.poolAddress} is already initialized at a different price.`);
+	return {
+		status: "already-initialized-matching",
+		snapshot,
+		action: null
+	};
+}
+/** Prepare a new pool only through the newest verified factory in this family. */
+async function prepareLatestAerodromeSlipstreamPool(params) {
+	const deployment = resolveLatestAerodromeSlipstreamLifecycleDeployment(params.chainId);
+	if (!deployment) throw new PoolLifecycleError("UNSUPPORTED_DEPLOYMENT", `No latest Aerodrome Slipstream lifecycle deployment is configured for chain ${params.chainId}.`);
+	return prepareAerodromeSlipstreamPool({
+		...params,
+		deployment
+	});
+}
+//#endregion
+//#region src/pool-lifecycle/aerodrome-slipstream/simulate.ts
+const ZERO = (0, viem.getAddress)("0x0000000000000000000000000000000000000000");
+async function simulateAerodromeSlipstreamPoolAction(params) {
+	if (!(0, viem.isAddress)(params.account, { strict: true }) || (0, viem.getAddress)(params.account) === ZERO) throw new PoolLifecycleError("INVALID_INPUT", "Simulation account must be a non-zero EVM address.");
+	const deployment = validatePreparedAerodromeSlipstreamPoolAction(params.action);
+	const blockNumber = params.blockNumber ?? await params.publicClient.getBlockNumber();
+	const snapshot = await inspectAerodromeSlipstreamPool({
+		publicClient: params.publicClient,
+		deployment,
+		key: {
+			tokenA: params.action.identity.key.token0,
+			tokenB: params.action.identity.key.token1,
+			tickSpacing: params.action.identity.key.tickSpacing
+		},
+		blockNumber
+	});
+	if (snapshot.status !== "absent") throw new PoolLifecycleError("POOL_STATE_MISMATCH", `Slipstream pool already exists at ${snapshot.poolAddress}; refresh the action.`);
+	try {
+		const request = {
+			account: (0, viem.getAddress)(params.account),
+			to: params.action.transaction.to,
+			data: params.action.transaction.data,
+			value: 0n,
+			blockNumber
+		};
+		const [call, gasEstimate] = await Promise.all([params.publicClient.call({
+			...request,
+			batch: false
+		}), params.publicClient.estimateGas(request)]);
+		if (!call.data || call.data === "0x") throw new PoolLifecycleError("SIMULATION_FAILED", "Slipstream create simulation returned no pool address.");
+		return {
+			transaction: params.action.transaction,
+			blockNumber,
+			returnData: call.data,
+			returnedPoolAddress: (0, viem.getAddress)((0, viem.decodeFunctionResult)({
+				abi: aerodromeSlipstreamFactoryAbi,
+				functionName: "createPool",
+				data: call.data
+			})),
+			gasEstimate
+		};
+	} catch (error) {
+		if (error instanceof PoolLifecycleError) throw error;
+		throw new PoolLifecycleError("SIMULATION_FAILED", error instanceof Error ? error.message : "Slipstream action simulation failed.", error);
+	}
+}
+//#endregion
+//#region src/pool-lifecycle/aerodrome-slipstream/verify.ts
+function assertCanonicalLog(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", "Slipstream lifecycle log does not belong to the canonical receipt.");
+}
+function decodeAerodromeSlipstreamPoolActionReceipt(action, receipt) {
+	validatePreparedAerodromeSlipstreamPoolAction(action);
+	const created = [];
+	const initialized = [];
+	for (const log of receipt.logs) {
+		if ((0, viem.getAddress)(log.address) === action.identity.factory) try {
+			const event = (0, viem.decodeEventLog)({
+				abi: aerodromeSlipstreamFactoryAbi,
+				eventName: "PoolCreated",
+				data: log.data,
+				topics: log.topics
+			});
+			if ((0, viem.getAddress)(event.args.token0) === action.identity.key.token0 && (0, viem.getAddress)(event.args.token1) === action.identity.key.token1 && Number(event.args.tickSpacing) === action.identity.key.tickSpacing) {
+				assertCanonicalLog(log, receipt);
+				created.push({
+					poolAddress: (0, viem.getAddress)(event.args.pool),
+					logIndex: log.logIndex
+				});
+			}
+		} catch (error) {
+			if (error instanceof PoolLifecycleError) throw error;
+		}
+		try {
+			const event = (0, viem.decodeEventLog)({
+				abi: aerodromeSlipstreamPoolAbi,
+				eventName: "Initialize",
+				data: log.data,
+				topics: log.topics
+			});
+			assertCanonicalLog(log, receipt);
+			initialized.push({
+				poolAddress: (0, viem.getAddress)(log.address),
+				sqrtPriceX96: event.args.sqrtPriceX96,
+				tick: Number(event.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 Slipstream lifecycle events.");
+	return {
+		receiptStatus: receipt.status,
+		poolCreated: created[0] ?? null,
+		initialization: initialized[0] ?? null
+	};
+}
+async function verifyAerodromeSlipstreamPoolAction(params) {
+	const deployment = validatePreparedAerodromeSlipstreamPoolAction(params.action);
+	let receipt;
+	try {
+		const [chainId, transaction, canonical] = await Promise.all([
+			params.publicClient.getChainId(),
+			params.publicClient.getTransaction({ hash: params.receipt.transactionHash }),
+			params.publicClient.getTransactionReceipt({ hash: params.receipt.transactionHash })
+		]);
+		if (chainId !== deployment.chainId || canonical.transactionHash !== params.receipt.transactionHash || canonical.blockHash !== params.receipt.blockHash || transaction.to === null || transaction.value !== 0n || (0, viem.getAddress)(transaction.to) !== params.action.transaction.to || transaction.input.toLowerCase() !== params.action.transaction.data.toLowerCase()) return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber: params.receipt.blockNumber,
+			identity: params.action.identity,
+			state: null,
+			evidence: {
+				receiptStatus: params.receipt.status,
+				poolCreated: null,
+				initialization: null
+			},
+			warnings: ["Canonical transaction does not match the prepared Slipstream action."]
+		};
+		receipt = canonical;
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "verification-unavailable",
+			blockNumber: params.receipt.blockNumber,
+			identity: params.action.identity,
+			state: null,
+			evidence: {
+				receiptStatus: params.receipt.status,
+				poolCreated: null,
+				initialization: null
+			},
+			warnings: [error instanceof Error ? error.message : "Could not load canonical transaction evidence."]
+		};
+	}
+	let evidence;
+	try {
+		evidence = decodeAerodromeSlipstreamPoolActionReceipt(params.action, receipt);
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber: receipt.blockNumber,
+			identity: params.action.identity,
+			state: null,
+			evidence: {
+				receiptStatus: receipt.status,
+				poolCreated: null,
+				initialization: null
+			},
+			warnings: [error instanceof Error ? error.message : "Invalid receipt evidence."]
+		};
+	}
+	if (receipt.status === "reverted") return {
+		verified: false,
+		outcome: "reverted",
+		blockNumber: receipt.blockNumber,
+		identity: params.action.identity,
+		state: null,
+		evidence,
+		warnings: []
+	};
+	try {
+		const snapshot = await inspectAerodromeSlipstreamPool({
+			publicClient: params.publicClient,
+			deployment,
+			key: {
+				tokenA: params.action.identity.key.token0,
+				tokenB: params.action.identity.key.token1,
+				tickSpacing: params.action.identity.key.tickSpacing
+			},
+			blockNumber: receipt.blockNumber
+		});
+		const identity = {
+			...params.action.identity,
+			poolAddress: snapshot.poolAddress
+		};
+		if (!evidence.poolCreated || !evidence.initialization || snapshot.status !== "initialized" || evidence.poolCreated.poolAddress !== snapshot.poolAddress || evidence.initialization.poolAddress !== snapshot.poolAddress || evidence.initialization.sqrtPriceX96 !== params.action.expected.sqrtPriceX96) return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber: receipt.blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings: ["Receipt evidence does not prove the expected atomic Slipstream lifecycle."]
+		};
+		return snapshot.sqrtPriceX96 === params.action.expected.sqrtPriceX96 ? {
+			verified: true,
+			outcome: "created-and-initialized",
+			blockNumber: receipt.blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings: []
+		} : {
+			verified: true,
+			outcome: "initialized-then-price-moved",
+			blockNumber: receipt.blockNumber,
+			identity,
+			state: snapshot,
+			evidence,
+			warnings: ["Pool price moved after initialization in the receipt block."]
+		};
+	} catch (error) {
+		return {
+			verified: false,
+			outcome: "wrong-deployment",
+			blockNumber: receipt.blockNumber,
+			identity: params.action.identity,
+			state: null,
+			evidence,
+			warnings: [error instanceof Error ? error.message : "Slipstream state verification failed."]
+		};
+	}
+}
+//#endregion
 //#region src/pool-lifecycle/v3/types.ts
 function invalidPreparedAction(message) {
 	throw new PoolLifecycleError("INVALID_INPUT", message);
@@ -28036,6 +28740,7 @@ async function verifyV4PoolAction(params) {
 */
 //#endregion
 exports.AERODROME_PROTOCOLS = AERODROME_PROTOCOLS;
+exports.AERODROME_SLIPSTREAM_LIFECYCLE_DEPLOYMENTS = AERODROME_SLIPSTREAM_LIFECYCLE_DEPLOYMENTS;
 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;
@@ -28093,6 +28798,8 @@ exports.V4_ZERO_ADDRESS = V4_ZERO_ADDRESS;
 exports.VAULT_FEES_ABI = VAULT_FEES_ABI;
 exports.VaultClient = VaultClient;
 exports.abis = abis;
+exports.aerodromeSlipstreamFactoryAbi = aerodromeSlipstreamFactoryAbi;
+exports.aerodromeSlipstreamPoolAbi = aerodromeSlipstreamPoolAbi;
 exports.algebraCustomPoolEntryPointAbi = algebraCustomPoolEntryPointAbi;
 exports.algebraDirectionalPoolStateAbi = algebraDirectionalPoolStateAbi;
 exports.algebraIntegralPairFactoryAbi = algebraIntegralPairFactoryAbi;
@@ -28105,7 +28812,9 @@ exports.apechainAddresses = apechainAddresses;
 exports.arbitrumAddresses = arbitrumAddresses;
 exports.arbitrumgoerliAddresses = arbitrumgoerliAddresses;
 exports.arthswapConfig = arthswapConfig;
+exports.assertAerodromeSlipstreamInitialPrice = assertAerodromeSlipstreamInitialPrice;
 exports.assertAlgebraInitialPrice = assertAlgebraInitialPrice;
+exports.assertLatestAerodromeSlipstreamLifecycleDeployment = assertLatestAerodromeSlipstreamLifecycleDeployment;
 exports.assertPreparedV3PoolAction = assertPreparedV3PoolAction;
 exports.assertPreparedV4PoolAction = assertPreparedV4PoolAction;
 exports.assertV3InitialPrice = assertV3InitialPrice;
@@ -28122,6 +28831,7 @@ exports.bittensorAddresses = bittensorAddresses;
 exports.bittensorUniV3Config = bittensorUniV3Config;
 exports.blastAddresses = blastAddresses;
 exports.bscAddresses = bscAddresses;
+exports.buildAerodromeSlipstreamCreateAndInitializeTransaction = buildAerodromeSlipstreamCreateAndInitializeTransaction;
 exports.buildAlgebraCreatePoolTransaction = buildAlgebraCreatePoolTransaction;
 exports.buildAlgebraInitializePoolTransaction = buildAlgebraInitializePoolTransaction;
 exports.buildV3CreateAndInitializeTransaction = buildV3CreateAndInitializeTransaction;
@@ -28131,6 +28841,7 @@ exports.buildV4InitializePoolTransaction = buildV4InitializePoolTransaction;
 exports.calculateLimitPrice = calculateLimitPrice;
 exports.calculateSwapAmount = calculateSwapAmount;
 exports.camelotConfig = camelotConfig;
+exports.canonicalizeAerodromeSlipstreamPoolKey = canonicalizeAerodromeSlipstreamPoolKey;
 exports.canonicalizeAlgebraPoolKey = canonicalizeAlgebraPoolKey;
 exports.canonicalizeV3PoolKey = canonicalizeV3PoolKey;
 exports.canonicalizeV4PoolKey = canonicalizeV4PoolKey;
@@ -28138,10 +28849,12 @@ exports.celoAddresses = celoAddresses;
 exports.chainIdToName = chainIdToName;
 exports.chainNameToId = chainNameToId;
 exports.crustConfig = crustConfig;
+exports.decodeAerodromeSlipstreamPoolActionReceipt = decodeAerodromeSlipstreamPoolActionReceipt;
 exports.decodeAlgebraPoolActionReceipt = decodeAlgebraPoolActionReceipt;
 exports.decodeV3PoolActionReceipt = decodeV3PoolActionReceipt;
 exports.decodeV4PoolActionReceipt = decodeV4PoolActionReceipt;
 exports.deprecatedBundlesURL = deprecatedBundlesURL;
+exports.deserializePreparedAerodromeSlipstreamPoolAction = deserializePreparedAerodromeSlipstreamPoolAction;
 exports.deserializePreparedAlgebraPoolAction = deserializePreparedAlgebraPoolAction;
 exports.deserializePreparedPoolAction = deserializePreparedPoolAction;
 exports.deserializePreparedV3PoolAction = deserializePreparedV3PoolAction;
@@ -28205,6 +28918,7 @@ exports.hemiAddresses = hemiAddresses;
 exports.henjinConfig = henjinConfig;
 exports.herculesConfig = herculesConfig;
 exports.horizaConfig = horizaConfig;
+exports.inspectAerodromeSlipstreamPool = inspectAerodromeSlipstreamPool;
 exports.inspectAlgebraCustomPoolEntryPoint = inspectAlgebraCustomPoolEntryPoint;
 exports.inspectAlgebraPool = inspectAlgebraPool;
 exports.inspectV3Pool = inspectV3Pool;
@@ -28258,7 +28972,9 @@ exports.parseExactDecimal = parseExactDecimal;
 exports.polygonAddresses = polygonAddresses;
 exports.polyzkevmAddresses = polyzkevmAddresses;
 exports.poolsharkConfig = poolsharkConfig;
+exports.prepareAerodromeSlipstreamPool = prepareAerodromeSlipstreamPool;
 exports.prepareAlgebraPool = prepareAlgebraPool;
+exports.prepareLatestAerodromeSlipstreamPool = prepareLatestAerodromeSlipstreamPool;
 exports.prepareV3CreateAndInitialize = prepareV3CreateAndInitialize;
 exports.prepareV3CreatePool = prepareV3CreatePool;
 exports.prepareV3InitializePool = prepareV3InitializePool;
@@ -28267,8 +28983,10 @@ exports.quickSwapAlgebraConfig = quickSwapAlgebraConfig;
 exports.quickSwapConfig = quickSwapConfig;
 exports.quickSwapIntegralConfig = quickSwapIntegralConfig;
 exports.quickSwapUniv3Config = quickSwapUniv3Config;
+exports.resolveAerodromeSlipstreamLifecycleDeployment = resolveAerodromeSlipstreamLifecycleDeployment;
 exports.resolveAlgebraLifecycleDeployment = resolveAlgebraLifecycleDeployment;
 exports.resolveCurrentV4LifecycleDeployment = resolveCurrentV4LifecycleDeployment;
+exports.resolveLatestAerodromeSlipstreamLifecycleDeployment = resolveLatestAerodromeSlipstreamLifecycleDeployment;
 exports.resolvePoolLifecycleDeployment = resolvePoolLifecycleDeployment;
 exports.resolveV3LifecycleDeployment = resolveV3LifecycleDeployment;
 exports.resolveV4LifecycleDeployment = resolveV4LifecycleDeployment;
@@ -28282,6 +29000,7 @@ exports.seiAddresses = seiAddresses;
 exports.serializePreparedPoolAction = serializePreparedPoolAction;
 exports.shadowConfig = shadowConfig;
 exports.shouldValidateUniswapV4VaultHook = shouldValidateUniswapV4VaultHook;
+exports.simulateAerodromeSlipstreamPoolAction = simulateAerodromeSlipstreamPoolAction;
 exports.simulateAlgebraPoolAction = simulateAlgebraPoolAction;
 exports.simulateSwap = simulateSwap;
 exports.simulateV3PoolAction = simulateV3PoolAction;
@@ -28313,7 +29032,9 @@ exports.v3PoolInitializerAbi = v3PoolInitializerAbi;
 exports.v4PoolKeysEqual = v4PoolKeysEqual;
 exports.v4PoolManagerAbi = v4PoolManagerAbi;
 exports.v4StateViewAbi = v4StateViewAbi;
+exports.validateAerodromeSlipstreamLifecycleDeployment = validateAerodromeSlipstreamLifecycleDeployment;
 exports.validateAlgebraLifecycleDeployment = validateAlgebraLifecycleDeployment;
+exports.validatePreparedAerodromeSlipstreamPoolAction = validatePreparedAerodromeSlipstreamPoolAction;
 exports.validatePreparedAlgebraPoolAction = validatePreparedAlgebraPoolAction;
 exports.validatePreparedV3PoolAction = validatePreparedV3PoolAction;
 exports.validatePreparedV4PoolAction = validatePreparedV4PoolAction;
@@ -28322,6 +29043,7 @@ exports.validateSqrtPriceX96 = validateSqrtPriceX96;
 exports.validateSwapParams = validateSwapParams;
 exports.validateV4LifecycleDeployment = validateV4LifecycleDeployment;
 exports.validateV4PoolKey = validateV4PoolKey;
+exports.verifyAerodromeSlipstreamPoolAction = verifyAerodromeSlipstreamPoolAction;
 exports.verifyAlgebraPoolAction = verifyAlgebraPoolAction;
 exports.verifyV3PoolAction = verifyV3PoolAction;
 exports.verifyV4PoolAction = verifyV4PoolAction;