@steerprotocol/sdk 4.0.0-next.10 → 4.0.0-next.12

package/dist/index.d.mts

@@ -1,4 +1,6 @@
 import "viem";
+import * as v from "valibot";
+import { SmartPoolExecutionContext } from "@steerprotocol/data-connector-loader";
 //#region src/http/transport.d.ts
 /** Transport settings shared by client defaults and per-request overrides. */
 interface HttpRequestOptions {
@@ -112,6 +114,11 @@ export interface ChainContext {
   readonly chainId: number;
   readonly transport?: RpcTransport;
   readonly indexerRequest?: HttpTransport;
+  /** Per-client credential snapshot for WASM connector requests, outside network metadata. */
+  readonly connectorCredentials?: () => {
+    readonly subgraphStudioKey?: string;
+    readonly sentioApiKey?: string;
+  };
   readonly logger?: Logger;
 }
 export interface ContractDeployment {
@@ -148,53 +155,43 @@ export interface PageFreshness {
   readonly source: "stored" | "retained" | "bundled";
 }
 //#endregion
-//#region src/amm/adapters/uniswap-v4/types.d.ts
-interface V4PoolKey {
-  readonly currency0: Address;
-  readonly currency1: Address;
-  readonly fee: number;
-  readonly tickSpacing: number;
-  readonly hooks: Address;
+//#region src/data/adapter.d.ts
+export declare enum DataAdapterKind {
+  Subgraph = "subgraph",
+  Api = "api",
+  Rpc = "rpc"
 }
-type V4PoolReference = V4PoolKey | {
-  readonly poolId: Hex;
+/** Public endpoint metadata must not contain credentials. */
+export type DataAdapterDefinition = {
+  readonly kind: DataAdapterKind.Subgraph;
+  readonly url: string;
+} | {
+  readonly kind: DataAdapterKind.Api;
+  readonly url: string;
+} | {
+  readonly kind: DataAdapterKind.Rpc;
 };
-type V4ReadOptions = PoolReadOptions;
-interface V4SwapQuoteRequest extends SwapQuoteRequest<V4PoolReference> {
-  readonly hookData?: Hex;
-}
-interface V4DirectionalFees {
-  /** One pip is one millionth. */
-  readonly protocolFeePips: number;
-  readonly protocolFeePercent: string;
+export declare abstract class DataAdapter {
+  readonly definition: DataAdapterDefinition;
+  constructor(definition: DataAdapterDefinition);
+  get subgraphUrl(): string | undefined;
 }
-interface V4PoolFees {
-  /** Original key fee, including the dynamic-fee flag when set. */
-  readonly configuredFee: number;
-  /** Stored LP fee in millionths; hooks can override it during a swap. */
-  readonly lpFeePips: number;
-  readonly lpFeePercent: string;
-  /** Raw packed uint24 containing both directional protocol fees. */
-  readonly protocolFeePacked: number;
-  readonly currency0ToCurrency1: V4DirectionalFees;
-  readonly currency1ToCurrency0: V4DirectionalFees;
+/** Per-request HTTP settings; credentials never become public adapter metadata. */
+export type DataAdapterRequestOptions = HttpRequestOptions;
+export interface TokenFilter {
+  readonly address?: Address;
+  /** Case-insensitive substring match. */
+  readonly symbol?: string;
+  /** Case-insensitive substring match. */
+  readonly name?: string;
 }
-interface V4PoolState extends ConcentratedPoolState {
-  readonly key: V4PoolKey;
-  readonly poolId: Hex;
-  readonly poolManager: Address;
-  readonly currency0Decimals: number;
-  readonly currency1Decimals: number;
-  readonly currency0IsNative: boolean;
-  readonly currency1IsNative: boolean;
-  readonly price: PoolPrice;
-  readonly fees: V4PoolFees;
-  readonly blockNumber: bigint;
+export type PoolTokenFilter = TokenFilter;
+export interface PoolListRequest extends PageRequest {
+  /** Matches either pool token. All supplied fields must match the same token. */
+  readonly token?: PoolTokenFilter;
 }
-interface V4Contracts extends ContractMap {
-  readonly poolManager: ContractDeployment;
-  readonly stateView: ContractDeployment;
-  readonly quoter: ContractDeployment;
+export declare abstract class PoolDataAdapter<TPoolRef> extends DataAdapter {
+  abstract listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<TPoolRef>>;
 }
 //#endregion
 //#region src/amm/enums.d.ts
@@ -266,1551 +263,1055 @@ export declare enum AmmFamily {
   UniswapV4 = "uniswap-v4"
 }
 //#endregion
-//#region src/core/deployment.d.ts
-export interface DeploymentDefinition<TContracts extends ContractMap = ContractMap> {
-  readonly id: string;
-  readonly chainId: number;
-  readonly contracts: TContracts;
-  readonly dataAdapter: DataAdapterDefinition;
+//#region src/amm/adapters/aerodrome/types.d.ts
+interface SlipstreamContracts extends ContractMap {
+  readonly factory: ContractDeployment;
+  readonly quoter: ContractDeployment;
+  readonly positionManager: ContractDeployment;
 }
-export interface DeploymentReference<TAdapter, TContracts extends ContractMap = ContractMap, TContext extends ChainContext = ChainContext> {
-  readonly definition: DeploymentDefinition<TContracts>;
-  connect(context: TContext): TAdapter;
+interface SlipstreamPoolFees {
+  /** Observed fee in millionths at the snapshot block, not a guarantee for a later swap. */
+  readonly swapFeePips: number;
+  readonly swapFeePercent: string;
+  /** Portion of unstaked LP trading fees allocated away, not an additional trader fee. */
+  readonly unstakedFeePips: number;
+  readonly unstakedFeePercent: string;
 }
-/** Import a deployment object for lookup; consumers do not look up free-form IDs. */
-export declare class Deployment<TAdapter, TContracts extends ContractMap = ContractMap, TContext extends ChainContext = ChainContext> implements DeploymentReference<TAdapter, TContracts, TContext> {
-  #private;
-  readonly definition: DeploymentDefinition<TContracts>;
-  constructor(definition: DeploymentDefinition<TContracts>, factory: (context: TContext, definition: DeploymentDefinition<TContracts>) => TAdapter);
-  connect(context: TContext): TAdapter;
+interface SlipstreamPoolState extends ConcentratedPoolState {
+  readonly address: Address;
+  readonly factory: Address;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly token0Decimals: number;
+  readonly token1Decimals: number;
+  readonly tickSpacing: number;
+  /** Already included in liquidity. */
+  readonly stakedLiquidity: bigint;
+  readonly gauge: Address;
+  readonly positionManager: Address;
+  readonly fees: SlipstreamPoolFees;
+  readonly balances: {
+    readonly token0: PoolTokenBalance;
+    readonly token1: PoolTokenBalance;
+  };
+  readonly price: PoolPrice;
+  readonly blockNumber: bigint;
 }
-/** Construction is explicit. Lookup creates an adapter without global registration or caching. */
-export declare class DeploymentRegistry<TBase> {
-  #private;
-  readonly context: ChainContext;
-  constructor(context: ChainContext, deployments: readonly DeploymentReference<TBase>[]);
-  get<TAdapter extends TBase>(deployment: DeploymentReference<TAdapter>): TAdapter;
-  list(): readonly DeploymentReference<TBase>[];
+/** Optional caller for fee modules that apply transaction-origin discounts. */
+interface SlipstreamQuoteOptions extends ReadOptions {
+  readonly account?: Address;
 }
 //#endregion
-//#region src/lending/adapter.d.ts
-export declare enum LendingProtocol {
-  AaveV3 = "aave-v3"
-}
-export declare enum LendingFamily {
-  AaveV3 = "aave-v3"
-}
-export declare abstract class LendingAdapter<TMarketRef = unknown, TMarketState = unknown, TContracts extends ContractMap = ContractMap> {
-  readonly context: ChainContext;
-  readonly deployment: DeploymentDefinition<TContracts>;
-  readonly dataAdapter: LendingDataAdapter<TMarketRef>;
-  abstract readonly family: LendingFamily;
-  abstract readonly protocol: LendingProtocol;
-  constructor(context: ChainContext, deployment: DeploymentDefinition<TContracts>, dataAdapter: LendingDataAdapter<TMarketRef>);
-  get subgraphUrl(): string | undefined;
-  abstract getMarket(reference: TMarketRef, options?: ReadOptions): Promise<TMarketState>;
-}
-export interface AaveReserveState {
-  readonly asset: Address;
-  readonly supplyRateRay: bigint;
-  readonly variableBorrowRateRay: bigint;
-}
-export interface SupplyRequest {
-  readonly asset: Address;
-  readonly amount: bigint;
-  readonly account: Address;
+//#region src/amm/adapters/aerodrome/adapter.d.ts
+export declare abstract class AerodromeSlipstreamAdapter extends AmmAdapter<Address, SlipstreamPoolState, SlipstreamContracts> {
+  #private;
+  readonly family = AmmFamily.AerodromeSlipstream;
+  getPool(address: Address, options?: ReadOptions): Promise<SlipstreamPoolState>;
+  quote(request: SwapQuoteRequest<Address>, options?: SlipstreamQuoteOptions): Promise<Readonly<{
+    amountIn: bigint;
+    amountOut: bigint;
+  }>>;
+  getTicks(address: Address, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
+  getSurroundingTicks(address: Address, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
 }
-export interface AaveV3Contracts extends ContractMap {
-  readonly pool: ContractDeployment;
+//#endregion
+//#region src/amm/adapters/aerodrome/data-adapter.d.ts
+/** Dedicated factory-bound endpoints. Indexed addresses still require native pool verification. */
+export declare class SlipstreamDataAdapter extends PoolDataAdapter<Address> {
+  #private;
+  constructor(definition: DataAdapterDefinition, factory: Address, indexerRequest?: HttpTransport, chainId?: number);
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<`0x${string}`>>;
 }
-export declare abstract class AaveV3Adapter extends LendingAdapter<Address, AaveReserveState, AaveV3Contracts> {
-  readonly family = LendingFamily.AaveV3;
-  abstract prepareSupply(request: SupplyRequest): Promise<TransactionPlan>;
+//#endregion
+//#region src/amm/adapters/aerodrome/slipstream.d.ts
+export declare class AerodromeSlipstream extends AerodromeSlipstreamAdapter {
+  readonly protocol = AmmProtocol.Aerodrome;
+  readonly version = AerodromeVersion.Slipstream;
 }
 //#endregion
-//#region src/vault/enums.d.ts
-export declare enum VaultKind {
-  Liquidity = "liquidity",
-  Lending = "lending",
-  Composite = "composite"
+//#region src/amm/adapters/aerodrome/slipstream-v2.d.ts
+export declare class AerodromeSlipstreamV2 extends AerodromeSlipstreamAdapter {
+  readonly protocol = AmmProtocol.Aerodrome;
+  readonly version = AerodromeVersion.SlipstreamV2;
 }
-export declare enum PositionKind {
-  Liquidity = "liquidity",
-  Lending = "lending",
-  Idle = "idle"
+//#endregion
+//#region src/amm/adapters/aerodrome/slipstream-v3.d.ts
+export declare class AerodromeSlipstreamV3 extends AerodromeSlipstreamAdapter {
+  readonly protocol = AmmProtocol.Aerodrome;
+  readonly version = AerodromeVersion.SlipstreamV3;
 }
 //#endregion
-//#region src/vault/resolver-types.d.ts
-export declare enum ProtocolContractRole {
-  AmmFactory = "amm-factory",
-  PoolManager = "pool-manager",
-  LendingPool = "lending-pool",
-  LendingMarketFactory = "lending-market-factory"
+//#region src/amm/adapters/algebra/types.d.ts
+interface AlgebraContracts extends ContractMap {
+  readonly factory: ContractDeployment;
+  readonly poolDeployer: ContractDeployment;
+  readonly quoter: ContractDeployment;
 }
-export interface VaultReadContext {
-  readonly steer: SteerNetwork;
+/** Fields shared by qualified Algebra families; fee and plugin layouts remain family-specific. */
+interface AlgebraPoolState extends ConcentratedPoolState {
   readonly address: Address;
+  readonly factory: Address;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly token0Decimals: number;
+  readonly token1Decimals: number;
+  readonly tickSpacing: number;
+  readonly price: PoolPrice;
+  readonly balances: {
+    readonly token0: PoolTokenBalance;
+    readonly token1: PoolTokenBalance;
+  };
   readonly blockNumber: bigint;
 }
-export interface VaultIdentity {
-  readonly chainId: number;
-  readonly vaultAddress: Address;
-  readonly registryAddress: Address;
-  /** Beacon registered for this vault in Steer's VaultRegistry. */
-  readonly beaconAddress: Address;
-  /** Beacon actually used by the vault proxy. */
-  readonly proxyBeaconAddress: Address;
-  readonly implementationAddress: Address;
-}
-/** The reader must check registry membership and the proxy's actual beacon/implementation. */
-export interface VaultIdentityReader {
-  getBlockNumber(steer: SteerNetwork): Promise<bigint>;
-  /** Read actual contracts at context.blockNumber; return null for an unregistered vault. */
-  readIdentity(context: VaultReadContext): Promise<VaultIdentity | null>;
-}
-export type UnderlyingReference = {
-  readonly kind: PositionKind.Liquidity;
-  readonly role: ProtocolContractRole.AmmFactory | ProtocolContractRole.PoolManager;
-  readonly protocolAddress: Address;
-  readonly pool: unknown;
-} | {
-  readonly kind: PositionKind.Lending;
-  readonly role: ProtocolContractRole.LendingPool | ProtocolContractRole.LendingMarketFactory;
-  readonly protocolAddress: Address;
-  readonly market: unknown;
-};
-export type ProtocolBinding = {
-  readonly kind: PositionKind.Liquidity;
-  readonly role: ProtocolContractRole.AmmFactory | ProtocolContractRole.PoolManager;
-  readonly protocolAddress: Address;
-  readonly deployment: DeploymentReference<AmmAdapter>;
-} | {
-  readonly kind: PositionKind.Lending;
-  readonly role: ProtocolContractRole.LendingPool | ProtocolContractRole.LendingMarketFactory;
-  readonly protocolAddress: Address;
-  readonly deployment: DeploymentReference<LendingAdapter>;
+//#endregion
+//#region src/amm/adapters/algebra-integral/types.d.ts
+/** Base pools accept an address. Custom pool listings carry their verified routing identity. */
+type AlgebraPoolReference = Address | {
+  readonly address: Address;
+  readonly deployer: Address;
 };
-export interface ResolvedVaultContext extends VaultReadContext {
-  readonly underlying: readonly VaultUnderlying[];
-  readonly metadata: VaultMetadata;
-}
-/** Exact implementation-specific readers and constructors, supplied by SDK integration code. */
-export interface VaultImplementationBinding {
-  /** Exact indexed names associated with this implementation; omitted means unknown support. */
-  readonly beaconNames?: readonly string[];
-  readonly beaconAddress: Address;
-  readonly implementationAddress: Address;
-  /** Runtime hash checked by this binding's native snapshot reader before returning accounting. */
-  readonly implementationCodeHash?: Hex;
-  readonly kind: VaultKind;
-  readUnderlying(context: VaultReadContext): Promise<readonly UnderlyingReference[]>;
-  createVault(context: ResolvedVaultContext): KnownSteerVault;
+type AlgebraIntegralContracts = AlgebraContracts;
+interface AlgebraIntegralPoolState extends AlgebraPoolState {
+  /** Zero for a base pool; custom deployer for a custom pool. */
+  readonly deployer: Address;
+  readonly plugin: Address;
+  readonly pluginConfig: number;
+  readonly fees: {
+    /** Stored pool fee, which can be stale when dynamic fees are enabled. */
+    readonly lastFeePips: number;
+    readonly lastFeePercent: string;
+    /** Share of swap fees allocated to the community, in thousandths. */
+    readonly communityFeePermille: number;
+    readonly communityFeePercent: string;
+  };
 }
-export interface VaultResolverDefinition {
-  readonly reader: VaultIdentityReader;
-  readonly implementations: readonly VaultImplementationBinding[];
-  readonly protocols: readonly ProtocolBinding[];
+//#endregion
+//#region src/amm/adapters/algebra-integral/adapter.d.ts
+export declare abstract class AlgebraIntegralAdapter extends AmmAdapter<AlgebraPoolReference, AlgebraIntegralPoolState, AlgebraIntegralContracts> {
+  #private;
+  readonly family = AmmFamily.AlgebraIntegral;
+  getPool(reference: AlgebraPoolReference, options?: ReadOptions): Promise<AlgebraIntegralPoolState>;
+  getTicks(reference: AlgebraPoolReference, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
+  getSurroundingTicks(reference: AlgebraPoolReference, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
+  quote(request: SwapQuoteRequest<AlgebraPoolReference>, options?: ReadOptions): Promise<Readonly<{
+    amountIn: bigint;
+    amountOut: bigint;
+  }>>;
 }
-export declare enum VaultResolutionErrorCode {
-  NotConfigured = "not-configured",
-  InvalidMapping = "invalid-mapping",
-  NotRegistered = "not-registered",
-  IdentityMismatch = "identity-mismatch",
-  UnsupportedImplementation = "unsupported-implementation",
-  UnsupportedProtocol = "unsupported-protocol",
-  InvalidVault = "invalid-vault"
+export declare class Blackhole extends AlgebraIntegralAdapter {
+  readonly protocol = AmmProtocol.Blackhole;
+  readonly version = BlackholeVersion.CL;
 }
-export declare class VaultResolutionError extends Error {
-  readonly code: VaultResolutionErrorCode;
-  constructor(code: VaultResolutionErrorCode, message: string);
+export declare class QuickSwapIntegral extends AlgebraIntegralAdapter {
+  readonly protocol = AmmProtocol.QuickSwap;
+  readonly version = QuickSwapVersion.V4;
 }
 //#endregion
-//#region src/vault/resolver.d.ts
-/** One resolver belongs to one Steer deployment and its registered integrations. */
-export declare class VaultResolver {
+//#region src/amm/adapters/algebra-integral/data-adapter.d.ts
+export declare class AlgebraIntegralDataAdapter extends PoolDataAdapter<AlgebraPoolReference> {
   #private;
-  readonly amms: DeploymentRegistry<AmmAdapter>;
-  readonly lending: DeploymentRegistry<LendingAdapter>;
-  constructor(definition: VaultResolverDefinition, amms: DeploymentRegistry<AmmAdapter>, lending: DeploymentRegistry<LendingAdapter>);
-  resolve(steer: SteerNetwork, address: Address, options?: VaultLoadOptions): Promise<KnownSteerVault>;
-  /** Bounded bulk identity pages at one block; compatibility uses four active loads. */
-  resolveMany(steer: SteerNetwork, addresses: readonly Address[], options: VaultLoadOptions & {
-    allowFailure: true;
-  }): Promise<readonly VaultLoadResult[]>;
-  resolveMany(steer: SteerNetwork, addresses: readonly Address[], options?: VaultLoadOptions & {
-    allowFailure?: false;
-  }): Promise<readonly KnownSteerVault[]>;
-  resolveMany(steer: SteerNetwork, addresses: readonly Address[], options?: VaultLoadOptions & {
-    allowFailure?: boolean;
-  }): Promise<readonly KnownSteerVault[] | readonly VaultLoadResult[]>;
-  /** Identity and accounting share a pinned block; dispatch custom constructors and methods. */
-  snapshots(steer: SteerNetwork, addresses: readonly Address[], options: ReadOptions & {
-    allowFailure: true;
-  }): Promise<readonly VaultSnapshotResult[]>;
-  snapshots(steer: SteerNetwork, addresses: readonly Address[], options?: ReadOptions & {
-    allowFailure?: false;
-  }): Promise<readonly LiquidityVaultSnapshot[]>;
-  snapshots(steer: SteerNetwork, addresses: readonly Address[], options?: ReadOptions & {
-    allowFailure?: boolean;
-  }): Promise<readonly LiquidityVaultSnapshot[] | readonly VaultSnapshotResult[]>;
+  constructor(definition: DataAdapterDefinition, factory: Address, request?: HttpTransport);
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<AlgebraPoolReference>>;
 }
 //#endregion
-//#region src/vault/steer.d.ts
-export interface SteerContracts extends ContractMap {
-  readonly KeeperRegistry: ContractDeployment;
-  readonly Orchestrator: ContractDeployment;
-  readonly StrategyRegistry: ContractDeployment;
-  readonly VaultRegistry: ContractDeployment;
-  readonly BundleRegistry: ContractDeployment;
-  readonly GasVault: ContractDeployment;
-  readonly SteerPeriphery: ContractDeployment;
+//#region src/amm/adapters/algebra-legacy/types.d.ts
+type AlgebraLegacyContracts = AlgebraContracts;
+interface AlgebraSwapFee {
+  /** Stored fee, not a guarantee of the fee on the next swap. */
+  readonly lastFeePips: number;
+  readonly lastFeePercent: string;
 }
-/** Connected Steer deployment with one automatic vault-loading path. */
-export declare class SteerNetwork {
-  #private;
-  readonly context: ChainContext;
-  readonly deployment: DeploymentDefinition<SteerContracts>;
-  readonly dataAdapter: SteerDataAdapter;
-  constructor(context: ChainContext, deployment: DeploymentDefinition<SteerContracts>, dataAdapter: SteerDataAdapter, resolver?: VaultResolver);
-  get contracts(): SteerContracts;
-  get subgraphUrl(): string | undefined;
-  listUserVaults(request: UserVaultListRequest, options?: DataAdapterRequestOptions): Promise<UserVaultPage>;
-  listVaults(request?: VaultListRequest, options?: DataAdapterRequestOptions): Promise<Page<VaultMetadata>>;
-  /** Synchronous registration check with no RPC or HTTP; does not verify a particular vault. */
-  supportsVaultSnapshots(beaconName: string): boolean;
-  getVault(address: Address, options?: VaultLoadOptions): Promise<KnownSteerVault>;
-  getVaults(addresses: readonly Address[], options: VaultLoadOptions & {
-    allowFailure: true;
-  }): Promise<readonly VaultLoadResult[]>;
-  getVaults(addresses: readonly Address[], options?: VaultLoadOptions & {
-    allowFailure?: false;
-  }): Promise<readonly KnownSteerVault[]>;
-  getVaults(addresses: readonly Address[], options?: VaultLoadOptions & {
-    allowFailure?: boolean;
-  }): Promise<readonly KnownSteerVault[] | readonly VaultLoadResult[]>;
-  getVaultSnapshots(addresses: readonly Address[], options: ReadOptions & {
-    allowFailure: true;
-  }): Promise<readonly VaultSnapshotResult[]>;
-  getVaultSnapshots(addresses: readonly Address[], options?: ReadOptions & {
-    allowFailure?: false;
-  }): Promise<readonly LiquidityVaultSnapshot[]>;
-  getVaultSnapshots(addresses: readonly Address[], options?: ReadOptions & {
-    allowFailure?: boolean;
-  }): Promise<readonly LiquidityVaultSnapshot[] | readonly VaultSnapshotResult[]>;
-  getVaultUserPositions(addresses: readonly Address[], account: Address, options?: ReadOptions): Promise<readonly VaultUserPosition[]>;
-  getLiquidityVault(address: Address, options?: VaultLoadOptions): Promise<LiquidityVault>;
-  getLendingVault(address: Address, options?: VaultLoadOptions): Promise<LendingVault>;
-  getCompositeVault(address: Address, options?: VaultLoadOptions): Promise<CompositeVault>;
+interface AlgebraLegacyPoolState extends AlgebraPoolState {
+  readonly fees: {
+    readonly currency0ToCurrency1: AlgebraSwapFee;
+    readonly currency1ToCurrency0: AlgebraSwapFee;
+    readonly communityFeeToken0Permille: number;
+    readonly communityFeeToken1Permille: number;
+    readonly communityFeeToken0Percent: string;
+    readonly communityFeeToken1Percent: string;
+  };
 }
 //#endregion
-//#region src/vault/vault.d.ts
-export declare abstract class SteerVault {
-  readonly address: Address;
-  readonly chain: ChainContext;
-  readonly steer: SteerNetwork;
-  abstract readonly kind: VaultKind;
-  readonly underlying: readonly VaultUnderlying[];
-  readonly metadata: VaultMetadata;
-  constructor(address: Address, chain: ChainContext, steer: SteerNetwork, underlying: readonly VaultUnderlying[], metadata: VaultMetadata);
-  abstract getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
-  abstract getPositions(options?: ReadOptions): Promise<readonly StrategyPosition[]>;
-  /** SDK request shape; contract implementations encode their own ABI and enforce asset rules. */
-  abstract previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<DepositPreview>;
-  abstract prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<TransactionPlan>;
-  /** Share-denominated exit; implementations map this to the contract's withdrawal flow. */
-  abstract prepareWithdraw(request: PrepareWithdrawRequest, options?: ReadOptions): Promise<TransactionPlan>;
+//#region src/amm/adapters/algebra-legacy/adapter.d.ts
+export declare abstract class AlgebraLegacyAdapter extends AmmAdapter<Address, AlgebraLegacyPoolState, AlgebraLegacyContracts> {
+  #private;
+  readonly family = AmmFamily.AlgebraLegacy;
+  getPool(reference: Address, options?: ReadOptions): Promise<AlgebraLegacyPoolState>;
+  getTicks(reference: Address, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
+  getSurroundingTicks(reference: Address, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
+  quote(request: SwapQuoteRequest<Address>, options?: ReadOptions): Promise<Readonly<{
+    amountIn: bigint;
+    amountOut: bigint;
+  }>>;
 }
-export declare abstract class LiquidityVault<TAmm extends AmmAdapter = AmmAdapter, TPool extends LiquidityPool = LiquidityPool> extends SteerVault {
-  readonly kind = VaultKind.Liquidity;
-  abstract readonly amm: TAmm;
-  abstract getPositions(options?: ReadOptions): Promise<readonly LiquidityPosition<TPool>[]>;
-  abstract getSnapshot(options?: ReadOptions): Promise<LiquidityVaultSnapshot<TPool>>;
-  /** Calculate the other token maximum at the vault's current deposit ratio. Does not swap. */
-  abstract quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
-  abstract previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<LiquidityDepositPreview>;
-  abstract prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<DepositPlan>;
-  /** Simulates the original withdrawal as account at one verified block. Never submits. */
-  previewWithdraw(request: WithdrawRequest, options?: ReadOptions): Promise<WithdrawPreview>;
-  /** Re-simulates independently; does not trust a previously returned preview. */
-  prepareWithdraw(request: PrepareWithdrawRequest, options?: ReadOptions): Promise<WithdrawPlan>;
-  /** Proportional accounting amounts at one block, not a withdrawal quote. */
-  getUserPosition(account: Address, options?: ReadOptions): Promise<LiquidityVaultUserPosition<TPool>>;
+//#endregion
+//#region src/amm/adapters/algebra-legacy/directional.d.ts
+export declare abstract class AlgebraDirectionalAdapter extends AlgebraLegacyAdapter {}
+//#endregion
+//#region src/amm/adapters/algebra-legacy/camelot.d.ts
+export declare class Camelot extends AlgebraDirectionalAdapter {
+  readonly protocol = AmmProtocol.Camelot;
+  readonly version = CamelotVersion.V3;
 }
-export declare abstract class LendingVault<TLending extends LendingAdapter = LendingAdapter> extends SteerVault {
-  readonly kind = VaultKind.Lending;
-  abstract readonly lending: TLending;
+//#endregion
+//#region src/amm/adapters/algebra-legacy/data-adapter.d.ts
+export declare class AlgebraLegacyDataAdapter extends PoolDataAdapter<Address> {
+  #private;
+  constructor(definition: DataAdapterDefinition, factory: Address, request?: HttpTransport);
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<`0x${string}`>>;
 }
-export declare abstract class CompositeVault extends SteerVault {
-  readonly kind = VaultKind.Composite;
+//#endregion
+//#region src/amm/adapters/algebra-legacy/quickswap.d.ts
+export declare class QuickSwap extends AlgebraLegacyAdapter {
+  readonly protocol = AmmProtocol.QuickSwap;
+  readonly version = QuickSwapVersion.V3;
 }
 //#endregion
-//#region src/vault/types.d.ts
-type VaultAmmFilter = { [Protocol in AmmProtocol]: Omit<AmmLookupRequest<Protocol>, "chainId">; }[AmmProtocol];
-/** Indexed descriptive data. This record does not establish current onchain identity. */
-interface VaultMetadata {
-  readonly id: Address;
-  readonly name: string | null;
-  readonly symbol: string | null;
-  readonly decimals: string | null;
-  readonly beaconName: string;
-  readonly createdAt: string;
-  readonly state: string | null;
-  /** Pool contract address or a 32-byte pool ID for singleton AMMs such as V4. */
-  readonly pool: Hex | null;
-  readonly poolKey?: string | null;
-  readonly token0: Address | null;
-  readonly token1: Address | null;
-  readonly payloadIpfs: string | null;
-  readonly strategyToken: {
-    readonly id: string;
-  } | null;
+//#region src/amm/adapters/pancakeswap-infinity-cl/types.d.ts
+interface InfinityCLPoolKey {
+  readonly currency0: Address;
+  readonly currency1: Address;
+  readonly hooks: Address;
+  readonly poolManager: Address;
+  readonly fee: number;
+  readonly parameters: Hex;
 }
-/** Loading options. Supplied indexed metadata never replaces onchain identity checks. */
-interface VaultLoadOptions extends ReadOptions {
-  /** Complete records for the requested addresses; omit to fetch from the subgraph. */
-  readonly metadata?: readonly VaultMetadata[];
+interface InfinityCLPoolKeyInput extends Omit<InfinityCLPoolKey, "parameters"> {
+  readonly tickSpacing: number;
+  readonly hookPermissions?: number;
 }
-interface VaultListRequest extends PageRequest {
-  /** Select a configured AMM using the same protocol/version rules as getAmm(). */
-  readonly amm?: VaultAmmFilter;
-  /** Match either underlying token; all supplied fields must match that same token. */
-  readonly token?: TokenFilter;
+interface InfinityCLPoolIdReference {
+  readonly poolId: Hex;
 }
-interface VaultDiscoveryRequest extends VaultListRequest {
-  readonly chainId: number;
+type InfinityCLPoolReference = InfinityCLPoolKey | InfinityCLPoolIdReference;
+interface InfinityCLSwapQuoteRequest extends SwapQuoteRequest<InfinityCLPoolReference> {
+  readonly hookData?: Hex;
 }
-/** Scans at most limit indexed share-vault candidates (default 1,000) per page. */
-interface UserVaultListRequest extends VaultListRequest {
-  readonly account: Address;
+interface InfinityCLDirectionalFees {
+  readonly protocolFeePips: number;
+  readonly protocolFeePercent: string;
 }
-interface UserVaultDiscoveryRequest extends UserVaultListRequest {
-  readonly chainId: number;
+interface InfinityCLPoolFees {
+  readonly configuredFee: number;
+  readonly lpFeePips: number;
+  readonly lpFeePercent: string;
+  readonly protocolFeePacked: number;
+  readonly currency0ToCurrency1: InfinityCLDirectionalFees;
+  readonly currency1ToCurrency0: InfinityCLDirectionalFees;
 }
-/** Indexed candidates with positive onchain shares, not verified vault implementations.
- * Empty pages may have a nextCursor. Completeness depends on the indexed inventory.
- */
-interface UserVaultPage extends Page<Address> {
-  readonly indexedBlock: bigint;
+interface InfinityCLPoolState extends ConcentratedPoolState {
+  readonly key: InfinityCLPoolKey;
+  readonly poolId: Hex;
+  readonly poolManager: Address;
+  readonly tickSpacing: number;
+  readonly currency0Decimals: number;
+  readonly currency1Decimals: number;
+  readonly currency0IsNative: boolean;
+  readonly currency1IsNative: boolean;
+  readonly price: PoolPrice;
+  readonly fees: InfinityCLPoolFees;
+  readonly blockNumber: bigint;
 }
-/** SDK connection dependency, supplied by SteerClient to its data adapter factory. */
-interface SteerConnectionContext extends ChainContext {
-  readonly amms: DeploymentRegistry<AmmAdapter>;
+interface InfinityCLContracts extends ContractMap {
+  readonly poolManager: ContractDeployment;
+  readonly vault: ContractDeployment;
+  readonly quoter: ContractDeployment;
 }
-interface AssetAmount {
-  readonly asset: Address;
-  readonly amount: bigint;
+//#endregion
+//#region src/amm/adapters/pancakeswap-infinity-cl/adapter.d.ts
+export declare abstract class InfinityCLAdapter extends AmmAdapter<InfinityCLPoolReference, InfinityCLPoolState, InfinityCLContracts, InfinityCLPoolIdReference> {
+  #private;
+  readonly family = AmmFamily.PancakeSwapInfinityCL;
+  createPoolKey(input: InfinityCLPoolKeyInput): InfinityCLPoolKey;
+  getPoolId(key: InfinityCLPoolKey): Hex;
+  getPoolKey(id: Hex, options?: ReadOptions): Promise<InfinityCLPoolKey>;
+  getPool(reference: InfinityCLPoolReference, options?: ReadOptions): Promise<InfinityCLPoolState>;
+  getTicks(reference: InfinityCLPoolReference, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
+  getSurroundingTicks(reference: InfinityCLPoolReference, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
+  quote(request: InfinityCLSwapQuoteRequest, options?: PoolReadOptions): Promise<Readonly<{
+    amountIn: bigint;
+    amountOut: bigint;
+  }>>;
 }
-interface DepositRequest {
-  /** Token owner and transaction sender. */
-  readonly account: Address;
-  readonly assets: readonly AssetAmount[];
-  readonly receiver: Address;
+export declare class PancakeSwapInfinityCL extends InfinityCLAdapter {
+  readonly protocol = AmmProtocol.PancakeSwap;
+  readonly version = PancakeSwapVersion.InfinityCL;
 }
-interface DepositPreview {
-  readonly shares: bigint;
+//#endregion
+//#region src/amm/adapters/pancakeswap-infinity-cl/data-adapter.d.ts
+/** Listings return stable IDs; the manager resolves their canonical keys onchain. */
+export declare class PancakeSwapInfinityCLDataAdapter extends PoolDataAdapter<InfinityCLPoolIdReference> {
+  #private;
+  constructor(definition: DataAdapterDefinition, manager: Address, indexerRequest?: HttpTransport);
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<InfinityCLPoolIdReference>>;
 }
-interface PrepareDepositRequest extends DepositRequest {
-  /** Integer basis points from zero through 10,000, applied to accepted token amounts. */
-  readonly slippageBps: number;
+//#endregion
+//#region src/amm/adapters/uniswap-v3/types.d.ts
+interface V3PoolFees {
+  /** Fixed swap fee in millionths, including any protocol share deducted from it. */
+  readonly swapFeePips: number;
+  /** Percentage, e.g. "0.05" for 500 pips, without a percent sign. */
+  readonly swapFeePercent: string;
 }
-/** Contract-compatible quote, independent of the account's balances and allowances. */
-interface LiquidityDepositPreview extends DepositPreview {
-  readonly blockNumber: bigint;
+interface V3PoolState extends ConcentratedPoolState {
+  readonly address: Address;
+  readonly factory: Address;
   readonly token0: Address;
   readonly token1: Address;
-  readonly amounts: TokenPairAmounts;
-  readonly unusedAmounts: TokenPairAmounts;
-  /** Settlement of pre-existing receiver shares, separate from deposited assets. */
-  readonly rewards?: VaultRewardPayout;
+  readonly fees: V3PoolFees;
+  readonly token0Decimals: number;
+  readonly token1Decimals: number;
+  /** Actual pool-contract balances, including any fees or donated tokens it holds. */
+  readonly balances: {
+    readonly token0: PoolTokenBalance;
+    readonly token1: PoolTokenBalance;
+  };
+  /** 36 significant digits, rounded down. Undefined for an uninitialized pool. */
+  readonly price: PoolPrice | undefined;
+  readonly tickSpacing: number;
+  readonly blockNumber: bigint;
 }
-/** Inferred token maxima, suitable for previewDeposit or prepareDeposit. No tokens are swapped. */
-interface DepositQuote extends LiquidityDepositPreview {
-  /** Token0 and token1 maxima, in that order. */
-  readonly assets: readonly [AssetAmount, AssetAmount];
+interface V3Contracts extends ContractMap {
+  readonly factory: ContractDeployment;
 }
-/** Ordered capped approvals, if needed, followed by the unsigned deposit. */
-interface DepositPlan extends TransactionPlan {
-  readonly account: Address;
-  readonly preview: LiquidityDepositPreview;
-  readonly minimumAmounts: TokenPairAmounts;
+//#endregion
+//#region src/amm/adapters/uniswap-v3/base.d.ts
+/** A compatible deployment reuses this class; a behavioral fork may subclass it. */
+export declare abstract class UniswapV3Adapter extends AmmAdapter<Address, V3PoolState, V3Contracts> {
+  readonly family = AmmFamily.UniswapV3;
 }
-interface WithdrawRequest {
-  readonly shares: bigint;
-  /** Share holder and transaction sender. The contract burns msg.sender shares. */
-  readonly account: Address;
-  readonly receiver: Address;
+//#endregion
+//#region src/amm/adapters/uniswap-v3/adapter.d.ts
+/** Standard V3 reads and quoting reused by compatible protocol subclasses. */
+export declare abstract class RpcUniswapV3Adapter extends UniswapV3Adapter {
+  #private;
+  getTicks(reference: Address, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
+  getSurroundingTicks(reference: Address, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
+  getPool(address: Address, options?: ReadOptions): Promise<V3PoolState>;
+  quote(request: SwapQuoteRequest<Address>, options?: ReadOptions): Promise<{
+    amountIn: bigint;
+    amountOut: bigint;
+  }>;
 }
-interface PrepareWithdrawRequest extends WithdrawRequest {
-  /** Integer basis points, from zero through 10,000. Explicitly chosen by the caller. */
-  readonly slippageBps: number;
+export declare class UniswapV3 extends RpcUniswapV3Adapter {
+  readonly protocol = AmmProtocol.Uniswap;
+  readonly version = UniswapVersion.V3;
 }
-/** Separate reward asset paid when a vault operation settles pre-existing shares. */
-interface VaultRewardPayout {
-  readonly token: Address;
-  readonly recipient: Address;
-  readonly amount: PoolTokenBalance;
+//#endregion
+//#region src/core/deployment.d.ts
+export interface DeploymentDefinition<TContracts extends ContractMap = ContractMap> {
+  readonly id: string;
+  readonly chainId: number;
+  readonly contracts: TContracts;
+  readonly dataAdapter: DataAdapterDefinition;
 }
-/** Reward paid to the shareholder during withdrawal. */
-type WithdrawRewards = VaultRewardPayout;
-/** Actual withdrawal simulation, including contract burn rounding and fee policy. */
-interface WithdrawPreview {
-  readonly rewardPayouts?: readonly VaultRewardPayout[];
-  readonly rewards?: WithdrawRewards;
-  readonly blockNumber: bigint;
-  readonly shares: bigint;
-  readonly token0: Address;
-  readonly token1: Address;
-  readonly amounts: TokenPairAmounts;
+export interface DeploymentReference<TAdapter, TContracts extends ContractMap = ContractMap, TContext extends ChainContext = ChainContext> {
+  readonly definition: DeploymentDefinition<TContracts>;
+  connect(context: TContext): TAdapter;
 }
-/** Unsigned transactions must be submitted by account on chainId. */
-interface WithdrawPlan extends TransactionPlan {
-  readonly account: Address;
-  readonly preview: WithdrawPreview;
-  readonly minimumAmounts: TokenPairAmounts;
+/** Import a deployment object for lookup; consumers do not look up free-form IDs. */
+export declare class Deployment<TAdapter, TContracts extends ContractMap = ContractMap, TContext extends ChainContext = ChainContext> implements DeploymentReference<TAdapter, TContracts, TContext> {
+  #private;
+  readonly definition: DeploymentDefinition<TContracts>;
+  constructor(definition: DeploymentDefinition<TContracts>, factory: (context: TContext, definition: DeploymentDefinition<TContracts>) => TAdapter);
+  connect(context: TContext): TAdapter;
 }
-/** Configured protocol relationships exist even when a vault has no active positions. */
-type VaultUnderlying = {
-  readonly kind: PositionKind.Liquidity;
-  readonly amm: AmmAdapter;
-  readonly pool: unknown;
-} | {
-  readonly kind: PositionKind.Lending;
-  readonly lending: LendingAdapter;
-  readonly market: unknown;
-};
-type StrategyPosition = (VaultUnderlying & {
-  readonly positionId: string;
-}) | {
-  readonly kind: PositionKind.Idle;
-  readonly balance: AssetAmount;
-};
-/** Token amounts use the snapshot's token ordering and decimals. */
-interface TokenPairAmounts {
-  readonly token0: PoolTokenBalance;
-  readonly token1: PoolTokenBalance;
+export declare class DeploymentRegistry<TBase> {
+  #private;
+  readonly context: ChainContext;
+  constructor(context: ChainContext, deployments: readonly DeploymentReference<TBase>[]);
+  get<TAdapter extends TBase>(deployment: DeploymentReference<TAdapter>): TAdapter;
+  list(): readonly DeploymentReference<TBase>[];
 }
-/** Both position fees and vault-wide sums use this structure. Recorded fees are part of gross. */
-interface LiquidityFees {
-  /** Collectible fees, including fee growth since the last checkpoint. */
-  readonly gross: TokenPairAmounts;
-  /** LP share after the verified implementation's fee cut and rounding policy. */
-  readonly net: TokenPairAmounts;
-  /** Gross fees already checkpointed in the pool's tokensOwed fields. */
-  readonly recorded: TokenPairAmounts;
+//#endregion
+//#region src/amm/adapters/uniswap-v4/types.d.ts
+interface V4PoolKey {
+  readonly currency0: Address;
+  readonly currency1: Address;
+  readonly fee: number;
+  readonly tickSpacing: number;
+  readonly hooks: Address;
 }
-/** V4 pools are identified by their key and manager, never an invented address. */
-interface V4VaultPool {
+type V4PoolReference = V4PoolKey | {
   readonly poolId: Hex;
-  readonly poolManager: Address;
-  readonly key: V4PoolKey;
+};
+type V4ReadOptions = PoolReadOptions;
+interface V4SwapQuoteRequest extends SwapQuoteRequest<V4PoolReference> {
+  readonly hookData?: Hex;
 }
-type LiquidityPool = Address | V4VaultPool;
-interface LiquidityPosition<TPool extends LiquidityPool = LiquidityPool> {
-  /** NFT checkpoint amounts excluded from LP fees/totals when the qualified vault cannot pay them out. */
-  readonly nftTokensOwed?: TokenPairAmounts;
-  readonly kind: PositionKind.Liquidity;
-  readonly amm: AmmAdapter;
-  readonly pool: TPool;
-  readonly positionId: string;
-  readonly lowerTick: number;
-  readonly upperTick: number;
-  /** Arbitrary relative units, not basis points. */
-  readonly relativeWeight: number;
-  /** Rounded down to 18 decimal places; undefined when all weights are zero. */
-  readonly weightPercent: string | undefined;
-  readonly liquidity: bigint;
-  readonly principal: TokenPairAmounts;
-  readonly fees: LiquidityFees;
-}
-/** Configured strategy ranges, which need not correspond one-to-one to active NFTs. */
-interface LiquidityPositionRange {
-  readonly lowerTick: number;
-  readonly upperTick: number;
-  readonly relativeWeight: number;
-  readonly weightPercent: string | undefined;
-}
-/** One reward asset, deduplicated by token even when base and bonus rewards overlap. */
-interface VaultRewardFee {
-  readonly identifier: string;
-  readonly recipient: Address;
-  readonly unpaid: PoolTokenBalance;
-  readonly unclaimed: PoolTokenBalance;
-}
-interface VaultRewardAsset {
-  readonly token: Address;
-  readonly decimals: number;
-  readonly balance: PoolTokenBalance;
-  readonly reservedFees: PoolTokenBalance;
-  /** Stored fees not attributed to the current fee identifiers, still excluded from LP holdings. */
-  readonly unattributedReservedFees: PoolTokenBalance;
-  readonly accumulatedPerShareX18: bigint;
-  readonly unclaimed: {
-    readonly gross: PoolTokenBalance;
-    readonly net: PoolTokenBalance;
-    readonly fee: PoolTokenBalance;
-  };
-  readonly feeRecipients: readonly VaultRewardFee[];
-}
-/** Separate reward-token accounting, never folded into proportional LP pair holdings. */
-interface LiquidityVaultRewards {
-  readonly token: Address;
-  readonly decimals: number;
-  readonly balance: PoolTokenBalance;
-  readonly accumulatedPerShareX18: bigint;
-  readonly totalSupply: bigint;
-  readonly unclaimed: {
-    readonly gross: PoolTokenBalance;
-    readonly net: PoolTokenBalance;
-    readonly steerFee: PoolTokenBalance;
-    readonly strategistFee: PoolTokenBalance;
-  };
-  readonly unpaidFees: {
-    readonly steer: PoolTokenBalance;
-    readonly strategist: PoolTokenBalance;
-  };
+interface V4DirectionalFees {
+  /** One pip is one millionth. */
+  readonly protocolFeePips: number;
+  readonly protocolFeePercent: string;
 }
-/** One result for every requested vault, preserving input order and duplicates. */
-type VaultLoadResult = {
-  readonly status: "success";
-  readonly vault: KnownSteerVault;
-} | {
-  readonly status: "failure";
-  readonly error: Error;
-};
-type VaultSnapshotResult = {
-  readonly status: "success";
-  readonly snapshot: LiquidityVaultSnapshot;
-} | {
-  readonly status: "failure";
-  readonly error: Error;
-};
-interface LiquidityVaultSnapshot<TPool extends LiquidityPool = LiquidityPool> {
-  readonly rewardAssets?: readonly VaultRewardAsset[];
-  readonly blockNumber: bigint;
-  /** Verified implementation at blockNumber, supplied by registered bulk snapshot readers. */
-  readonly implementation?: {
-    readonly address: Address;
-    readonly codeHash: Hex;
-    readonly beacon: Address;
-    /** Indexed descriptive name, not onchain identity evidence. */
-    readonly beaconName: string;
-  };
-  readonly pool: TPool;
-  readonly token0: Address;
-  readonly token1: Address;
-  readonly token0Decimals: number;
-  readonly token1Decimals: number;
-  readonly positions: readonly LiquidityPosition<TPool>[];
-  /** ERC-20 holdings, including already collected protocol/strategist fee reserves. */
-  readonly balances: TokenPairAmounts;
-  readonly reservedFees: TokenPairAmounts;
-  /** Already collected rewards excluded from idle when the reward asset overlaps the LP pair. */
-  readonly reservedRewards?: TokenPairAmounts;
-  readonly configuredPositions?: readonly LiquidityPositionRange[];
-  readonly rewards?: LiquidityVaultRewards;
-  readonly idle: TokenPairAmounts;
-  readonly principal: TokenPairAmounts;
-  readonly feeRateBps: number;
-  /** Sums of the corresponding fees across all positions. */
-  readonly fees: LiquidityFees;
-  /** Idle + principal + net uncollected fees. Accounting snapshot, not a withdrawal quote. */
-  readonly total: TokenPairAmounts;
+interface V4PoolFees {
+  /** Original key fee, including the dynamic-fee flag when set. */
+  readonly configuredFee: number;
+  /** Stored LP fee in millionths; hooks can override it during a swap. */
+  readonly lpFeePips: number;
+  readonly lpFeePercent: string;
+  /** Raw packed uint24 containing both directional protocol fees. */
+  readonly protocolFeePacked: number;
+  readonly currency0ToCurrency1: V4DirectionalFees;
+  readonly currency1ToCurrency0: V4DirectionalFees;
 }
-/** Same-block proportional accounting, not a withdrawal quote. Share amounts are raw ERC-20 units. */
-interface LiquidityVaultUserPosition<TPool extends LiquidityPool = LiquidityPool> {
+interface V4PoolState extends ConcentratedPoolState {
+  readonly key: V4PoolKey;
+  readonly poolId: Hex;
+  readonly poolManager: Address;
+  readonly currency0Decimals: number;
+  readonly currency1Decimals: number;
+  readonly currency0IsNative: boolean;
+  readonly currency1IsNative: boolean;
+  readonly price: PoolPrice;
+  readonly fees: V4PoolFees;
   readonly blockNumber: bigint;
-  readonly account: Address;
-  readonly pool: TPool;
-  readonly token0: Address;
-  readonly token1: Address;
-  readonly shares: bigint;
-  readonly totalSupply: bigint;
-  /** Rounded down to 18 decimal places; zero when totalSupply is zero. */
-  readonly ownershipPercent: string;
-  /** Proportional LP totals, including available idle, principal and net uncollected fees. */
-  readonly amounts: TokenPairAmounts;
 }
-/** One requested liquidity vault's same-block wallet holdings. */
-interface VaultUserPosition<TPool extends LiquidityPool = LiquidityPool> {
-  readonly vault: Address;
-  readonly position: LiquidityVaultUserPosition<TPool>;
+interface V4Contracts extends ContractMap {
+  readonly poolManager: ContractDeployment;
+  readonly stateView: ContractDeployment;
+  readonly quoter: ContractDeployment;
 }
-type KnownSteerVault = LiquidityVault | LendingVault | CompositeVault;
 //#endregion
-//#region src/data/adapter.d.ts
-export declare enum DataAdapterKind {
-  Subgraph = "subgraph",
-  Api = "api",
-  Rpc = "rpc"
-}
-/** Public endpoint metadata must not contain credentials. */
-export type DataAdapterDefinition = {
-  readonly kind: DataAdapterKind.Subgraph;
-  readonly url: string;
-} | {
-  readonly kind: DataAdapterKind.Api;
-  readonly url: string;
-} | {
-  readonly kind: DataAdapterKind.Rpc;
-};
-export declare abstract class DataAdapter {
-  readonly definition: DataAdapterDefinition;
-  constructor(definition: DataAdapterDefinition);
-  get subgraphUrl(): string | undefined;
+//#region src/amm/adapters/uniswap-v4/data-adapter.d.ts
+export declare abstract class V4PoolDataAdapter extends PoolDataAdapter<V4PoolKey> {
+  abstract getPoolKey(id: Hex, options?: V4ReadOptions): Promise<V4PoolKey>;
 }
-/** Per-request HTTP settings; credentials never become public adapter metadata. */
-export type DataAdapterRequestOptions = HttpRequestOptions;
-export interface TokenFilter {
-  readonly address?: Address;
-  /** Case-insensitive substring match. */
-  readonly symbol?: string;
-  /** Case-insensitive substring match. */
-  readonly name?: string;
+/** Indexed references carry full keys; every onchain use still validates the configured manager. */
+export declare class UniswapV4DataAdapter extends V4PoolDataAdapter {
+  #private;
+  constructor(definition: DataAdapterDefinition, manager: Address, context: ChainContext);
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<V4PoolKey>>;
+  getPoolKey(id: Hex, options?: V4ReadOptions): Promise<V4PoolKey>;
 }
-export type PoolTokenFilter = TokenFilter;
-export interface PoolListRequest extends PageRequest {
-  /** Matches either pool token. All supplied fields must match the same token. */
-  readonly token?: PoolTokenFilter;
+//#endregion
+//#region src/amm/adapters/uniswap-v4/adapter.d.ts
+export declare abstract class UniswapV4Adapter extends AmmAdapter<V4PoolReference, V4PoolState, V4Contracts, V4PoolKey> {
+  #private;
+  readonly dataAdapter: V4PoolDataAdapter;
+  readonly family = AmmFamily.UniswapV4;
+  constructor(context: ChainContext, deployment: DeploymentDefinition<V4Contracts>, dataAdapter: V4PoolDataAdapter);
+  getPoolId(key: V4PoolKey): Hex;
+  getPoolKey(id: Hex, options?: V4ReadOptions): Promise<V4PoolKey>;
+  getTicks(reference: V4PoolReference, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
+  getSurroundingTicks(reference: V4PoolReference, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
+  getPool(reference: V4PoolReference, options?: V4ReadOptions): Promise<V4PoolState>;
+  quote(request: V4SwapQuoteRequest, options?: V4ReadOptions): Promise<SwapQuote>;
 }
-export declare abstract class PoolDataAdapter<TPoolRef> extends DataAdapter {
-  abstract listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<TPoolRef>>;
+export declare class UniswapV4 extends UniswapV4Adapter {
+  readonly protocol = AmmProtocol.Uniswap;
+  readonly version = UniswapVersion.V4;
 }
-export declare abstract class LendingDataAdapter<TMarketRef> extends DataAdapter {
-  abstract listMarkets(request?: PageRequest): Promise<Page<TMarketRef>>;
+//#endregion
+//#region src/amm/adapters/uniswap-v4/errors.d.ts
+/** A verified absent key, rather than a failed provider or indexer request. */
+export declare class V4PoolKeyNotFoundError extends Error {
+  constructor(message?: string);
 }
-export declare abstract class SteerDataAdapter extends DataAdapter {
-  listUserVaults(_request: UserVaultListRequest, _options?: DataAdapterRequestOptions): Promise<UserVaultPage>;
-  getVaultMetadata(_addresses: readonly Address[], _options?: DataAdapterRequestOptions): Promise<readonly VaultMetadata[]>;
-  abstract listVaults(request?: VaultListRequest, options?: DataAdapterRequestOptions): Promise<Page<VaultMetadata>>;
+//#endregion
+//#region src/amm/adapters/pancakeswap-v3/adapter.d.ts
+/** Pancake V3 uses the V3 family with a wider slot0 protocol-fee field. */
+export declare class PancakeSwapV3 extends RpcUniswapV3Adapter {
+  readonly protocol = AmmProtocol.PancakeSwap;
+  readonly version = PancakeSwapVersion.V3;
 }
 //#endregion
-//#region src/amm/adapters/aerodrome/types.d.ts
-interface SlipstreamContracts extends ContractMap {
-  readonly factory: ContractDeployment;
-  readonly quoter: ContractDeployment;
-  readonly positionManager: ContractDeployment;
+//#region src/amm/adapters/retro-v3/adapter.d.ts
+export declare class RetroV3 extends RpcUniswapV3Adapter {
+  readonly protocol = AmmProtocol.Retro;
+  readonly version = RetroVersion.V3;
 }
-interface SlipstreamPoolFees {
-  /** Observed fee in millionths at the snapshot block, not a guarantee for a later swap. */
-  readonly swapFeePips: number;
-  readonly swapFeePercent: string;
-  /** Portion of unstaked LP trading fees allocated away, not an additional trader fee. */
-  readonly unstakedFeePips: number;
-  readonly unstakedFeePercent: string;
+//#endregion
+//#region src/amm/adapters/sushiswap-v3/adapter.d.ts
+export declare class SushiSwapV3 extends RpcUniswapV3Adapter {
+  readonly protocol = AmmProtocol.SushiSwap;
+  readonly version = SushiSwapVersion.V3;
 }
-interface SlipstreamPoolState extends ConcentratedPoolState {
-  readonly address: Address;
-  readonly factory: Address;
-  readonly token0: Address;
-  readonly token1: Address;
-  readonly token0Decimals: number;
-  readonly token1Decimals: number;
-  readonly tickSpacing: number;
-  /** Already included in liquidity. */
-  readonly stakedLiquidity: bigint;
-  readonly gauge: Address;
-  readonly positionManager: Address;
-  readonly fees: SlipstreamPoolFees;
-  readonly balances: {
-    readonly token0: PoolTokenBalance;
-    readonly token1: PoolTokenBalance;
+//#endregion
+//#region src/amm/selection.d.ts
+declare const ammDefinitions: {
+  readonly aerodrome: {
+    readonly slipstream: {
+      readonly adapter: typeof AerodromeSlipstream;
+      readonly family: AmmFamily.AerodromeSlipstream;
+    };
+    readonly "slipstream-v2": {
+      readonly adapter: typeof AerodromeSlipstreamV2;
+      readonly family: AmmFamily.AerodromeSlipstream;
+    };
+    readonly "slipstream-v3": {
+      readonly adapter: typeof AerodromeSlipstreamV3;
+      readonly family: AmmFamily.AerodromeSlipstream;
+    };
   };
-  readonly price: PoolPrice;
-  readonly blockNumber: bigint;
-}
-/** Optional caller for fee modules that apply transaction-origin discounts. */
-interface SlipstreamQuoteOptions extends ReadOptions {
-  readonly account?: Address;
-}
+  readonly sushiswap: {
+    readonly v3: {
+      readonly adapter: typeof SushiSwapV3;
+      readonly family: AmmFamily.UniswapV3;
+    };
+  };
+  readonly retro: {
+    readonly v3: {
+      readonly adapter: typeof RetroV3;
+      readonly family: AmmFamily.UniswapV3;
+    };
+  };
+  readonly uniswap: {
+    readonly v3: {
+      readonly adapter: typeof UniswapV3;
+      readonly family: AmmFamily.UniswapV3;
+    };
+    readonly v4: {
+      readonly adapter: typeof UniswapV4;
+      readonly family: AmmFamily.UniswapV4;
+    };
+  };
+  readonly quickswap: {
+    readonly v3: {
+      readonly adapter: typeof QuickSwap;
+      readonly family: AmmFamily.AlgebraLegacy;
+    };
+    readonly v4: {
+      readonly adapter: typeof QuickSwapIntegral;
+      readonly family: AmmFamily.AlgebraIntegral;
+    };
+  };
+  readonly blackhole: {
+    readonly cl: {
+      readonly adapter: typeof Blackhole;
+      readonly family: AmmFamily.AlgebraIntegral;
+    };
+  };
+  readonly camelot: {
+    readonly v3: {
+      readonly adapter: typeof Camelot;
+      readonly family: AmmFamily.AlgebraLegacy;
+    };
+  };
+  readonly pancakeswap: {
+    readonly v3: {
+      readonly adapter: typeof PancakeSwapV3;
+      readonly family: AmmFamily.UniswapV3;
+    };
+    readonly "infinity-cl": {
+      readonly adapter: typeof PancakeSwapInfinityCL;
+      readonly family: AmmFamily.PancakeSwapInfinityCL;
+    };
+  };
+};
 //#endregion
-//#region src/amm/adapters/aerodrome/adapter.d.ts
-/** Shared Slipstream contract behavior. Generations supply exact deployment bindings. */
-export declare abstract class AerodromeSlipstreamAdapter extends AmmAdapter<Address, SlipstreamPoolState, SlipstreamContracts> {
-  #private;
-  readonly family = AmmFamily.AerodromeSlipstream;
-  getPool(address: Address, options?: ReadOptions): Promise<SlipstreamPoolState>;
-  quote(request: SwapQuoteRequest<Address>, options?: SlipstreamQuoteOptions): Promise<Readonly<{
-    amountIn: bigint;
-    amountOut: bigint;
-  }>>;
-  getTicks(address: Address, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
-  getSurroundingTicks(address: Address, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
+//#region src/amm/types.d.ts
+type AmmVersion = AerodromeVersion | SushiSwapVersion | RetroVersion | UniswapVersion | QuickSwapVersion | BlackholeVersion | CamelotVersion | PancakeSwapVersion;
+type AdapterFromDefinition<T> = T extends {
+  readonly adapter: abstract new (...args: never[]) => infer TAdapter;
+} ? TAdapter : never;
+type RegisteredAmmAdapters = { -readonly [P in keyof typeof ammDefinitions]: { -readonly [V in keyof (typeof ammDefinitions)[P]]: AdapterFromDefinition<(typeof ammDefinitions)[P][V]>; }; };
+/** Protocol versions select concrete adapters; families remain an implementation detail. */
+interface AmmProtocolAdapters extends RegisteredAmmAdapters {}
+type AmmProtocolVersion<TProtocol extends AmmProtocol> = TProtocol extends AmmProtocol ? keyof AmmProtocolAdapters[TProtocol] : never;
+type AmmProtocolAdapter<TProtocol extends AmmProtocol, TVersion> = TProtocol extends AmmProtocol ? TVersion extends keyof AmmProtocolAdapters[TProtocol] ? AmmProtocolAdapters[TProtocol][TVersion] : never : never;
+interface AmmLookupRequest<TProtocol extends AmmProtocol, TVersion extends AmmProtocolVersion<TProtocol> = AmmProtocolVersion<TProtocol>> {
+  readonly chainId: number;
+  readonly protocol: TProtocol;
+  /** May be omitted only when the remaining selectors identify one deployment. */
+  readonly version?: TVersion;
+  readonly deployment?: AmmDeployment;
 }
-//#endregion
-//#region src/amm/adapters/aerodrome/data-adapter.d.ts
-/** Dedicated factory-bound endpoints. Indexed addresses still require native pool verification. */
-export declare class SlipstreamDataAdapter extends PoolDataAdapter<Address> {
-  #private;
-  constructor(definition: DataAdapterDefinition, factory: Address, indexerRequest?: HttpTransport, chainId?: number);
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<`0x${string}`>>;
+interface SwapQuoteRequest<TPoolRef> {
+  readonly pool: TPoolRef;
+  readonly inputCurrency: Address;
+  readonly outputCurrency: Address;
+  readonly amountIn: bigint;
 }
-//#endregion
-//#region src/amm/adapters/aerodrome/slipstream.d.ts
-export declare class AerodromeSlipstream extends AerodromeSlipstreamAdapter {
-  readonly protocol = AmmProtocol.Aerodrome;
-  readonly version = AerodromeVersion.Slipstream;
+interface SwapQuote {
+  readonly amountIn: bigint;
+  readonly amountOut: bigint;
 }
-//#endregion
-//#region src/amm/adapters/aerodrome/slipstream-v2.d.ts
-export declare class AerodromeSlipstreamV2 extends AerodromeSlipstreamAdapter {
-  readonly protocol = AmmProtocol.Aerodrome;
-  readonly version = AerodromeVersion.SlipstreamV2;
+interface PoolState {
+  /** Whether the pool's LP/swap fee mechanism supports changing fees. Not protocol-fee settings. */
+  readonly dynamicFee: boolean;
 }
-//#endregion
-//#region src/amm/adapters/aerodrome/slipstream-v3.d.ts
-export declare class AerodromeSlipstreamV3 extends AerodromeSlipstreamAdapter {
-  readonly protocol = AmmProtocol.Aerodrome;
-  readonly version = AerodromeVersion.SlipstreamV3;
+interface ConcentratedPoolState extends PoolState {
+  readonly sqrtPriceX96: bigint;
+  readonly tick: number;
+  readonly liquidity: bigint;
 }
-//#endregion
-//#region src/amm/adapters/algebra/types.d.ts
-interface AlgebraContracts extends ContractMap {
-  readonly factory: ContractDeployment;
-  readonly poolDeployer: ContractDeployment;
-  readonly quoter: ContractDeployment;
+interface PoolPrice {
+  /** Currency1 per whole currency0, as a decimal string. */
+  readonly currency0InCurrency1: string;
+  /** Currency0 per whole currency1, as a decimal string. */
+  readonly currency1InCurrency0: string;
 }
-/** Fields shared by qualified Algebra families; fee and plugin layouts remain family-specific. */
-interface AlgebraPoolState extends ConcentratedPoolState {
-  readonly address: Address;
-  readonly factory: Address;
-  readonly token0: Address;
-  readonly token1: Address;
-  readonly token0Decimals: number;
-  readonly token1Decimals: number;
-  readonly tickSpacing: number;
-  readonly price: PoolPrice;
-  readonly balances: {
-    readonly token0: PoolTokenBalance;
-    readonly token1: PoolTokenBalance;
-  };
-  readonly blockNumber: bigint;
+interface PoolTokenBalance {
+  readonly raw: bigint;
+  /** Exact decimal amount using the token's decimals, without scientific notation. */
+  readonly formatted: string;
 }
-//#endregion
-//#region src/amm/adapters/algebra-integral/types.d.ts
-/** Base pools accept an address. Custom pool listings carry their verified routing identity. */
-type AlgebraPoolReference = Address | {
+interface SlipstreamPoolLookupRequest extends ReadOptions {
+  readonly chainId: number;
+  readonly family: AmmFamily.AerodromeSlipstream;
   readonly address: Address;
-  readonly deployer: Address;
+}
+type SlipstreamPoolsLookupRequest = Omit<SlipstreamPoolLookupRequest, "address"> & {
+  readonly addresses: readonly Address[];
 };
-type AlgebraIntegralContracts = AlgebraContracts;
-interface AlgebraIntegralPoolState extends AlgebraPoolState {
-  /** Zero for a base pool; custom deployer for a custom pool. */
-  readonly deployer: Address;
-  readonly plugin: Address;
-  readonly pluginConfig: number;
-  readonly fees: {
-    /** Stored pool fee, which can be stale when dynamic fees are enabled. */
-    readonly lastFeePips: number;
-    readonly lastFeePercent: string;
-    /** Share of swap fees allocated to the community, in thousandths. */
-    readonly communityFeePermille: number;
-    readonly communityFeePercent: string;
-  };
+interface V3PoolLookupRequest extends ReadOptions {
+  readonly chainId: number;
+  readonly family: AmmFamily.UniswapV3;
+  readonly address: Address;
 }
-//#endregion
-//#region src/amm/adapters/algebra-integral/adapter.d.ts
-/** Integral 1.2-compatible contract behavior, shared by matching protocol deployments. */
-export declare abstract class AlgebraIntegralAdapter extends AmmAdapter<AlgebraPoolReference, AlgebraIntegralPoolState, AlgebraIntegralContracts> {
-  #private;
-  readonly family = AmmFamily.AlgebraIntegral;
-  getPool(reference: AlgebraPoolReference, options?: ReadOptions): Promise<AlgebraIntegralPoolState>;
-  getTicks(reference: AlgebraPoolReference, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
-  getSurroundingTicks(reference: AlgebraPoolReference, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
-  quote(request: SwapQuoteRequest<AlgebraPoolReference>, options?: ReadOptions): Promise<Readonly<{
-    amountIn: bigint;
-    amountOut: bigint;
-  }>>;
+interface V4PoolLookupRequest extends PoolReadOptions {
+  readonly chainId: number;
+  readonly family: AmmFamily.UniswapV4;
+  readonly reference: V4PoolReference;
+  readonly poolManager?: Address;
 }
-export declare class Blackhole extends AlgebraIntegralAdapter {
-  readonly protocol = AmmProtocol.Blackhole;
-  readonly version = BlackholeVersion.CL;
+interface AlgebraPoolLookupRequest extends ReadOptions {
+  readonly chainId: number;
+  readonly family: AmmFamily.AlgebraIntegral;
+  readonly reference: AlgebraPoolReference;
 }
-export declare class QuickSwapIntegral extends AlgebraIntegralAdapter {
-  readonly protocol = AmmProtocol.QuickSwap;
-  readonly version = QuickSwapVersion.V4;
+interface AlgebraLegacyPoolLookupRequest extends ReadOptions {
+  readonly chainId: number;
+  readonly family: AmmFamily.AlgebraLegacy;
+  readonly address: Address;
 }
-//#endregion
-//#region src/amm/adapters/algebra-integral/data-adapter.d.ts
-export declare class AlgebraIntegralDataAdapter extends PoolDataAdapter<AlgebraPoolReference> {
-  #private;
-  constructor(definition: DataAdapterDefinition, factory: Address, request?: HttpTransport);
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<AlgebraPoolReference>>;
+interface InfinityCLPoolLookupRequest extends PoolReadOptions {
+  readonly chainId: number;
+  readonly family: AmmFamily.PancakeSwapInfinityCL;
+  readonly reference: InfinityCLPoolReference;
+  readonly poolManager?: Address;
 }
-//#endregion
-//#region src/amm/adapters/algebra-legacy/types.d.ts
-type AlgebraLegacyContracts = AlgebraContracts;
-interface AlgebraSwapFee {
-  /** Stored fee, not a guarantee of the fee on the next swap. */
-  readonly lastFeePips: number;
-  readonly lastFeePercent: string;
+type PoolLookupRequest = SlipstreamPoolLookupRequest | InfinityCLPoolLookupRequest | AlgebraLegacyPoolLookupRequest | V3PoolLookupRequest | V4PoolLookupRequest | AlgebraPoolLookupRequest;
+type V3PoolsLookupRequest = Omit<V3PoolLookupRequest, "address"> & {
+  readonly addresses: readonly Address[];
+};
+type AlgebraLegacyPoolsLookupRequest = Omit<AlgebraLegacyPoolLookupRequest, "address"> & {
+  readonly addresses: readonly Address[];
+};
+type AlgebraPoolsLookupRequest = Omit<AlgebraPoolLookupRequest, "reference"> & {
+  readonly references: readonly AlgebraPoolReference[];
+};
+type V4PoolsLookupRequest = Omit<V4PoolLookupRequest, "reference"> & {
+  readonly references: readonly V4PoolReference[];
+};
+type InfinityCLPoolsLookupRequest = Omit<InfinityCLPoolLookupRequest, "reference"> & {
+  readonly references: readonly InfinityCLPoolReference[];
+};
+type PoolsLookupRequest = SlipstreamPoolsLookupRequest | V3PoolsLookupRequest | AlgebraLegacyPoolsLookupRequest | AlgebraPoolsLookupRequest | V4PoolsLookupRequest | InfinityCLPoolsLookupRequest;
+/** A verified discovery snapshot paired with the registered AMM used to read it. */
+type DiscoveredPool = (SlipstreamPoolState & {
+  readonly amm: AerodromeSlipstreamAdapter;
+}) | (V3PoolState & {
+  readonly amm: UniswapV3Adapter;
+}) | (V4PoolState & {
+  readonly amm: UniswapV4Adapter;
+}) | (AlgebraIntegralPoolState & {
+  readonly amm: AlgebraIntegralAdapter;
+}) | (AlgebraLegacyPoolState & {
+  readonly amm: AlgebraLegacyAdapter;
+}) | (InfinityCLPoolState & {
+  readonly amm: InfinityCLAdapter;
+});
+type PoolReadResult<TPool> = {
+  readonly status: "success";
+  readonly pool: TPool;
+} | {
+  readonly status: "failure";
+  readonly error: Error;
+};
+type PoolBatchReadOptions = PoolReadOptions & {
+  readonly allowFailure?: boolean;
+};
+type PoolReadOptions = ReadOptions & DataAdapterRequestOptions;
+interface TickLiquidity {
+  readonly tick: number;
+  readonly initialized: boolean;
+  readonly liquidityGross: bigint;
+  readonly liquidityNet: bigint;
 }
-interface AlgebraLegacyPoolState extends AlgebraPoolState {
-  readonly fees: {
-    readonly currency0ToCurrency1: AlgebraSwapFee;
-    readonly currency1ToCurrency0: AlgebraSwapFee;
-    readonly communityFeeToken0Permille: number;
-    readonly communityFeeToken1Permille: number;
-    readonly communityFeeToken0Percent: string;
-    readonly communityFeeToken1Percent: string;
-  };
+/** Mathematical pool state anchored to the tick reads' block. */
+interface TickPoolState extends ConcentratedPoolState {
+  readonly tickSpacing: number;
+  readonly currency0Decimals: number;
+  readonly currency1Decimals: number;
+  readonly blockNumber: bigint;
 }
-//#endregion
-//#region src/amm/adapters/algebra-legacy/adapter.d.ts
-/** Legacy V1-compatible contract behavior, shared by matching protocol deployments. */
-export declare abstract class AlgebraLegacyAdapter extends AmmAdapter<Address, AlgebraLegacyPoolState, AlgebraLegacyContracts> {
-  #private;
-  readonly family = AmmFamily.AlgebraLegacy;
-  getPool(reference: Address, options?: ReadOptions): Promise<AlgebraLegacyPoolState>;
-  getTicks(reference: Address, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
-  getSurroundingTicks(reference: Address, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
-  quote(request: SwapQuoteRequest<Address>, options?: ReadOptions): Promise<Readonly<{
-    amountIn: bigint;
-    amountOut: bigint;
-  }>>;
-}
-//#endregion
-//#region src/amm/adapters/algebra-legacy/directional.d.ts
-export declare abstract class AlgebraDirectionalAdapter extends AlgebraLegacyAdapter {}
-//#endregion
-//#region src/amm/adapters/algebra-legacy/camelot.d.ts
-export declare class Camelot extends AlgebraDirectionalAdapter {
-  readonly protocol = AmmProtocol.Camelot;
-  readonly version = CamelotVersion.V3;
-}
-//#endregion
-//#region src/amm/adapters/algebra-legacy/data-adapter.d.ts
-export declare class AlgebraLegacyDataAdapter extends PoolDataAdapter<Address> {
-  #private;
-  constructor(definition: DataAdapterDefinition, factory: Address, request?: HttpTransport);
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<`0x${string}`>>;
-}
-//#endregion
-//#region src/amm/adapters/algebra-legacy/quickswap.d.ts
-export declare class QuickSwap extends AlgebraLegacyAdapter {
-  readonly protocol = AmmProtocol.QuickSwap;
-  readonly version = QuickSwapVersion.V3;
-}
-//#endregion
-//#region src/amm/adapters/pancakeswap-infinity-cl/types.d.ts
-interface InfinityCLPoolKey {
-  readonly currency0: Address;
-  readonly currency1: Address;
-  readonly hooks: Address;
-  readonly poolManager: Address;
-  readonly fee: number;
-  readonly parameters: Hex;
-}
-interface InfinityCLPoolKeyInput extends Omit<InfinityCLPoolKey, "parameters"> {
-  readonly tickSpacing: number;
-  readonly hookPermissions?: number;
-}
-interface InfinityCLPoolIdReference {
-  readonly poolId: Hex;
+interface PoolTicks {
+  readonly pool: TickPoolState;
+  readonly ticks: readonly TickLiquidity[];
 }
-type InfinityCLPoolReference = InfinityCLPoolKey | InfinityCLPoolIdReference;
-interface InfinityCLSwapQuoteRequest extends SwapQuoteRequest<InfinityCLPoolReference> {
-  readonly hookData?: Hex;
+interface TickRange {
+  readonly lowerTick: number;
+  readonly upperTick: number;
 }
-interface InfinityCLDirectionalFees {
-  readonly protocolFeePips: number;
-  readonly protocolFeePercent: string;
+interface SurroundingTicks extends PoolTicks, TickRange {}
+interface LiquidityInterval extends TickRange {
+  readonly liquidityActive: bigint;
+  readonly sqrtPriceLowerX96: bigint;
+  readonly sqrtPriceUpperX96: bigint;
+  readonly lowerPrice: PoolPrice;
+  readonly upperPrice: PoolPrice;
 }
-interface InfinityCLPoolFees {
-  readonly configuredFee: number;
-  readonly lpFeePips: number;
-  readonly lpFeePercent: string;
-  readonly protocolFeePacked: number;
-  readonly currency0ToCurrency1: InfinityCLDirectionalFees;
-  readonly currency1ToCurrency0: InfinityCLDirectionalFees;
+interface LiquidityDistribution extends TickRange {
+  readonly pool: TickPoolState;
+  readonly intervals: readonly LiquidityInterval[];
 }
-interface InfinityCLPoolState extends ConcentratedPoolState {
-  readonly key: InfinityCLPoolKey;
-  readonly poolId: Hex;
-  readonly poolManager: Address;
-  readonly tickSpacing: number;
-  readonly currency0Decimals: number;
-  readonly currency1Decimals: number;
-  readonly currency0IsNative: boolean;
-  readonly currency1IsNative: boolean;
-  readonly price: PoolPrice;
-  readonly fees: InfinityCLPoolFees;
-  readonly blockNumber: bigint;
+interface LiquidityDepthRequest {
+  /** Decimal currency1 per whole currency0. Fees and hook execution are excluded. */
+  readonly fromPrice: string;
+  readonly toPrice: string;
 }
-interface InfinityCLContracts extends ContractMap {
-  readonly poolManager: ContractDeployment;
-  readonly vault: ContractDeployment;
-  readonly quoter: ContractDeployment;
+interface LiquidityDepth {
+  readonly amount0: PoolTokenBalance;
+  readonly amount1: PoolTokenBalance;
 }
 //#endregion
-//#region src/amm/adapters/pancakeswap-infinity-cl/adapter.d.ts
-export declare abstract class InfinityCLAdapter extends AmmAdapter<InfinityCLPoolReference, InfinityCLPoolState, InfinityCLContracts, InfinityCLPoolIdReference> {
-  #private;
-  readonly family = AmmFamily.PancakeSwapInfinityCL;
-  createPoolKey(input: InfinityCLPoolKeyInput): InfinityCLPoolKey;
-  getPoolId(key: InfinityCLPoolKey): Hex;
-  getPoolKey(id: Hex, options?: ReadOptions): Promise<InfinityCLPoolKey>;
-  getPool(reference: InfinityCLPoolReference, options?: ReadOptions): Promise<InfinityCLPoolState>;
-  getTicks(reference: InfinityCLPoolReference, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
-  getSurroundingTicks(reference: InfinityCLPoolReference, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
-  quote(request: InfinityCLSwapQuoteRequest, options?: PoolReadOptions): Promise<Readonly<{
-    amountIn: bigint;
-    amountOut: bigint;
-  }>>;
-}
-export declare class PancakeSwapInfinityCL extends InfinityCLAdapter {
-  readonly protocol = AmmProtocol.PancakeSwap;
-  readonly version = PancakeSwapVersion.InfinityCL;
+//#region src/amm/adapter.d.ts
+export declare abstract class AmmAdapter<TPoolRef = unknown, TPoolState = unknown, TContracts extends ContractMap = ContractMap, TListedRef extends TPoolRef = TPoolRef> {
+  readonly context: ChainContext;
+  readonly deployment: DeploymentDefinition<TContracts>;
+  readonly dataAdapter: PoolDataAdapter<TListedRef>;
+  abstract readonly family: AmmFamily;
+  abstract readonly protocol: AmmProtocol;
+  abstract readonly version: AmmVersion;
+  constructor(context: ChainContext, deployment: DeploymentDefinition<TContracts>, dataAdapter: PoolDataAdapter<TListedRef>);
+  get contracts(): TContracts;
+  get subgraphUrl(): string | undefined;
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<TListedRef>>;
+  abstract getTicks(reference: TPoolRef, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
+  abstract getSurroundingTicks(reference: TPoolRef, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
+  getLiquidityDistribution(reference: TPoolRef, range: TickRange, options?: PoolReadOptions): Promise<LiquidityDistribution>;
+  abstract quote(request: SwapQuoteRequest<TPoolRef>, options?: PoolReadOptions): Promise<SwapQuote>;
+  abstract getPool(reference: TPoolRef, options?: ReadOptions): Promise<TPoolState>;
+  /** Read snapshots at one block, preserving input order and duplicate references. */
+  getPools(references: readonly TPoolRef[], options: PoolReadOptions & {
+    allowFailure: true;
+  }): Promise<readonly PoolReadResult<TPoolState>[]>;
+  getPools(references: readonly TPoolRef[], options?: PoolReadOptions & {
+    allowFailure?: false;
+  }): Promise<readonly TPoolState[]>;
+  getPools(references: readonly TPoolRef[], options?: PoolBatchReadOptions): Promise<readonly TPoolState[] | readonly PoolReadResult<TPoolState>[]>;
 }
 //#endregion
-//#region src/amm/adapters/pancakeswap-infinity-cl/data-adapter.d.ts
-/** Listings return stable IDs; the manager resolves their canonical keys onchain. */
-export declare class PancakeSwapInfinityCLDataAdapter extends PoolDataAdapter<InfinityCLPoolIdReference> {
+//#region src/amm/adapters/pancakeswap-v3/data-adapter.d.ts
+export declare class PancakeSwapV3DataAdapter extends PoolDataAdapter<Address> {
   #private;
-  constructor(definition: DataAdapterDefinition, manager: Address, indexerRequest?: HttpTransport);
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<InfinityCLPoolIdReference>>;
+  constructor(definition: DataAdapterDefinition, factory: Address, indexerRequest?: HttpTransport);
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<`0x${string}`>>;
 }
 //#endregion
-//#region src/amm/adapters/uniswap-v3/types.d.ts
-interface V3PoolFees {
-  /** Fixed swap fee in millionths, including any protocol share deducted from it. */
-  readonly swapFeePips: number;
-  /** Percentage, e.g. "0.05" for 500 pips, without a percent sign. */
-  readonly swapFeePercent: string;
-}
-interface V3PoolState extends ConcentratedPoolState {
-  readonly address: Address;
-  readonly factory: Address;
-  readonly token0: Address;
-  readonly token1: Address;
-  readonly fees: V3PoolFees;
-  readonly token0Decimals: number;
-  readonly token1Decimals: number;
-  /** Actual pool-contract balances, including any fees or donated tokens it holds. */
-  readonly balances: {
-    readonly token0: PoolTokenBalance;
-    readonly token1: PoolTokenBalance;
-  };
-  /** 36 significant digits, rounded down. Undefined for an uninitialized pool. */
-  readonly price: PoolPrice | undefined;
-  readonly tickSpacing: number;
-  readonly blockNumber: bigint;
-}
-interface V3Contracts extends ContractMap {
-  readonly factory: ContractDeployment;
+//#region src/amm/adapters/uniswap-v3/data-adapter.d.ts
+export declare class UniswapV3DataAdapter extends PoolDataAdapter<Address> {
+  #private;
+  constructor(definition: DataAdapterDefinition, factory: Address, indexerRequest?: HttpTransport);
+  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<Address>>;
 }
 //#endregion
-//#region src/amm/adapters/uniswap-v3/base.d.ts
-/** A compatible deployment reuses this class; a behavioral fork may subclass it. */
-export declare abstract class UniswapV3Adapter extends AmmAdapter<Address, V3PoolState, V3Contracts> {
-  readonly family = AmmFamily.UniswapV3;
-}
+//#region src/amm/ticks/distribution.d.ts
+/** Reconstruct intervals from the stored current tick, including its exact boundary-side semantics. */
+export declare function buildLiquidityDistribution(window: SurroundingTicks): LiquidityDistribution;
+/** Fee-free geometric depth. Does not simulate swaps or hooks; amounts round down per interval. */
+export declare function calculateLiquidityDepth(distribution: LiquidityDistribution, request: LiquidityDepthRequest): LiquidityDepth;
 //#endregion
-//#region src/amm/adapters/uniswap-v3/adapter.d.ts
-/** Standard V3 reads and quoting reused by compatible protocol subclasses. */
-export declare abstract class RpcUniswapV3Adapter extends UniswapV3Adapter {
-  #private;
-  getTicks(reference: Address, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
-  getSurroundingTicks(reference: Address, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
-  getPool(address: Address, options?: ReadOptions): Promise<V3PoolState>;
-  quote(request: SwapQuoteRequest<Address>, options?: ReadOptions): Promise<{
-    amountIn: bigint;
-    amountOut: bigint;
+//#region src/contracts/apechain.d.ts
+export declare const apechainContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x245194Ed39516431FF511A74c7B6Df4cb4b5F1F3";
+    startBlock: 643298n;
   }>;
-}
-export declare class UniswapV3 extends RpcUniswapV3Adapter {
-  readonly protocol = AmmProtocol.Uniswap;
-  readonly version = UniswapVersion.V3;
-}
-//#endregion
-//#region src/amm/adapters/pancakeswap-v3/adapter.d.ts
-/** Pancake V3 uses the V3 family with a wider slot0 protocol-fee field. */
-export declare class PancakeSwapV3 extends RpcUniswapV3Adapter {
-  readonly protocol = AmmProtocol.PancakeSwap;
-  readonly version = PancakeSwapVersion.V3;
-}
+  CamelotMultiPositionLiquidityManager: Readonly<{
+    address: "0x116Dba5DcE9CcDA828218b7eB46406810632014C";
+    startBlock: 643002n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
+    startBlock: 643030n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xd5532a58E4ABB6485FF4e7BCf5bED278e32A516e";
+    startBlock: 643272n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 642937n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 642981n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 642883n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 642917n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xd47CE509bE01e62cd4629E2f1eb22BA04e7dA192";
+  }>;
+}>;
 //#endregion
-//#region src/amm/adapters/retro-v3/adapter.d.ts
-export declare class RetroV3 extends RpcUniswapV3Adapter {
-  readonly protocol = AmmProtocol.Retro;
-  readonly version = RetroVersion.V3;
-}
+//#region src/contracts/arbitrum.d.ts
+export declare const arbitrumContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x279228AAfd13Bb4642ABB772a248c78555DC39c4";
+    startBlock: 88699181n;
+  }>;
+  CamelotMultiPositionLiquidityManager: Readonly<{
+    address: "0xa2C286BD8E5d2cBA08674ACD202b37d9F922026f";
+    startBlock: 151369116n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x16BA7102271dC83Fff2f709691c2B601DAD7668e";
+    startBlock: 88699087n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
+    startBlock: 88699141n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xd964811233b8A0185D3C93664df82136C80d1bb2";
+    startBlock: 88698868n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
+    startBlock: 88698956n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 88698828n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 88698903n;
+  }>;
+  Helper: Readonly<{
+    address: "0xd1b49Bb21d2c2638CFDdf4B2dC8dbC61DCBCe0ee";
+    startBlock: 367658396n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0x122126e397677cfd6476c531416b7cbec74c06c8";
+    startBlock: 367649306n;
+  }>;
+  PoolHelper: Readonly<{
+    address: "0x657bB5fD00e6D6BdA438988DcaF5B62Ef16F6163";
+    startBlock: 256472779n;
+  }>;
+}>;
 //#endregion
-//#region src/amm/adapters/sushiswap-v3/adapter.d.ts
-export declare class SushiSwapV3 extends RpcUniswapV3Adapter {
-  readonly protocol = AmmProtocol.SushiSwap;
-  readonly version = SushiSwapVersion.V3;
-}
+//#region src/contracts/arc.d.ts
+export declare const arcContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0xE463a4A82881EF599fe8310f23ba8766Dcc448A3";
+    startBlock: 21326564n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x8725f2f77508EDd583C6f3840F88Db6A2d0Cf009";
+    startBlock: 21326605n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x08857cb7B2a481DB85984E32BdC03e95c0662eb6";
+    startBlock: 21326585n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x52Db9bcb9EFdBAaa8E1D2326E0b69c57Bf14c333";
+    startBlock: 21326644n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x6511080422911D210681f5618DBd50DEC3e954de";
+    startBlock: 21326748n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x0a271fc23BA4c6A4a668E7Ceef9aDE60C59f5Ec5";
+    startBlock: 21326697n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0x20B895F7C02e754AdC461e80b39a9e85f02e2bE3";
+    startBlock: 21326621n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x3e2135a491CD90Ed1e7313Bd8Efd51aba8018F69";
+    startBlock: 21326728n;
+  }>;
+  StakingRewards: Readonly<{
+    address: "0xfdC6A32f2622be7Bf1481BFAC8bC6e35C42fD665";
+    startBlock: 21326676n;
+  }>;
+  Helper: Readonly<{
+    address: "0xCD31EbF762A5d1F88399E692316903767DA06Cf9";
+    startBlock: 21326630n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x83966243D6055b1A1157f800cBC9f5084162b871";
+    startBlock: 21326767n;
+  }>;
+}>;
 //#endregion
-//#region src/amm/adapters/uniswap-v4/data-adapter.d.ts
-/** Data providers for the V4 family return complete keys and resolve IDs. */
-export declare abstract class V4PoolDataAdapter extends PoolDataAdapter<V4PoolKey> {
-  abstract getPoolKey(id: Hex, options?: V4ReadOptions): Promise<V4PoolKey>;
-}
-/** Indexed references carry full keys; every onchain use still validates the configured manager. */
-export declare class UniswapV4DataAdapter extends V4PoolDataAdapter {
-  #private;
-  constructor(definition: DataAdapterDefinition, manager: Address, context: ChainContext);
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<V4PoolKey>>;
-  getPoolKey(id: Hex, options?: V4ReadOptions): Promise<V4PoolKey>;
-}
+//#region src/contracts/astar.d.ts
+export declare const astarContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x7Daa68204232a78dBF1Dd853a4018330EE934A39";
+    startBlock: 5466115n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xe1C56f99a459ED47B629F3D818BcC84826bCed66";
+    startBlock: 5465971n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x1afD31627170607657224eD4aE701470209C4B2e";
+    startBlock: 5466109n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 5465955n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
+    startBlock: 5465965n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 5465944n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 5465950n;
+  }>;
+}>;
 //#endregion
-//#region src/amm/adapters/uniswap-v4/adapter.d.ts
-/** Standard manager-based V4 reads and quotes, reusable by compatible deployments. */
-export declare abstract class UniswapV4Adapter extends AmmAdapter<V4PoolReference, V4PoolState, V4Contracts, V4PoolKey> {
-  #private;
-  readonly dataAdapter: V4PoolDataAdapter;
-  readonly family = AmmFamily.UniswapV4;
-  constructor(context: ChainContext, deployment: DeploymentDefinition<V4Contracts>, dataAdapter: V4PoolDataAdapter);
-  getPoolId(key: V4PoolKey): Hex;
-  getPoolKey(id: Hex, options?: V4ReadOptions): Promise<V4PoolKey>;
-  getTicks(reference: V4PoolReference, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
-  getSurroundingTicks(reference: V4PoolReference, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
-  getPool(reference: V4PoolReference, options?: V4ReadOptions): Promise<V4PoolState>;
-  quote(request: V4SwapQuoteRequest, options?: V4ReadOptions): Promise<SwapQuote>;
-}
-/** Uniswap deployments reuse the family implementation unchanged. */
-export declare class UniswapV4 extends UniswapV4Adapter {
-  readonly protocol = AmmProtocol.Uniswap;
-  readonly version = UniswapVersion.V4;
-}
+//#region src/contracts/astarzkevm.d.ts
+export declare const astarZkEvmContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xD40699A642172DeD33BCFe4E3F84D54610C757Cd";
+    startBlock: 215291n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
+    startBlock: 215237n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x37Cff062D52Dd6E9E39Df619CCd30c037a36bB83";
+    startBlock: 215281n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 210939n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 210954n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x99eca0E5Db125900E3a0389F6D3503837e99F59b";
+    startBlock: 210922n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 210932n;
+  }>;
+}>;
 //#endregion
-//#region src/amm/adapters/uniswap-v4/errors.d.ts
-/** A verified absent key, rather than a failed provider or indexer request. */
-export declare class V4PoolKeyNotFoundError extends Error {
-  constructor(message?: string);
-}
+//#region src/contracts/avalanche.d.ts
+export declare const avalancheContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 30433379n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 30433780n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 30433735n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
+    startBlock: 30434642n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x87A37bEEcE2918A342F95773Bea7cAA6823c6DC3";
+    startBlock: 30435305n;
+  }>;
+  DynamicJobs: Readonly<{
+    address: "0x7c464A0AB1f5ebf3E2dCccfec7EF41D02ED7a2f4";
+    startBlock: 30435322n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 30434925n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 30434591n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x5D8249e3F5f702e1Fd720167b40424fc2daDCd1e";
+    startBlock: 30435289n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x391cf3047db983caB8dD95B16c4e6C3918d72d23";
+  }>;
+}>;
 //#endregion
-//#region src/amm/types.d.ts
-type AmmVersion = AerodromeVersion | SushiSwapVersion | RetroVersion | UniswapVersion | QuickSwapVersion | BlackholeVersion | CamelotVersion | PancakeSwapVersion;
-/** Protocol versions select concrete adapters; families remain an implementation detail. */
-interface AmmProtocolAdapters {
-  [AmmProtocol.Blackhole]: {
-    [BlackholeVersion.CL]: Blackhole;
-  };
-  [AmmProtocol.Aerodrome]: {
-    [AerodromeVersion.Slipstream]: AerodromeSlipstream;
-    [AerodromeVersion.SlipstreamV2]: AerodromeSlipstreamV2;
-    [AerodromeVersion.SlipstreamV3]: AerodromeSlipstreamV3;
-  };
-  [AmmProtocol.SushiSwap]: {
-    [SushiSwapVersion.V3]: SushiSwapV3;
-  };
-  [AmmProtocol.Retro]: {
-    [RetroVersion.V3]: RetroV3;
-  };
-  [AmmProtocol.Uniswap]: {
-    [UniswapVersion.V3]: UniswapV3;
-    [UniswapVersion.V4]: UniswapV4;
-  };
-  [AmmProtocol.QuickSwap]: {
-    [QuickSwapVersion.V3]: QuickSwap;
-    [QuickSwapVersion.V4]: QuickSwapIntegral;
-  };
-  [AmmProtocol.Camelot]: {
-    [CamelotVersion.V3]: Camelot;
-  };
-  [AmmProtocol.PancakeSwap]: {
-    [PancakeSwapVersion.V3]: PancakeSwapV3;
-    [PancakeSwapVersion.InfinityCL]: PancakeSwapInfinityCL;
-  };
-}
-type AmmProtocolVersion<TProtocol extends AmmProtocol> = TProtocol extends AmmProtocol ? keyof AmmProtocolAdapters[TProtocol] : never;
-type AmmProtocolAdapter<TProtocol extends AmmProtocol, TVersion> = TProtocol extends AmmProtocol ? TVersion extends keyof AmmProtocolAdapters[TProtocol] ? AmmProtocolAdapters[TProtocol][TVersion] : never : never;
-interface AmmLookupRequest<TProtocol extends AmmProtocol, TVersion extends AmmProtocolVersion<TProtocol> = AmmProtocolVersion<TProtocol>> {
-  readonly chainId: number;
-  readonly protocol: TProtocol;
-  /** May be omitted only when the remaining selectors identify one deployment. */
-  readonly version?: TVersion;
-  readonly deployment?: AmmDeployment;
-}
-interface SwapQuoteRequest<TPoolRef> {
-  readonly pool: TPoolRef;
-  readonly inputCurrency: Address;
-  readonly outputCurrency: Address;
-  readonly amountIn: bigint;
-}
-interface SwapQuote {
-  readonly amountIn: bigint;
-  readonly amountOut: bigint;
-}
-interface PoolState {
-  /** Whether the pool's LP/swap fee mechanism supports changing fees. Not protocol-fee settings. */
-  readonly dynamicFee: boolean;
-}
-interface ConcentratedPoolState extends PoolState {
-  readonly sqrtPriceX96: bigint;
-  readonly tick: number;
-  readonly liquidity: bigint;
-}
-interface PoolPrice {
-  /** Currency1 per whole currency0, as a decimal string. */
-  readonly currency0InCurrency1: string;
-  /** Currency0 per whole currency1, as a decimal string. */
-  readonly currency1InCurrency0: string;
-}
-interface PoolTokenBalance {
-  readonly raw: bigint;
-  /** Exact decimal amount using the token's decimals, without scientific notation. */
-  readonly formatted: string;
-}
-interface SlipstreamPoolLookupRequest extends ReadOptions {
-  readonly chainId: number;
-  readonly family: AmmFamily.AerodromeSlipstream;
-  readonly address: Address;
-}
-type SlipstreamPoolsLookupRequest = Omit<SlipstreamPoolLookupRequest, "address"> & {
-  readonly addresses: readonly Address[];
-};
-interface V3PoolLookupRequest extends ReadOptions {
-  readonly chainId: number;
-  readonly family: AmmFamily.UniswapV3;
-  readonly address: Address;
-}
-interface V4PoolLookupRequest extends PoolReadOptions {
-  readonly chainId: number;
-  readonly family: AmmFamily.UniswapV4;
-  readonly reference: V4PoolReference;
-  readonly poolManager?: Address;
-}
-interface AlgebraPoolLookupRequest extends ReadOptions {
-  readonly chainId: number;
-  readonly family: AmmFamily.AlgebraIntegral;
-  readonly reference: AlgebraPoolReference;
-}
-interface AlgebraLegacyPoolLookupRequest extends ReadOptions {
-  readonly chainId: number;
-  readonly family: AmmFamily.AlgebraLegacy;
-  readonly address: Address;
-}
-interface InfinityCLPoolLookupRequest extends PoolReadOptions {
-  readonly chainId: number;
-  readonly family: AmmFamily.PancakeSwapInfinityCL;
-  readonly reference: InfinityCLPoolReference;
-  readonly poolManager?: Address;
-}
-type PoolLookupRequest = SlipstreamPoolLookupRequest | InfinityCLPoolLookupRequest | AlgebraLegacyPoolLookupRequest | V3PoolLookupRequest | V4PoolLookupRequest | AlgebraPoolLookupRequest;
-type V3PoolsLookupRequest = Omit<V3PoolLookupRequest, "address"> & {
-  readonly addresses: readonly Address[];
-};
-type AlgebraLegacyPoolsLookupRequest = Omit<AlgebraLegacyPoolLookupRequest, "address"> & {
-  readonly addresses: readonly Address[];
-};
-type AlgebraPoolsLookupRequest = Omit<AlgebraPoolLookupRequest, "reference"> & {
-  readonly references: readonly AlgebraPoolReference[];
-};
-type V4PoolsLookupRequest = Omit<V4PoolLookupRequest, "reference"> & {
-  readonly references: readonly V4PoolReference[];
-};
-type InfinityCLPoolsLookupRequest = Omit<InfinityCLPoolLookupRequest, "reference"> & {
-  readonly references: readonly InfinityCLPoolReference[];
-};
-type PoolsLookupRequest = SlipstreamPoolsLookupRequest | V3PoolsLookupRequest | AlgebraLegacyPoolsLookupRequest | AlgebraPoolsLookupRequest | V4PoolsLookupRequest | InfinityCLPoolsLookupRequest;
-/** A verified discovery snapshot paired with the registered AMM used to read it. */
-type DiscoveredPool = (SlipstreamPoolState & {
-  readonly amm: AerodromeSlipstreamAdapter;
-}) | (V3PoolState & {
-  readonly amm: UniswapV3Adapter;
-}) | (V4PoolState & {
-  readonly amm: UniswapV4Adapter;
-}) | (AlgebraIntegralPoolState & {
-  readonly amm: AlgebraIntegralAdapter;
-}) | (AlgebraLegacyPoolState & {
-  readonly amm: AlgebraLegacyAdapter;
-}) | (InfinityCLPoolState & {
-  readonly amm: InfinityCLAdapter;
-});
-type PoolReadResult<TPool> = {
-  readonly status: "success";
-  readonly pool: TPool;
-} | {
-  readonly status: "failure";
-  readonly error: Error;
-};
-type PoolBatchReadOptions = PoolReadOptions & {
-  readonly allowFailure?: boolean;
-};
-type PoolReadOptions = ReadOptions & DataAdapterRequestOptions;
-interface TickLiquidity {
-  readonly tick: number;
-  readonly initialized: boolean;
-  readonly liquidityGross: bigint;
-  readonly liquidityNet: bigint;
-}
-/** Mathematical pool state anchored to the tick reads' block. */
-interface TickPoolState extends ConcentratedPoolState {
-  readonly tickSpacing: number;
-  readonly currency0Decimals: number;
-  readonly currency1Decimals: number;
-  readonly blockNumber: bigint;
-}
-interface PoolTicks {
-  readonly pool: TickPoolState;
-  readonly ticks: readonly TickLiquidity[];
-}
-interface TickRange {
-  readonly lowerTick: number;
-  readonly upperTick: number;
-}
-interface SurroundingTicks extends PoolTicks, TickRange {}
-interface LiquidityInterval extends TickRange {
-  readonly liquidityActive: bigint;
-  readonly sqrtPriceLowerX96: bigint;
-  readonly sqrtPriceUpperX96: bigint;
-  readonly lowerPrice: PoolPrice;
-  readonly upperPrice: PoolPrice;
-}
-interface LiquidityDistribution extends TickRange {
-  readonly pool: TickPoolState;
-  readonly intervals: readonly LiquidityInterval[];
-}
-interface LiquidityDepthRequest {
-  /** Decimal currency1 per whole currency0. Fees and hook execution are excluded. */
-  readonly fromPrice: string;
-  readonly toPrice: string;
-}
-interface LiquidityDepth {
-  readonly amount0: PoolTokenBalance;
-  readonly amount1: PoolTokenBalance;
-}
-//#endregion
-//#region src/amm/adapter.d.ts
-export declare abstract class AmmAdapter<TPoolRef = unknown, TPoolState = unknown, TContracts extends ContractMap = ContractMap, TListedRef extends TPoolRef = TPoolRef> {
-  readonly context: ChainContext;
-  readonly deployment: DeploymentDefinition<TContracts>;
-  readonly dataAdapter: PoolDataAdapter<TListedRef>;
-  abstract readonly family: AmmFamily;
-  abstract readonly protocol: AmmProtocol;
-  abstract readonly version: AmmVersion;
-  constructor(context: ChainContext, deployment: DeploymentDefinition<TContracts>, dataAdapter: PoolDataAdapter<TListedRef>);
-  get contracts(): TContracts;
-  get subgraphUrl(): string | undefined;
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<TListedRef>>;
-  abstract getTicks(reference: TPoolRef, ticks: readonly number[], options?: PoolReadOptions): Promise<PoolTicks>;
-  abstract getSurroundingTicks(reference: TPoolRef, range: TickRange, options?: PoolReadOptions): Promise<SurroundingTicks>;
-  getLiquidityDistribution(reference: TPoolRef, range: TickRange, options?: PoolReadOptions): Promise<LiquidityDistribution>;
-  abstract quote(request: SwapQuoteRequest<TPoolRef>, options?: PoolReadOptions): Promise<SwapQuote>;
-  abstract getPool(reference: TPoolRef, options?: ReadOptions): Promise<TPoolState>;
-  /** Read snapshots at one block, preserving input order and duplicate references. */
-  getPools(references: readonly TPoolRef[], options: PoolReadOptions & {
-    allowFailure: true;
-  }): Promise<readonly PoolReadResult<TPoolState>[]>;
-  getPools(references: readonly TPoolRef[], options?: PoolReadOptions & {
-    allowFailure?: false;
-  }): Promise<readonly TPoolState[]>;
-  getPools(references: readonly TPoolRef[], options?: PoolBatchReadOptions): Promise<readonly TPoolState[] | readonly PoolReadResult<TPoolState>[]>;
-}
-//#endregion
-//#region src/amm/adapters/pancakeswap-v3/data-adapter.d.ts
-export declare class PancakeSwapV3DataAdapter extends PoolDataAdapter<Address> {
-  #private;
-  constructor(definition: DataAdapterDefinition, factory: Address, indexerRequest?: HttpTransport);
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<`0x${string}`>>;
-}
-//#endregion
-//#region src/amm/ticks/distribution.d.ts
-/** Reconstruct intervals from the stored current tick, including its exact boundary-side semantics. */
-export declare function buildLiquidityDistribution(window: SurroundingTicks): LiquidityDistribution;
-/** Fee-free geometric depth. Does not simulate swaps or hooks; amounts round down per interval. */
-export declare function calculateLiquidityDepth(distribution: LiquidityDistribution, request: LiquidityDepthRequest): LiquidityDepth;
-//#endregion
-//#region src/contracts/apechain.d.ts
-export declare const apechainContracts: Readonly<{
+//#region src/contracts/base.d.ts
+export declare const baseContracts: Readonly<{
   BundleRegistry: Readonly<{
-    address: "0x245194Ed39516431FF511A74c7B6Df4cb4b5F1F3";
-    startBlock: 643298n;
-  }>;
-  CamelotMultiPositionLiquidityManager: Readonly<{
-    address: "0x116Dba5DcE9CcDA828218b7eB46406810632014C";
-    startBlock: 643002n;
+    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
+    startBlock: 2092242n;
   }>;
   GasVault: Readonly<{
-    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
-    startBlock: 643030n;
+    address: "0x3B41454CB7858B6D0535e61bAe9362AF0151Cc2d";
+    startBlock: 2092217n;
   }>;
   SteerPeriphery: Readonly<{
-    address: "0xd5532a58E4ABB6485FF4e7BCf5bED278e32A516e";
-    startBlock: 643272n;
+    address: "0x16BA7102271dC83Fff2f709691c2B601DAD7668e";
+    startBlock: 2092232n;
   }>;
   StrategyRegistry: Readonly<{
-    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
-    startBlock: 642937n;
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 2092162n;
   }>;
   VaultRegistry: Readonly<{
-    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
-    startBlock: 642981n;
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 2092181n;
   }>;
   KeeperRegistry: Readonly<{
     address: "0x1A7e75715d157736103eC429Ff7079994D907472";
-    startBlock: 642883n;
+    startBlock: 2092152n;
   }>;
   Orchestrator: Readonly<{
-    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
-    startBlock: 642917n;
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 2092171n;
+  }>;
+  Helper: Readonly<{
+    address: "0xa98376572375692455172f6750C67339667974fe";
+    startBlock: 17910406n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0x588B34D2a9598497f481A9d31B4eD372C6135f32";
+    startBlock: 48700149n;
+  }>;
+  PoolHelper: Readonly<{
+    address: "0x603823Ad53c1C7D402c5A20CD1B05488Dafc2646";
+    startBlock: 20147258n;
   }>;
   FeeManager: Readonly<{
-    address: "0xd47CE509bE01e62cd4629E2f1eb22BA04e7dA192";
+    address: "0xac4D51669B80D09d8Cc5EeFF50026c4d1D3290e6";
   }>;
 }>;
 //#endregion
-//#region src/contracts/arbitrum.d.ts
-export declare const arbitrumContracts: Readonly<{
+//#region src/contracts/bera.d.ts
+export declare const beraContracts: Readonly<{
   BundleRegistry: Readonly<{
-    address: "0x279228AAfd13Bb4642ABB772a248c78555DC39c4";
-    startBlock: 88699181n;
-  }>;
-  CamelotMultiPositionLiquidityManager: Readonly<{
-    address: "0xa2C286BD8E5d2cBA08674ACD202b37d9F922026f";
-    startBlock: 151369116n;
+    address: "0x6d5A04974ba2CdC3E307135fE5886b8c7C499e9A";
+    startBlock: 785307n;
   }>;
   GasVault: Readonly<{
-    address: "0x16BA7102271dC83Fff2f709691c2B601DAD7668e";
-    startBlock: 88699087n;
-  }>;
-  SteerPeriphery: Readonly<{
-    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
-    startBlock: 88699141n;
-  }>;
-  StrategyRegistry: Readonly<{
-    address: "0xd964811233b8A0185D3C93664df82136C80d1bb2";
-    startBlock: 88698868n;
-  }>;
-  VaultRegistry: Readonly<{
-    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
-    startBlock: 88698956n;
-  }>;
-  KeeperRegistry: Readonly<{
-    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
-    startBlock: 88698828n;
-  }>;
-  Orchestrator: Readonly<{
-    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
-    startBlock: 88698903n;
-  }>;
-  Helper: Readonly<{
-    address: "0xd1b49Bb21d2c2638CFDdf4B2dC8dbC61DCBCe0ee";
-    startBlock: 367658396n;
-  }>;
-  SingleAssetDeposit: Readonly<{
-    address: "0x122126e397677cfd6476c531416b7cbec74c06c8";
-    startBlock: 367649306n;
-  }>;
-  PoolHelper: Readonly<{
-    address: "0x657bB5fD00e6D6BdA438988DcaF5B62Ef16F6163";
-    startBlock: 256472779n;
-  }>;
-}>;
-//#endregion
-//#region src/contracts/arc.d.ts
-export declare const arcContracts: Readonly<{
-  KeeperRegistry: Readonly<{
-    address: "0xE463a4A82881EF599fe8310f23ba8766Dcc448A3";
-    startBlock: 21326564n;
-  }>;
-  Orchestrator: Readonly<{
-    address: "0x8725f2f77508EDd583C6f3840F88Db6A2d0Cf009";
-    startBlock: 21326605n;
-  }>;
-  StrategyRegistry: Readonly<{
-    address: "0x08857cb7B2a481DB85984E32BdC03e95c0662eb6";
-    startBlock: 21326585n;
-  }>;
-  VaultRegistry: Readonly<{
-    address: "0x52Db9bcb9EFdBAaa8E1D2326E0b69c57Bf14c333";
-    startBlock: 21326644n;
-  }>;
-  BundleRegistry: Readonly<{
-    address: "0x6511080422911D210681f5618DBd50DEC3e954de";
-    startBlock: 21326748n;
-  }>;
-  GasVault: Readonly<{
-    address: "0x0a271fc23BA4c6A4a668E7Ceef9aDE60C59f5Ec5";
-    startBlock: 21326697n;
-  }>;
-  WhitelistRegistry: Readonly<{
-    address: "0x20B895F7C02e754AdC461e80b39a9e85f02e2bE3";
-    startBlock: 21326621n;
-  }>;
-  SteerPeriphery: Readonly<{
-    address: "0x3e2135a491CD90Ed1e7313Bd8Efd51aba8018F69";
-    startBlock: 21326728n;
-  }>;
-  StakingRewards: Readonly<{
-    address: "0xfdC6A32f2622be7Bf1481BFAC8bC6e35C42fD665";
-    startBlock: 21326676n;
-  }>;
-  Helper: Readonly<{
-    address: "0xCD31EbF762A5d1F88399E692316903767DA06Cf9";
-    startBlock: 21326630n;
-  }>;
-  FeeManager: Readonly<{
-    address: "0x83966243D6055b1A1157f800cBC9f5084162b871";
-    startBlock: 21326767n;
-  }>;
-}>;
-//#endregion
-//#region src/contracts/astar.d.ts
-export declare const astarContracts: Readonly<{
-  BundleRegistry: Readonly<{
-    address: "0x7Daa68204232a78dBF1Dd853a4018330EE934A39";
-    startBlock: 5466115n;
-  }>;
-  GasVault: Readonly<{
-    address: "0xe1C56f99a459ED47B629F3D818BcC84826bCed66";
-    startBlock: 5465971n;
-  }>;
-  SteerPeriphery: Readonly<{
-    address: "0x1afD31627170607657224eD4aE701470209C4B2e";
-    startBlock: 5466109n;
-  }>;
-  StrategyRegistry: Readonly<{
-    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
-    startBlock: 5465955n;
-  }>;
-  VaultRegistry: Readonly<{
-    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
-    startBlock: 5465965n;
-  }>;
-  KeeperRegistry: Readonly<{
-    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
-    startBlock: 5465944n;
-  }>;
-  Orchestrator: Readonly<{
-    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
-    startBlock: 5465950n;
-  }>;
-}>;
-//#endregion
-//#region src/contracts/astarzkevm.d.ts
-export declare const astarZkEvmContracts: Readonly<{
-  BundleRegistry: Readonly<{
-    address: "0xD40699A642172DeD33BCFe4E3F84D54610C757Cd";
-    startBlock: 215291n;
-  }>;
-  GasVault: Readonly<{
-    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
-    startBlock: 215237n;
-  }>;
-  SteerPeriphery: Readonly<{
-    address: "0x37Cff062D52Dd6E9E39Df619CCd30c037a36bB83";
-    startBlock: 215281n;
-  }>;
-  StrategyRegistry: Readonly<{
-    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
-    startBlock: 210939n;
-  }>;
-  VaultRegistry: Readonly<{
-    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
-    startBlock: 210954n;
-  }>;
-  KeeperRegistry: Readonly<{
-    address: "0x99eca0E5Db125900E3a0389F6D3503837e99F59b";
-    startBlock: 210922n;
-  }>;
-  Orchestrator: Readonly<{
-    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
-    startBlock: 210932n;
-  }>;
-}>;
-//#endregion
-//#region src/contracts/avalanche.d.ts
-export declare const avalancheContracts: Readonly<{
-  KeeperRegistry: Readonly<{
-    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
-    startBlock: 30433379n;
-  }>;
-  Orchestrator: Readonly<{
-    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
-    startBlock: 30433780n;
-  }>;
-  StrategyRegistry: Readonly<{
-    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
-    startBlock: 30433735n;
-  }>;
-  VaultRegistry: Readonly<{
-    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
-    startBlock: 30434642n;
-  }>;
-  BundleRegistry: Readonly<{
-    address: "0x87A37bEEcE2918A342F95773Bea7cAA6823c6DC3";
-    startBlock: 30435305n;
-  }>;
-  DynamicJobs: Readonly<{
-    address: "0x7c464A0AB1f5ebf3E2dCccfec7EF41D02ED7a2f4";
-    startBlock: 30435322n;
-  }>;
-  GasVault: Readonly<{
-    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
-    startBlock: 30434925n;
-  }>;
-  WhitelistRegistry: Readonly<{
-    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
-    startBlock: 30434591n;
-  }>;
-  SteerPeriphery: Readonly<{
-    address: "0x5D8249e3F5f702e1Fd720167b40424fc2daDCd1e";
-    startBlock: 30435289n;
-  }>;
-  FeeManager: Readonly<{
-    address: "0x391cf3047db983caB8dD95B16c4e6C3918d72d23";
-  }>;
-}>;
-//#endregion
-//#region src/contracts/base.d.ts
-export declare const baseContracts: Readonly<{
-  BundleRegistry: Readonly<{
-    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
-    startBlock: 2092242n;
-  }>;
-  GasVault: Readonly<{
-    address: "0x3B41454CB7858B6D0535e61bAe9362AF0151Cc2d";
-    startBlock: 2092217n;
-  }>;
-  SteerPeriphery: Readonly<{
-    address: "0x16BA7102271dC83Fff2f709691c2B601DAD7668e";
-    startBlock: 2092232n;
-  }>;
-  StrategyRegistry: Readonly<{
-    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
-    startBlock: 2092162n;
-  }>;
-  VaultRegistry: Readonly<{
-    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
-    startBlock: 2092181n;
-  }>;
-  KeeperRegistry: Readonly<{
-    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
-    startBlock: 2092152n;
-  }>;
-  Orchestrator: Readonly<{
-    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
-    startBlock: 2092171n;
-  }>;
-  Helper: Readonly<{
-    address: "0xa98376572375692455172f6750C67339667974fe";
-    startBlock: 17910406n;
-  }>;
-  SingleAssetDeposit: Readonly<{
-    address: "0x588B34D2a9598497f481A9d31B4eD372C6135f32";
-    startBlock: 48700149n;
-  }>;
-  PoolHelper: Readonly<{
-    address: "0x603823Ad53c1C7D402c5A20CD1B05488Dafc2646";
-    startBlock: 20147258n;
-  }>;
-  FeeManager: Readonly<{
-    address: "0xac4D51669B80D09d8Cc5EeFF50026c4d1D3290e6";
-  }>;
-}>;
-//#endregion
-//#region src/contracts/bera.d.ts
-export declare const beraContracts: Readonly<{
-  BundleRegistry: Readonly<{
-    address: "0x6d5A04974ba2CdC3E307135fE5886b8c7C499e9A";
-    startBlock: 785307n;
-  }>;
-  GasVault: Readonly<{
-    address: "0xcfffEc77F478959ef5D6B1AE9f4d9b35D12921E1";
-    startBlock: 785218n;
+    address: "0xcfffEc77F478959ef5D6B1AE9f4d9b35D12921E1";
+    startBlock: 785218n;
   }>;
   SteerPeriphery: Readonly<{
     address: "0x71bE4708C86B8AFd6Aa47929Ce073e400B5B7747";
@@ -3584,17 +3085,635 @@ export interface ChainDefinition {
     readonly isWrappingEnabled?: boolean;
   };
 }
-//#endregion
-//#region src/data/indexers.d.ts
-type TheGraphIndexerConfig = {
-  readonly apiKey: string;
-  readonly proxyUrl?: never;
+//#endregion
+//#region src/data/indexers.d.ts
+type TheGraphIndexerConfig = {
+  readonly apiKey: string;
+  readonly proxyUrl?: never;
+} | {
+  readonly proxyUrl: string;
+  readonly apiKey?: never;
+};
+interface IndexerConfig {
+  readonly theGraph?: TheGraphIndexerConfig;
+  readonly sentio?: {
+    readonly apiKey: string;
+  };
+}
+//#endregion
+//#region src/ipfs/client.d.ts
+interface IpfsRequestOptions extends HttpRequestOptions {
+  /** Maximum decoded response size. Defaults to 16 MiB. */
+  readonly maxResponseBytes?: number;
+}
+interface IpfsClientOptions extends IpfsRequestOptions {
+  /** Gateway base URLs, in fallback order. Defaults to https://ipfs.io/ipfs/. */
+  readonly gateways?: readonly string[];
+}
+export declare class IpfsClient {
+  #private;
+  constructor(options?: IpfsClientOptions);
+  getBytes(reference: string, options?: IpfsRequestOptions): Promise<Uint8Array<ArrayBuffer>>;
+  getJson(reference: string, options?: IpfsRequestOptions): Promise<unknown>;
+}
+//#endregion
+//#region src/lending/adapter.d.ts
+export declare abstract class LendingDataAdapter<TMarketRef> extends DataAdapter {
+  abstract listMarkets(request?: PageRequest): Promise<Page<TMarketRef>>;
+}
+export declare enum LendingProtocol {
+  AaveV3 = "aave-v3"
+}
+export declare enum LendingFamily {
+  AaveV3 = "aave-v3"
+}
+export declare abstract class LendingAdapter<TMarketRef = unknown, TMarketState = unknown, TContracts extends ContractMap = ContractMap> {
+  readonly context: ChainContext;
+  readonly deployment: DeploymentDefinition<TContracts>;
+  readonly dataAdapter: LendingDataAdapter<TMarketRef>;
+  abstract readonly family: LendingFamily;
+  abstract readonly protocol: LendingProtocol;
+  constructor(context: ChainContext, deployment: DeploymentDefinition<TContracts>, dataAdapter: LendingDataAdapter<TMarketRef>);
+  get subgraphUrl(): string | undefined;
+  abstract getMarket(reference: TMarketRef, options?: ReadOptions): Promise<TMarketState>;
+}
+export interface AaveReserveState {
+  readonly asset: Address;
+  readonly supplyRateRay: bigint;
+  readonly variableBorrowRateRay: bigint;
+}
+export interface SupplyRequest {
+  readonly asset: Address;
+  readonly amount: bigint;
+  readonly account: Address;
+}
+export interface AaveV3Contracts extends ContractMap {
+  readonly pool: ContractDeployment;
+}
+export declare abstract class AaveV3Adapter extends LendingAdapter<Address, AaveReserveState, AaveV3Contracts> {
+  readonly family = LendingFamily.AaveV3;
+  abstract prepareSupply(request: SupplyRequest): Promise<TransactionPlan>;
+}
+//#endregion
+//#region src/vault/enums.d.ts
+export declare enum VaultKind {
+  Liquidity = "liquidity",
+  Lending = "lending",
+  Composite = "composite"
+}
+export declare enum PositionKind {
+  Liquidity = "liquidity",
+  Lending = "lending",
+  Idle = "idle"
+}
+//#endregion
+//#region src/vault/resolution/types.d.ts
+export declare enum ProtocolContractRole {
+  AmmFactory = "amm-factory",
+  PoolManager = "pool-manager",
+  LendingPool = "lending-pool",
+  LendingMarketFactory = "lending-market-factory"
+}
+export interface VaultReadContext {
+  readonly steer: SteerNetwork;
+  readonly address: Address;
+  readonly blockNumber: bigint;
+}
+export interface VaultIdentity {
+  readonly chainId: number;
+  readonly vaultAddress: Address;
+  readonly registryAddress: Address;
+  /** Beacon registered for this vault in Steer's VaultRegistry. */
+  readonly beaconAddress: Address;
+  /** Beacon actually used by the vault proxy. */
+  readonly proxyBeaconAddress: Address;
+  readonly implementationAddress: Address;
+}
+/** The reader must check registry membership and the proxy's actual beacon/implementation. */
+export interface VaultIdentityReader {
+  getBlockNumber(steer: SteerNetwork): Promise<bigint>;
+  /** Read actual contracts at context.blockNumber; return null for an unregistered vault. */
+  readIdentity(context: VaultReadContext): Promise<VaultIdentity | null>;
+}
+export type UnderlyingReference = {
+  readonly kind: PositionKind.Liquidity;
+  readonly role: ProtocolContractRole.AmmFactory | ProtocolContractRole.PoolManager;
+  readonly protocolAddress: Address;
+  readonly pool: unknown;
+} | {
+  readonly kind: PositionKind.Lending;
+  readonly role: ProtocolContractRole.LendingPool | ProtocolContractRole.LendingMarketFactory;
+  readonly protocolAddress: Address;
+  readonly market: unknown;
+};
+export type ProtocolBinding = {
+  readonly kind: PositionKind.Liquidity;
+  readonly role: ProtocolContractRole.AmmFactory | ProtocolContractRole.PoolManager;
+  readonly protocolAddress: Address;
+  readonly deployment: DeploymentReference<AmmAdapter>;
+} | {
+  readonly kind: PositionKind.Lending;
+  readonly role: ProtocolContractRole.LendingPool | ProtocolContractRole.LendingMarketFactory;
+  readonly protocolAddress: Address;
+  readonly deployment: DeploymentReference<LendingAdapter>;
+};
+export interface ResolvedVaultContext extends VaultReadContext {
+  readonly underlying: readonly VaultUnderlying[];
+  readonly metadata: VaultMetadata;
+}
+/** Exact implementation-specific readers and constructors, supplied by SDK integration code. */
+export interface VaultImplementationBinding {
+  /** Exact indexed names associated with this implementation; omitted means unknown support. */
+  readonly beaconNames?: readonly string[];
+  readonly beaconAddress: Address;
+  readonly implementationAddress: Address;
+  /** Runtime hash checked by this binding's native snapshot reader before returning accounting. */
+  readonly implementationCodeHash?: Hex;
+  readonly kind: VaultKind;
+  readUnderlying(context: VaultReadContext): Promise<readonly UnderlyingReference[]>;
+  createVault(context: ResolvedVaultContext): KnownSteerVault;
+}
+export interface VaultResolverDefinition {
+  readonly reader: VaultIdentityReader;
+  readonly implementations: readonly VaultImplementationBinding[];
+  readonly protocols: readonly ProtocolBinding[];
+}
+export declare enum VaultResolutionErrorCode {
+  NotConfigured = "not-configured",
+  InvalidMapping = "invalid-mapping",
+  NotRegistered = "not-registered",
+  IdentityMismatch = "identity-mismatch",
+  UnsupportedImplementation = "unsupported-implementation",
+  UnsupportedProtocol = "unsupported-protocol",
+  InvalidVault = "invalid-vault"
+}
+export declare class VaultResolutionError extends Error {
+  readonly code: VaultResolutionErrorCode;
+  constructor(code: VaultResolutionErrorCode, message: string);
+}
+//#endregion
+//#region src/vault/resolution/index.d.ts
+export declare class VaultResolver {
+  #private;
+  readonly amms: DeploymentRegistry<AmmAdapter>;
+  readonly lending: DeploymentRegistry<LendingAdapter>;
+  constructor(definition: VaultResolverDefinition, amms: DeploymentRegistry<AmmAdapter>, lending: DeploymentRegistry<LendingAdapter>);
+  resolve(steer: SteerNetwork, address: Address, options?: VaultLoadOptions): Promise<KnownSteerVault>;
+  resolveMany(steer: SteerNetwork, addresses: readonly Address[], options: VaultLoadOptions & {
+    allowFailure: true;
+  }): Promise<readonly VaultLoadResult[]>;
+  resolveMany(steer: SteerNetwork, addresses: readonly Address[], options?: VaultLoadOptions & {
+    allowFailure?: false;
+  }): Promise<readonly KnownSteerVault[]>;
+  resolveMany(steer: SteerNetwork, addresses: readonly Address[], options?: VaultLoadOptions & {
+    allowFailure?: boolean;
+  }): Promise<readonly KnownSteerVault[] | readonly VaultLoadResult[]>;
+  /** Identity and accounting share a pinned block; dispatch custom constructors and methods. */
+  snapshots(steer: SteerNetwork, addresses: readonly Address[], options: ReadOptions & {
+    allowFailure: true;
+  }): Promise<readonly VaultSnapshotResult[]>;
+  snapshots(steer: SteerNetwork, addresses: readonly Address[], options?: ReadOptions & {
+    allowFailure?: false;
+  }): Promise<readonly LiquidityVaultSnapshot[]>;
+  snapshots(steer: SteerNetwork, addresses: readonly Address[], options?: ReadOptions & {
+    allowFailure?: boolean;
+  }): Promise<readonly LiquidityVaultSnapshot[] | readonly VaultSnapshotResult[]>;
+}
+//#endregion
+//#region src/vault/steer.d.ts
+export interface SteerContracts extends ContractMap {
+  readonly KeeperRegistry: ContractDeployment;
+  readonly Orchestrator: ContractDeployment;
+  readonly StrategyRegistry: ContractDeployment;
+  readonly VaultRegistry: ContractDeployment;
+  readonly BundleRegistry: ContractDeployment;
+  readonly GasVault: ContractDeployment;
+  readonly SteerPeriphery: ContractDeployment;
+}
+export declare class SteerNetwork {
+  #private;
+  readonly context: ChainContext;
+  readonly deployment: DeploymentDefinition<SteerContracts>;
+  readonly dataAdapter: SteerDataAdapter;
+  readonly ipfs: IpfsClient;
+  constructor(context: ChainContext, deployment: DeploymentDefinition<SteerContracts>, dataAdapter: SteerDataAdapter, resolver?: VaultResolver, ipfs?: IpfsClient);
+  get contracts(): SteerContracts;
+  get subgraphUrl(): string | undefined;
+  listUserVaults(request: UserVaultListRequest, options?: DataAdapterRequestOptions): Promise<UserVaultPage>;
+  listVaults(request?: VaultListRequest, options?: DataAdapterRequestOptions): Promise<Page<VaultMetadata>>;
+  /** Synchronous registration check with no RPC or HTTP; does not verify a particular vault. */
+  supportsVaultSnapshots(beaconName: string): boolean;
+  getVault(address: Address, options?: VaultLoadOptions): Promise<KnownSteerVault>;
+  getVaults(addresses: readonly Address[], options: VaultLoadOptions & {
+    allowFailure: true;
+  }): Promise<readonly VaultLoadResult[]>;
+  getVaults(addresses: readonly Address[], options?: VaultLoadOptions & {
+    allowFailure?: false;
+  }): Promise<readonly KnownSteerVault[]>;
+  getVaults(addresses: readonly Address[], options?: VaultLoadOptions & {
+    allowFailure?: boolean;
+  }): Promise<readonly KnownSteerVault[] | readonly VaultLoadResult[]>;
+  getVaultSnapshots(addresses: readonly Address[], options: ReadOptions & {
+    allowFailure: true;
+  }): Promise<readonly VaultSnapshotResult[]>;
+  getVaultSnapshots(addresses: readonly Address[], options?: ReadOptions & {
+    allowFailure?: false;
+  }): Promise<readonly LiquidityVaultSnapshot[]>;
+  getVaultSnapshots(addresses: readonly Address[], options?: ReadOptions & {
+    allowFailure?: boolean;
+  }): Promise<readonly LiquidityVaultSnapshot[] | readonly VaultSnapshotResult[]>;
+  getVaultUserPositions(addresses: readonly Address[], account: Address, options?: ReadOptions): Promise<readonly VaultUserPosition[]>;
+  getLiquidityVault(address: Address, options?: VaultLoadOptions): Promise<LiquidityVault>;
+  getLendingVault(address: Address, options?: VaultLoadOptions): Promise<LendingVault>;
+  getCompositeVault(address: Address, options?: VaultLoadOptions): Promise<CompositeVault>;
+}
+//#endregion
+//#region src/vault/vault.d.ts
+export declare abstract class SteerVault {
+  #private;
+  readonly address: Address;
+  readonly chain: ChainContext;
+  readonly steer: SteerNetwork;
+  abstract readonly kind: VaultKind;
+  readonly underlying: readonly VaultUnderlying[];
+  readonly metadata: VaultMetadata;
+  constructor(address: Address, chain: ChainContext, steer: SteerNetwork, underlying: readonly VaultUnderlying[], metadata: VaultMetadata);
+  /** Fetch and validate the stored manifest; runtime execution fields are not synthesized. */
+  getConfig(options?: IpfsRequestOptions): Promise<Readonly<{
+    readonly strategyConfigData: Readonly<{
+      [x: string]: unknown;
+    }>;
+    readonly vaultPayload: Readonly<{
+      [x: string]: unknown;
+    }>;
+    readonly dataConnectorsData: readonly Readonly<{
+      bundleHash: string;
+      readonly configData: Readonly<{
+        [x: string]: unknown;
+      }>;
+    } & {
+      [key: string]: unknown;
+    }>[];
+    strategy?: Readonly<{
+      chainId: number;
+      execBundle: string;
+      tokenId: string;
+    } & {
+      [key: string]: unknown;
+    }> | undefined;
+  } & {
+    [key: string]: unknown;
+  }>>;
+  abstract getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
+  abstract getPositions(options?: ReadOptions): Promise<readonly StrategyPosition[]>;
+  /** SDK request shape; contract implementations encode their own ABI and enforce asset rules. */
+  abstract previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<DepositPreview>;
+  abstract prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<TransactionPlan>;
+  /** Share-denominated exit; implementations map this to the contract's withdrawal flow. */
+  abstract prepareWithdraw(request: PrepareWithdrawRequest, options?: ReadOptions): Promise<TransactionPlan>;
+}
+export declare abstract class LiquidityVault<TAmm extends AmmAdapter = AmmAdapter, TPool extends LiquidityPool = LiquidityPool> extends SteerVault {
+  readonly kind = VaultKind.Liquidity;
+  abstract readonly amm: TAmm;
+  abstract getPositions(options?: ReadOptions): Promise<readonly LiquidityPosition<TPool>[]>;
+  abstract getSnapshot(options?: ReadOptions): Promise<LiquidityVaultSnapshot<TPool>>;
+  /** Read strategy inputs at an explicit block, with timestamp-bounded indexed execution history. */
+  getExecutionContext(request: ExecutionContextRequest, options?: DataAdapterRequestOptions): Promise<SmartPoolExecutionContext>;
+  /** Run v2 connectors in manifest order, using configuration cached on this vault. */
+  executeDataConnectors(context: SmartPoolExecutionContext, options?: IpfsRequestOptions): Promise<readonly unknown[]>;
+  /** Execute the registered WASM locally. Returns parsed output without submitting transactions. */
+  executeStrategy(context: SmartPoolExecutionContext, connectorData: readonly unknown[], options?: IpfsRequestOptions): Promise<unknown>;
+  /** Calculate the other token maximum at the vault's current deposit ratio. Does not swap. */
+  abstract quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
+  abstract previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<LiquidityDepositPreview>;
+  abstract prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<DepositPlan>;
+  /** Simulates the original withdrawal as account at one verified block. Never submits. */
+  previewWithdraw(request: WithdrawRequest, options?: ReadOptions): Promise<WithdrawPreview>;
+  /** Re-simulates independently; does not trust a previously returned preview. */
+  prepareWithdraw(request: PrepareWithdrawRequest, options?: ReadOptions): Promise<WithdrawPlan>;
+  /** Proportional accounting amounts at one block, not a withdrawal quote. */
+  getUserPosition(account: Address, options?: ReadOptions): Promise<LiquidityVaultUserPosition<TPool>>;
+}
+export declare abstract class LendingVault<TLending extends LendingAdapter = LendingAdapter> extends SteerVault {
+  readonly kind = VaultKind.Lending;
+  abstract readonly lending: TLending;
+}
+export declare abstract class CompositeVault extends SteerVault {
+  readonly kind = VaultKind.Composite;
+}
+//#endregion
+//#region src/vault/types.d.ts
+type VaultAmmFilter = { [Protocol in AmmProtocol]: Omit<AmmLookupRequest<Protocol>, "chainId">; }[AmmProtocol];
+/** Indexed descriptive data. This record does not establish current onchain identity. */
+interface VaultMetadata {
+  readonly id: Address;
+  readonly name: string | null;
+  readonly symbol: string | null;
+  readonly decimals: string | null;
+  readonly beaconName: string;
+  readonly createdAt: string;
+  readonly state: string | null;
+  /** Pool contract address or a 32-byte pool ID for singleton AMMs such as V4. */
+  readonly pool: Hex | null;
+  readonly poolKey?: string | null;
+  readonly token0: Address | null;
+  readonly token1: Address | null;
+  readonly payloadIpfs: string | null;
+  readonly strategyToken: {
+    readonly id: string;
+  } | null;
+}
+interface ExecutionContextRequest {
+  readonly blockNumber: bigint;
+  /** Explicit execution epoch in Unix seconds, never inferred from the wall clock. */
+  readonly epochTimestamp: bigint;
+  /** Strategy epoch duration in seconds. */
+  readonly epochLength: number;
+}
+interface VaultExecutionHistoryRequest {
+  readonly vaultAddress: Address;
+  readonly blockNumber: bigint;
+  readonly timestamp: bigint;
+}
+/** Loading options. Supplied indexed metadata never replaces onchain identity checks. */
+interface VaultLoadOptions extends ReadOptions {
+  /** Complete records for the requested addresses; omit to fetch from the subgraph. */
+  readonly metadata?: readonly VaultMetadata[];
+}
+interface VaultListRequest extends PageRequest {
+  /** Select a configured AMM using the same protocol/version rules as getAmm(). */
+  readonly amm?: VaultAmmFilter;
+  /** Match either underlying token; all supplied fields must match that same token. */
+  readonly token?: TokenFilter;
+}
+interface VaultDiscoveryRequest extends VaultListRequest {
+  readonly chainId: number;
+}
+/** Scans at most limit indexed share-vault candidates (default 1,000) per page. */
+interface UserVaultListRequest extends VaultListRequest {
+  readonly account: Address;
+}
+interface UserVaultDiscoveryRequest extends UserVaultListRequest {
+  readonly chainId: number;
+}
+/** Indexed candidates with positive onchain shares, not verified vault implementations.
+ * Empty pages may have a nextCursor. Completeness depends on the indexed inventory.
+ */
+interface UserVaultPage extends Page<Address> {
+  readonly indexedBlock: bigint;
+}
+/** SDK connection dependency, supplied by SteerClient to its data adapter factory. */
+interface SteerConnectionContext extends ChainContext {
+  readonly amms: DeploymentRegistry<AmmAdapter>;
+}
+interface AssetAmount {
+  readonly asset: Address;
+  readonly amount: bigint;
+}
+interface DepositRequest {
+  /** Token owner and transaction sender. */
+  readonly account: Address;
+  readonly assets: readonly AssetAmount[];
+  readonly receiver: Address;
+}
+interface DepositPreview {
+  readonly shares: bigint;
+}
+interface PrepareDepositRequest extends DepositRequest {
+  /** Integer basis points from zero through 10,000, applied to accepted token amounts. */
+  readonly slippageBps: number;
+}
+/** Contract-compatible quote, independent of the account's balances and allowances. */
+interface LiquidityDepositPreview extends DepositPreview {
+  readonly blockNumber: bigint;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly amounts: TokenPairAmounts;
+  readonly unusedAmounts: TokenPairAmounts;
+  /** Settlement of pre-existing receiver shares, separate from deposited assets. */
+  readonly rewards?: VaultRewardPayout;
+}
+/** Inferred token maxima, suitable for previewDeposit or prepareDeposit. No tokens are swapped. */
+interface DepositQuote extends LiquidityDepositPreview {
+  /** Token0 and token1 maxima, in that order. */
+  readonly assets: readonly [AssetAmount, AssetAmount];
+}
+/** Ordered capped approvals, if needed, followed by the unsigned deposit. */
+interface DepositPlan extends TransactionPlan {
+  readonly account: Address;
+  readonly preview: LiquidityDepositPreview;
+  readonly minimumAmounts: TokenPairAmounts;
+}
+interface WithdrawRequest {
+  readonly shares: bigint;
+  /** Share holder and transaction sender. The contract burns msg.sender shares. */
+  readonly account: Address;
+  readonly receiver: Address;
+}
+interface PrepareWithdrawRequest extends WithdrawRequest {
+  /** Integer basis points, from zero through 10,000. Explicitly chosen by the caller. */
+  readonly slippageBps: number;
+}
+/** Separate reward asset paid when a vault operation settles pre-existing shares. */
+interface VaultRewardPayout {
+  readonly token: Address;
+  readonly recipient: Address;
+  readonly amount: PoolTokenBalance;
+}
+/** Reward paid to the shareholder during withdrawal. */
+type WithdrawRewards = VaultRewardPayout;
+/** Actual withdrawal simulation, including contract burn rounding and fee policy. */
+interface WithdrawPreview {
+  readonly rewardPayouts?: readonly VaultRewardPayout[];
+  readonly rewards?: WithdrawRewards;
+  readonly blockNumber: bigint;
+  readonly shares: bigint;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly amounts: TokenPairAmounts;
+}
+/** Unsigned transactions must be submitted by account on chainId. */
+interface WithdrawPlan extends TransactionPlan {
+  readonly account: Address;
+  readonly preview: WithdrawPreview;
+  readonly minimumAmounts: TokenPairAmounts;
+}
+/** Configured protocol relationships exist even when a vault has no active positions. */
+type VaultUnderlying = {
+  readonly kind: PositionKind.Liquidity;
+  readonly amm: AmmAdapter;
+  readonly pool: unknown;
+} | {
+  readonly kind: PositionKind.Lending;
+  readonly lending: LendingAdapter;
+  readonly market: unknown;
+};
+type StrategyPosition = (VaultUnderlying & {
+  readonly positionId: string;
+}) | {
+  readonly kind: PositionKind.Idle;
+  readonly balance: AssetAmount;
+};
+/** Token amounts use the snapshot's token ordering and decimals. */
+interface TokenPairAmounts {
+  readonly token0: PoolTokenBalance;
+  readonly token1: PoolTokenBalance;
+}
+/** Both position fees and vault-wide sums use this structure. Recorded fees are part of gross. */
+interface LiquidityFees {
+  /** Collectible fees, including fee growth since the last checkpoint. */
+  readonly gross: TokenPairAmounts;
+  /** LP share after the verified implementation's fee cut and rounding policy. */
+  readonly net: TokenPairAmounts;
+  /** Gross fees already checkpointed in the pool's tokensOwed fields. */
+  readonly recorded: TokenPairAmounts;
+}
+/** V4 pools are identified by their key and manager, never an invented address. */
+interface V4VaultPool {
+  readonly poolId: Hex;
+  readonly poolManager: Address;
+  readonly key: V4PoolKey;
+}
+type LiquidityPool = Address | V4VaultPool;
+interface LiquidityPosition<TPool extends LiquidityPool = LiquidityPool> {
+  /** NFT checkpoint amounts excluded from LP fees/totals when the qualified vault cannot pay them out. */
+  readonly nftTokensOwed?: TokenPairAmounts;
+  readonly kind: PositionKind.Liquidity;
+  readonly amm: AmmAdapter;
+  readonly pool: TPool;
+  readonly positionId: string;
+  readonly lowerTick: number;
+  readonly upperTick: number;
+  /** Arbitrary relative units, not basis points. */
+  readonly relativeWeight: number;
+  /** Rounded down to 18 decimal places; undefined when all weights are zero. */
+  readonly weightPercent: string | undefined;
+  readonly liquidity: bigint;
+  readonly principal: TokenPairAmounts;
+  readonly fees: LiquidityFees;
+}
+/** Configured strategy ranges, which need not correspond one-to-one to active NFTs. */
+interface LiquidityPositionRange {
+  readonly lowerTick: number;
+  readonly upperTick: number;
+  readonly relativeWeight: number;
+  readonly weightPercent: string | undefined;
+}
+/** One reward asset, deduplicated by token even when base and bonus rewards overlap. */
+interface VaultRewardFee {
+  readonly identifier: string;
+  readonly recipient: Address;
+  readonly unpaid: PoolTokenBalance;
+  readonly unclaimed: PoolTokenBalance;
+}
+interface VaultRewardAsset {
+  readonly token: Address;
+  readonly decimals: number;
+  readonly balance: PoolTokenBalance;
+  readonly reservedFees: PoolTokenBalance;
+  /** Stored fees not attributed to the current fee identifiers, still excluded from LP holdings. */
+  readonly unattributedReservedFees: PoolTokenBalance;
+  readonly accumulatedPerShareX18: bigint;
+  readonly unclaimed: {
+    readonly gross: PoolTokenBalance;
+    readonly net: PoolTokenBalance;
+    readonly fee: PoolTokenBalance;
+  };
+  readonly feeRecipients: readonly VaultRewardFee[];
+}
+/** Separate reward-token accounting, never folded into proportional LP pair holdings. */
+interface LiquidityVaultRewards {
+  readonly token: Address;
+  readonly decimals: number;
+  readonly balance: PoolTokenBalance;
+  readonly accumulatedPerShareX18: bigint;
+  readonly totalSupply: bigint;
+  readonly unclaimed: {
+    readonly gross: PoolTokenBalance;
+    readonly net: PoolTokenBalance;
+    readonly steerFee: PoolTokenBalance;
+    readonly strategistFee: PoolTokenBalance;
+  };
+  readonly unpaidFees: {
+    readonly steer: PoolTokenBalance;
+    readonly strategist: PoolTokenBalance;
+  };
+}
+/** One result for every requested vault, preserving input order and duplicates. */
+type VaultLoadResult = {
+  readonly status: "success";
+  readonly vault: KnownSteerVault;
 } | {
-  readonly proxyUrl: string;
-  readonly apiKey?: never;
+  readonly status: "failure";
+  readonly error: Error;
 };
-interface IndexerConfig {
-  readonly theGraph?: TheGraphIndexerConfig;
+type VaultSnapshotResult = {
+  readonly status: "success";
+  readonly snapshot: LiquidityVaultSnapshot;
+} | {
+  readonly status: "failure";
+  readonly error: Error;
+};
+interface LiquidityVaultSnapshot<TPool extends LiquidityPool = LiquidityPool> {
+  readonly rewardAssets?: readonly VaultRewardAsset[];
+  readonly blockNumber: bigint;
+  /** Verified implementation at blockNumber, supplied by registered bulk snapshot readers. */
+  readonly implementation?: {
+    readonly address: Address;
+    readonly codeHash: Hex;
+    readonly beacon: Address;
+    /** Indexed descriptive name, not onchain identity evidence. */
+    readonly beaconName: string;
+  };
+  readonly pool: TPool;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly token0Decimals: number;
+  readonly token1Decimals: number;
+  readonly positions: readonly LiquidityPosition<TPool>[];
+  /** ERC-20 holdings, including already collected protocol/strategist fee reserves. */
+  readonly balances: TokenPairAmounts;
+  readonly reservedFees: TokenPairAmounts;
+  /** Already collected rewards excluded from idle when the reward asset overlaps the LP pair. */
+  readonly reservedRewards?: TokenPairAmounts;
+  readonly configuredPositions?: readonly LiquidityPositionRange[];
+  readonly rewards?: LiquidityVaultRewards;
+  readonly idle: TokenPairAmounts;
+  readonly principal: TokenPairAmounts;
+  readonly feeRateBps: number;
+  /** Sums of the corresponding fees across all positions. */
+  readonly fees: LiquidityFees;
+  /** Idle + principal + net uncollected fees. Accounting snapshot, not a withdrawal quote. */
+  readonly total: TokenPairAmounts;
+}
+/** Same-block proportional accounting, not a withdrawal quote. Share amounts are raw ERC-20 units. */
+interface LiquidityVaultUserPosition<TPool extends LiquidityPool = LiquidityPool> {
+  readonly blockNumber: bigint;
+  readonly account: Address;
+  readonly pool: TPool;
+  readonly token0: Address;
+  readonly token1: Address;
+  readonly shares: bigint;
+  readonly totalSupply: bigint;
+  /** Rounded down to 18 decimal places; zero when totalSupply is zero. */
+  readonly ownershipPercent: string;
+  /** Proportional LP totals, including available idle, principal and net uncollected fees. */
+  readonly amounts: TokenPairAmounts;
+}
+/** One requested liquidity vault's same-block wallet holdings. */
+interface VaultUserPosition<TPool extends LiquidityPool = LiquidityPool> {
+  readonly vault: Address;
+  readonly position: LiquidityVaultUserPosition<TPool>;
+}
+type KnownSteerVault = LiquidityVault | LendingVault | CompositeVault;
+//#endregion
+//#region src/vault/data-adapter.d.ts
+export declare abstract class SteerDataAdapter extends DataAdapter {
+  /** Latest indexed execution through the requested block and timestamp, or null if absent. */
+  getLastVaultExecution(_request: VaultExecutionHistoryRequest, _options?: DataAdapterRequestOptions): Promise<bigint | null>;
+  listUserVaults(_request: UserVaultListRequest, _options?: DataAdapterRequestOptions): Promise<UserVaultPage>;
+  getVaultMetadata(_addresses: readonly Address[], _options?: DataAdapterRequestOptions): Promise<readonly VaultMetadata[]>;
+  abstract listVaults(request?: VaultListRequest, options?: DataAdapterRequestOptions): Promise<Page<VaultMetadata>>;
 }
 //#endregion
 //#region src/core/client.d.ts
@@ -3607,6 +3726,7 @@ export interface SteerNetworkDefinition {
   readonly vaultResolver?: VaultResolverDefinition;
 }
 export interface SteerClientOptions {
+  readonly ipfs?: IpfsClient;
   readonly logger?: Logger;
   /** SDK integration override. Replaces the built-in network catalog when supplied. */
   readonly catalog?: readonly SteerNetworkDefinition[];
@@ -3617,6 +3737,7 @@ export interface SteerClientOptions {
 /** Steer is the SDK root; chain identity selects a deployment, not another protocol. */
 export declare class SteerClient {
   #private;
+  readonly ipfs: IpfsClient;
   constructor(options?: SteerClientOptions);
   getChains(): readonly ChainDefinition[];
   getDeployment(chainId: number): SteerNetwork;
@@ -3641,19 +3762,7 @@ export declare class SteerClient {
   getPool(request: V4PoolLookupRequest): Promise<V4PoolState & {
     readonly amm: UniswapV4Adapter;
   }>;
-  getPool(request: PoolLookupRequest): Promise<(SlipstreamPoolState & {
-    readonly amm: AerodromeSlipstreamAdapter;
-  }) | (InfinityCLPoolState & {
-    readonly amm: InfinityCLAdapter;
-  }) | (AlgebraLegacyPoolState & {
-    readonly amm: AlgebraLegacyAdapter;
-  }) | (AlgebraIntegralPoolState & {
-    readonly amm: AlgebraIntegralAdapter;
-  }) | (V3PoolState & {
-    readonly amm: UniswapV3Adapter;
-  }) | (V4PoolState & {
-    readonly amm: UniswapV4Adapter;
-  })>;
+  getPool(request: PoolLookupRequest): Promise<DiscoveredPool>;
   getPools(request: SlipstreamPoolsLookupRequest): Promise<readonly (SlipstreamPoolState & {
     readonly amm: AerodromeSlipstreamAdapter;
   })[]>;
@@ -3700,13 +3809,6 @@ export declare class SteerClient {
   getCompositeVault(chainId: number, address: Address, options?: VaultLoadOptions): Promise<CompositeVault>;
 }
 //#endregion
-//#region src/data/uniswap-v3.d.ts
-export declare class UniswapV3DataAdapter extends PoolDataAdapter<Address> {
-  #private;
-  constructor(definition: DataAdapterDefinition, factory: Address, indexerRequest?: HttpTransport);
-  listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<Address>>;
-}
-//#endregion
 //#region src/vault/adapters/aerodrome/types.d.ts
 interface AerodromeVaultSnapshot extends LiquidityVaultSnapshot<Address> {
   readonly configuredPositions: NonNullable<LiquidityVaultSnapshot["configuredPositions"]>;
@@ -3857,5 +3959,72 @@ export declare class UniswapV4Vault extends LiquidityVault<UniswapV4Adapter, V4V
   prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<DepositPlan>;
 }
 //#endregion
-export { type AerodromeDepositPlan, type AerodromeDepositPreview, type AerodromeVaultSnapshot, type AerodromeWithdrawPlan, type AerodromeWithdrawPreview, type AlgebraContracts, type AlgebraIntegralContracts, type AlgebraIntegralPoolState, type AlgebraLegacyContracts, type AlgebraLegacyPoolLookupRequest, type AlgebraLegacyPoolState, type AlgebraLegacyPoolsLookupRequest, type AlgebraPoolLookupRequest, type AlgebraPoolReference, type AlgebraPoolState, type AlgebraPoolsLookupRequest, type AlgebraSwapFee, type AmmLookupRequest, type AmmProtocolAdapter, type AmmProtocolAdapters, type AmmProtocolVersion, type AmmVersion, type AssetAmount, type BlackholeNativeUnwrapPlan, type BlackholePosition, type BlackholeVaultSnapshot, type BlackholeWithdrawPlan, type BlackholeWithdrawPreview, type ConcentratedPoolState, type DepositPlan, type DepositPreview, type DepositQuote, type DepositRequest, type DiscoveredPool, type IndexerConfig, type InfinityCLContracts, type InfinityCLDirectionalFees, type InfinityCLPoolFees, type InfinityCLPoolIdReference, type InfinityCLPoolKey, type InfinityCLPoolKeyInput, type InfinityCLPoolLookupRequest, type InfinityCLPoolReference, type InfinityCLPoolState, type InfinityCLPoolsLookupRequest, type InfinityCLSwapQuoteRequest, type KnownSteerVault, type LiquidityDepositPreview, type LiquidityDepth, type LiquidityDepthRequest, type LiquidityDistribution, type LiquidityFees, type LiquidityInterval, type LiquidityPool, type LiquidityPosition, type LiquidityPositionRange, type LiquidityVaultRewards, type LiquidityVaultSnapshot, type LiquidityVaultUserPosition, type LogEvent, type Logger, type PoolBatchReadOptions, type PoolLookupRequest, type PoolPrice, type PoolReadOptions, type PoolReadResult, type PoolState, type PoolTicks, type PoolTokenBalance, type PoolsLookupRequest, type PrepareDepositRequest, type PrepareWithdrawRequest, type SlipstreamContracts, type SlipstreamPoolFees, type SlipstreamPoolLookupRequest, type SlipstreamPoolState, type SlipstreamPoolsLookupRequest, type SlipstreamQuoteOptions, type StrategyPosition, type SurroundingTicks, type SwapQuote, type SwapQuoteRequest, type TheGraphIndexerConfig, type TickLiquidity, type TickPoolState, type TickRange, type TokenPairAmounts, type UserVaultDiscoveryRequest, type UserVaultListRequest, type UserVaultPage, type V3Contracts, type V3PoolFees, type V3PoolLookupRequest, type V3PoolState, type V3PoolsLookupRequest, type V4Contracts, type V4DirectionalFees, type V4PoolFees, type V4PoolKey, type V4PoolLookupRequest, type V4PoolReference, type V4PoolState, type V4PoolsLookupRequest, type V4ReadOptions, type V4SwapQuoteRequest, type V4VaultPool, type VaultAmmFilter, type VaultDiscoveryRequest, type VaultListRequest, type VaultLoadOptions, type VaultLoadResult, type VaultMetadata, type VaultRewardAsset, type VaultRewardFee, type VaultRewardPayout, type VaultSnapshotResult, type VaultUnderlying, type VaultUserPosition, type WithdrawPlan, type WithdrawPreview, type WithdrawRequest, type WithdrawRewards, ethereumContracts as mainnetContracts };
+//#region src/vault/config.d.ts
+declare const vaultConfigSchema: v.SchemaWithPipe<readonly [v.LooseObjectSchema<{
+  readonly strategyConfigData: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.ReadonlyAction<{
+    [x: string]: unknown;
+  }>]>;
+  readonly vaultPayload: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.ReadonlyAction<{
+    [x: string]: unknown;
+  }>]>;
+  readonly dataConnectorsData: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.LooseObjectSchema<{
+    readonly bundleHash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    readonly configData: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.ReadonlyAction<{
+      [x: string]: unknown;
+    }>]>;
+  }, undefined>, v.ReadonlyAction<{
+    bundleHash: string;
+    readonly configData: Readonly<{
+      [x: string]: unknown;
+    }>;
+  } & {
+    [key: string]: unknown;
+  }>]>, undefined>, v.ReadonlyAction<Readonly<{
+    bundleHash: string;
+    readonly configData: Readonly<{
+      [x: string]: unknown;
+    }>;
+  } & {
+    [key: string]: unknown;
+  }>[]>]>;
+  readonly strategy: v.OptionalSchema<v.SchemaWithPipe<readonly [v.LooseObjectSchema<{
+    readonly chainId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly execBundle: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    readonly tokenId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+  }, undefined>, v.ReadonlyAction<{
+    chainId: number;
+    execBundle: string;
+    tokenId: string;
+  } & {
+    [key: string]: unknown;
+  }>]>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+  readonly strategyConfigData: Readonly<{
+    [x: string]: unknown;
+  }>;
+  readonly vaultPayload: Readonly<{
+    [x: string]: unknown;
+  }>;
+  readonly dataConnectorsData: readonly Readonly<{
+    bundleHash: string;
+    readonly configData: Readonly<{
+      [x: string]: unknown;
+    }>;
+  } & {
+    [key: string]: unknown;
+  }>[];
+  strategy?: Readonly<{
+    chainId: number;
+    execBundle: string;
+    tokenId: string;
+  } & {
+    [key: string]: unknown;
+  }> | undefined;
+} & {
+  [key: string]: unknown;
+}>]>;
+/** Stored manifest. Each strategy, vault and connector owns its configuration schema. */
+type VaultConfig = v.InferOutput<typeof vaultConfigSchema>;
+//#endregion
+export { type AerodromeDepositPlan, type AerodromeDepositPreview, type AerodromeVaultSnapshot, type AerodromeWithdrawPlan, type AerodromeWithdrawPreview, type AlgebraContracts, type AlgebraIntegralContracts, type AlgebraIntegralPoolState, type AlgebraLegacyContracts, type AlgebraLegacyPoolLookupRequest, type AlgebraLegacyPoolState, type AlgebraLegacyPoolsLookupRequest, type AlgebraPoolLookupRequest, type AlgebraPoolReference, type AlgebraPoolState, type AlgebraPoolsLookupRequest, type AlgebraSwapFee, type AmmLookupRequest, type AmmProtocolAdapter, type AmmProtocolAdapters, type AmmProtocolVersion, type AmmVersion, type AssetAmount, type BlackholeNativeUnwrapPlan, type BlackholePosition, type BlackholeVaultSnapshot, type BlackholeWithdrawPlan, type BlackholeWithdrawPreview, type ConcentratedPoolState, type DepositPlan, type DepositPreview, type DepositQuote, type DepositRequest, type DiscoveredPool, type ExecutionContextRequest, type IndexerConfig, type InfinityCLContracts, type InfinityCLDirectionalFees, type InfinityCLPoolFees, type InfinityCLPoolIdReference, type InfinityCLPoolKey, type InfinityCLPoolKeyInput, type InfinityCLPoolLookupRequest, type InfinityCLPoolReference, type InfinityCLPoolState, type InfinityCLPoolsLookupRequest, type InfinityCLSwapQuoteRequest, type IpfsClientOptions, type IpfsRequestOptions, type KnownSteerVault, type LiquidityDepositPreview, type LiquidityDepth, type LiquidityDepthRequest, type LiquidityDistribution, type LiquidityFees, type LiquidityInterval, type LiquidityPool, type LiquidityPosition, type LiquidityPositionRange, type LiquidityVaultRewards, type LiquidityVaultSnapshot, type LiquidityVaultUserPosition, type LogEvent, type Logger, type PoolBatchReadOptions, type PoolLookupRequest, type PoolPrice, type PoolReadOptions, type PoolReadResult, type PoolState, type PoolTicks, type PoolTokenBalance, type PoolsLookupRequest, type PrepareDepositRequest, type PrepareWithdrawRequest, type SlipstreamContracts, type SlipstreamPoolFees, type SlipstreamPoolLookupRequest, type SlipstreamPoolState, type SlipstreamPoolsLookupRequest, type SlipstreamQuoteOptions, type StrategyPosition, type SurroundingTicks, type SwapQuote, type SwapQuoteRequest, type TheGraphIndexerConfig, type TickLiquidity, type TickPoolState, type TickRange, type TokenPairAmounts, type UserVaultDiscoveryRequest, type UserVaultListRequest, type UserVaultPage, type V3Contracts, type V3PoolFees, type V3PoolLookupRequest, type V3PoolState, type V3PoolsLookupRequest, type V4Contracts, type V4DirectionalFees, type V4PoolFees, type V4PoolKey, type V4PoolLookupRequest, type V4PoolReference, type V4PoolState, type V4PoolsLookupRequest, type V4ReadOptions, type V4SwapQuoteRequest, type V4VaultPool, type VaultAmmFilter, type VaultConfig, type VaultDiscoveryRequest, type VaultExecutionHistoryRequest, type VaultListRequest, type VaultLoadOptions, type VaultLoadResult, type VaultMetadata, type VaultRewardAsset, type VaultRewardFee, type VaultRewardPayout, type VaultSnapshotResult, type VaultUnderlying, type VaultUserPosition, type WithdrawPlan, type WithdrawPreview, type WithdrawRequest, type WithdrawRewards, ethereumContracts as mainnetContracts };
 //# sourceMappingURL=index.d.mts.map