@steerprotocol/sdk 3.4.2 → 3.5.0

package/dist/index.browser.mjs

@@ -9256,7 +9256,7 @@ const steerSubgraphConfig = {
 	[Chain.Zircuit]: offlineSubgraphUrl("zircuit"),
 	[Chain.Moonbeam]: offlineSubgraphUrl("moonbeam"),
 	[Chain.Sei]: offlineSubgraphUrl("sei"),
-	[Chain.Sonic]: offlineSubgraphUrl("sonic"),
+	[Chain.Sonic]: "https://api.subgraph.ormilabs.com/api/public/803c8c8c-be12-4188-8523-b9853e23051d/subgraphs/steer-protocol-sonic/prod/gn",
 	[Chain.Zeta]: offlineSubgraphUrl("zeta"),
 	[Chain.Mainnet]: "https://api.subgraph.ormilabs.com/api/public/803c8c8c-be12-4188-8523-b9853e23051d/subgraphs/steer-protocol-mainnet/prod/gn",
 	[Chain.Soneium]: offlineSubgraphUrl("soneium"),
@@ -24414,7 +24414,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,
@@ -24456,179 +24456,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",
@@ -24661,6 +24661,164 @@ function validateAlgebraLifecycleDeployment(value) {
 	return configured;
 }
 //#endregion
+//#region src/pool-lifecycle/capabilities/aerodrome-slipstream.ts
+const factoryRegistry = getAddress("0x5C3F18F06CC09CA1910767A34a20F771039E37C0");
+const voter = getAddress("0x16613524e02aD97edfef371Bc883F2f5D6c480A5");
+const originalFactory = 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: 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: 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: getAddress("0xaDe65c38CD4849aDBA595a4323a8C7DdfE89716a"),
+		factoryRuntimeCodeHash: "0x0e72100f63ce8e32c95370fa9636d38c8cf434a820f2a7a69985e50930d2cb85",
+		poolImplementation: 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: 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: getAddress("0xf8f2eB4940CFE7d13603DDDD87f123820Fc061Ef"),
+		factoryRuntimeCodeHash: "0x4961963494e47f363617ab9a0f3999a28b33c519e51392952db06350cce700bd",
+		poolImplementation: 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: 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 && getAddress(candidate.factory) === configured.factory && candidate.factoryRuntimeCodeHash === configured.factoryRuntimeCodeHash && getAddress(candidate.poolImplementation) === configured.poolImplementation && candidate.poolImplementationRuntimeCodeHash === configured.poolImplementationRuntimeCodeHash && candidate.poolProxyRuntimeCodeHash === configured.poolProxyRuntimeCodeHash && getAddress(candidate.factoryRegistry) === configured.factoryRegistry && getAddress(candidate.voter) === configured.voter && (configured.legacyCLFactory === null ? candidate.legacyCLFactory === null : 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";
@@ -25340,7 +25498,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");
 }
 /**
@@ -25409,6 +25568,29 @@ const algebraIntegralPoolStateAbi = parseAbi(["function globalState() view retur
 */
 const algebraCustomPoolEntryPointAbi = 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 = 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 = 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 = [
@@ -25682,8 +25864,8 @@ function assertAlgebraInitialPrice(key, price) {
 }
 //#endregion
 //#region src/pool-lifecycle/algebra/inspect.ts
-const ZERO = getAddress("0x0000000000000000000000000000000000000000");
-async function requireCode(client, address, label, blockNumber) {
+const ZERO$2 = getAddress("0x0000000000000000000000000000000000000000");
+async function requireCode$1(client, address, label, blockNumber) {
 	const code = await client.getCode({
 		address,
 		blockNumber
@@ -25699,7 +25881,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 = getAddress(await params.publicClient.readContract({
 		address: entryPoint,
 		abi: algebraCustomPoolEntryPointAbi,
@@ -25722,9 +25904,9 @@ async function inspectAlgebraPool(params) {
 	const blockNumber = params.blockNumber ?? await publicClient.getBlockNumber();
 	const factory = 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({
@@ -25740,8 +25922,8 @@ async function inspectAlgebraPool(params) {
 		blockNumber
 	})]);
 	const poolDeployer = 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") {
@@ -25770,7 +25952,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 = getAddress(poolRaw);
-	if (poolAddress === ZERO) return {
+	if (poolAddress === ZERO$2) return {
 		schemaVersion: 1,
 		blockNumber,
 		deployment,
@@ -25786,7 +25968,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,
@@ -25854,7 +26036,7 @@ async function inspectAlgebraPool(params) {
 		pluginConfig = Number(state[3]);
 		unlocked = state[5];
 		const pluginAddress = getAddress(pluginRaw);
-		plugin = pluginAddress === ZERO ? null : pluginAddress;
+		plugin = pluginAddress === ZERO$2 ? null : pluginAddress;
 	} else {
 		const state = await publicClient.readContract({
 			address: poolAddress,
@@ -26028,29 +26210,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" || !isAddress(value, { strict: true })) return invalid$1(`${label} must be a valid address.`);
+	if (typeof value !== "string" || !isAddress(value, { strict: true })) return invalid$2(`${label} must be a valid address.`);
 	const result = 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
@@ -26058,30 +26240,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") !== 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") !== 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 = getAddress(deployment.factory);
 		expectedData = deployment.createPool === "pair-with-plugin-data" ? encodeFunctionData({
 			abi: algebraIntegralPluginDataFactoryAbi,
@@ -26098,11 +26280,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 = encodeFunctionData({
@@ -26111,7 +26293,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) {
@@ -26389,6 +26571,528 @@ async function verifyAlgebraPoolAction(params) {
 	}
 }
 //#endregion
+//#region src/pool-lifecycle/aerodrome-slipstream/key.ts
+function canonicalizeAerodromeSlipstreamPoolKey(key) {
+	let tokenA;
+	let tokenB;
+	try {
+		tokenA = getAddress(key.tokenA);
+		tokenB = 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" || !isAddress(value, { strict: true })) return invalid$1(`${label} must be a valid address.`);
+	const address = 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 = 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 = 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 (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 (getAddress(implementation) !== deployment.poolImplementation || getAddress(factoryRegistry) !== deployment.factoryRegistry || getAddress(voter) !== deployment.voter || deployment.legacyCLFactory !== null && 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 = 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 || getAddress(actualFactory) !== deployment.factory || getAddress(token0) !== key.token0 || 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: 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: 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 = getAddress("0x0000000000000000000000000000000000000000");
+async function simulateAerodromeSlipstreamPoolAction(params) {
+	if (!isAddress(params.account, { strict: true }) || 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: 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: getAddress(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 (getAddress(log.address) === action.identity.factory) try {
+			const event = decodeEventLog({
+				abi: aerodromeSlipstreamFactoryAbi,
+				eventName: "PoolCreated",
+				data: log.data,
+				topics: log.topics
+			});
+			if (getAddress(event.args.token0) === action.identity.key.token0 && getAddress(event.args.token1) === action.identity.key.token1 && Number(event.args.tickSpacing) === action.identity.key.tickSpacing) {
+				assertCanonicalLog(log, receipt);
+				created.push({
+					poolAddress: getAddress(event.args.pool),
+					logIndex: log.logIndex
+				});
+			}
+		} catch (error) {
+			if (error instanceof PoolLifecycleError) throw error;
+		}
+		try {
+			const event = decodeEventLog({
+				abi: aerodromeSlipstreamPoolAbi,
+				eventName: "Initialize",
+				data: log.data,
+				topics: log.topics
+			});
+			assertCanonicalLog(log, receipt);
+			initialized.push({
+				poolAddress: 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 || 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);
@@ -28034,6 +28738,6 @@ async function verifyV4PoolAction(params) {
 * See {@link SmartRewards} for detailed API documentation.
 */
 //#endregion
-export { AERODROME_PROTOCOLS, ALGEBRA_INTEGRAL_PROTOCOLS, ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS, ALGEBRA_LIFECYCLE_DEPLOYMENTS, ALGEBRA_PROTOCOLS, AMMType, API_URLS, AlgebgraHookBeacons, CURRENT_V4_LIFECYCLE_DEPLOYMENTS, Chain, ChainId, DIRECTIONAL_ALGEBRA_PROTOCOLS, FEE_MANAGER_ABI, FeeManagerClient, MAX_SQRT_RATIO, MIN_SQRT_RATIO, MultiPositionManagers, POOLSHARK_PROTOCOLS, POOL_LIFECYCLE_DEPLOYMENTS, PREPARED_POOL_ACTION_SERIALIZATION_VERSION, PoolClient, PoolLifecycleError, Protocol, QuickSwapQuoterV2, QuoterV2AlgebgraIntegral, QuoterV2AlgebgraIntegral21, QuoterV2Factory, QuoterV2Shadow, QuoterV2Thick, SHADOW_PROTOCOLS, SingleAssetDepositClient, SmartRewards, StakingClient, StakingProtocol, SteerClient, StrykePositionManagers, SubgraphClient, SubgraphVaultClient, TEST_UNISWAP_JIT_HOOK_BEACON, UNISWAP_V4_BEACON_NAMES, UNISWAP_V4_HOOK_BEACON_NAMES, UNISWAP_V4_NO_ORACLE_BEACON, UniswapHookBeacons, UniswapV3PoolABI, UniswapV3QuoterABI, UniswapV4Beacons, V3_CONFIG_PROTOCOLS, V3_LIFECYCLE_DEPLOYMENTS, V4_ALL_HOOK_MASK, V4_DYNAMIC_FEE_FLAG, V4_LIFECYCLE_DEPLOYMENTS, V4_LIFECYCLE_DEPLOYMENTS_BY_ID, V4_MAX_STATIC_FEE, V4_MAX_TICK_SPACING, V4_ZERO_ADDRESS, VAULT_FEES_ABI, VaultClient, abis, algebraCustomPoolEntryPointAbi, algebraDirectionalPoolStateAbi, algebraIntegralPairFactoryAbi, algebraIntegralPluginDataFactoryAbi, algebraIntegralPoolStateAbi, algebraLegacyPoolStateAbi, algebraPairFactoryAbi, algebraPoolBaseAbi, apechainAddresses, arbitrumAddresses, arbitrumgoerliAddresses, arthswapConfig, assertAlgebraInitialPrice, assertPreparedV3PoolAction, assertPreparedV4PoolAction, assertV3InitialPrice, assertV4InitialPrice, astarAddresses, astarzkevmAddresses, avalancheAddresses, bartiotestAddresses, baseAddresses, baseSwapConfig, basexConfig, beraAddresses, bittensorAddresses, bittensorUniV3Config, blastAddresses, bscAddresses, buildAlgebraCreatePoolTransaction, buildAlgebraInitializePoolTransaction, buildV3CreateAndInitializeTransaction, buildV3CreatePoolTransaction, buildV3InitializePoolTransaction, buildV4InitializePoolTransaction, calculateLimitPrice, calculateSwapAmount, camelotConfig, canonicalizeAlgebraPoolKey, canonicalizeV3PoolKey, canonicalizeV4PoolKey, celoAddresses, chainIdToName, chainNameToId, crustConfig, decodeAlgebraPoolActionReceipt, decodeV3PoolActionReceipt, decodeV4PoolActionReceipt, deprecatedBundlesURL, deserializePreparedAlgebraPoolAction, deserializePreparedPoolAction, deserializePreparedV3PoolAction, deserializePreparedV4PoolAction, determineSwapDirection, encodeCurrencyInitialSqrtPriceX96, encodeInitialSqrtPriceX96, encodeSqrtRatioX96, equilibreConfig, erc1155Abi, erc20Abi, erc721Abi, estimateLpTokens, ethAddresses, evmosAddresses, fantomAddresses, fenixConfig, filecoinAddresses, flareAddresses, forgeConfig, fusionxConfig, getAmmConfig, getAmmConfigByChainId, getApiUrl, getBeaconNameByProtocol, getContractAddressByChainIdAndContractName, getExpectedParamType, getFactoryAddress, getInitCodeHash, getNFTManagerAddress, getNetworkByChainId, getPoolHelperByChainId, getPoolSlot0, getProtcolTypeByAmmType, getProtocolBySubgraph, getProtocolConfigByBeacon, getProtocolContractAddresses, getProtocolInfoByChainId, getProtocolInfoByName, getProtocolSubgraphURL, getProtocolTypeByBeacon, getProtocolsForChainId, getQuoterV2Address, getStabilityVaultsPeripheryAddress, getStabilityVaultsSubgraphUrl, getSubgraphUrlByChainId, getSupportedChainByChainId, getSupportedChainIds, getSupportedChains, getSwapRouterAddress, getTheGraphResolverUrl, getTickLensAddress, getUniswapV4BeaconSupportedChains, getV4LifecycleDeploymentId, getV4PoolId, getVaultExecutionContext, getVaultReserves, glyphConfig, goerliAddresses, hemiAddresses, henjinConfig, herculesConfig, horizaConfig, inspectAlgebraCustomPoolEntryPoint, inspectAlgebraPool, inspectV3Pool, inspectV4Pool, integerSqrt, isAerodromeVault, isAlgebraDirectionProtocol, isAlgebraIntegral21QuoteParams, isAlgebraIntegralProtocol, isAlgebraIntegralV2Protocol, isAlgebraProtocol, isAlgebraProtocolBySubgraph, isAlgebraQuoteParams, isPoolSharkProtocol, isShadowProtocol, isShadowQuoteParams, isSingleAssetDepositSupported, isThickQuoteParams, isThickV2Protocol, isUniswapQuoteParams, isUniswapV4Beacon, isUniswapV4BeaconAvailableOnChain, isUniswapV4HookBeacon, isValidStakingProtocol, katanaAddresses, katanaConfig, kavaAddresses, kimConfig, kinetixConfig, lineaAddresses, linehubConfig, localhostAddresses, lynexConfig, maiaConfig, mantaAddresses, mantleAddresses, metaVaultConfig, metisAddresses, modeAddresses, moonbeamAddresses, mumbaiAddresses, nestVaultConfig, networks, normalizeProtocol, novaswapConfig, okxtestnetAddresses, optimismAddresses, optimismgoerliAddresses, pancakeSwapConfig, parseExactDecimal, polygonAddresses, polyzkevmAddresses, poolsharkConfig, prepareAlgebraPool, prepareV3CreateAndInitialize, prepareV3CreatePool, prepareV3InitializePool, prepareV4Initialize, quickSwapAlgebraConfig, quickSwapConfig, quickSwapIntegralConfig, quickSwapUniv3Config, resolveAlgebraLifecycleDeployment, resolveCurrentV4LifecycleDeployment, resolvePoolLifecycleDeployment, resolveV3LifecycleDeployment, resolveV4LifecycleDeployment, resolveV4LifecycleDeploymentById, retroConfig, robinhoodAddresses, rootstockAddresses, sagaAddresses, scrollAddresses, seiAddresses, serializePreparedPoolAction, shadowConfig, shouldValidateUniswapV4VaultHook, simulateAlgebraPoolAction, simulateSwap, simulateV3PoolAction, simulateV4PoolAction, singleTokenDepositAbi, soneiumAddresses, sonicAddresses, sortErc20Pair, sortEvmCurrencyPair, spark32Config, sparkConfig, stabilityVaultsConfig, steerSubgraphConfig, supswapConfig, sushiConfig, swapmodeConfig, swapsicleConfig, taikoAddresses, telosAddresses, thenaConfig, thickConfig, thrusterConfig, thundercoreAddresses, uniAddresses, uniswapConfig, v3FactoryAbi, v3PoolAbi, v3PoolInitializerAbi, v4PoolKeysEqual, v4PoolManagerAbi, v4StateViewAbi, validateAlgebraLifecycleDeployment, validatePreparedAlgebraPoolAction, validatePreparedV3PoolAction, validatePreparedV4PoolAction, validateQuoteParams, validateSqrtPriceX96, validateSwapParams, validateV4LifecycleDeployment, validateV4PoolKey, verifyAlgebraPoolAction, verifyV3PoolAction, verifyV4PoolAction, xlayerAddresses, zetaAddresses, zircuitAddresses };
+export { AERODROME_PROTOCOLS, AERODROME_SLIPSTREAM_LIFECYCLE_DEPLOYMENTS, ALGEBRA_INTEGRAL_PROTOCOLS, ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS, ALGEBRA_LIFECYCLE_DEPLOYMENTS, ALGEBRA_PROTOCOLS, AMMType, API_URLS, AlgebgraHookBeacons, CURRENT_V4_LIFECYCLE_DEPLOYMENTS, Chain, ChainId, DIRECTIONAL_ALGEBRA_PROTOCOLS, FEE_MANAGER_ABI, FeeManagerClient, MAX_SQRT_RATIO, MIN_SQRT_RATIO, MultiPositionManagers, POOLSHARK_PROTOCOLS, POOL_LIFECYCLE_DEPLOYMENTS, PREPARED_POOL_ACTION_SERIALIZATION_VERSION, PoolClient, PoolLifecycleError, Protocol, QuickSwapQuoterV2, QuoterV2AlgebgraIntegral, QuoterV2AlgebgraIntegral21, QuoterV2Factory, QuoterV2Shadow, QuoterV2Thick, SHADOW_PROTOCOLS, SingleAssetDepositClient, SmartRewards, StakingClient, StakingProtocol, SteerClient, StrykePositionManagers, SubgraphClient, SubgraphVaultClient, TEST_UNISWAP_JIT_HOOK_BEACON, UNISWAP_V4_BEACON_NAMES, UNISWAP_V4_HOOK_BEACON_NAMES, UNISWAP_V4_NO_ORACLE_BEACON, UniswapHookBeacons, UniswapV3PoolABI, UniswapV3QuoterABI, UniswapV4Beacons, V3_CONFIG_PROTOCOLS, V3_LIFECYCLE_DEPLOYMENTS, V4_ALL_HOOK_MASK, V4_DYNAMIC_FEE_FLAG, V4_LIFECYCLE_DEPLOYMENTS, V4_LIFECYCLE_DEPLOYMENTS_BY_ID, V4_MAX_STATIC_FEE, V4_MAX_TICK_SPACING, V4_ZERO_ADDRESS, VAULT_FEES_ABI, VaultClient, abis, aerodromeSlipstreamFactoryAbi, aerodromeSlipstreamPoolAbi, algebraCustomPoolEntryPointAbi, algebraDirectionalPoolStateAbi, algebraIntegralPairFactoryAbi, algebraIntegralPluginDataFactoryAbi, algebraIntegralPoolStateAbi, algebraLegacyPoolStateAbi, algebraPairFactoryAbi, algebraPoolBaseAbi, apechainAddresses, arbitrumAddresses, arbitrumgoerliAddresses, arthswapConfig, assertAerodromeSlipstreamInitialPrice, assertAlgebraInitialPrice, assertLatestAerodromeSlipstreamLifecycleDeployment, assertPreparedV3PoolAction, assertPreparedV4PoolAction, assertV3InitialPrice, assertV4InitialPrice, astarAddresses, astarzkevmAddresses, avalancheAddresses, bartiotestAddresses, baseAddresses, baseSwapConfig, basexConfig, beraAddresses, bittensorAddresses, bittensorUniV3Config, blastAddresses, bscAddresses, buildAerodromeSlipstreamCreateAndInitializeTransaction, buildAlgebraCreatePoolTransaction, buildAlgebraInitializePoolTransaction, buildV3CreateAndInitializeTransaction, buildV3CreatePoolTransaction, buildV3InitializePoolTransaction, buildV4InitializePoolTransaction, calculateLimitPrice, calculateSwapAmount, camelotConfig, canonicalizeAerodromeSlipstreamPoolKey, canonicalizeAlgebraPoolKey, canonicalizeV3PoolKey, canonicalizeV4PoolKey, celoAddresses, chainIdToName, chainNameToId, crustConfig, decodeAerodromeSlipstreamPoolActionReceipt, decodeAlgebraPoolActionReceipt, decodeV3PoolActionReceipt, decodeV4PoolActionReceipt, deprecatedBundlesURL, deserializePreparedAerodromeSlipstreamPoolAction, deserializePreparedAlgebraPoolAction, deserializePreparedPoolAction, deserializePreparedV3PoolAction, deserializePreparedV4PoolAction, determineSwapDirection, encodeCurrencyInitialSqrtPriceX96, encodeInitialSqrtPriceX96, encodeSqrtRatioX96, equilibreConfig, erc1155Abi, erc20Abi, erc721Abi, estimateLpTokens, ethAddresses, evmosAddresses, fantomAddresses, fenixConfig, filecoinAddresses, flareAddresses, forgeConfig, fusionxConfig, getAmmConfig, getAmmConfigByChainId, getApiUrl, getBeaconNameByProtocol, getContractAddressByChainIdAndContractName, getExpectedParamType, getFactoryAddress, getInitCodeHash, getNFTManagerAddress, getNetworkByChainId, getPoolHelperByChainId, getPoolSlot0, getProtcolTypeByAmmType, getProtocolBySubgraph, getProtocolConfigByBeacon, getProtocolContractAddresses, getProtocolInfoByChainId, getProtocolInfoByName, getProtocolSubgraphURL, getProtocolTypeByBeacon, getProtocolsForChainId, getQuoterV2Address, getStabilityVaultsPeripheryAddress, getStabilityVaultsSubgraphUrl, getSubgraphUrlByChainId, getSupportedChainByChainId, getSupportedChainIds, getSupportedChains, getSwapRouterAddress, getTheGraphResolverUrl, getTickLensAddress, getUniswapV4BeaconSupportedChains, getV4LifecycleDeploymentId, getV4PoolId, getVaultExecutionContext, getVaultReserves, glyphConfig, goerliAddresses, hemiAddresses, henjinConfig, herculesConfig, horizaConfig, inspectAerodromeSlipstreamPool, inspectAlgebraCustomPoolEntryPoint, inspectAlgebraPool, inspectV3Pool, inspectV4Pool, integerSqrt, isAerodromeVault, isAlgebraDirectionProtocol, isAlgebraIntegral21QuoteParams, isAlgebraIntegralProtocol, isAlgebraIntegralV2Protocol, isAlgebraProtocol, isAlgebraProtocolBySubgraph, isAlgebraQuoteParams, isPoolSharkProtocol, isShadowProtocol, isShadowQuoteParams, isSingleAssetDepositSupported, isThickQuoteParams, isThickV2Protocol, isUniswapQuoteParams, isUniswapV4Beacon, isUniswapV4BeaconAvailableOnChain, isUniswapV4HookBeacon, isValidStakingProtocol, katanaAddresses, katanaConfig, kavaAddresses, kimConfig, kinetixConfig, lineaAddresses, linehubConfig, localhostAddresses, lynexConfig, maiaConfig, mantaAddresses, mantleAddresses, metaVaultConfig, metisAddresses, modeAddresses, moonbeamAddresses, mumbaiAddresses, nestVaultConfig, networks, normalizeProtocol, novaswapConfig, okxtestnetAddresses, optimismAddresses, optimismgoerliAddresses, pancakeSwapConfig, parseExactDecimal, polygonAddresses, polyzkevmAddresses, poolsharkConfig, prepareAerodromeSlipstreamPool, prepareAlgebraPool, prepareLatestAerodromeSlipstreamPool, prepareV3CreateAndInitialize, prepareV3CreatePool, prepareV3InitializePool, prepareV4Initialize, quickSwapAlgebraConfig, quickSwapConfig, quickSwapIntegralConfig, quickSwapUniv3Config, resolveAerodromeSlipstreamLifecycleDeployment, resolveAlgebraLifecycleDeployment, resolveCurrentV4LifecycleDeployment, resolveLatestAerodromeSlipstreamLifecycleDeployment, resolvePoolLifecycleDeployment, resolveV3LifecycleDeployment, resolveV4LifecycleDeployment, resolveV4LifecycleDeploymentById, retroConfig, robinhoodAddresses, rootstockAddresses, sagaAddresses, scrollAddresses, seiAddresses, serializePreparedPoolAction, shadowConfig, shouldValidateUniswapV4VaultHook, simulateAerodromeSlipstreamPoolAction, simulateAlgebraPoolAction, simulateSwap, simulateV3PoolAction, simulateV4PoolAction, singleTokenDepositAbi, soneiumAddresses, sonicAddresses, sortErc20Pair, sortEvmCurrencyPair, spark32Config, sparkConfig, stabilityVaultsConfig, steerSubgraphConfig, supswapConfig, sushiConfig, swapmodeConfig, swapsicleConfig, taikoAddresses, telosAddresses, thenaConfig, thickConfig, thrusterConfig, thundercoreAddresses, uniAddresses, uniswapConfig, v3FactoryAbi, v3PoolAbi, v3PoolInitializerAbi, v4PoolKeysEqual, v4PoolManagerAbi, v4StateViewAbi, validateAerodromeSlipstreamLifecycleDeployment, validateAlgebraLifecycleDeployment, validatePreparedAerodromeSlipstreamPoolAction, validatePreparedAlgebraPoolAction, validatePreparedV3PoolAction, validatePreparedV4PoolAction, validateQuoteParams, validateSqrtPriceX96, validateSwapParams, validateV4LifecycleDeployment, validateV4PoolKey, verifyAerodromeSlipstreamPoolAction, verifyAlgebraPoolAction, verifyV3PoolAction, verifyV4PoolAction, xlayerAddresses, zetaAddresses, zircuitAddresses };
 
 //# sourceMappingURL=index.browser.mjs.map