@steerprotocol/sdk 3.3.1 → 3.4.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _$viem from "viem";
-import { Address, Client, Hash, Hex, PublicClient, TestClient, WalletClient } from "viem";
+import { Address, Client, Hash, Hex, PublicClient, TestClient, TransactionReceipt, WalletClient } from "viem";
 import { Campaign, createClient } from "@steerprotocol/api-sdk";
 import { Pool } from "@uniswap/v3-sdk";
 import { Decimal } from "decimal.js";
@@ -8873,15 +8873,199 @@ interface TokensFromLpResponse {
   token1Val: bigint;
 }
 //#endregion
+//#region src/pool-lifecycle/capabilities/v4.d.ts
+interface V4LifecycleDeploymentProvenance {
+  readonly source: 'sdk-config' | 'official-deployment' | 'verified-explorer';
+  readonly urls: readonly `https://${string}`[];
+}
+type V4LifecycleDeploymentId = `uniswap-v4:${number}:${Protocol.UniswapV4}:${Lowercase<Address>}:${Lowercase<Address>}:pool-manager-initialize-v1:v1`;
+type V4LifecycleDeploymentByIdRegistry = Readonly<Partial<Record<string, V4LifecycleDeployment>>>;
+/** A PoolManager/StateView pair explicitly approved for lifecycle writes. */
+interface V4LifecycleDeployment {
+  readonly supported: true;
+  readonly schemaVersion: 1;
+  readonly deploymentId: V4LifecycleDeploymentId;
+  readonly chainId: number;
+  readonly protocol: Protocol.UniswapV4;
+  readonly family: 'uniswap-v4';
+  readonly adapter: 'pool-manager-initialize-v1';
+  readonly version: 1;
+  readonly poolManager: Address;
+  readonly stateView: Address;
+  readonly provenance: V4LifecycleDeploymentProvenance;
+  /** Earliest PoolManager event block from the official V4 subgraph manifest. */
+  readonly startBlock: bigint;
+}
+interface ResolveV4LifecycleDeploymentParams {
+  readonly chainId: number;
+  readonly protocol: SupportedProtocol;
+}
+declare function getV4LifecycleDeploymentId(params: {
+  readonly chainId: number;
+  readonly protocol: Protocol.UniswapV4;
+  readonly poolManager: Address;
+  readonly stateView: Address;
+  readonly adapter: 'pool-manager-initialize-v1';
+  readonly version: 1;
+}): V4LifecycleDeploymentId;
+/**
+ * Explicit lifecycle-write registry. Entries are not inferred from discovery
+ * configuration so a newly discovered deployment remains unsupported until it
+ * is deliberately reviewed and versioned here.
+ */
+declare const CURRENT_V4_LIFECYCLE_DEPLOYMENTS: readonly V4LifecycleDeployment[];
+/**
+ * Every approved V4 deployment, including historical managers. When a current
+ * deployment changes, retain the former entry here so existing plans remain
+ * independently resolvable by deploymentId.
+ */
+declare const V4_LIFECYCLE_DEPLOYMENTS: readonly V4LifecycleDeployment[];
+declare const V4_LIFECYCLE_DEPLOYMENTS_BY_ID: V4LifecycleDeploymentByIdRegistry;
+/** Resolve the explicitly selected current-default deployment for a chain/protocol pair. */
+declare function resolveCurrentV4LifecycleDeployment(params: ResolveV4LifecycleDeploymentParams): V4LifecycleDeployment | undefined;
+/** Backwards-compatible alias; prefer the name that makes current-default semantics explicit. */
+declare const resolveV4LifecycleDeployment: typeof resolveCurrentV4LifecycleDeployment;
+/** Resolve an exact current or historical deployment without consulting defaults. */
+declare function resolveV4LifecycleDeploymentById(deploymentId: string): V4LifecycleDeployment | undefined;
+/**
+ * Validate capability metadata supplied across a UI/CLI boundary and return
+ * the canonical frozen registry entry.
+ */
+declare function validateV4LifecycleDeployment(value: unknown): V4LifecycleDeployment;
+//#endregion
+//#region src/pool-lifecycle/types.d.ts
+/** A signer-neutral EVM transaction that can be consumed by a UI or CLI. */
+interface EncodedEvmTransaction {
+  readonly chainId: number;
+  readonly to: Address;
+  readonly data: Hex;
+  readonly value: bigint;
+}
+/** Common envelope around a protocol-specific pool lifecycle action. */
+interface PreparedPoolAction<Kind extends string, Identity, Expected, Preflight> {
+  readonly schemaVersion: 1;
+  readonly kind: Kind;
+  readonly protocol: SupportedProtocol;
+  readonly transaction: EncodedEvmTransaction;
+  readonly identity: Identity;
+  readonly expected: Expected;
+  readonly preflight: Preflight;
+}
+interface PoolActionSimulation {
+  readonly transaction: EncodedEvmTransaction;
+  readonly blockNumber: bigint;
+  readonly returnData: Hex | null;
+  readonly gasEstimate: bigint;
+}
+type PoolActionOutcome = 'created' | 'created-and-initialized' | 'initialized-existing' | 'already-initialized-matching' | 'already-initialized-different-price' | 'initialized-then-price-moved' | 'not-initialized' | 'wrong-deployment' | 'verification-unavailable' | 'reverted';
+interface PoolActionVerification<Identity, State, Evidence> {
+  readonly verified: boolean;
+  readonly outcome: PoolActionOutcome;
+  readonly blockNumber: bigint;
+  readonly identity: Identity;
+  readonly state: State | null;
+  readonly evidence: Evidence;
+  readonly warnings: readonly string[];
+}
+declare const PREPARED_POOL_ACTION_SERIALIZATION_VERSION: 1;
+type AnyPreparedPoolAction = PreparedPoolAction<string, unknown, unknown, unknown>;
+/**
+ * Serialize a prepared action in a versioned JSON envelope. Bigints use an
+ * explicit tag so ordinary decimal strings remain distinguishable on decode.
+ */
+declare function serializePreparedPoolAction(action: AnyPreparedPoolAction, space?: number): string;
+/** Parse a versioned serialized action; protocol adapters must validate its shape. */
+declare function deserializePreparedPoolAction(serialized: string): unknown;
+//#endregion
+//#region src/pool-lifecycle/v4/types.d.ts
+interface V4PoolKeyInput {
+  readonly currencyA: Address;
+  readonly currencyB: Address;
+  readonly fee: number;
+  readonly tickSpacing: number;
+  readonly hooks: Address;
+}
+interface V4PoolKey {
+  readonly currency0: Address;
+  readonly currency1: Address;
+  readonly fee: number;
+  readonly tickSpacing: number;
+  readonly hooks: Address;
+}
+/** A Q64.96 price explicitly bound to the canonical V4 currency order. */
+interface V4InitialPrice {
+  readonly currency0: Address;
+  readonly currency1: Address;
+  readonly sqrtPriceX96: bigint;
+}
+interface V4PoolSnapshotBase {
+  readonly schemaVersion: 1;
+  readonly blockNumber: bigint;
+  readonly deployment: V4LifecycleDeployment;
+  readonly key: V4PoolKey;
+  readonly poolId: Hex;
+  readonly tick: number;
+  readonly protocolFee: number;
+  readonly lpFee: number;
+}
+interface V4UninitializedPoolSnapshot extends V4PoolSnapshotBase {
+  readonly status: 'uninitialized';
+  readonly sqrtPriceX96: 0n;
+  readonly tick: 0;
+  readonly protocolFee: 0;
+  readonly lpFee: 0;
+}
+interface V4InitializedPoolSnapshot extends V4PoolSnapshotBase {
+  readonly status: 'initialized';
+  readonly sqrtPriceX96: bigint;
+}
+type V4PoolSnapshot = V4UninitializedPoolSnapshot | V4InitializedPoolSnapshot;
+interface V4PoolIdentity {
+  readonly family: 'uniswap-v4';
+  readonly adapter: 'pool-manager-initialize-v1';
+  readonly version: 1;
+  readonly deploymentId: V4LifecycleDeployment['deploymentId'];
+  readonly chainId: number;
+  readonly poolManager: Address;
+  readonly stateView: Address;
+  readonly poolId: Hex;
+  readonly key: V4PoolKey;
+}
+interface V4InitializeExpectation extends V4InitialPrice {}
+interface V4UninitializedPreflightSummary {
+  readonly blockNumber: bigint;
+  readonly deploymentId: V4LifecycleDeployment['deploymentId'];
+  readonly status: 'uninitialized';
+  readonly poolId: Hex;
+  readonly sqrtPriceX96: 0n;
+}
+type PreparedV4InitializePoolAction = PreparedPoolAction<'v4-initialize', V4PoolIdentity, V4InitializeExpectation, V4UninitializedPreflightSummary> & {
+  readonly preflight: V4UninitializedPreflightSummary;
+};
+type PreparedV4PoolAction = PreparedV4InitializePoolAction;
+interface V4PoolActionSimulation extends PoolActionSimulation {
+  readonly returnedTick: number;
+}
+interface V4InitializeEvidence {
+  readonly poolId: Hex;
+  readonly currency0: Address;
+  readonly currency1: Address;
+  readonly fee: number;
+  readonly tickSpacing: number;
+  readonly hooks: Address;
+  readonly sqrtPriceX96: bigint;
+  readonly tick: number;
+  readonly logIndex: number;
+}
+interface V4ReceiptEvidence {
+  readonly receiptStatus: 'success' | 'reverted';
+  readonly initializations: readonly V4InitializeEvidence[];
+}
+type V4PoolActionVerification = PoolActionVerification<V4PoolIdentity, V4PoolSnapshot, V4ReceiptEvidence>;
+//#endregion
 //#region src/base/vault/execution-context.d.ts
 type VaultExecutionPoolFamily = 'uniswap-v3-compatible' | 'algebra' | 'algebra-integral' | 'algebra-directional' | 'aerodrome-cl' | 'uniswap-v4';
