@steerprotocol/sdk 3.8.1 → 4.0.0-next.10

package/dist/index.d.cts

@@ -1 +1,3861 @@
-export * from './index.d.mts'
+import "viem";
+//#region src/http/transport.d.ts
+/** Transport settings shared by client defaults and per-request overrides. */
+interface HttpRequestOptions {
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly fetch?: typeof globalThis.fetch;
+  readonly signal?: AbortSignal;
+  /** Defaults to 15 seconds. Zero disables the timeout. */
+  readonly timeoutMs?: number;
+}
+type HttpTransport = (url: string, init: RequestInit, options?: HttpRequestOptions) => Promise<Response>;
+/** Excludes URLs, headers, and response bodies that may contain credentials. */
+export declare class HttpError extends Error {
+  readonly status: number;
+  constructor(status: number);
+}
+//#endregion
+//#region src/observability/operation.d.ts
+/** SDK-controlled fields only. No request data or raw errors are emitted. */
+interface LogEvent {
+  readonly event: string;
+  readonly operationId: string;
+  readonly chainId: number;
+  readonly protocol: string;
+  readonly version?: string;
+  readonly durationMs?: number;
+  readonly resultCount?: number;
+  readonly errorCode?: "HTTP_ERROR" | "TIMEOUT" | "CANCELLED" | "OPERATION_FAILED";
+  readonly requestId?: string;
+  readonly status?: number;
+  readonly headersDurationMs?: number;
+  readonly provider?: "theGraph" | "other";
+  readonly routing?: "proxy" | "direct";
+  readonly query?: "snapshot" | "pools";
+  readonly indexedBlock?: number;
+}
+/** Structurally compatible with Consola. The application owns levels and reporters. */
+interface Logger {
+  debug(event: LogEvent): unknown;
+  info(event: LogEvent): unknown;
+  warn(event: LogEvent): unknown;
+  error(event: LogEvent): unknown;
+}
+//#endregion
+//#region src/core/types.d.ts
+export type Address = `0x${string}`;
+export type Hex = `0x${string}`;
+/** Known identities do not imply implemented vault or protocol operations. */
+export declare enum ChainId {
+  Ethereum = 1,
+  Polygon = 137,
+  Arc = 5042,
+  Arbitrum = 42161,
+  Optimism = 10,
+  BSC = 56,
+  Evmos = 9001,
+  Metis = 1088,
+  Avalanche = 43114,
+  Thundercore = 108,
+  PolygonzkEVM = 1101,
+  Celo = 42220,
+  Kava = 2222,
+  Linea = 59144,
+  Scroll = 534352,
+  Manta = 169,
+  Astar = 592,
+  Mantle = 5000,
+  Fantom = 250,
+  AstarZkevm = 3776,
+  Blast = 81457,
+  Mode = 34443,
+  Telos = 40,
+  Base = 8453,
+  XLayer = 196,
+  Rootstock = 30,
+  Taiko = 167000,
+  ZklinkNova = 810180,
+  Flare = 14,
+  BeraChainBartio = 80084,
+  Filecoin = 314,
+  Apechain = 33139,
+  Zircuit = 48900,
+  Moonbeam = 1284,
+  Sei = 1329,
+  Sonic = 146,
+  Bera = 80094,
+  Zeta = 7000,
+  Soneium = 1868,
+  Mainnet = 1,
+  Unichain = 130,
+  TataraTestnet = 129399,
+  Hemi = 43111,
+  OkxTestnet = 195,
+  Core = 1116,
+  Peaq = 3338,
+  Katana = 747474,
+  Ronin = 2020,
+  Saga = 5464,
+  Nibiru = 6900,
+  Hyperevm = 999,
+  Bittensor = 964,
+  Monad = 143,
+  Robinhood = 4663
+}
+export interface ReadOptions {
+  readonly blockNumber?: bigint;
+}
+export interface RpcTransport {
+  request(method: string, params: readonly unknown[]): Promise<unknown>;
+}
+export interface ChainContext {
+  readonly chainId: number;
+  readonly transport?: RpcTransport;
+  readonly indexerRequest?: HttpTransport;
+  readonly logger?: Logger;
+}
+export interface ContractDeployment {
+  readonly address: Address;
+  readonly startBlock?: bigint;
+}
+export type ContractMap = Readonly<Record<string, ContractDeployment>>;
+export interface TransactionRequest {
+  readonly to: Address;
+  readonly data: Hex;
+  readonly value: bigint;
+}
+/** Preparation never submits a transaction or requests a wallet signature. */
+export interface TransactionPlan {
+  readonly chainId: number;
+  readonly transactions: readonly TransactionRequest[];
+}
+export interface PageRequest {
+  readonly cursor?: string;
+  readonly limit?: number;
+}
+export interface Page<T> {
+  readonly items: readonly T[];
+  readonly nextCursor?: string;
+  /** Present for catalog-backed listings. Discovery metadata is not RPC identity verification. */
+  readonly freshness?: PageFreshness;
+}
+export interface PageFreshness {
+  readonly revision: string;
+  readonly generatedAt: string;
+  readonly blockNumber: bigint;
+  readonly blockHash?: Hex;
+  /** Retained and bundled catalogs are explicit storage fallback sources. */
+  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;
+}
+type V4PoolReference = V4PoolKey | {
+  readonly poolId: Hex;
+};
+type V4ReadOptions = PoolReadOptions;
+interface V4SwapQuoteRequest extends SwapQuoteRequest<V4PoolReference> {
+  readonly hookData?: Hex;
+}
+interface V4DirectionalFees {
+  /** One pip is one millionth. */
+  readonly protocolFeePips: number;
+  readonly protocolFeePercent: string;
+}
+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;
+}
+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;
+}
+interface V4Contracts extends ContractMap {
+  readonly poolManager: ContractDeployment;
+  readonly stateView: ContractDeployment;
+  readonly quoter: ContractDeployment;
+}
+//#endregion
+//#region src/amm/enums.d.ts
+export declare enum AmmProtocol {
+  Blackhole = "blackhole",
+  Aerodrome = "aerodrome",
+  SushiSwap = "sushiswap",
+  Retro = "retro",
+  PancakeSwap = "pancakeswap",
+  QuickSwap = "quickswap",
+  Camelot = "camelot",
+  Uniswap = "uniswap"
+}
+export declare enum AerodromeVersion {
+  Slipstream = "slipstream",
+  SlipstreamV2 = "slipstream-v2",
+  SlipstreamV3 = "slipstream-v3"
+}
+export declare enum SushiSwapVersion {
+  V3 = "v3"
+}
+export declare enum RetroVersion {
+  V3 = "v3"
+}
+export declare enum UniswapVersion {
+  V3 = "v3",
+  V4 = "v4"
+}
+export declare enum QuickSwapVersion {
+  V3 = "v3",
+  V4 = "v4"
+}
+export declare enum BlackholeVersion {
+  CL = "cl"
+}
+export declare enum CamelotVersion {
+  V3 = "v3"
+}
+export declare enum PancakeSwapVersion {
+  V3 = "v3",
+  InfinityCL = "infinity-cl"
+}
+/** Named deployments for explicitly selecting between otherwise ambiguous matches. */
+export declare enum AmmDeployment {
+  BlackholeCLAvalanche = "blackhole-cl-avalanche",
+  AerodromeSlipstreamBase = "aerodrome-slipstream-base",
+  AerodromeSlipstreamV2Base = "aerodrome-slipstream-v2-base",
+  AerodromeSlipstreamV3Base = "aerodrome-slipstream-v3-base",
+  SushiSwapV3Polygon = "sushiswap-v3-polygon",
+  RetroV3Polygon = "retro-v3-polygon",
+  UniswapV3Polygon = "uniswap-v3-polygon",
+  QuickSwapV4Polygon = "quickswap-integral-polygon",
+  UniswapV3Base = "uniswap-v3-base",
+  UniswapV4Robinhood = "uniswap-v4-robinhood",
+  UniswapV4Bsc = "uniswap-v4-bsc",
+  UniswapV4Base = "uniswap-v4-base",
+  QuickSwapV3Polygon = "quickswap-polygon",
+  QuickSwapV4Base = "quickswap-integral-base",
+  CamelotV3Arbitrum = "camelot-arbitrum",
+  PancakeSwapV3Bsc = "pancakeswap-v3-bsc",
+  PancakeSwapInfinityCLBsc = "pancakeswap-infinity-cl-bsc"
+}
+export declare enum AmmFamily {
+  AerodromeSlipstream = "aerodrome-slipstream",
+  PancakeSwapInfinityCL = "pancakeswap-infinity-cl",
+  AlgebraLegacy = "algebra-legacy",
+  AlgebraIntegral = "algebra-integral",
+  UniswapV3 = "uniswap-v3",
+  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;
+}
+export interface DeploymentReference<TAdapter, TContracts extends ContractMap = ContractMap, TContext extends ChainContext = ChainContext> {
+  readonly definition: DeploymentDefinition<TContracts>;
+  connect(context: TContext): TAdapter;
+}
+/** 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;
+}
+/** 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>[];
+}
+//#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;
+}
+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/resolver-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/resolver.d.ts
+/** One resolver belongs to one Steer deployment and its registered integrations. */
+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>;
+  /** 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[]>;
+}
+//#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;
+}
+/** 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>;
+}
+//#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>;
+}
+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>>;
+}
+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;
+}
+/** 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 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;
+}
+/** 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/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;
+}
+/** 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;
+}
+export type PoolTokenFilter = TokenFilter;
+export interface PoolListRequest extends PageRequest {
+  /** Matches either pool token. All supplied fields must match the same token. */
+  readonly token?: PoolTokenFilter;
+}
+export declare abstract class PoolDataAdapter<TPoolRef> extends DataAdapter {
+  abstract listPools(request?: PoolListRequest, options?: DataAdapterRequestOptions): Promise<Page<TPoolRef>>;
+}
+export declare abstract class LendingDataAdapter<TMarketRef> extends DataAdapter {
+  abstract listMarkets(request?: PageRequest): Promise<Page<TMarketRef>>;
+}
+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/aerodrome/types.d.ts
+interface SlipstreamContracts extends ContractMap {
+  readonly factory: ContractDeployment;
+  readonly quoter: ContractDeployment;
+  readonly positionManager: ContractDeployment;
+}
+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;
+}
+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;
+}
+/** Optional caller for fee modules that apply transaction-origin discounts. */
+interface SlipstreamQuoteOptions extends ReadOptions {
+  readonly account?: Address;
+}
+//#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>;
+}
+//#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}`>>;
+}
+//#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/amm/adapters/aerodrome/slipstream-v2.d.ts
+export declare class AerodromeSlipstreamV2 extends AerodromeSlipstreamAdapter {
+  readonly protocol = AmmProtocol.Aerodrome;
+  readonly version = AerodromeVersion.SlipstreamV2;
+}
+//#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/amm/adapters/algebra/types.d.ts
+interface AlgebraContracts extends ContractMap {
+  readonly factory: ContractDeployment;
+  readonly poolDeployer: ContractDeployment;
+  readonly quoter: ContractDeployment;
+}
+/** 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;
+}
+//#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;
+};
+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;
+  };
+}
+//#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;
+  }>>;
+}
+export declare class Blackhole extends AlgebraIntegralAdapter {
+  readonly protocol = AmmProtocol.Blackhole;
+  readonly version = BlackholeVersion.CL;
+}
+export declare class QuickSwapIntegral extends AlgebraIntegralAdapter {
+  readonly protocol = AmmProtocol.QuickSwap;
+  readonly version = QuickSwapVersion.V4;
+}
+//#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>>;
+}
+//#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;
+}
+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/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;
+}
+type InfinityCLPoolReference = InfinityCLPoolKey | InfinityCLPoolIdReference;
+interface InfinityCLSwapQuoteRequest extends SwapQuoteRequest<InfinityCLPoolReference> {
+  readonly hookData?: Hex;
+}
+interface InfinityCLDirectionalFees {
+  readonly protocolFeePips: number;
+  readonly protocolFeePercent: string;
+}
+interface InfinityCLPoolFees {
+  readonly configuredFee: number;
+  readonly lpFeePips: number;
+  readonly lpFeePercent: string;
+  readonly protocolFeePacked: number;
+  readonly currency0ToCurrency1: InfinityCLDirectionalFees;
+  readonly currency1ToCurrency0: InfinityCLDirectionalFees;
+}
+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 InfinityCLContracts extends ContractMap {
+  readonly poolManager: ContractDeployment;
+  readonly vault: ContractDeployment;
+  readonly quoter: ContractDeployment;
+}
+//#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;
+}
+//#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>>;
+}
+//#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;
+}
+//#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;
+}
+//#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;
+  }>;
+}
+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;
+}
+//#endregion
+//#region src/amm/adapters/retro-v3/adapter.d.ts
+export declare class RetroV3 extends RpcUniswapV3Adapter {
+  readonly protocol = AmmProtocol.Retro;
+  readonly version = RetroVersion.V3;
+}
+//#endregion
+//#region src/amm/adapters/sushiswap-v3/adapter.d.ts
+export declare class SushiSwapV3 extends RpcUniswapV3Adapter {
+  readonly protocol = AmmProtocol.SushiSwap;
+  readonly version = SushiSwapVersion.V3;
+}
+//#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>;
+}
+//#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;
+}
+//#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);
+}
+//#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<{
+  BundleRegistry: Readonly<{
+    address: "0x245194Ed39516431FF511A74c7B6Df4cb4b5F1F3";
+    startBlock: 643298n;
+  }>;
+  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/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/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;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x71bE4708C86B8AFd6Aa47929Ce073e400B5B7747";
+    startBlock: 785298n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x1C735AdFe82133DdA6a08b81b813e4D7aff3b32a";
+    startBlock: 785194n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x1578228D5c62e2705AEe5BA1DeBd6D9a68830189";
+    startBlock: 785208n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xDAeed7DA964B212963Ce207660633758fc6ECfec";
+    startBlock: 785177n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xB1B736e7189ea99634f33EC199a1753E6CC7171C";
+    startBlock: 785187n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/berachainbartio.d.ts
+export declare const beraChainBartioContracts: Readonly<{
+  Orchestrator_Proxy: Readonly<{
+    address: "0x6d5d2BFc6269e6694FD4578Db74Bc2eA1e082FE1";
+    startBlock: 5094230n;
+  }>;
+  StakingRewards_Proxy: Readonly<{
+    address: "0xc97B1df5fBB12339D1493d171E10a30Af60164c0";
+    startBlock: 5094345n;
+  }>;
+  KeeperRegistry_Proxy: Readonly<{
+    address: "0xba318B1141ffD56a0B7C17b4f0A8D258016e79D5";
+    startBlock: 5094220n;
+  }>;
+  VaultRegistry_Proxy: Readonly<{
+    address: "0xa07bE822021cf648632Ab026978541ACa0C785B2";
+    startBlock: 5094258n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x2870B7F2469FBABa16aAabc3d642216685C94E1f";
+    startBlock: 5094269n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xb503E92D4e60b3E4F3c4D1F5037BaBde07994D4C";
+    startBlock: 5094352n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0xdAD90649Ee38d6eE64e73231888Cc546978Ef20A";
+    startBlock: 5094244n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xba318B1141ffD56a0B7C17b4f0A8D258016e79D5";
+    startBlock: 5094220n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0xbAa0E7Ac5e57E0d5614762D45D7df574Ed36efB8";
+    startBlock: 5094358n;
+  }>;
+  StakingRewards_Implementation: Readonly<{
+    address: "0xa017BDE31e344b18E6474D083581C73B1FA0481e";
+    startBlock: 5094344n;
+  }>;
+  KeeperRegistry_Implementation: Readonly<{
+    address: "0xcD5248462534F637302461342AEE5fF806CB3A30";
+    startBlock: 5094216n;
+  }>;
+  StrategyRegistry_Implementation: Readonly<{
+    address: "0x9B6D9a22628c4672f6d40DF99594a8fB4029599E";
+    startBlock: 5094233n;
+  }>;
+  DefaultProxyAdmin: Readonly<{
+    address: "0xaBd55d8720Bc18ec4CDF79681763D879d3C99039";
+    startBlock: 5094210n;
+  }>;
+  StrategyRegistry_Proxy: Readonly<{
+    address: "0x2c9305e4Db122017a751Df245620E36008d30BC8";
+    startBlock: 5094238n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x2c9305e4Db122017a751Df245620E36008d30BC8";
+    startBlock: 5094238n;
+  }>;
+  SteerPeriphery_Implementation: Readonly<{
+    address: "0x1c2Ba63289fe76c98A5919A78839b429cf177C00";
+    startBlock: 5094350n;
+  }>;
+  KodiakMultiPositionLiquidityManager: Readonly<{
+    address: "0xE34e9384d04190a3673249E60C75A2D3C30E3F9c";
+    startBlock: 5094209n;
+  }>;
+  SteerPeriphery_Proxy: Readonly<{
+    address: "0xb503E92D4e60b3E4F3c4D1F5037BaBde07994D4C";
+    startBlock: 5094352n;
+  }>;
+  StakingRewards: Readonly<{
+    address: "0xc97B1df5fBB12339D1493d171E10a30Af60164c0";
+    startBlock: 5094345n;
+  }>;
+  Orchestrator_Implementation: Readonly<{
+    address: "0x5891EA0B417bea4316a2D55D63fA7e583476F554";
+    startBlock: 5094225n;
+  }>;
+  Helper: Readonly<{
+    address: "0x7e816Dfd0d141aF36E0bC920b90d748C781334E9";
+    startBlock: 5094249n;
+  }>;
+  FeeManager_Proxy: Readonly<{
+    address: "0x16351b41F131664fF717cA18fe82302abbfCbD7d";
+    startBlock: 5094363n;
+  }>;
+  FeeManager_Implementation: Readonly<{
+    address: "0x512A8641197fE9222DD9558E586612EE3F2B4ea3";
+    startBlock: 5094360n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xa07bE822021cf648632Ab026978541ACa0C785B2";
+    startBlock: 5094258n;
+  }>;
+  BundleRegistry_Implementation: Readonly<{
+    address: "0xA545DdAC80a1DcCc1156A9d7bBa93BB0A8563Bc3";
+    startBlock: 5094355n;
+  }>;
+  VaultRegistry_Implementation: Readonly<{
+    address: "0x95fda2FEE2595D0C0C8a82871df6EA48F188aFe0";
+    startBlock: 5094254n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x6d5d2BFc6269e6694FD4578Db74Bc2eA1e082FE1";
+    startBlock: 5094230n;
+  }>;
+  BundleRegistry_Proxy: Readonly<{
+    address: "0xbAa0E7Ac5e57E0d5614762D45D7df574Ed36efB8";
+    startBlock: 5094358n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x0D3Ea88C8C3cb26EF21ab9E9ac6D178602Ef2779";
+  }>;
+  GasVault_Implementation: Readonly<{
+    address: "0x4Be69FCff456216B98467A564f5f9B4BFb1792Fe";
+    startBlock: 5094266n;
+  }>;
+  GasVault_Proxy: Readonly<{
+    address: "0x2870B7F2469FBABa16aAabc3d642216685C94E1f";
+    startBlock: 5094269n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/bittensor.d.ts
+export declare const bittensorContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0x3B4cAD7D6cd045bD038697a4EaA3AD5A99E5Aa70";
+    startBlock: 8081621n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x588B34D2a9598497f481A9d31B4eD372C6135f32";
+    startBlock: 8081627n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xcE33017087582548c996581d1cde9549ea54221d";
+    startBlock: 8081624n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x83966243D6055b1A1157f800cBC9f5084162b871";
+    startBlock: 8081631n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x10b988Df6b17B4dF7Fe6DFf6De45346e8fa8376D";
+    startBlock: 8081645n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x4E4D0040AF576482E7757aD4aE47b4f4587807d6";
+    startBlock: 8081637n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x83ee3e4Bcac37f69C133f908E5a704eA9b7d74Eb";
+    startBlock: 8081642n;
+  }>;
+  Helper: Readonly<{
+    address: "0xEe351402D6A89E4468D2E6fD0f702602AdeAde91";
+    startBlock: 8081629n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xC347cB5492360aD29a9Cb14A11ecBF5aa23038C7";
+    startBlock: 8081648n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0x6511080422911D210681f5618DBd50DEC3e954de";
+    startBlock: 8081628n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/blast.d.ts
+export declare const blastContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xDe6024872d45032B9C62c2E015d2bcff2922B337";
+    startBlock: 417476n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
+    startBlock: 417398n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xdca3251Ebe8f85458E8d95813bCb816460e4bef1";
+    startBlock: 417462n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 411072n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 417373n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 411010n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 411025n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x7Daa68204232a78dBF1Dd853a4018330EE934A39";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/bsc.d.ts
+export declare const bscContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x36C796BcA1E8E4031D3FdFA1ff0FA5EF429e0ED2";
+    startBlock: 28461525n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x0C5c5BEB833fD382b04e039f151942DC3D9A60ce";
+    startBlock: 28461501n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xe240B9a2936f6Fb8860219bC059349e50F03492e";
+    startBlock: 28461517n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 28461392n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x31e4ee367d4f2685BAfcAb9566e9C87E60D48983";
+    startBlock: 28461459n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 28461329n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x3B41454CB7858B6D0535e61bAe9362AF0151Cc2d";
+    startBlock: 28461434n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/celo.d.ts
+export declare const celoContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xDe6024872d45032B9C62c2E015d2bcff2922B337";
+    startBlock: 19813153n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xab36D30C1A1C683037Bd7AAC67f29B2e3ECC6576";
+    startBlock: 19813141n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xdca3251Ebe8f85458E8d95813bCb816460e4bef1";
+    startBlock: 19813148n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 19813118n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x116Dba5DcE9CcDA828218b7eB46406810632014C";
+    startBlock: 19813127n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 19813113n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 19813123n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/core.d.ts
+export declare const coreContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x245194Ed39516431FF511A74c7B6Df4cb4b5F1F3";
+    startBlock: 23460135n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
+    startBlock: 23460078n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xd5532a58E4ABB6485FF4e7BCf5bED278e32A516e";
+    startBlock: 23460128n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 23460063n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 23460073n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xf71Bb63b641031150220f84Fa0326F851ecb3d30";
+    startBlock: 23460052n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 23460059n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/evmos.d.ts
+export declare const evmosContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x7Daa68204232a78dBF1Dd853a4018330EE934A39";
+    startBlock: 13671980n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 13671912n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x1afD31627170607657224eD4aE701470209C4B2e";
+    startBlock: 13671971n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x30138931Beab8eE0233F8a094660c60A4383eb21";
+    startBlock: 13671887n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xD90c8970708FfdFC403bdb56636621e3E9CCe921";
+    startBlock: 13671900n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x116Dba5DcE9CcDA828218b7eB46406810632014C";
+    startBlock: 13671871n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x3B41454CB7858B6D0535e61bAe9362AF0151Cc2d";
+    startBlock: 13671882n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/fantom.d.ts
+export declare const fantomContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xCF9b0A9D456d6325Bc3B508aB67365D697fe0590";
+    startBlock: 76157142n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x7760D5cb6366dD1dEad394012186202B1834cDE5";
+    startBlock: 76157028n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xcb77e4C30D92c8b959811E99213625C7b9490b96";
+    startBlock: 76157080n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xEfecC1cEb7325C269fdb6337208E096f73f76CeD";
+    startBlock: 76156961n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x4DE18F1582Aa71671828F329B826ad45B2798b12";
+    startBlock: 76156993n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x4Cb98E1eeef513086B6a724f6B5401031b125649";
+    startBlock: 76156897n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xc38507394FAdcf1a421BC4103FD66151089FbcfE";
+    startBlock: 76156977n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/filecoin.d.ts
+export declare const filecoinContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x279228AAfd13Bb4642ABB772a248c78555DC39c4";
+    startBlock: 4333421n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xe1C56f99a459ED47B629F3D818BcC84826bCed66";
+    startBlock: 4333398n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xab36D30C1A1C683037Bd7AAC67f29B2e3ECC6576";
+    startBlock: 4333415n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 4333366n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 4333381n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 4333359n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 4333373n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x0C5c5BEB833fD382b04e039f151942DC3D9A60ce";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/flare.d.ts
+export declare const flareContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x9fCFb37f7ED723dE280F5E1D3617aB7d06caaa0A";
+    startBlock: 26092328n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x245194Ed39516431FF511A74c7B6Df4cb4b5F1F3";
+    startBlock: 26092127n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x7Daa68204232a78dBF1Dd853a4018330EE934A39";
+    startBlock: 26092312n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xDe6024872d45032B9C62c2E015d2bcff2922B337";
+    startBlock: 26092027n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x64F9A121Ccbb8956249Ed52C4f63d0f759da53Ce";
+    startBlock: 26092102n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xdca3251Ebe8f85458E8d95813bCb816460e4bef1";
+    startBlock: 26092014n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xe240B9a2936f6Fb8860219bC059349e50F03492e";
+    startBlock: 26092087n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xb944789b5C962f1096Ce8674456E68fb0F2e3BB7";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/hemi.d.ts
+export declare const hemiContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xc9De841A2A00DeaAF9F0E5374Fd5011C952e5f5C";
+    startBlock: 1390479n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xAa4448AeF5f5967693751BFB67197946BB6D1dC0";
+    startBlock: 1390468n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xd47CE509bE01e62cd4629E2f1eb22BA04e7dA192";
+    startBlock: 1390475n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x0C5c5BEB833fD382b04e039f151942DC3D9A60ce";
+    startBlock: 1390398n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x37Cff062D52Dd6E9E39Df619CCd30c037a36bB83";
+    startBlock: 1390406n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x279228AAfd13Bb4642ABB772a248c78555DC39c4";
+    startBlock: 1390389n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xE431A1dE6F37cD08AAA8821F83bD2157857E8172";
+    startBlock: 1390401n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/hyperevm.d.ts
+export declare const hyperevmContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0x5920168d62238e28e147BEdC0f5eDF02eB6b66f1";
+    startBlock: 14721941n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xb031c61cE15fC62de2Bea264A2d7ac467e5B1e53";
+    startBlock: 14722124n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x324e36ad36D204831a7E1eFD1FF882384499F4C0";
+    startBlock: 14722368n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x210770DEDbB70d269969ac9415241ca4A7b30341";
+    startBlock: 14723039n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x221b9F402d33dB2F48725782644fB2dd3090e08f";
+    startBlock: 14724137n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xB8a1C40cE7e0ea1121D016913E32a73004819e24";
+    startBlock: 14723222n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0xfEcB56d58B7f70A0EB2E3822fE7C4Eb959095F63";
+    startBlock: 14722490n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x40CA241eE876caF5BFa9c0724069f082473a6fFC";
+    startBlock: 14723954n;
+  }>;
+  StakingRewards: Readonly<{
+    address: "0xbE0De6ea74EC22840e4cf91a85aA3F139787ac9e";
+    startBlock: 14723771n;
+  }>;
+  Helper: Readonly<{
+    address: "0xc98D361ef423fef0174643b42b6f3B018111Ae6a";
+    startBlock: 14722795n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x8BfAdC53bfd06F051685b42690076d9c94aaBCBd";
+    startBlock: 14724320n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0x776bddf9b0513f4e2f4622c55c32d5b56fb54927";
+    startBlock: 20161135n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/katana.d.ts
+export declare const katanaContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0xe6C78a5Bb134F00a3111f34b5ee863c82041292F";
+    startBlock: 2202723n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x1C735AdFe82133DdA6a08b81b813e4D7aff3b32a";
+    startBlock: 2202743n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x27C6b12cC14a498E0E252BD7F3E7Af060eBAB048";
+    startBlock: 2202735n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x1D04A1f5FD79e09B7692baDeE2846Fd0F90dCF24";
+    startBlock: 2202756n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x491bf4ACa9a475E107Cfa4BcDd836648B72C34e5";
+    startBlock: 2202801n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x2CCADD513EBBdc51b135879cb7BC1693CB476ED6";
+    startBlock: 2202776n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0xBCF95873ed5397Bc0B2e0A35b06C0dd9Ac84C8B8";
+    startBlock: 2202746n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x4DE18F1582Aa71671828F329B826ad45B2798b12";
+    startBlock: 2202791n;
+  }>;
+  StakingRewards: Readonly<{
+    address: "0x5BBDCB03183f5afE2C9DA5a30E2Cdac1CCd151E1";
+    startBlock: 2202749n;
+  }>;
+  Helper: Readonly<{
+    address: "0x64833f91Df7E9b5b1f35510a7FEbd213201AA06e";
+    startBlock: 2202749n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x7760D5cb6366dD1dEad394012186202B1834cDE5";
+    startBlock: 2202811n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0x01ffCeBd15e2EfFD96ba1c3014c9260ecB575823";
+    startBlock: 8260827n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/kava.d.ts
+export declare const kavaContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xfb4F2358F8677e1309868aBce4c447A55eAfb326";
+    startBlock: 5915652n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x7c31a819a36E29939058b61fDAEA28bC3CFb66B8";
+    startBlock: 5915251n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xf90107890B640387ec3b0474F0c61674AEbCb510";
+    startBlock: 5915571n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xdca3251Ebe8f85458E8d95813bCb816460e4bef1";
+    startBlock: 5915194n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xe240B9a2936f6Fb8860219bC059349e50F03492e";
+    startBlock: 5915232n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 5915167n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xDe6024872d45032B9C62c2E015d2bcff2922B337";
+    startBlock: 5915211n;
+  }>;
+  PoolHelper: Readonly<{
+    address: "0x4B76fE1D77faD404e4AFD7Fa9797cDCC84Aa2469";
+    startBlock: 12934741n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/linea.d.ts
+export declare const lineaContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xE431A1dE6F37cD08AAA8821F83bD2157857E8172";
+    startBlock: 656320n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
+    startBlock: 656313n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x0C5c5BEB833fD382b04e039f151942DC3D9A60ce";
+    startBlock: 656317n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 656297n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
+    startBlock: 656303n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 656294n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 656300n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xBcD427Ff26b70E73149858C4898DFa60107bedBe";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/mainnet.d.ts
+export declare const ethereumContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x38E6291bADD1680054A3fB67f449F8848444Dfa4";
+    startBlock: 21701103n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xa3137A5F54f803BDf0c0209a11EE41446f0C2AfA";
+    startBlock: 21701090n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xCEBF1A54A9Ce703FC80967760b5A6cbDb4111099";
+    startBlock: 21701098n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xBb9C7123432B3871b2edF3Cc026c22684F999189";
+    startBlock: 21701068n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x5ef68cc787Cd560ab8b723a2499e9a79c639C647";
+    startBlock: 21701081n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x86fd6C835FEeA48e1f344d0312D9b081441ced69";
+    startBlock: 21701065n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x4867dc4e325C3fF0F676A6316d69180f15bcd463";
+    startBlock: 21701073n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 23239469n;
+  }>;
+  Helper: Readonly<{
+    address: "0x18F89CD017f58837721C05ff0aD309ACf7B4087C";
+    startBlock: 21701078n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/manta.d.ts
+export declare const mantaContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 407259n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xe1C56f99a459ED47B629F3D818BcC84826bCed66";
+    startBlock: 407252n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xD90c8970708FfdFC403bdb56636621e3E9CCe921";
+    startBlock: 407256n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 407239n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 407246n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xf71Bb63b641031150220f84Fa0326F851ecb3d30";
+    startBlock: 407236n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 407243n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/mantle.d.ts
+export declare const mantleContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x7c31a819a36E29939058b61fDAEA28bC3CFb66B8";
+    startBlock: 48569983n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x116Dba5DcE9CcDA828218b7eB46406810632014C";
+    startBlock: 48569748n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x36C796BcA1E8E4031D3FdFA1ff0FA5EF429e0ED2";
+    startBlock: 48569965n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 48569697n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 48569734n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 48569643n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 48569676n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/metis.d.ts
+export declare const metisContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xB27a61fAf33d2F6ad7Af8CC2512C3b58901F779B";
+    startBlock: 6067804n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x31e4ee367d4f2685BAfcAb9566e9C87E60D48983";
+    startBlock: 6067770n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
+    startBlock: 6067794n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 6067712n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x116Dba5DcE9CcDA828218b7eB46406810632014C";
+    startBlock: 6067741n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 6067702n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 6067725n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/mode.d.ts
+export declare const modeContracts: Readonly<{
+  PoolHelper: Readonly<{
+    address: "0xA9d55eb3fBEE553db12cB25C8cF8ADbdB6d74541";
+    startBlock: 13458174n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
+    startBlock: 5307828n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x3B41454CB7858B6D0535e61bAe9362AF0151Cc2d";
+    startBlock: 5307798n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x16BA7102271dC83Fff2f709691c2B601DAD7668e";
+    startBlock: 5307816n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 5307749n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 5307774n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 5307737n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 5307762n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x7Daa68204232a78dBF1Dd853a4018330EE934A39";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/monad.d.ts
+export declare const monadContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0xc76A94F0cb1877B2C036821CEB3b9a21eEADb266";
+    startBlock: 111283055n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xAc7D3A933c44b4D4bad6D5F0685900482E0d995E";
+    startBlock: 111283115n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xCD31EbF762A5d1F88399E692316903767DA06Cf9";
+    startBlock: 111283234n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0xfB30AE7542a5E8A5BC134128c0c9dEb4646a2508";
+    startBlock: 111283142n;
+  }>;
+  Helper: Readonly<{
+    address: "0x8725f2f77508EDd583C6f3840F88Db6A2d0Cf009";
+    startBlock: 111283171n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x52Db9bcb9EFdBAaa8E1D2326E0b69c57Bf14c333";
+    startBlock: 111283296n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x2c637b31A2b320E4f28c148328443d22498294fa";
+    startBlock: 111283356n;
+  }>;
+  StakingRewards: Readonly<{
+    address: "0x8c78E9F6336bFC518B6651e3A2d02F745a94B09E";
+    startBlock: 111283417n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xcE33017087582548c996581d1cde9549ea54221d";
+    startBlock: 111283601n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x0a271fc23BA4c6A4a668E7Ceef9aDE60C59f5Ec5";
+    startBlock: 111283478n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xb05107884d9a54B0dd58eBd06C93399941B0e6Cd";
+    startBlock: 111283540n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/moonbeam.d.ts
+export declare const moonbeamContracts: Readonly<{
+  PoolHelper: Readonly<{
+    address: "0xDA6BA21f39d33e922ecC43d41E7068988dc36C6A";
+    startBlock: 9389000n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0xbfd2E0C4cF82d91ec13731e7bc14Ac6120cd01F5";
+    startBlock: 8677441n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x00D0Cc8Db826dA3F68B0F645acC7785F917aAff8";
+    startBlock: 8677412n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xa4a2f232C92f2DE7181E9fe4d46297FbBb4afaaA";
+    startBlock: 8677428n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x4Cb98E1eeef513086B6a724f6B5401031b125649";
+    startBlock: 8677373n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xE11709193e7b2E0a0F2a4591022cFf4f01E75050";
+    startBlock: 8677394n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xa3fd4B3BD38aB8BBF3f26BB17aA410222B9965Bc";
+    startBlock: 8677361n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xEfecC1cEb7325C269fdb6337208E096f73f76CeD";
+    startBlock: 8677382n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xfF42cD42d8a5812CB38fb3C0720Dfc490912f48B";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/nibiru.d.ts
+export declare const nibiruContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0x1D04A1f5FD79e09B7692baDeE2846Fd0F90dCF24";
+    startBlock: 25374486n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x2CCADD513EBBdc51b135879cb7BC1693CB476ED6";
+    startBlock: 25374513n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x5BBDCB03183f5afE2C9DA5a30E2Cdac1CCd151E1";
+    startBlock: 25374497n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x3Add6C19e86C22B2fe5AD9c328C0C3Db88382534";
+    startBlock: 25374534n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0xCF9b0A9D456d6325Bc3B508aB67365D697fe0590";
+    startBlock: 25374594n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xa98376572375692455172f6750C67339667974fe";
+    startBlock: 25374560n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0x215431CF4699f8bb01F339E09E9603F2975b2997";
+    startBlock: 25374516n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xcb77e4C30D92c8b959811E99213625C7b9490b96";
+    startBlock: 25374582n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0x4e48fced3b4cd92bbfba0314ed844046a91c4fd5";
+    startBlock: 32069570n;
+  }>;
+  Helper: Readonly<{
+    address: "0xc38507394FAdcf1a421BC4103FD66151089FbcfE";
+    startBlock: 25374521n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/okxtestnet.d.ts
+export declare const okxTestnetContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x2cDAD0Cfa7D5cFc1e54E9f4b9dAcBcFd51b7c466";
+    startBlock: 10562524n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x93470e5d4aFFab0CE2E80D47be420C42F0EB9692";
+    startBlock: 10562507n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x22Ee5c43031F045f792cCd81c8fEcf70e51B1011";
+    startBlock: 10562516n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x1673a527836C577c8807480C89CE6de529ab0017";
+    startBlock: 10562093n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xEfE1A4a97181d37d9Fd2aacb306E9a2dB956Ccdd";
+    startBlock: 10562483n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x125116e39Ec5CECfE29F3d139050cd036Ea2ce19";
+    startBlock: 10562075n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xD259853e5d3DB0844f1E70fB876AEdEfBb021148";
+    startBlock: 10562445n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/optimism.d.ts
+export declare const optimismContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x64F9A121Ccbb8956249Ed52C4f63d0f759da53Ce";
+    startBlock: 97061023n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x5D8249e3F5f702e1Fd720167b40424fc2daDCd1e";
+    startBlock: 97060844n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x7c464A0AB1f5ebf3E2dCccfec7EF41D02ED7a2f4";
+    startBlock: 97060953n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 96971404n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
+    startBlock: 96971465n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 96971378n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 96971425n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/peaq.d.ts
+export declare const peaqContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xdca3251Ebe8f85458E8d95813bCb816460e4bef1";
+    startBlock: 5383056n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x30138931Beab8eE0233F8a094660c60A4383eb21";
+    startBlock: 5383001n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 5383047n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 5382980n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 5382992n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xf71Bb63b641031150220f84Fa0326F851ecb3d30";
+    startBlock: 5382976n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 5382986n;
+  }>;
+  Helper: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 5382988n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0x1C735AdFe82133DdA6a08b81b813e4D7aff3b32a";
+    startBlock: 6429095n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/polygon.d.ts
+export declare const polygonContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x3cEa6c4d74d84aF61d9Dc4AA59a69bBf9fE0A5e1";
+    startBlock: 41535643n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xAEF566edD7f25D50b584e4227F62cB5A2e2eBae7";
+    startBlock: 41535585n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x29E1888F7DD0757f2873E494463Ec389dab38D27";
+    startBlock: 41535635n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x0f88432be83a7AA4608CC6C0dE555bE74c10F5c3";
+    startBlock: 41535505n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x24825B3C44742600D3995d1D3760cceE999A7f0b";
+    startBlock: 41535540n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x40402363fD11729183108b10DC96776675229ae7";
+    startBlock: 41535492n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x76C9557c63ECFB3a3215A9e7fDA9245b672f521a";
+    startBlock: 41535523n;
+  }>;
+  Helper: Readonly<{
+    address: "0x526e12c87dc9d48623D28e24d997EF81EcA22133";
+    startBlock: 74667935n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0x7c0222afd475e707b48c6dae27cd2a16d2643218";
+    startBlock: 75114382n;
+  }>;
+  PoolHelper: Readonly<{
+    address: "0xa7da6196B871A53f6aEC27F9EA4BBC39C1390EF4";
+    startBlock: 59943299n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/polygonzkevm.d.ts
+export declare const polygonZkEvmContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xdca3251Ebe8f85458E8d95813bCb816460e4bef1";
+    startBlock: 1022506n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x254d37F5eD7E96fc2d242CB06B17FAe1EE9E1ADA";
+    startBlock: 1022454n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 1022486n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 1022115n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
+    startBlock: 1022413n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 1022098n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 1022377n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/robinhood.d.ts
+export declare const robinhoodContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0xF6aB5f1faED774e62D30c2A65e39a5a25F8E14e7";
+    startBlock: 8704501n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x20B895F7C02e754AdC461e80b39a9e85f02e2bE3";
+    startBlock: 8704962n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xAc7D3A933c44b4D4bad6D5F0685900482E0d995E";
+    startBlock: 8704773n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x5c7d564fA5CE0e874367121E33c1ff10dB2115dC";
+    startBlock: 8705247n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0xEe351402D6A89E4468D2E6fD0f702602AdeAde91";
+    startBlock: 8705995n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x3B4cAD7D6cd045bD038697a4EaA3AD5A99E5Aa70";
+    startBlock: 8705555n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0xCD31EbF762A5d1F88399E692316903767DA06Cf9";
+    startBlock: 8705032n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xCCd21830A8774484AE824AC05B3784D195686C7e";
+    startBlock: 8705824n;
+  }>;
+  StakingRewards: Readonly<{
+    address: "0x8c78E9F6336bFC518B6651e3A2d02F745a94B09E";
+    startBlock: 8705422n;
+  }>;
+  Helper: Readonly<{
+    address: "0x2af1bD206aAf5e74073691707d0A006ae2128ED3";
+    startBlock: 8705074n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x22518d0C864F6C6391b76850d96D5fC27a7A45bD";
+    startBlock: 8706188n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/ronin.d.ts
+export declare const roninContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x82013a220c21caFEa99381738EDFbC52a6956f90";
+    startBlock: 45874579n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xcb77e4C30D92c8b959811E99213625C7b9490b96";
+    startBlock: 45874479n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x7bb362141BB277C7609519e9fBA4927A5e2e5cC7";
+    startBlock: 45874567n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x491bf4ACa9a475E107Cfa4BcDd836648B72C34e5";
+    startBlock: 45874447n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xac4D51669B80D09d8Cc5EeFF50026c4d1D3290e6";
+    startBlock: 45874467n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xE11709193e7b2E0a0F2a4591022cFf4f01E75050";
+    startBlock: 45874428n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x9427EA2b2262CC5f2F1876F85eFF4e48Fe33A8b2";
+    startBlock: 45874439n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/rootstock.d.ts
+export declare const rootstockContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xD40699A642172DeD33BCFe4E3F84D54610C757Cd";
+    startBlock: 6413199n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x5D8249e3F5f702e1Fd720167b40424fc2daDCd1e";
+    startBlock: 6413185n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x37Cff062D52Dd6E9E39Df619CCd30c037a36bB83";
+    startBlock: 6413193n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xe1C56f99a459ED47B629F3D818BcC84826bCed66";
+    startBlock: 6413160n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
+    startBlock: 6413173n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x9f5b097AD23e2CF4F34e502A3E41D941678877Dc";
+    startBlock: 6413154n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x254d37F5eD7E96fc2d242CB06B17FAe1EE9E1ADA";
+    startBlock: 6413166n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xAa4448AeF5f5967693751BFB67197946BB6D1dC0";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/saga.d.ts
+export declare const sagaContracts: Readonly<{
+  KeeperRegistry: Readonly<{
+    address: "0xdED9B1e5b1d419106d8C982a0D3fE1bbCB983d87";
+    startBlock: 3008348n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x7Daa68204232a78dBF1Dd853a4018330EE934A39";
+    startBlock: 3008357n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x1afD31627170607657224eD4aE701470209C4B2e";
+    startBlock: 3008353n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xe6C78a5Bb134F00a3111f34b5ee863c82041292F";
+    startBlock: 3008375n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0xEfecC1cEb7325C269fdb6337208E096f73f76CeD";
+    startBlock: 3008395n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x1C735AdFe82133DdA6a08b81b813e4D7aff3b32a";
+    startBlock: 3008383n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0xc9De841A2A00DeaAF9F0E5374Fd5011C952e5f5C";
+    startBlock: 3008358n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x4Cb98E1eeef513086B6a724f6B5401031b125649";
+    startBlock: 3008391n;
+  }>;
+  Helper: Readonly<{
+    address: "0xB3d8529332450CFc942F480fDc9Ac5c17805c24b";
+    startBlock: 3106793n;
+  }>;
+  SingleAssetDeposit: Readonly<{
+    address: "0xa1330e9017aB685dc34B746005f4DAB0476b16b4";
+    startBlock: 4003688n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/scroll.d.ts
+export declare const scrollContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 287617n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xe1C56f99a459ED47B629F3D818BcC84826bCed66";
+    startBlock: 287579n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xD90c8970708FfdFC403bdb56636621e3E9CCe921";
+    startBlock: 287609n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x925C4454820b2b88c2f70F2621E6890b451266Dd";
+    startBlock: 287545n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 287562n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xf71Bb63b641031150220f84Fa0326F851ecb3d30";
+    startBlock: 287537n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x09eb271b444d1db7163c8555919dE85b20Be7D1d";
+    startBlock: 287553n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xa4a2f232C92f2DE7181E9fe4d46297FbBb4afaaA";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/sei.d.ts
+export declare const seiContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x391cf3047db983caB8dD95B16c4e6C3918d72d23";
+    startBlock: 119979618n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x4Cb98E1eeef513086B6a724f6B5401031b125649";
+    startBlock: 119979437n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xfF42cD42d8a5812CB38fb3C0720Dfc490912f48B";
+    startBlock: 119979598n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xB1B736e7189ea99634f33EC199a1753E6CC7171C";
+    startBlock: 119979272n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xa3fd4B3BD38aB8BBF3f26BB17aA410222B9965Bc";
+    startBlock: 119979309n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x9fCFb37f7ED723dE280F5E1D3617aB7d06caaa0A";
+    startBlock: 119979224n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xb944789b5C962f1096Ce8674456E68fb0F2e3BB7";
+    startBlock: 119979256n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x9790aFEc5d23a840bC0597D9F54584057254d190";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/soneium.d.ts
+export declare const soneiumContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x15471a7555B9d7dbe8fd577FDE381E8Fb7E7702d";
+    startBlock: 2154765n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x3144706Fd5EF06c8fC1B80494902D0fC0Da8497B";
+    startBlock: 2154739n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x1e5Fd638E8BF242Ae2a5bdd9ABBfd2681D25aDDC";
+    startBlock: 2154753n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xb95572432c935f62E25376280724FDbAD9F8F755";
+    startBlock: 2154691n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x371A7af1c64396186DfE0d3D0BdBAf43a0Fd8a09";
+    startBlock: 2154716n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x2Ca933639900b88346EdB1D1dDF58A752314D566";
+    startBlock: 2154680n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x42D1316c1ce4E0f143C12771004AFb91a03CaF6d";
+    startBlock: 2154701n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/sonic.d.ts
+export declare const sonicContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x42D1316c1ce4E0f143C12771004AFb91a03CaF6d";
+    startBlock: 474917n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x9A9E78387c21d88138481dA872E1DbaEF71078B2";
+    startBlock: 474894n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xb95572432c935f62E25376280724FDbAD9F8F755";
+    startBlock: 474909n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x169133E32C4A68Ad0F922c567Db816951000f0AA";
+    startBlock: 474861n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x253B89EfA5a23B1b0305416973F21F6a11CEfab0";
+    startBlock: 474881n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x9d72AAc456B5Adf6a557d68EF30862a0755CcCDf";
+    startBlock: 474855n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x8cB05d7b3B525070f489167DbB9C0f174e1FB137";
+    startBlock: 474869n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x51aC65B177F084455750131A81706C32b466101D";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/taiko.d.ts
+export declare const taikoContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xAa4448AeF5f5967693751BFB67197946BB6D1dC0";
+    startBlock: 35165n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xC1Ecd10398A6D7036CceE1f50551ff169715081c";
+    startBlock: 34588n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xD40699A642172DeD33BCFe4E3F84D54610C757Cd";
+    startBlock: 35160n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 34577n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 34583n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 34571n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 34575n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x254d37F5eD7E96fc2d242CB06B17FAe1EE9E1ADA";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/tataratestnet.d.ts
+export declare const tataraTestnetContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xaA98e8f03F528B73157E30a17de3EC40dB7382fE";
+    startBlock: 1115328n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x795BF9303441ef0b1134220d9142A49d8212260C";
+    startBlock: 1115180n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x2DBca2283f74cB663d1E0E7A85dFf46938B24c87";
+    startBlock: 1115320n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x13c422072097C7488c1bB9ff28D95798Aa0cDBFA";
+    startBlock: 1115072n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x22Ee5c43031F045f792cCd81c8fEcf70e51B1011";
+    startBlock: 1115087n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xb78e325915b10D02BA75C24C2bdae7197BBA65ef";
+    startBlock: 1115057n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x7bE509f52EBBC41855b3213Fc743B2b865635f20";
+    startBlock: 1115064n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/telos.d.ts
+export declare const telosContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x806c2240793b3738000fcb62C66BF462764B903F";
+    startBlock: 337121451n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x3B41454CB7858B6D0535e61bAe9362AF0151Cc2d";
+    startBlock: 337121367n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x16BA7102271dC83Fff2f709691c2B601DAD7668e";
+    startBlock: 337121426n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 337121273n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x2822eE30383EAbCBA817Ab4A7a592F4a194e14b5";
+    startBlock: 337121319n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 337121247n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 337121296n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0xE431A1dE6F37cD08AAA8821F83bD2157857E8172";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/thundercore.d.ts
+export declare const thundercoreContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x279228AAfd13Bb4642ABB772a248c78555DC39c4";
+    startBlock: 135181905n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x30138931Beab8eE0233F8a094660c60A4383eb21";
+    startBlock: 135181876n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xab36D30C1A1C683037Bd7AAC67f29B2e3ECC6576";
+    startBlock: 135181890n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 135181826n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 135181847n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x99eca0E5Db125900E3a0389F6D3503837e99F59b";
+    startBlock: 135181811n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xd964811233b8A0185D3C93664df82136C80d1bb2";
+    startBlock: 135181840n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/unichain.d.ts
+export declare const unichainContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x7bb362141BB277C7609519e9fBA4927A5e2e5cC7";
+    startBlock: 8620614n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xBcD427Ff26b70E73149858C4898DFa60107bedBe";
+    startBlock: 8620543n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x01ffCeBd15e2EfFD96ba1c3014c9260ecB575823";
+    startBlock: 8620593n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xfF42cD42d8a5812CB38fb3C0720Dfc490912f48B";
+    startBlock: 8620443n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x6d5A04974ba2CdC3E307135fE5886b8c7C499e9A";
+    startBlock: 8620494n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0xbfd2E0C4cF82d91ec13731e7bc14Ac6120cd01F5";
+    startBlock: 8620421n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x391cf3047db983caB8dD95B16c4e6C3918d72d23";
+    startBlock: 8620465n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/xlayer.d.ts
+export declare const xLayerContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x279228AAfd13Bb4642ABB772a248c78555DC39c4";
+    startBlock: 653519n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x30138931Beab8eE0233F8a094660c60A4383eb21";
+    startBlock: 653502n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xab36D30C1A1C683037Bd7AAC67f29B2e3ECC6576";
+    startBlock: 653511n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xF4de4180829272ae5f69AcAcf820f4F7d547513b";
+    startBlock: 653475n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xa1Dd21fbd9e1F0BF28d41F18bDC22326e50C02e9";
+    startBlock: 653490n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x99eca0E5Db125900E3a0389F6D3503837e99F59b";
+    startBlock: 653467n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xd964811233b8A0185D3C93664df82136C80d1bb2";
+    startBlock: 653482n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/zeta.d.ts
+export declare const zetaContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0x51aC65B177F084455750131A81706C32b466101D";
+    startBlock: 6576836n;
+  }>;
+  GasVault: Readonly<{
+    address: "0x8b82CaF0CDcbbf53F9b071c643609EFE02307536";
+    startBlock: 6576804n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x42D1316c1ce4E0f143C12771004AFb91a03CaF6d";
+    startBlock: 6576833n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x918b3E95eE1329D9549E32874db0BF161D516457";
+    startBlock: 6576795n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x49c40936D8430dCBf5787bb6F0F3B26578cc3c12";
+    startBlock: 6576801n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x7bb362141BB277C7609519e9fBA4927A5e2e5cC7";
+    startBlock: 6576790n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x82013a220c21caFEa99381738EDFbC52a6956f90";
+    startBlock: 6576793n;
+  }>;
+}>;
+//#endregion
+//#region src/contracts/zircuit.d.ts
+export declare const zircuitContracts: Readonly<{
+  BundleRegistry: Readonly<{
+    address: "0xcA19bEc25A41443F35EeAE03411Dce87D8c0Edc4";
+    startBlock: 5524154n;
+  }>;
+  GasVault: Readonly<{
+    address: "0xe1C56f99a459ED47B629F3D818BcC84826bCed66";
+    startBlock: 5522254n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0xD90c8970708FfdFC403bdb56636621e3E9CCe921";
+    startBlock: 5524033n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0x317EEDB54711681056f37e10d5DE0B55455b476f";
+    startBlock: 5522181n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0x38a07152ee64C7067fEeBA904D72ABc9a9DA0C77";
+    startBlock: 5522213n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x1A7e75715d157736103eC429Ff7079994D907472";
+    startBlock: 5522168n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0x8fB2Cd40046b08F155d06C3A31b69C1Bd2C971e2";
+    startBlock: 5522196n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x0C5c5BEB833fD382b04e039f151942DC3D9A60ce";
+  }>;
+}>;
+//#endregion
+//#region src/contracts/zklinknova.d.ts
+export declare const zkLinkNovaContracts: Readonly<{
+  GasVault: Readonly<{
+    address: "0x57174e55abFaa7d858F8a4C395967FFaF990190A";
+    startBlock: 34588n;
+  }>;
+  SteerPeriphery: Readonly<{
+    address: "0x525b443C8d2D0aA8Bd70d22177EC6250286b9708";
+    startBlock: 35160n;
+  }>;
+  WhitelistRegistry: Readonly<{
+    address: "0x5cC4EA2EbC2F0fF5783A6b21653d23849a6a000f";
+    startBlock: 34579n;
+  }>;
+  KeeperRegistry: Readonly<{
+    address: "0x340C336E0e549e020DedD966F667c7B77D37C513";
+    startBlock: 34571n;
+  }>;
+  BundleRegistry: Readonly<{
+    address: "0x0c38a501079bD12CE350431246311c21231f1242";
+    startBlock: 35165n;
+  }>;
+  StrategyRegistry: Readonly<{
+    address: "0xd58a20afa275D400e4f74c3e822Eb06BDBbee259";
+    startBlock: 34577n;
+  }>;
+  StakingRewards: Readonly<{
+    address: "0x92984a7df4Dc7Cb963eAb076738E2D1Be6453d77";
+    startBlock: 35157n;
+  }>;
+  Helper: Readonly<{
+    address: "0xd401d054fAA7A304d0412982A63d9aC39eb5b3b4";
+    startBlock: 34580n;
+  }>;
+  VaultRegistry: Readonly<{
+    address: "0xFB3b5b859B08Dc86fDA0aF9332E5Ca4cF6689d66";
+    startBlock: 34583n;
+  }>;
+  Orchestrator: Readonly<{
+    address: "0xa5cF70F6e4e236De8c778Bc89741c617816f73aF";
+    startBlock: 34575n;
+  }>;
+  FeeManager: Readonly<{
+    address: "0x7581aC01c19B57408Dd1Bd2ed2cea899BeFEE7dA";
+    startBlock: 34594n;
+  }>;
+}>;
+//#endregion
+//#region src/core/chain.d.ts
+/** Network metadata. Steer owns deployments and the public SDK entry point. */
+export interface ChainDefinition {
+  readonly id: number;
+  readonly name: string;
+  readonly transactionType?: 0 | 2;
+  readonly wrappedNativeToken?: {
+    readonly address: Address;
+    readonly symbol?: string;
+    readonly isWrappingEnabled?: boolean;
+  };
+}
+//#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;
+}
+//#endregion
+//#region src/core/client.d.ts
+/** SDK-owned catalog entry. Every entry represents Steer on a network. */
+export interface SteerNetworkDefinition {
+  readonly chain: ChainDefinition;
+  readonly deployment: DeploymentReference<SteerDataAdapter, SteerContracts, SteerConnectionContext>;
+  readonly amms?: readonly DeploymentReference<AmmAdapter>[];
+  readonly lending?: readonly DeploymentReference<LendingAdapter>[];
+  readonly vaultResolver?: VaultResolverDefinition;
+}
+export interface SteerClientOptions {
+  readonly logger?: Logger;
+  /** SDK integration override. Replaces the built-in network catalog when supplied. */
+  readonly catalog?: readonly SteerNetworkDefinition[];
+  readonly indexers?: IndexerConfig;
+  readonly http?: HttpRequestOptions;
+  readonly transports?: Readonly<Partial<Record<number, RpcTransport>>>;
+}
+/** Steer is the SDK root; chain identity selects a deployment, not another protocol. */
+export declare class SteerClient {
+  #private;
+  constructor(options?: SteerClientOptions);
+  getChains(): readonly ChainDefinition[];
+  getDeployment(chainId: number): SteerNetwork;
+  getSubgraphUrl(chainId: number): string | undefined;
+  getAmm<TProtocol extends AmmProtocol, TVersion extends AmmProtocolVersion<TProtocol> = AmmProtocolVersion<TProtocol>>(request: AmmLookupRequest<TProtocol, TVersion>): AmmProtocolAdapter<TProtocol, TVersion>;
+  getLending<TAdapter extends LendingAdapter>(deployment: DeploymentReference<TAdapter>): TAdapter;
+  getPool(request: SlipstreamPoolLookupRequest): Promise<SlipstreamPoolState & {
+    readonly amm: AerodromeSlipstreamAdapter;
+  }>;
+  getPool(request: InfinityCLPoolLookupRequest): Promise<InfinityCLPoolState & {
+    readonly amm: InfinityCLAdapter;
+  }>;
+  getPool(request: AlgebraLegacyPoolLookupRequest): Promise<AlgebraLegacyPoolState & {
+    readonly amm: AlgebraLegacyAdapter;
+  }>;
+  getPool(request: AlgebraPoolLookupRequest): Promise<AlgebraIntegralPoolState & {
+    readonly amm: AlgebraIntegralAdapter;
+  }>;
+  getPool(request: V3PoolLookupRequest): Promise<V3PoolState & {
+    readonly amm: UniswapV3Adapter;
+  }>;
+  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;
+  })>;
+  getPools(request: SlipstreamPoolsLookupRequest): Promise<readonly (SlipstreamPoolState & {
+    readonly amm: AerodromeSlipstreamAdapter;
+  })[]>;
+  getPools(request: V3PoolsLookupRequest): Promise<readonly (V3PoolState & {
+    readonly amm: UniswapV3Adapter;
+  })[]>;
+  getPools(request: AlgebraPoolsLookupRequest): Promise<readonly (AlgebraIntegralPoolState & {
+    readonly amm: AlgebraIntegralAdapter;
+  })[]>;
+  getPools(request: AlgebraLegacyPoolsLookupRequest): Promise<readonly (AlgebraLegacyPoolState & {
+    readonly amm: AlgebraLegacyAdapter;
+  })[]>;
+  getPools(request: V4PoolsLookupRequest): Promise<readonly (V4PoolState & {
+    readonly amm: UniswapV4Adapter;
+  })[]>;
+  getPools(request: InfinityCLPoolsLookupRequest): Promise<readonly (InfinityCLPoolState & {
+    readonly amm: InfinityCLAdapter;
+  })[]>;
+  getPools(request: PoolsLookupRequest): Promise<readonly DiscoveredPool[]>;
+  getVault(chainId: number, address: Address, options?: VaultLoadOptions): Promise<KnownSteerVault>;
+  getVaults(chainId: number, addresses: readonly Address[], options: VaultLoadOptions & {
+    allowFailure: true;
+  }): Promise<readonly VaultLoadResult[]>;
+  getVaults(chainId: number, addresses: readonly Address[], options?: VaultLoadOptions & {
+    allowFailure?: false;
+  }): Promise<readonly KnownSteerVault[]>;
+  getVaults(chainId: number, addresses: readonly Address[], options?: VaultLoadOptions & {
+    allowFailure?: boolean;
+  }): Promise<readonly KnownSteerVault[] | readonly VaultLoadResult[]>;
+  getVaultSnapshots(chainId: number, addresses: readonly Address[], options: ReadOptions & {
+    allowFailure: true;
+  }): Promise<readonly VaultSnapshotResult[]>;
+  getVaultSnapshots(chainId: number, addresses: readonly Address[], options?: ReadOptions & {
+    allowFailure?: false;
+  }): Promise<readonly LiquidityVaultSnapshot[]>;
+  getVaultSnapshots(chainId: number, addresses: readonly Address[], options?: ReadOptions & {
+    allowFailure?: boolean;
+  }): Promise<readonly LiquidityVaultSnapshot[] | readonly VaultSnapshotResult[]>;
+  getVaultUserPositions(chainId: number, addresses: readonly Address[], account: Address, options?: ReadOptions): Promise<readonly VaultUserPosition[]>;
+  listUserVaults(request: UserVaultDiscoveryRequest, options?: DataAdapterRequestOptions): Promise<UserVaultPage>;
+  listVaults(request: VaultDiscoveryRequest, options?: DataAdapterRequestOptions): Promise<Page<VaultMetadata>>;
+  getLiquidityVault(chainId: number, address: Address, options?: VaultLoadOptions): Promise<LiquidityVault<AmmAdapter<unknown, unknown, Readonly<Record<string, ContractDeployment>>, unknown>, LiquidityPool>>;
+  getLendingVault(chainId: number, address: Address, options?: VaultLoadOptions): Promise<LendingVault<LendingAdapter<unknown, unknown, Readonly<Record<string, ContractDeployment>>>>>;
+  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"]>;
+  readonly reservedRewards: NonNullable<LiquidityVaultSnapshot["reservedRewards"]>;
+  readonly rewards: NonNullable<LiquidityVaultSnapshot["rewards"]>;
+}
+interface AerodromeWithdrawPreview extends WithdrawPreview {
+  readonly rewards: WithdrawRewards;
+}
+interface AerodromeWithdrawPlan extends WithdrawPlan {
+  readonly preview: AerodromeWithdrawPreview;
+}
+interface AerodromeDepositPreview extends LiquidityDepositPreview {
+  readonly rewards: VaultRewardPayout;
+}
+interface AerodromeDepositPlan extends DepositPlan {
+  readonly preview: AerodromeDepositPreview;
+}
+//#endregion
+//#region src/vault/adapters/aerodrome/vault.d.ts
+/** Staked NFT liquidity and separately denominated gauge rewards. */
+export declare abstract class AerodromeVault extends LiquidityVault<AerodromeSlipstreamAdapter, Address> {
+  #private;
+  readonly amm: AerodromeSlipstreamAdapter;
+  readonly pool: Address;
+  getSnapshot(options?: ReadOptions): Promise<AerodromeVaultSnapshot>;
+  getPositions(options?: ReadOptions): Promise<readonly LiquidityPosition<`0x${string}`>[]>;
+  getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
+  quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
+  previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<AerodromeDepositPreview>;
+  prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<Readonly<{
+    preview: AerodromeDepositPreview;
+    account: Address;
+    minimumAmounts: TokenPairAmounts;
+    chainId: number;
+    transactions: readonly TransactionRequest[];
+  }>>;
+  previewWithdraw(request: WithdrawRequest, options?: ReadOptions): Promise<AerodromeWithdrawPreview>;
+  prepareWithdraw(request: PrepareWithdrawRequest, options?: ReadOptions): Promise<AerodromeWithdrawPlan>;
+}
+/** Original and V3 runtimes bind immutable, generation-specific NFT managers. */
+export declare class AerodromeFixedVault extends AerodromeVault {
+  constructor(context: ResolvedVaultContext);
+}
+/** The qualified newer runtime stores its NFT manager and supports original and V2 factories. */
+export declare class AerodromeStoredVault extends AerodromeVault {
+  constructor(context: ResolvedVaultContext);
+}
+//#endregion
+//#region src/vault/adapters/algebra-integral/vault.d.ts
+/** Positions, accounting and unsigned withdrawals for explicitly qualified deployments. */
+export declare class AlgebraIntegralVault extends LiquidityVault<AlgebraIntegralAdapter, Address> {
+  #private;
+  readonly amm: AlgebraIntegralAdapter;
+  readonly pool: Address;
+  constructor(context: ResolvedVaultContext);
+  getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
+  getPositions(options?: ReadOptions): Promise<readonly LiquidityPosition<`0x${string}`>[]>;
+  getSnapshot(options?: ReadOptions): Promise<LiquidityVaultSnapshot<Address>>;
+  quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
+  previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<LiquidityDepositPreview>;
+  prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<DepositPlan>;
+}
+//#endregion
+//#region src/vault/adapters/algebra-legacy/vault.d.ts
+/** Positions, accounting and unsigned withdrawals for explicitly qualified deployments. */
+export declare class AlgebraLegacyVault extends LiquidityVault<AlgebraLegacyAdapter, Address> {
+  #private;
+  readonly amm: AlgebraLegacyAdapter;
+  readonly pool: Address;
+  constructor(context: ResolvedVaultContext);
+  getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
+  getPositions(options?: ReadOptions): Promise<readonly LiquidityPosition<`0x${string}`>[]>;
+  getSnapshot(options?: ReadOptions): Promise<LiquidityVaultSnapshot<Address>>;
+  quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
+  previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<LiquidityDepositPreview>;
+  prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<DepositPlan>;
+}
+//#endregion
+//#region src/vault/adapters/blackhole/types.d.ts
+interface BlackholePosition extends LiquidityPosition<Address> {
+  readonly nftTokensOwed: TokenPairAmounts;
+}
+interface BlackholeWithdrawPlan extends WithdrawPlan {
+  readonly preview: BlackholeWithdrawPreview;
+}
+interface BlackholeVaultSnapshot extends LiquidityVaultSnapshot<Address> {
+  readonly positions: readonly BlackholePosition[];
+  readonly rewardAssets: readonly VaultRewardAsset[];
+  readonly reservedRewards: NonNullable<LiquidityVaultSnapshot["reservedRewards"]>;
+  readonly configuredPositions: NonNullable<LiquidityVaultSnapshot["configuredPositions"]>;
+}
+interface BlackholeWithdrawPreview extends WithdrawPreview {
+  readonly rewardPayouts: NonNullable<WithdrawPreview["rewardPayouts"]>;
+}
+/** Separate post-confirmation step. WAVAX pays AVAX directly to the transaction sender. */
+interface BlackholeNativeUnwrapPlan extends TransactionPlan {
+  readonly account: Address;
+  readonly blockNumber: bigint;
+  readonly amount: PoolTokenBalance;
+}
+//#endregion
+//#region src/vault/adapters/blackhole/vault.d.ts
+/** Exact source-qualified Blackhole NFT/farming vault, with separate reward assets. */
+export declare class BlackholeVault extends LiquidityVault<AlgebraIntegralAdapter, Address> {
+  readonly amm: AlgebraIntegralAdapter;
+  readonly pool: Address;
+  constructor(context: ResolvedVaultContext);
+  getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
+  getSnapshot(options?: ReadOptions): Promise<BlackholeVaultSnapshot>;
+  getPositions(options?: ReadOptions): Promise<readonly BlackholePosition[]>;
+  quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
+  previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<LiquidityDepositPreview>;
+  prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<DepositPlan>;
+  prepareUnwrapNative(request: {
+    readonly account: Address;
+    readonly amount: bigint;
+  }, options?: ReadOptions): Promise<BlackholeNativeUnwrapPlan>;
+  previewWithdraw(request: WithdrawRequest, options?: ReadOptions): Promise<BlackholeWithdrawPreview>;
+  prepareWithdraw(request: PrepareWithdrawRequest, options?: ReadOptions): Promise<BlackholeWithdrawPlan>;
+}
+//#endregion
+//#region src/vault/adapters/uniswap-v3/vault.d.ts
+/** Directly owned V3 positions for the exact qualified multi-position implementations. */
+export declare class UniswapV3Vault extends LiquidityVault<UniswapV3Adapter, Address> {
+  #private;
+  readonly amm: UniswapV3Adapter;
+  readonly pool: Address;
+  constructor(context: ResolvedVaultContext);
+  getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
+  getPositions(options?: ReadOptions): Promise<readonly LiquidityPosition<`0x${string}`>[]>;
+  getSnapshot(options?: ReadOptions): Promise<LiquidityVaultSnapshot<Address>>;
+  quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
+  previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<LiquidityDepositPreview>;
+  prepareDeposit(request: PrepareDepositRequest, options?: ReadOptions): Promise<DepositPlan>;
+}
+//#endregion
+//#region src/vault/adapters/uniswap-v4/vault.d.ts
+export declare class UniswapV4Vault extends LiquidityVault<UniswapV4Adapter, V4VaultPool> {
+  readonly amm: UniswapV4Adapter;
+  readonly pool: V4VaultPool;
+  constructor(context: ResolvedVaultContext);
+  getShareBalance(account: Address, options?: ReadOptions): Promise<bigint>;
+  getPositions(options?: ReadOptions): Promise<readonly LiquidityPosition<V4VaultPool>[]>;
+  getSnapshot(options?: ReadOptions): Promise<LiquidityVaultSnapshot<V4VaultPool>>;
+  quoteDeposit(input: AssetAmount, options?: ReadOptions): Promise<DepositQuote>;
+  previewDeposit(request: DepositRequest, options?: ReadOptions): Promise<LiquidityDepositPreview>;
+  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 };
+//# sourceMappingURL=index.d.cts.map