-interface VaultExecutionPoolKey {
-  currency0: Address;
-  currency1: Address;
-  fee: number;
-  tickSpacing: number;
-  hooks: Address;
-}
+type VaultExecutionPoolKey = V4PoolKey;
 interface GetVaultExecutionContextParams {
   publicClient: PublicClient;
   vaultAddress: Address;
@@ -10180,19 +10364,19 @@ interface PoolFilter$1 {
  *
  * @example
  * ```typescript
- * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { createPublicClient, http } from 'viem';
  * import { mainnet } from 'viem/chains';
  * import { PoolClient } from '@steerprotocol/sdk';
  *
  * const client = createPublicClient({
  *   chain: mainnet,
  *   transport: http()
- * }) as PublicClient & WalletClient;
+ * });
  *
  * const poolClient = new PoolClient(client, 'your-subgraph-studio-key');
  *
  * // Fetch top pools
- * const topPools = await poolClient.getTopPools(100, Protocol.UniswapV3, 1);
+ * const topPools = await poolClient.getTopPools(100, Protocol.Uniswap, 1);
  * ```
  *
  * @extends SubgraphClient
@@ -10210,7 +10394,7 @@ declare class PoolClient extends SubgraphClient {
   /**
    * Creates a new PoolClient instance
    *
-   * @param client - Combined public and wallet client for blockchain interactions
+   * @param client - Public client for read-only blockchain interactions
    * @param subgraphStudioKey - Optional Subgraph Studio API key for higher rate limits
    *
    * @example
@@ -10218,7 +10402,7 @@ declare class PoolClient extends SubgraphClient {
    * const poolClient = new PoolClient(client, 'your-api-key');
    * ```
    */
-  constructor(client: PublicClient & WalletClient, subgraphStudioKey?: string);
+  constructor(client: PublicClient, subgraphStudioKey?: string);
   /**
    * Resets the API call counter for metrics tracking
    *
@@ -10275,7 +10459,7 @@ declare class PoolClient extends SubgraphClient {
    * @example
    * ```typescript
    * // Get top 100 Uniswap V3 pools on Ethereum
-   * const topPools = await poolClient.getTopPools(100, Protocol.UniswapV3, 1);
+   * const topPools = await poolClient.getTopPools(100, Protocol.Uniswap, 1);
    * if (topPools.success) {
    *   console.log(`Found ${topPools.data.length} pools`);
    * }
@@ -10297,7 +10481,7 @@ declare class PoolClient extends SubgraphClient {
    * // Get specific pool details
    * const poolDetails = await poolClient.getPoolById(
    *   '0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640',
-   *   Protocol.UniswapV3,
+   *   Protocol.Uniswap,
    *   1
    * );
    * if (poolDetails.success && poolDetails.data) {
@@ -10326,7 +10510,7 @@ declare class PoolClient extends SubgraphClient {
    * ];
    * const pools = await poolClient.fetchPoolsForTokensBatch(
    *   tokenAddresses,
-   *   Protocol.UniswapV3,
+   *   Protocol.Uniswap,
    *   1,
    *   5
    * );
@@ -10348,7 +10532,7 @@ declare class PoolClient extends SubgraphClient {
    * // Get all USDC pools on Uniswap V3
    * const usdcPools = await poolClient.fetchPoolsForToken(
    *   '0xa0b86a33e6f8b07b71c3a39ef77a6b6e8f1b7b7e',
-   *   Protocol.UniswapV3,
+   *   Protocol.Uniswap,
    *   1
    * );
    * if (usdcPools.success) {
@@ -10661,8 +10845,8 @@ declare class StakingClient extends SubgraphClient {
  * const summary = await steerClient.rewards.getRewardSummary(userAddress, chainId);
  *
  * // Use pool data functionality
- * const topPools = await steerClient.pools.getTopPools(100, Protocol.UniswapV3, 1);
- * const poolDetails = await steerClient.pools.getPoolById(poolId, Protocol.UniswapV3, 1);
+ * const topPools = await steerClient.pools.getTopPools(100, Protocol.Uniswap, 1);
+ * const poolDetails = await steerClient.pools.getPoolById(poolId, Protocol.Uniswap, 1);
  *
  * // Use staking functionality
  * const stakingPools = await steerClient.staking.getStakingPools(1);
@@ -10762,5 +10946,1480 @@ declare class FeeManagerClient extends SubgraphClient {
   }[]>>;
 }
 //#endregion
-export { AERODROME_PROTOCOLS, ALGEBRA_INTEGRAL_PROTOCOLS, ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS, ALGEBRA_PROTOCOLS, AMMConfigType, AMMType, API_URLS, AlgebgraHookBeacons, AlgebraIntegral21QuoteParams, AlgebraQuoteParams, AlgebraVaultDetails, ApiPageInfo, ApiVaultFilter, AprFilter, AprResponse, BaseQuoteParams, BaseVaultDetails, BlackholeAprDetailedParams, BlackholeAprDetailedResponse, BlackholeSnapshotAnalysis, CalculateLimitPriceParams, CalculateSwapAmountParams, Chain, ChainId, ClaimProofEdge, ClaimProofNode, ClaimProofsPageInfo, ClaimProofsResponse, ClaimRewardEdge, ClaimRewardNode, ClaimRewardParams, ClaimRewardsConnection, ClaimRewardsParams, Contract, ContractAddresses, ContractName, DIRECTIONAL_ALGEBRA_PROTOCOLS, DefaultFeeManagerConfigParams, DeprecationData, EstimateLpTokensParams, FEE_MANAGER_ABI, Fee, FeeManagerClient, FeeManagerConfigParams, FeeWithdrawalParams, FormattedRoute, GetRewardParams, GetSupportedChainsOptions, GetVaultExecutionContextParams, GlobalStateABI, type GraphQLPoolData, type GraphQLTokenData, LimitPoolState, LpPriceResponse, LpTokenEstimationResponse, MultiPositionManagers, MultiVaultFeeWithdrawalParams, MultipleFeeWithdrawalParams, NetworkConfig, NetworkData, Networks, POOLSHARK_PROTOCOLS, PageInfo, PendingRewardsParams, PendingRewardsResponse, PoolClient, PoolData, PoolEdge, PoolFilter, PoolNode, PoolSharkGlobalState, PoolSlot0, PoolsConnection, PoolsharkStructs, Protocol, ProtocolContractAddresses, ProtocolDetails, ProtocolInfo, QuickSwapQuoterV2, QuoteParams, QuoterFunctionArgs, QuoterV2ABI, QuoterV2AlgebgraIntegral, QuoterV2AlgebgraIntegral21, QuoterV2Factory, QuoterV2Shadow, QuoterV2Thick, Reward, RewardBalance, RewardSummary, RouteShortcut, SHADOW_PROTOCOLS, ShadowQuoteParams, SimulateSwapParams, SingleAssetDepositClient, SingleAssetDepositParams, SingleAssetDepositPreview, Slot0, SmartRewarderContract, SmartRewards, StabilityVaultInfo, StakeParams, Staking, StakingClient, StakingPool, StakingPoolFilter, StakingProtocol, SteerClient, SteerConfig, SteerResponse, SteerSupportedChains, StrykePositionManagers, SubgraphClient, SubgraphResponse, SubgraphVaultClient, SubgraphVaultDetails, SubgraphVaultDetailsWithLpData, SubgraphVaultPosition, SupportedChain, SupportedChainFeatures, SupportedChainsFeature, SupportedChainsInclude, SupportedProtocol, SwapAmountResponse, SwapSimulationResponse, TEST_UNISWAP_JIT_HOOK_BEACON, ThickQuoteParams, Token0, Token1, TokenData, TokenEdge, TokenFilter, TokenNode, TokenValueParams, TokenValueResponse, TokensConnection, UNISWAP_V4_BEACON_NAMES, UNISWAP_V4_HOOK_BEACON_NAMES, UNISWAP_V4_NO_ORACLE_BEACON, UniswapHookBeacons, UniswapQuoteParams, UniswapV3PoolABI, UniswapV3QuoterABI, UniswapV4Beacons, VAULT_FEES_ABI, VaultAllowanceParams, VaultApproveParams, VaultApr, VaultBalanceParams, VaultClient, VaultDetails, VaultDetailsResponse, VaultEdge, VaultExecutionContext, VaultExecutionDataProvenance, VaultExecutionPoolFamily, VaultExecutionPoolKey, VaultExecutionPosition, VaultFetchOptions, VaultFilter, VaultNode, VaultTokens, VaultsConnection, WithdrawParams, abis, apechainAddresses, arbitrumAddresses, arbitrumgoerliAddresses, arthswapConfig, astarAddresses, astarzkevmAddresses, avalancheAddresses, bartiotestAddresses, baseAddresses, baseSwapConfig, basexConfig, beraAddresses, bittensorAddresses, bittensorUniV3Config, blastAddresses, bscAddresses, calculateLimitPrice, calculateSwapAmount, camelotConfig, celoAddresses, chainIdToName, chainNameToId, crustConfig, deprecatedBundlesURL, determineSwapDirection, 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, getVaultExecutionContext, getVaultReserves, glyphConfig, goerliAddresses, hemiAddresses, henjinConfig, herculesConfig, horizaConfig, 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, polygonAddresses, polyzkevmAddresses, poolsharkConfig, quickSwapAlgebraConfig, quickSwapConfig, quickSwapIntegralConfig, quickSwapUniv3Config, retroConfig, robinhoodAddresses, rootstockAddresses, sagaAddresses, scrollAddresses, seiAddresses, shadowConfig, shouldValidateUniswapV4VaultHook, simulateSwap, singleTokenDepositAbi, soneiumAddresses, sonicAddresses, spark32Config, sparkConfig, stabilityVaultsConfig, steerSubgraphConfig, supswapConfig, sushiConfig, swapmodeConfig, swapsicleConfig, taikoAddresses, telosAddresses, thenaConfig, thickConfig, thrusterConfig, thundercoreAddresses, uniAddresses, uniswapConfig, validateQuoteParams, validateSwapParams, xlayerAddresses, zetaAddresses, zircuitAddresses };
+//#region src/pool-lifecycle/errors.d.ts
+type PoolLifecycleErrorCode = 'INVALID_INPUT' | 'UNSUPPORTED_DEPLOYMENT' | 'CHAIN_MISMATCH' | 'CONTRACT_NOT_DEPLOYED' | 'DEPLOYMENT_MISMATCH' | 'DISABLED_FEE' | 'POOL_STATE_MISMATCH' | 'SIMULATION_FAILED';
+/** Error thrown when a pool lifecycle primitive cannot safely continue. */
+declare class PoolLifecycleError extends Error {
+  readonly code: PoolLifecycleErrorCode;
+  readonly causeValue?: unknown;
+  constructor(code: PoolLifecycleErrorCode, message: string, causeValue?: unknown);
+}
+//#endregion
+//#region src/pool-lifecycle/math.d.ts
+/** The smallest sqrt price accepted by Uniswap TickMath, inclusive. */
+declare const MIN_SQRT_RATIO = 4295128739n;
+/** The largest TickMath sqrt-price boundary, which is not itself valid. */
+declare const MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
+/**
+ * An exact fraction representation. {@link parseExactDecimal} returns a
+ * reduced, non-negative value; initial-price inputs must also be positive.
+ */
+interface ExactFraction {
+  readonly numerator: bigint;
+  readonly denominator: bigint;
+}
+/**
+ * A human-unit price expressed as quote-token units per one base-token unit.
+ *
+ * For example, a value of 2_500 / 1 means 2,500 quote tokens per base token.
+ * Token decimals are applied exactly by {@link encodeInitialSqrtPriceX96}; a
+ * JavaScript floating-point number is deliberately not part of this type.
+ */
+interface ExactPrice {
+  readonly baseToken: string;
+  readonly quoteToken: string;
+  readonly baseTokenDecimals: number;
+  readonly quoteTokenDecimals: number;
+  readonly quotePerBase: ExactFraction;
+}
+/**
+ * A human-unit price for an EVM currency pair. Unlike {@link ExactPrice}, the
+ * zero address is accepted and represents the native currency used by
+ * Uniswap V4. Callers are responsible for supplying 18 decimals for the
+ * native currency on EVM chains.
+ */
+interface ExactCurrencyPrice {
+  readonly baseCurrency: string;
+  readonly quoteCurrency: string;
+  readonly baseCurrencyDecimals: number;
+  readonly quoteCurrencyDecimals: number;
+  readonly quotePerBase: ExactFraction;
+}
+/** A validated, checksummed ERC20 pair in canonical address order. */
+interface CanonicalErc20Pair {
+  readonly token0: Address;
+  readonly token1: Address;
+}
+/** A canonical EVM currency pair; currency0 may be the native zero address. */
+interface CanonicalCurrencyPair {
+  readonly currency0: Address;
+  readonly currency1: Address;
+}
+/**
+ * The canonical raw-token ratio and its TickMath-compatible Q64.96 encoding.
+ */
+interface CanonicalInitialPrice extends CanonicalErc20Pair {
+  readonly amount0Raw: bigint;
+  readonly amount1Raw: bigint;
+  readonly sqrtPriceX96: bigint;
+  readonly baseTokenIsToken0: boolean;
+}
+/** A canonical raw-currency ratio and its Q64.96 initialization price. */
+interface CanonicalCurrencyInitialPrice extends CanonicalCurrencyPair {
+  readonly amount0Raw: bigint;
+  readonly amount1Raw: bigint;
+  readonly sqrtPriceX96: bigint;
+  readonly baseCurrencyIsCurrency0: boolean;
+}
+/**
+ * Parses an unsigned, fixed-point decimal string without converting through a
+ * JavaScript number. Signs, exponent notation, whitespace, and omitted whole
+ * or fractional digits are rejected. The returned fraction is reduced.
+ */
+declare function parseExactDecimal(value: string): ExactFraction;
+/**
+ * Validates, checksums, and sorts two distinct non-zero ERC20 addresses.
+ */
+declare function sortErc20Pair(tokenA: string, tokenB: string): CanonicalErc20Pair;
+/**
+ * Validates, checksums, and sorts two distinct EVM currencies. The zero
+ * address is allowed and, when present, necessarily sorts as currency0.
+ */
+declare function sortEvmCurrencyPair(currencyA: string, currencyB: string): CanonicalCurrencyPair;
+/**
+ * Returns floor(sqrt(value)) using bigint arithmetic only.
+ */
+declare function integerSqrt(value: bigint): bigint;
+/**
+ * Enforces the Uniswap TickMath interval: MIN is inclusive and MAX exclusive.
+ * Returns the input so it can be composed with transaction builders.
+ */
+declare function validateSqrtPriceX96(sqrtPriceX96: bigint): bigint;
+/**
+ * Encode an exact raw token1/token0 amount ratio without token metadata.
+ * The result matches the canonical V3 floor-rounding operation.
+ */
+declare function encodeSqrtRatioX96(amount1Raw: bigint, amount0Raw: bigint): bigint;
+/**
+ * Converts an exact quote-per-base human price into the canonical raw-token
+ * ratio and sqrtPriceX96 expected by concentrated-liquidity initializers.
+ *
+ * Address sorting and reciprocal orientation happen before the only lossy
+ * operation. The final encoding is exactly:
+ *
+ *   floor(sqrt((amount1Raw << 192) / amount0Raw))
+ */
+declare function encodeInitialSqrtPriceX96(price: ExactPrice): CanonicalInitialPrice;
+/**
+ * Currency-aware counterpart to {@link encodeInitialSqrtPriceX96}. It keeps
+ * the same exact orientation and floor-rounding rules while permitting the
+ * native zero-address currency required by Uniswap V4.
+ */
+declare function encodeCurrencyInitialSqrtPriceX96(price: ExactCurrencyPrice): CanonicalCurrencyInitialPrice;
+//#endregion
+//#region src/pool-lifecycle/capabilities/algebra.d.ts
+type AlgebraLifecycleVariant = 'legacy' | 'directional' | 'integral-v1' | 'integral-v2';
+type AlgebraLifecycleAdapter = 'algebra-legacy-pair-v1' | 'algebra-directional-pair-v1' | 'algebra-integral-pair-v1' | 'algebra-integral-plugin-data-v2';
+interface AlgebraLifecycleProvenance {
+  readonly source: 'sdk-config' | 'official-deployment' | 'verified-explorer';
+  readonly urls: readonly [`https://${string}`, ...`https://${string}`[]];
+}
+interface AlgebraLifecycleDeployment {
+  readonly supported: true;
+  readonly schemaVersion: 1;
+  readonly chainId: number;
+  readonly protocol: SupportedProtocol;
+  readonly family: 'algebra';
+  readonly variant: AlgebraLifecycleVariant;
+  readonly adapter: AlgebraLifecycleAdapter;
+  readonly version: 1 | 2;
+  readonly factory: Address;
+  readonly createPool: 'pair' | 'pair-with-plugin-data';
+  readonly state: 'legacy-global-state' | 'directional-global-state' | 'integral-global-state';
+  /**
+   * Metadata only. An EOA must not call this entry point directly: the
+   * authoritative contract requires msg.sender to equal the custom deployer.
+   */
+  readonly customPoolEntryPoint?: Address;
+  readonly customPoolCreation: 'not-configured' | 'adapter-specific-deployer-required';
+  readonly provenance: AlgebraLifecycleProvenance;
+}
+/**
+ * Explicit lifecycle capabilities for every Algebra-family protocol/chain pair
+ * currently present in the SDK AMM registry. Subgraph presence is never used as
+ * a runtime fallback.
+ */
+declare const ALGEBRA_LIFECYCLE_DEPLOYMENTS: readonly AlgebraLifecycleDeployment[];
+declare function resolveAlgebraLifecycleDeployment(params: {
+  readonly chainId: number;
+  readonly protocol: SupportedProtocol;
+}): AlgebraLifecycleDeployment | undefined;
+/** Validate external capability metadata and return its canonical frozen entry. */
+declare function validateAlgebraLifecycleDeployment(value: unknown): AlgebraLifecycleDeployment;
+//#endregion
+//#region src/pool-lifecycle/capabilities/v3.d.ts
+type V3LifecycleDeploymentProvenance = {
+  readonly source: 'sdk-config' | 'official-deployment' | 'verified-explorer';
+  readonly urls: readonly `https://${string}`[];
+};
+type V3LifecycleDeploymentCommon = {
+  readonly supported: true;
+  readonly schemaVersion: 1;
+  readonly chainId: number;
+  readonly protocol: SupportedProtocol;
+  readonly family: 'uniswap-v3-compatible';
+  readonly version: 1;
+  readonly factory: Address;
+  readonly poolInitCodeHash?: Hex;
+  readonly provenance: V3LifecycleDeploymentProvenance;
+  readonly startBlock?: bigint;
+};
+type V3AtomicLifecycleDeployment = V3LifecycleDeploymentCommon & {
+  readonly adapter: 'pool-initializer-v1';
+  readonly initializer: Address;
+  readonly atomicCreateAndInitialize: true;
+};
+type V3FactoryLifecycleDeployment = V3LifecycleDeploymentCommon & {
+  readonly adapter: 'v3-factory-v1';
+  readonly initializer: null;
+  readonly atomicCreateAndInitialize: false;
+};
+type V3LifecycleDeployment = V3AtomicLifecycleDeployment | V3FactoryLifecycleDeployment;
+type ResolveV3LifecycleDeploymentParams = {
+  readonly chainId: number;
+  readonly protocol: SupportedProtocol;
+};
+/** Explicit, fail-closed V3 create/initialize deployment allowlist. */
+declare const V3_LIFECYCLE_DEPLOYMENTS: Readonly<Partial<Record<string, V3LifecycleDeployment>>>;
+/**
+ * Protocols whose current SDK configuration is intentionally inventoried by
+ * the V3 lifecycle registry. Adding a factory for one of these protocols must
+ * also add an explicit lifecycle capability entry.
+ */
+declare const V3_CONFIG_PROTOCOLS: readonly SupportedProtocol[];
+declare function resolveV3LifecycleDeployment(params: ResolveV3LifecycleDeploymentParams): V3LifecycleDeployment | undefined;
+//#endregion
+//#region src/pool-lifecycle/capabilities.d.ts
+type SupportedPoolLifecycleDeployment = V3LifecycleDeployment | V4LifecycleDeployment | AlgebraLifecycleDeployment;
+type UnsupportedPoolLifecycleDeployment = {
+  readonly supported: false;
+  readonly schemaVersion: 1;
+  readonly family: 'unsupported';
+  readonly chainId: number;
+  readonly protocol: SupportedProtocol;
+  readonly reason: 'deployment-not-configured';
+};
+type PoolLifecycleDeploymentResult = SupportedPoolLifecycleDeployment | UnsupportedPoolLifecycleDeployment;
+type ResolvePoolLifecycleDeploymentParams = {
+  readonly chainId: number;
+  readonly protocol: SupportedProtocol;
+};
+type PoolLifecycleDeploymentRegistry = Readonly<Partial<Record<string, SupportedPoolLifecycleDeployment>>>;
+/**
+ * Collision-checked current-default deployments, independent of discovery.
+ * Historical V4 entries remain available through V4_LIFECYCLE_DEPLOYMENTS and
+ * its deployment-id resolver instead of competing for this chain/protocol key.
+ */
+declare const POOL_LIFECYCLE_DEPLOYMENTS: Readonly<Partial<Record<string, SupportedPoolLifecycleDeployment>>>;
+/**
+ * Resolve only explicitly versioned lifecycle capabilities. Discovery and
+ * subgraph metadata are never an implicit fallback for transaction building.
+ */
+declare function resolvePoolLifecycleDeployment(params: ResolvePoolLifecycleDeploymentParams): PoolLifecycleDeploymentResult;
+//#endregion
+//#region src/pool-lifecycle/abis/algebra.d.ts
+declare const algebraPairFactoryAbi: readonly [{
+  readonly name: "Pool";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "token0";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "token1";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "poolDeployer";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "poolByPair";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "tokenA";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenB";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "createPool";
+  readonly type: "function";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "tokenA";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenB";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}];
+declare const algebraIntegralPluginDataFactoryAbi: readonly [{
+  readonly name: "Pool";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "token0";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "token1";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "CustomPool";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "deployer";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "token0";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "token1";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "poolDeployer";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "poolByPair";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "tokenA";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenB";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "createPool";
+  readonly type: "function";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "tokenA";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenB";
+  }, {
+    readonly type: "bytes";
+    readonly name: "data";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "defaultConfigurationForPool";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint16";
+    readonly name: "communityFee";
+  }, {
+    readonly type: "int24";
+    readonly name: "tickSpacing";
+  }, {
+    readonly type: "uint16";
+    readonly name: "fee";
+  }];
+}, {
+  readonly name: "defaultPluginFactory";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}];
+declare const algebraIntegralPairFactoryAbi: readonly [{
+  readonly name: "Pool";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "token0";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "token1";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "CustomPool";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "deployer";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "token0";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "token1";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "poolDeployer";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "poolByPair";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "tokenA";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenB";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "createPool";
+  readonly type: "function";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "tokenA";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenB";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "address";
+    readonly name: "pool";
+  }];
+}, {
+  readonly name: "defaultTickspacing";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "int24";
+  }];
+}, {
+  readonly name: "defaultFee";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint16";
+  }];
+}, {
+  readonly name: "defaultPluginFactory";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}];
+declare const algebraPoolBaseAbi: readonly [{
+  readonly name: "Initialize";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "uint160";
+    readonly name: "price";
+  }, {
+    readonly type: "int24";
+    readonly name: "tick";
+  }];
+}, {
+  readonly name: "factory";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "token0";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "token1";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "tickSpacing";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "int24";
+  }];
+}, {
+  readonly name: "initialize";
+  readonly type: "function";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly type: "uint160";
+    readonly name: "initialPrice";
+  }];
+  readonly outputs: readonly [];
+}];
+declare const algebraLegacyPoolStateAbi: readonly [{
+  readonly name: "globalState";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint160";
+    readonly name: "price";
+  }, {
+    readonly type: "int24";
+    readonly name: "tick";
+  }, {
+    readonly type: "int24";
+    readonly name: "prevInitializedTick";
+  }, {
+    readonly type: "uint16";
+    readonly name: "fee";
+  }, {
+    readonly type: "uint16";
+    readonly name: "timepointIndex";
+  }, {
+    readonly type: "uint8";
+    readonly name: "communityFee";
+  }, {
+    readonly type: "bool";
+    readonly name: "unlocked";
+  }];
+}];
+declare const algebraDirectionalPoolStateAbi: readonly [{
+  readonly name: "globalState";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint160";
+    readonly name: "price";
+  }, {
+    readonly type: "int24";
+    readonly name: "tick";
+  }, {
+    readonly type: "uint16";
+    readonly name: "feeZto";
+  }, {
+    readonly type: "uint16";
+    readonly name: "feeOtz";
+  }, {
+    readonly type: "uint16";
+    readonly name: "timepointIndex";
+  }, {
+    readonly type: "uint8";
+    readonly name: "communityFeeToken0";
+  }, {
+    readonly type: "uint8";
+    readonly name: "communityFeeToken1";
+  }, {
+    readonly type: "bool";
+    readonly name: "unlocked";
+  }];
+}];
+declare const algebraIntegralPoolStateAbi: readonly [{
+  readonly name: "globalState";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint160";
+    readonly name: "price";
+  }, {
+    readonly type: "int24";
+    readonly name: "tick";
+  }, {
+    readonly type: "uint16";
+    readonly name: "lastFee";
+  }, {
+    readonly type: "uint8";
+    readonly name: "pluginConfig";
+  }, {
+    readonly type: "uint16";
+    readonly name: "communityFee";
+  }, {
+    readonly type: "bool";
+    readonly name: "unlocked";
+  }];
+}, {
+  readonly name: "plugin";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}];
+/**
+ * Kept separate from standard pool creation. Calling this directly from an EOA
+ * is invalid because the entry point requires msg.sender == deployer.
+ */
+declare const algebraCustomPoolEntryPointAbi: readonly [{
+  readonly name: "factory";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "createCustomPool";
+  readonly type: "function";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "deployer";
+  }, {
+    readonly type: "address";
+    readonly name: "creator";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenA";
+  }, {
+    readonly type: "address";
+    readonly name: "tokenB";
+  }, {
+    readonly type: "bytes";
+    readonly name: "data";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "address";
+    readonly name: "customPool";
+  }];
+}];
+//#endregion
+//#region src/pool-lifecycle/abis/v3.d.ts
+/** Minimal canonical Uniswap V3-compatible factory ABI used by pool lifecycle flows. */
+declare const v3FactoryAbi: readonly [{
+  readonly type: "function";
+  readonly name: "createPool";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly name: "tokenA";
+    readonly type: "address";
+  }, {
+    readonly name: "tokenB";
+    readonly type: "address";
+  }, {
+    readonly name: "fee";
+    readonly type: "uint24";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "pool";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "getPool";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly name: "tokenA";
+    readonly type: "address";
+  }, {
+    readonly name: "tokenB";
+    readonly type: "address";
+  }, {
+    readonly name: "fee";
+    readonly type: "uint24";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "pool";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "feeAmountTickSpacing";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly name: "fee";
+    readonly type: "uint24";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "tickSpacing";
+    readonly type: "int24";
+  }];
+}, {
+  readonly type: "event";
+  readonly name: "PoolCreated";
+  readonly inputs: readonly [{
+    readonly name: "token0";
+    readonly type: "address";
+    readonly indexed: true;
+  }, {
+    readonly name: "token1";
+    readonly type: "address";
+    readonly indexed: true;
+  }, {
+    readonly name: "fee";
+    readonly type: "uint24";
+    readonly indexed: true;
+  }, {
+    readonly name: "tickSpacing";
+    readonly type: "int24";
+    readonly indexed: false;
+  }, {
+    readonly name: "pool";
+    readonly type: "address";
+    readonly indexed: false;
+  }];
+}];
+/** Minimal PoolInitializer/NonfungiblePositionManager ABI used for atomic V3 setup. */
+declare const v3PoolInitializerAbi: readonly [{
+  readonly type: "function";
+  readonly name: "createAndInitializePoolIfNecessary";
+  readonly stateMutability: "payable";
+  readonly inputs: readonly [{
+    readonly name: "token0";
+    readonly type: "address";
+  }, {
+    readonly name: "token1";
+    readonly type: "address";
+  }, {
+    readonly name: "fee";
+    readonly type: "uint24";
+  }, {
+    readonly name: "sqrtPriceX96";
+    readonly type: "uint160";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "pool";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "factory";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+  }];
+}];
+/** Minimal canonical V3 pool ABI needed to initialize and verify a deployment. */
+declare const v3PoolAbi: readonly [{
+  readonly type: "function";
+  readonly name: "initialize";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly name: "sqrtPriceX96";
+    readonly type: "uint160";
+  }];
+  readonly outputs: readonly [];
+}, {
+  readonly type: "function";
+  readonly name: "factory";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "token0";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "token1";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "fee";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "uint24";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "tickSpacing";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "int24";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "slot0";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "sqrtPriceX96";
+    readonly type: "uint160";
+  }, {
+    readonly name: "tick";
+    readonly type: "int24";
+  }, {
+    readonly name: "observationIndex";
+    readonly type: "uint16";
+  }, {
+    readonly name: "observationCardinality";
+    readonly type: "uint16";
+  }, {
+    readonly name: "observationCardinalityNext";
+    readonly type: "uint16";
+  }, {
+    readonly name: "feeProtocol";
+    readonly type: "uint8";
+  }, {
+    readonly name: "unlocked";
+    readonly type: "bool";
+  }];
+}, {
+  readonly type: "event";
+  readonly name: "Initialize";
+  readonly inputs: readonly [{
+    readonly name: "sqrtPriceX96";
+    readonly type: "uint160";
+    readonly indexed: false;
+  }, {
+    readonly name: "tick";
+    readonly type: "int24";
+    readonly indexed: false;
+  }];
+}];
+//#endregion
+//#region src/pool-lifecycle/abis/v4.d.ts
+/** Minimal authoritative IPoolManager surface used by the V4 lifecycle adapter. */
+declare const v4PoolManagerAbi: readonly [{
+  readonly name: "initialize";
+  readonly type: "function";
+  readonly stateMutability: "nonpayable";
+  readonly inputs: readonly [{
+    readonly type: "tuple";
+    readonly components: readonly [{
+      readonly type: "address";
+      readonly name: "currency0";
+    }, {
+      readonly type: "address";
+      readonly name: "currency1";
+    }, {
+      readonly type: "uint24";
+      readonly name: "fee";
+    }, {
+      readonly type: "int24";
+      readonly name: "tickSpacing";
+    }, {
+      readonly type: "address";
+      readonly name: "hooks";
+    }];
+    readonly name: "key";
+  }, {
+    readonly type: "uint160";
+    readonly name: "sqrtPriceX96";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "int24";
+    readonly name: "tick";
+  }];
+}, {
+  readonly name: "Initialize";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "id";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "currency0";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "currency1";
+    readonly indexed: true;
+  }, {
+    readonly type: "uint24";
+    readonly name: "fee";
+  }, {
+    readonly type: "int24";
+    readonly name: "tickSpacing";
+  }, {
+    readonly type: "address";
+    readonly name: "hooks";
+  }, {
+    readonly type: "uint160";
+    readonly name: "sqrtPriceX96";
+  }, {
+    readonly type: "int24";
+    readonly name: "tick";
+  }];
+}];
+/** Minimal StateView/ImmutableState surface used for deployment and state checks. */
+declare const v4StateViewAbi: readonly [{
+  readonly name: "poolManager";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "getSlot0";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "poolId";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "uint160";
+    readonly name: "sqrtPriceX96";
+  }, {
+    readonly type: "int24";
+    readonly name: "tick";
+  }, {
+    readonly type: "uint24";
+    readonly name: "protocolFee";
+  }, {
+    readonly type: "uint24";
+    readonly name: "lpFee";
+  }];
+}];
+//#endregion
+//#region src/pool-lifecycle/algebra/types.d.ts
+interface AlgebraPoolKeyInput {
+  readonly tokenA: Address;
+  readonly tokenB: Address;
+}
+interface AlgebraPoolKey {
+  readonly token0: Address;
+  readonly token1: Address;
+}
+interface AlgebraInitialPrice extends AlgebraPoolKey {
+  readonly sqrtPriceX96: bigint;
+}
+interface AlgebraPoolSnapshot {
+  readonly schemaVersion: 1;
+  readonly blockNumber: bigint;
+  readonly deployment: AlgebraLifecycleDeployment;
+  readonly key: AlgebraPoolKey;
+  readonly status: 'absent' | 'uninitialized' | 'initialized';
+  readonly poolAddress: Address | null;
+  readonly sqrtPriceX96: bigint;
+  readonly tick: number | null;
+  readonly tickSpacing: number | null;
+  readonly fee: number | null;
+  readonly directionalFee: Readonly<{
+    zeroToOne: number;
+    oneToZero: number;
+  }> | null;
+  readonly plugin: Address | null;
+  readonly pluginConfig: number | null;
+  readonly unlocked: boolean | null;
+}
+interface AlgebraPoolIdentity {
+  readonly family: 'algebra';
+  readonly adapter: AlgebraLifecycleDeployment['adapter'];
+  readonly version: 1 | 2;
+  readonly variant: AlgebraLifecycleDeployment['variant'];
+  readonly chainId: number;
+  readonly factory: Address;
+  readonly key: AlgebraPoolKey;
+  readonly poolAddress: Address | null;
+}
+interface AlgebraPreflightSummary {
+  readonly blockNumber: bigint;
+  readonly status: AlgebraPoolSnapshot['status'];
+  readonly poolAddress: Address | null;
+  readonly sqrtPriceX96: bigint;
+}
+type PreparedAlgebraCreatePoolAction = PreparedPoolAction<'algebra-create', AlgebraPoolIdentity, {
+  readonly sqrtPriceX96: null;
+  readonly pluginData: Hex;
+}, AlgebraPreflightSummary>;
+type PreparedAlgebraInitializePoolAction = PreparedPoolAction<'algebra-initialize', AlgebraPoolIdentity, {
+  readonly sqrtPriceX96: bigint;
+  readonly pluginData: null;
+}, AlgebraPreflightSummary>;
+type PreparedAlgebraPoolAction = PreparedAlgebraCreatePoolAction | PreparedAlgebraInitializePoolAction;
+interface AlgebraPoolActionSimulation extends PoolActionSimulation {
+  readonly returnedPoolAddress: Address | null;
+}
+interface AlgebraReceiptEvidence {
+  readonly receiptStatus: 'success' | 'reverted';
+  readonly poolCreated: Readonly<{
+    poolAddress: Address;
+    logIndex: number;
+  }> | null;
+  readonly initialization: Readonly<{
+    poolAddress: Address;
+    sqrtPriceX96: bigint;
+    tick: number;
+    logIndex: number;
+  }> | null;
+}
+type AlgebraPoolActionVerification = PoolActionVerification<AlgebraPoolIdentity, AlgebraPoolSnapshot, AlgebraReceiptEvidence>;
+/** Re-derive target and calldata after a plan crosses a UI/CLI/JSON boundary. */
+declare function validatePreparedAlgebraPoolAction(value: unknown): AlgebraLifecycleDeployment;
+declare function deserializePreparedAlgebraPoolAction(serialized: string): PreparedAlgebraPoolAction;
+//#endregion
+//#region src/pool-lifecycle/algebra/inspect.d.ts
+interface InspectAlgebraPoolParams {
+  readonly publicClient: PublicClient;
+  readonly deployment: AlgebraLifecycleDeployment;
+  readonly key: AlgebraPoolKeyInput;
+  readonly blockNumber?: bigint;
+}
+interface InspectAlgebraCustomPoolEntryPointParams {
+  readonly publicClient: PublicClient;
+  readonly deployment: AlgebraLifecycleDeployment;
+  readonly blockNumber?: bigint;
+}
+/** Verify configured custom-pool routing without claiming a generic deployer ABI. */
+declare function inspectAlgebraCustomPoolEntryPoint(params: InspectAlgebraCustomPoolEntryPointParams): Promise<{
+  readonly blockNumber: bigint;
+  readonly entryPoint: Address;
+  readonly factory: Address;
+}>;
+declare function inspectAlgebraPool(params: InspectAlgebraPoolParams): Promise<AlgebraPoolSnapshot>;
+//#endregion
+//#region src/pool-lifecycle/algebra/actions.d.ts
+interface BuildBase {
+  readonly deployment: AlgebraLifecycleDeployment;
+  readonly key: AlgebraPoolKeyInput;
+  readonly preflight: AlgebraPoolSnapshot;
+}
+interface BuildAlgebraCreatePoolTransactionParams extends BuildBase {
+  readonly pluginData?: Hex;
+}
+interface BuildAlgebraInitializePoolTransactionParams extends BuildBase {
+  readonly initialPrice: AlgebraInitialPrice;
+}
+/** Build the version-specific standard-pool factory call without signing it. */
+declare function buildAlgebraCreatePoolTransaction(params: BuildAlgebraCreatePoolTransactionParams): PreparedAlgebraCreatePoolAction;
+/** Build a direct initialization call bound to an inspected, uninitialized pool. */
+declare function buildAlgebraInitializePoolTransaction(params: BuildAlgebraInitializePoolTransactionParams): PreparedAlgebraInitializePoolAction;
+type PrepareAlgebraPoolResult = {
+  readonly status: 'ready-create';
+  readonly snapshot: AlgebraPoolSnapshot;
+  readonly action: PreparedAlgebraCreatePoolAction;
+} | {
+  readonly status: 'ready-initialize';
+  readonly snapshot: AlgebraPoolSnapshot;
+  readonly action: PreparedAlgebraInitializePoolAction;
+} | {
+  readonly status: 'already-initialized-matching';
+  readonly snapshot: AlgebraPoolSnapshot;
+  readonly action: null;
+};
+/**
+ * Prepare the next honest lifecycle step. Creation and initialization remain
+ * separate when the SDK has no proven atomic initializer deployment.
+ */
+declare function prepareAlgebraPool(params: Omit<InspectAlgebraPoolParams, 'blockNumber'> & {
+  readonly initialPrice: AlgebraInitialPrice;
+  readonly pluginData?: Hex;
+  readonly blockNumber?: bigint;
+}): Promise<PrepareAlgebraPoolResult>;
+//#endregion
+//#region src/pool-lifecycle/algebra/key.d.ts
+declare function canonicalizeAlgebraPoolKey(input: AlgebraPoolKeyInput): AlgebraPoolKey;
+declare function assertAlgebraInitialPrice(key: AlgebraPoolKey, price: AlgebraInitialPrice): AlgebraInitialPrice;
+//#endregion
+//#region src/pool-lifecycle/algebra/simulate.d.ts
+interface SimulateAlgebraPoolActionParams {
+  readonly publicClient: PublicClient;
+  readonly account: Address;
+  readonly action: PreparedAlgebraPoolAction;
+  readonly blockNumber?: bigint;
+}
+declare function simulateAlgebraPoolAction(params: SimulateAlgebraPoolActionParams): Promise<AlgebraPoolActionSimulation>;
+//#endregion
+//#region src/pool-lifecycle/algebra/verify.d.ts
+interface VerifyAlgebraPoolActionParams {
+  readonly publicClient: PublicClient;
+  readonly action: PreparedAlgebraPoolAction;
+  readonly receipt: TransactionReceipt;
+}
+declare function decodeAlgebraPoolActionReceipt(action: PreparedAlgebraPoolAction, receipt: TransactionReceipt): AlgebraReceiptEvidence;
+declare function verifyAlgebraPoolAction(params: VerifyAlgebraPoolActionParams): Promise<AlgebraPoolActionVerification>;
+//#endregion
+//#region src/pool-lifecycle/v3/types.d.ts
+interface V3PoolKeyInput {
+  readonly tokenA: Address;
+  readonly tokenB: Address;
+  readonly fee: number;
+}
+interface V3PoolKey {
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly fee: number;
+}
+/** A Q64.96 price bound to the canonical V3 token order. */
+interface V3InitialPrice {
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly sqrtPriceX96: bigint;
+}
+type V3PoolStatus = 'absent' | 'uninitialized' | 'initialized';
+interface V3PoolSnapshotBase {
+  readonly schemaVersion: 1;
+  readonly blockNumber: bigint;
+  readonly deployment: V3LifecycleDeployment;
+  readonly key: V3PoolKey;
+  readonly feeTickSpacing: number;
+  readonly tickSpacing: number;
+}
+interface V3AbsentPoolSnapshot extends V3PoolSnapshotBase {
+  readonly status: 'absent';
+  readonly poolAddress: null;
+  readonly sqrtPriceX96: 0n;
+  readonly tick: null;
+}
+interface V3ExistingPoolSnapshotBase extends V3PoolSnapshotBase {
+  readonly poolAddress: Address;
+  readonly tick: number;
+}
+interface V3UninitializedPoolSnapshot extends V3ExistingPoolSnapshotBase {
+  readonly status: 'uninitialized';
+  readonly sqrtPriceX96: 0n;
+}
+interface V3InitializedPoolSnapshot extends V3ExistingPoolSnapshotBase {
+  readonly status: 'initialized';
+  readonly sqrtPriceX96: bigint;
+}
+type V3ExistingPoolSnapshot = V3UninitializedPoolSnapshot | V3InitializedPoolSnapshot;
+/** Pool lifecycle status and its address/price invariants are discriminated. */
+type V3PoolSnapshot = V3AbsentPoolSnapshot | V3UninitializedPoolSnapshot | V3InitializedPoolSnapshot;
+type V3PoolActionKind = 'v3-create' | 'v3-initialize' | 'v3-create-and-initialize';
+interface V3PoolIdentityBase {
+  readonly family: 'uniswap-v3-compatible';
+  readonly adapter: V3LifecycleDeployment['adapter'];
+  readonly version: 1;
+  readonly chainId: number;
+  readonly factory: Address;
+  readonly initializer: Address | null;
+  readonly key: V3PoolKey;
+}
+interface V3CreatePoolIdentity extends V3PoolIdentityBase {
+  readonly poolAddress: null;
+}
+interface V3ExistingPoolIdentity extends V3PoolIdentityBase {
+  readonly poolAddress: Address;
+}
+interface V3PoolIdentity extends V3PoolIdentityBase {
+  readonly poolAddress: Address | null;
+}
+interface V3CreateExpectation {
+  readonly sqrtPriceX96: null;
+}
+interface V3InitializeExpectation {
+  readonly sqrtPriceX96: bigint;
+}
+type V3PreflightSummary = {
+  readonly blockNumber: bigint;
+  readonly status: 'absent';
+  readonly poolAddress: null;
+  readonly sqrtPriceX96: 0n;
+} | {
+  readonly blockNumber: bigint;
+  readonly status: 'uninitialized';
+  readonly poolAddress: Address;
+  readonly sqrtPriceX96: 0n;
+} | {
+  readonly blockNumber: bigint;
+  readonly status: 'initialized';
+  readonly poolAddress: Address;
+  readonly sqrtPriceX96: bigint;
+};
+type V3AbsentPreflightSummary = Extract<V3PreflightSummary, {
+  status: 'absent';
+}>;
+type V3UninitializedPreflightSummary = Extract<V3PreflightSummary, {
+  status: 'uninitialized';
+}>;
+type V3InitializedPreflightSummary = Extract<V3PreflightSummary, {
+  status: 'initialized';
+}>;
+type PreparedV3CreatePoolAction = PreparedPoolAction<'v3-create', V3CreatePoolIdentity, V3CreateExpectation, V3AbsentPreflightSummary> & {
+  readonly preflight: V3AbsentPreflightSummary;
+};
+type PreparedV3InitializePoolAction = PreparedPoolAction<'v3-initialize', V3ExistingPoolIdentity, V3InitializeExpectation, V3UninitializedPreflightSummary> & {
+  readonly preflight: V3UninitializedPreflightSummary;
+};
+type PreparedV3CreateAndInitializeAction = PreparedPoolAction<'v3-create-and-initialize', V3PoolIdentity, V3InitializeExpectation, V3AbsentPreflightSummary | V3UninitializedPreflightSummary> & {
+  readonly preflight: V3AbsentPreflightSummary | V3UninitializedPreflightSummary;
+};
+type PreparedV3PoolAction = PreparedV3CreatePoolAction | PreparedV3InitializePoolAction | PreparedV3CreateAndInitializeAction;
+interface V3PoolActionSimulation extends PoolActionSimulation {
+  readonly returnedPoolAddress: Address | null;
+}
+interface V3PoolCreatedEvidence {
+  readonly poolAddress: Address;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly fee: number;
+  readonly tickSpacing: number;
+  readonly logIndex: number;
+}
+interface V3PoolInitializedEvidence {
+  readonly poolAddress: Address;
+  readonly sqrtPriceX96: bigint;
+  readonly tick: number;
+  readonly logIndex: number;
+}
+interface V3ReceiptEvidence {
+  readonly receiptStatus: 'success' | 'reverted';
+  readonly poolCreated: V3PoolCreatedEvidence | null;
+  readonly initializations: readonly V3PoolInitializedEvidence[];
+}
+type V3PoolActionVerification = PoolActionVerification<V3PoolIdentity, V3PoolSnapshot, V3ReceiptEvidence>;
+/**
+ * Runtime validation for plans crossing JSON, UI/CLI, or signer boundaries.
+ * It re-derives the exact target, value, and calldata from trusted capability
+ * metadata plus the declared kind, key, and expectation.
+ */
+declare function validatePreparedV3PoolAction(value: unknown): V3LifecycleDeployment;
+/** Assertion-form companion for consumers that need TypeScript narrowing. */
+declare function assertPreparedV3PoolAction(value: unknown): asserts value is PreparedV3PoolAction;
+/** Deserialize and fully validate a versioned V3 prepared action. */
+declare function deserializePreparedV3PoolAction(serialized: string): PreparedV3PoolAction;
+//#endregion
+//#region src/pool-lifecycle/v3/key.d.ts
+/** Validate and canonicalize a V3 key without assuming a hard-coded fee tier. */
+declare function canonicalizeV3PoolKey(input: V3PoolKeyInput): V3PoolKey;
+/** Ensure an initial price is bound to the same canonical token pair as a V3 key. */
+declare function assertV3InitialPrice(key: V3PoolKey, price: V3InitialPrice): V3InitialPrice;
+//#endregion
+//#region src/pool-lifecycle/v3/inspect.d.ts
+interface InspectV3PoolParams {
+  publicClient: PublicClient;
+  deployment: V3LifecycleDeployment;
+  key: V3PoolKeyInput;
+  blockNumber?: bigint;
+}
+/**
+ * Read a block-consistent V3 deployment and pool snapshot before building or
+ * verifying a lifecycle transaction.
+ */
+declare function inspectV3Pool(params: InspectV3PoolParams): Promise<V3PoolSnapshot>;
+//#endregion
+//#region src/pool-lifecycle/v3/actions.d.ts
+interface V3BuildBaseParams {
+  deployment: V3LifecycleDeployment;
+  key: V3PoolKeyInput;
+}
+interface BuildV3CreatePoolTransactionParams extends V3BuildBaseParams {
+  readonly preflight: V3AbsentPoolSnapshot;
+}
+interface BuildV3InitializePoolTransactionParams extends V3BuildBaseParams {
+  readonly preflight: V3UninitializedPoolSnapshot;
+  readonly initialPrice: V3InitialPrice;
+}
+interface BuildV3CreateAndInitializeTransactionParams extends Omit<V3BuildBaseParams, 'deployment'> {
+  readonly deployment: V3AtomicLifecycleDeployment;
+  readonly preflight: V3AbsentPoolSnapshot | V3UninitializedPoolSnapshot;
+  readonly initialPrice: V3InitialPrice;
+}
+interface PrepareV3CreateAndInitializeParams extends Omit<InspectV3PoolParams, 'deployment' | 'blockNumber'> {
+  readonly deployment: V3AtomicLifecycleDeployment;
+  initialPrice: V3InitialPrice;
+  blockNumber?: bigint;
+}
+interface PrepareV3CreatePoolParams extends Omit<InspectV3PoolParams, 'blockNumber'> {
+  blockNumber?: bigint;
+}
+interface PrepareV3InitializePoolParams extends Omit<InspectV3PoolParams, 'blockNumber'> {
+  initialPrice: V3InitialPrice;
+  blockNumber?: bigint;
+}
+type PrepareV3CreateAndInitializeResult = {
+  readonly status: 'ready';
+  readonly snapshot: V3PoolSnapshot;
+  readonly action: PreparedV3CreateAndInitializeAction;
+} | {
+  readonly status: 'already-initialized-matching';
+  readonly snapshot: V3PoolSnapshot;
+  readonly action: null;
+};
+type PrepareV3CreatePoolResult = {
+  readonly status: 'ready';
+  readonly snapshot: V3PoolSnapshot;
+  readonly action: PreparedV3CreatePoolAction;
+} | {
+  readonly status: 'already-exists';
+  readonly snapshot: Exclude<V3PoolSnapshot, {
+    status: 'absent';
+  }>;
+  readonly action: null;
+};
+type PrepareV3InitializePoolResult = {
+  readonly status: 'ready';
+  readonly snapshot: V3UninitializedPoolSnapshot;
+  readonly action: PreparedV3InitializePoolAction;
+} | {
+  readonly status: 'already-initialized-matching';
+  readonly snapshot: Extract<V3PoolSnapshot, {
+    status: 'initialized';
+  }>;
+  readonly action: null;
+};
+/** Build the low-level V3 factory create transaction without signing it. */
+declare function buildV3CreatePoolTransaction(params: BuildV3CreatePoolTransactionParams): PreparedV3CreatePoolAction;
+/** Build a direct one-time V3 pool initialize transaction without signing it. */
+declare function buildV3InitializePoolTransaction(params: BuildV3InitializePoolTransactionParams): PreparedV3InitializePoolAction;
+/** Build the canonical atomic create-and-initialize V3 periphery transaction. */
+declare function buildV3CreateAndInitializeTransaction(params: BuildV3CreateAndInitializeTransactionParams): PreparedV3CreateAndInitializeAction;
+/**
+ * Prepare only the factory-creation step. This is the first stage for
+ * deployments without a configured atomic initializer and deliberately does
+ * not claim that the irreversible initial price has been set.
+ */
+declare function prepareV3CreatePool(params: PrepareV3CreatePoolParams): Promise<PrepareV3CreatePoolResult>;
+/**
+ * Prepare only the direct, one-time pool initialization step. Callers using a
+ * factory-only deployment must mine and verify creation, re-inspect the pool,
+ * and then call this function; the SDK does not conceal the intervening race.
+ */
+declare function prepareV3InitializePool(params: PrepareV3InitializePoolParams): Promise<PrepareV3InitializePoolResult>;
+/**
+ * Safe default preparation flow for UI and CLI consumers. It returns no
+ * transaction for an already initialized pool only when the exact price
+ * matches, and rejects a conflicting existing price.
+ */
+declare function prepareV3CreateAndInitialize(params: PrepareV3CreateAndInitializeParams): Promise<PrepareV3CreateAndInitializeResult>;
+//#endregion
+//#region src/pool-lifecycle/v3/simulate.d.ts
+interface SimulateV3PoolActionParams {
+  publicClient: PublicClient;
+  account: Address;
+  action: PreparedV3PoolAction;
+  /** Defaults to the current block. Historical simulation must be explicit. */
+  blockNumber?: bigint;
+}
+/** Simulate and estimate a prepared action with the exact eventual sender. */
+declare function simulateV3PoolAction(params: SimulateV3PoolActionParams): Promise<V3PoolActionSimulation>;
+//#endregion
+//#region src/pool-lifecycle/v3/verify.d.ts
+interface VerifyV3PoolActionParams {
+  publicClient: PublicClient;
+  action: PreparedV3PoolAction;
+  receipt: TransactionReceipt;
+}
+/** Decode receipt evidence without making any RPC reads. */
+declare function decodeV3PoolActionReceipt(action: PreparedV3PoolAction, receipt: TransactionReceipt): V3ReceiptEvidence;
+/** Compose receipt decoding with receipt-block deployment and state verification. */
+declare function verifyV3PoolAction(params: VerifyV3PoolActionParams): Promise<V3PoolActionVerification>;
+//#endregion
+//#region src/pool-lifecycle/v4/key.d.ts
+declare const V4_DYNAMIC_FEE_FLAG = 8388608;
+declare const V4_MAX_STATIC_FEE = 1000000;
+declare const V4_MAX_TICK_SPACING = 32767;
+declare const V4_ALL_HOOK_MASK: bigint;
+declare const V4_ZERO_ADDRESS: `0x${string}`;
+/** Validate a complete PoolKey whose currencies are already canonically ordered. */
+declare function validateV4PoolKey(value: V4PoolKey): V4PoolKey;
+/**
+ * Validate and sort two currencies. Address zero is deliberately accepted and
+ * sorts first because V4 represents the native currency as address(0).
+ */
+declare function canonicalizeV4PoolKey(value: V4PoolKeyInput): V4PoolKey;
+/** Return the exact PoolId used by PoolIdLibrary.toId. */
+declare function getV4PoolId(key: V4PoolKey): Hex;
+declare function v4PoolKeysEqual(left: V4PoolKey, right: V4PoolKey): boolean;
+/** Validate price bounds and bind the price to the canonical PoolKey order. */
+declare function assertV4InitialPrice(key: V4PoolKey, value: V4InitialPrice): V4InitialPrice;
+//#endregion
+//#region src/pool-lifecycle/v4/inspect.d.ts
+interface InspectV4PoolParams {
+  readonly publicClient: PublicClient;
+  readonly deployment: V4LifecycleDeployment;
+  readonly key: V4PoolKeyInput;
+  readonly blockNumber?: bigint;
+}
+/** Read PoolManager identity and pool state at one pinned block. */
+declare function inspectV4Pool(params: InspectV4PoolParams): Promise<V4PoolSnapshot>;
+//#endregion
+//#region src/pool-lifecycle/v4/actions.d.ts
+interface BuildV4InitializePoolTransactionParams {
+  readonly deployment: V4LifecycleDeployment;
+  readonly key: V4PoolKeyInput;
+  readonly initialPrice: V4InitialPrice;
+  readonly preflight: V4UninitializedPoolSnapshot;
+}
+interface PrepareV4InitializeParams extends Omit<InspectV4PoolParams, 'blockNumber'> {
+  readonly initialPrice: V4InitialPrice;
+  readonly blockNumber?: bigint;
+}
+type PrepareV4InitializeResult = {
+  readonly status: 'ready';
+  readonly snapshot: V4UninitializedPoolSnapshot;
+  readonly action: PreparedV4InitializePoolAction;
+} | {
+  readonly status: 'already-initialized-matching';
+  readonly snapshot: V4InitializedPoolSnapshot;
+  readonly action: null;
+};
+/** Build a direct PoolManager.initialize transaction without signing it. */
+declare function buildV4InitializePoolTransaction(params: BuildV4InitializePoolTransactionParams): PreparedV4InitializePoolAction;
+/** Inspect first, then return either a safe unsigned plan or a matching no-op. */
+declare function prepareV4Initialize(params: PrepareV4InitializeParams): Promise<PrepareV4InitializeResult>;
+//#endregion
+//#region src/pool-lifecycle/v4/integrity.d.ts
+/**
+ * Fully validate a signer-boundary V4 action and return its canonical frozen
+ * capability. The target, value, PoolId, and calldata are all re-derived.
+ */
+declare function validatePreparedV4PoolAction(value: unknown): V4LifecycleDeployment;
+declare function assertPreparedV4PoolAction(value: unknown): asserts value is PreparedV4PoolAction;
+/** Deserialize the shared versioned envelope, then perform adapter validation. */
+declare function deserializePreparedV4PoolAction(serialized: string): PreparedV4PoolAction;
+//#endregion
+//#region src/pool-lifecycle/v4/simulate.d.ts
+interface SimulateV4PoolActionParams {
+  readonly publicClient: PublicClient;
+  readonly account: Address;
+  readonly action: PreparedV4PoolAction;
+  /** Defaults to fresh state; historical simulation must be explicit. */
+  readonly blockNumber?: bigint;
+}
+/** Re-inspect, call, and estimate with the exact eventual sender and envelope. */
+declare function simulateV4PoolAction(params: SimulateV4PoolActionParams): Promise<V4PoolActionSimulation>;
+//#endregion
+//#region src/pool-lifecycle/v4/verify.d.ts
+interface VerifyV4PoolActionParams {
+  readonly publicClient: PublicClient;
+  readonly action: PreparedV4PoolAction;
+  readonly receipt: TransactionReceipt;
+}
+/** Decode transaction-attributed PoolManager Initialize evidence without RPC reads. */
+declare function decodeV4PoolActionReceipt(action: PreparedV4PoolAction, receipt: TransactionReceipt): V4ReceiptEvidence;
+/** Verify exact calldata, canonical receipt/event, and receipt-block StateView state. */
+declare function verifyV4PoolAction(params: VerifyV4PoolActionParams): Promise<V4PoolActionVerification>;
+//#endregion
+export { AERODROME_PROTOCOLS, ALGEBRA_INTEGRAL_PROTOCOLS, ALGEBRA_INTEGRAL_V_2_0_PROTOCOLS, ALGEBRA_LIFECYCLE_DEPLOYMENTS, ALGEBRA_PROTOCOLS, AMMConfigType, AMMType, API_URLS, AlgebgraHookBeacons, AlgebraInitialPrice, AlgebraIntegral21QuoteParams, AlgebraLifecycleAdapter, AlgebraLifecycleDeployment, AlgebraLifecycleProvenance, AlgebraLifecycleVariant, AlgebraPoolActionSimulation, AlgebraPoolActionVerification, AlgebraPoolIdentity, AlgebraPoolKey, AlgebraPoolKeyInput, AlgebraPoolSnapshot, AlgebraPreflightSummary, AlgebraQuoteParams, AlgebraReceiptEvidence, AlgebraVaultDetails, ApiPageInfo, ApiVaultFilter, AprFilter, AprResponse, BaseQuoteParams, BaseVaultDetails, BlackholeAprDetailedParams, BlackholeAprDetailedResponse, BlackholeSnapshotAnalysis, BuildAlgebraCreatePoolTransactionParams, BuildAlgebraInitializePoolTransactionParams, BuildV3CreateAndInitializeTransactionParams, BuildV3CreatePoolTransactionParams, BuildV3InitializePoolTransactionParams, BuildV4InitializePoolTransactionParams, CURRENT_V4_LIFECYCLE_DEPLOYMENTS, CalculateLimitPriceParams, CalculateSwapAmountParams, CanonicalCurrencyInitialPrice, CanonicalCurrencyPair, CanonicalErc20Pair, CanonicalInitialPrice, Chain, ChainId, ClaimProofEdge, ClaimProofNode, ClaimProofsPageInfo, ClaimProofsResponse, ClaimRewardEdge, ClaimRewardNode, ClaimRewardParams, ClaimRewardsConnection, ClaimRewardsParams, Contract, ContractAddresses, ContractName, DIRECTIONAL_ALGEBRA_PROTOCOLS, DefaultFeeManagerConfigParams, DeprecationData, EncodedEvmTransaction, EstimateLpTokensParams, ExactCurrencyPrice, ExactFraction, ExactPrice, FEE_MANAGER_ABI, Fee, FeeManagerClient, FeeManagerConfigParams, FeeWithdrawalParams, FormattedRoute, GetRewardParams, GetSupportedChainsOptions, GetVaultExecutionContextParams, GlobalStateABI, type GraphQLPoolData, type GraphQLTokenData, InspectAlgebraCustomPoolEntryPointParams, InspectAlgebraPoolParams, InspectV3PoolParams, InspectV4PoolParams, LimitPoolState, LpPriceResponse, LpTokenEstimationResponse, MAX_SQRT_RATIO, MIN_SQRT_RATIO, MultiPositionManagers, MultiVaultFeeWithdrawalParams, MultipleFeeWithdrawalParams, NetworkConfig, NetworkData, Networks, POOLSHARK_PROTOCOLS, POOL_LIFECYCLE_DEPLOYMENTS, PREPARED_POOL_ACTION_SERIALIZATION_VERSION, PageInfo, PendingRewardsParams, PendingRewardsResponse, PoolActionOutcome, PoolActionSimulation, PoolActionVerification, PoolClient, PoolData, PoolEdge, PoolFilter, PoolLifecycleDeploymentRegistry, PoolLifecycleDeploymentResult, PoolLifecycleError, PoolLifecycleErrorCode, PoolNode, PoolSharkGlobalState, PoolSlot0, PoolsConnection, PoolsharkStructs, PrepareAlgebraPoolResult, PrepareV3CreateAndInitializeParams, PrepareV3CreateAndInitializeResult, PrepareV3CreatePoolParams, PrepareV3CreatePoolResult, PrepareV3InitializePoolParams, PrepareV3InitializePoolResult, PrepareV4InitializeParams, PrepareV4InitializeResult, PreparedAlgebraCreatePoolAction, PreparedAlgebraInitializePoolAction, PreparedAlgebraPoolAction, PreparedPoolAction, PreparedV3CreateAndInitializeAction, PreparedV3CreatePoolAction, PreparedV3InitializePoolAction, PreparedV3PoolAction, PreparedV4InitializePoolAction, PreparedV4PoolAction, Protocol, ProtocolContractAddresses, ProtocolDetails, ProtocolInfo, QuickSwapQuoterV2, QuoteParams, QuoterFunctionArgs, QuoterV2ABI, QuoterV2AlgebgraIntegral, QuoterV2AlgebgraIntegral21, QuoterV2Factory, QuoterV2Shadow, QuoterV2Thick, ResolvePoolLifecycleDeploymentParams, ResolveV3LifecycleDeploymentParams, ResolveV4LifecycleDeploymentParams, Reward, RewardBalance, RewardSummary, RouteShortcut, SHADOW_PROTOCOLS, ShadowQuoteParams, SimulateAlgebraPoolActionParams, SimulateSwapParams, SimulateV3PoolActionParams, SimulateV4PoolActionParams, SingleAssetDepositClient, SingleAssetDepositParams, SingleAssetDepositPreview, Slot0, SmartRewarderContract, SmartRewards, StabilityVaultInfo, StakeParams, Staking, StakingClient, StakingPool, StakingPoolFilter, StakingProtocol, SteerClient, SteerConfig, SteerResponse, SteerSupportedChains, StrykePositionManagers, SubgraphClient, SubgraphResponse, SubgraphVaultClient, SubgraphVaultDetails, SubgraphVaultDetailsWithLpData, SubgraphVaultPosition, SupportedChain, SupportedChainFeatures, SupportedChainsFeature, SupportedChainsInclude, SupportedPoolLifecycleDeployment, SupportedProtocol, SwapAmountResponse, SwapSimulationResponse, TEST_UNISWAP_JIT_HOOK_BEACON, ThickQuoteParams, Token0, Token1, TokenData, TokenEdge, TokenFilter, TokenNode, TokenValueParams, TokenValueResponse, TokensConnection, UNISWAP_V4_BEACON_NAMES, UNISWAP_V4_HOOK_BEACON_NAMES, UNISWAP_V4_NO_ORACLE_BEACON, UniswapHookBeacons, UniswapQuoteParams, UniswapV3PoolABI, UniswapV3QuoterABI, UniswapV4Beacons, UnsupportedPoolLifecycleDeployment, V3AbsentPoolSnapshot, V3AbsentPreflightSummary, V3AtomicLifecycleDeployment, V3CreateExpectation, V3CreatePoolIdentity, V3ExistingPoolIdentity, V3ExistingPoolSnapshot, V3FactoryLifecycleDeployment, V3InitialPrice, V3InitializeExpectation, V3InitializedPoolSnapshot, V3InitializedPreflightSummary, V3LifecycleDeployment, V3LifecycleDeploymentProvenance, V3PoolActionKind, V3PoolActionSimulation, V3PoolActionVerification, V3PoolCreatedEvidence, V3PoolIdentity, V3PoolInitializedEvidence, V3PoolKey, V3PoolKeyInput, V3PoolSnapshot, V3PoolStatus, V3PreflightSummary, V3ReceiptEvidence, V3UninitializedPoolSnapshot, V3UninitializedPreflightSummary, V3_CONFIG_PROTOCOLS, V3_LIFECYCLE_DEPLOYMENTS, V4InitialPrice, V4InitializeEvidence, V4InitializeExpectation, V4InitializedPoolSnapshot, V4LifecycleDeployment, V4LifecycleDeploymentByIdRegistry, V4LifecycleDeploymentId, V4LifecycleDeploymentProvenance, V4PoolActionSimulation, V4PoolActionVerification, V4PoolIdentity, V4PoolKey, V4PoolKeyInput, V4PoolSnapshot, V4ReceiptEvidence, V4UninitializedPoolSnapshot, V4UninitializedPreflightSummary, 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, VaultAllowanceParams, VaultApproveParams, VaultApr, VaultBalanceParams, VaultClient, VaultDetails, VaultDetailsResponse, VaultEdge, VaultExecutionContext, VaultExecutionDataProvenance, VaultExecutionPoolFamily, VaultExecutionPoolKey, VaultExecutionPosition, VaultFetchOptions, VaultFilter, VaultNode, VaultTokens, VaultsConnection, VerifyAlgebraPoolActionParams, VerifyV3PoolActionParams, VerifyV4PoolActionParams, WithdrawParams, 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 };
 //# sourceMappingURL=index.d.mts.map