@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2-humanode.1

package/src/factories/RebalancerContextFactory.ts

@@ -0,0 +1,771 @@
+import { type Logger } from 'pino';
+
+import { IRegistry } from '@humanode-hyperlane/registry';
+import {
+  type ChainMap,
+  type CoreAddresses,
+  MultiProtocolCore,
+  MultiProtocolProvider,
+  MultiProvider,
+  type Token,
+  WarpCore,
+  type WarpCoreConfig,
+} from '@humanode-hyperlane/sdk';
+import {
+  Address,
+  assert,
+  ProtocolType,
+  objMap,
+  toWei,
+} from '@humanode-hyperlane/utils';
+
+import { LiFiBridge } from '../bridges/LiFiBridge.js';
+import { type RebalancerConfig } from '../config/RebalancerConfig.js';
+import {
+  ExecutionType,
+  ExternalBridgeType,
+  getAllBridges,
+  getInventoryChainNames,
+  getInventoryOriginChainNames,
+  getOverrideExecutionType,
+  getStrategyChainConfig,
+  getStrategyChainNames,
+} from '../config/types.js';
+import {
+  InventoryRebalancer,
+  type InventorySignerConfig,
+} from '../core/InventoryRebalancer.js';
+import { Rebalancer } from '../core/Rebalancer.js';
+import { RebalancerOrchestrator } from '../core/RebalancerOrchestrator.js';
+import type { ExternalBridgeRegistry } from '../interfaces/IExternalBridge.js';
+import type { IRebalancer } from '../interfaces/IRebalancer.js';
+import type { IStrategy } from '../interfaces/IStrategy.js';
+import { Metrics } from '../metrics/Metrics.js';
+import { PriceGetter } from '../metrics/PriceGetter.js';
+import { type InventoryMonitorConfig, Monitor } from '../monitor/Monitor.js';
+import { StrategyFactory } from '../strategy/StrategyFactory.js';
+import {
+  ActionTracker,
+  type ActionTrackerConfig,
+} from '../tracking/ActionTracker.js';
+import type { IActionTracker } from '../tracking/IActionTracker.js';
+import { InflightContextAdapter } from '../tracking/InflightContextAdapter.js';
+import { InMemoryStore } from '../tracking/store/index.js';
+import type {
+  RebalanceAction,
+  RebalanceActionStatus,
+  RebalanceIntent,
+  RebalanceIntentStatus,
+  Transfer,
+  TransferStatus,
+} from '../tracking/types.js';
+import {
+  ExplorerClient,
+  type IExplorerClient,
+} from '../utils/ExplorerClient.js';
+import { isCollateralizedTokenEligibleForRebalancing } from '../utils/tokenUtils.js';
+
+const DEFAULT_EXPLORER_URL =
+  process.env.EXPLORER_API_URL || 'https://explorer4.hasura.app/v1/graphql';
+
+export class RebalancerContextFactory {
+  /**
+   * @param config - The rebalancer config
+   * @param warpCore - An instance of `WarpCore` configured for the specified `warpRouteId`.
+   * @param tokensByChainName - A map of chain->token to ease the lookup of token by chain
+   * @param multiProvider - MultiProvider instance (for movable collateral operations)
+   * @param multiProtocolProvider - MultiProtocolProvider instance (with mailbox metadata)
+   * @param registry - IRegistry instance
+   * @param logger - Logger instance
+   */
+  private constructor(
+    private readonly config: RebalancerConfig,
+    private readonly warpCore: WarpCore,
+    private readonly tokensByChainName: ChainMap<Token>,
+    private readonly multiProvider: MultiProvider,
+    private readonly multiProtocolProvider: MultiProtocolProvider,
+    private readonly registry: IRegistry,
+    private readonly logger: Logger,
+    private readonly inventorySignerKeysByProtocol?: Partial<
+      Record<ProtocolType, string>
+    >,
+  ) {}
+
+  /**
+   * @param config - The rebalancer config
+   * @param multiProvider - MultiProvider instance (for movable collateral operations)
+   * @param multiProtocolProvider - MultiProtocolProvider instance (optional, created from multiProvider if not provided)
+   * @param registry - IRegistry instance
+   * @param logger - Logger instance
+   */
+  public static async create(
+    config: RebalancerConfig,
+    multiProvider: MultiProvider,
+    multiProtocolProvider: MultiProtocolProvider | undefined,
+    registry: IRegistry,
+    logger: Logger,
+    inventorySignerKeysByProtocol?: Partial<Record<ProtocolType, string>>,
+    warpCoreConfigOverride?: WarpCoreConfig,
+  ): Promise<RebalancerContextFactory> {
+    logger.debug(
+      {
+        warpRouteId: config.warpRouteId,
+      },
+      'Creating RebalancerContextFactory',
+    );
+
+    // TODO: should we pull addressed for chains we care about, i.e those in the warp config
+    const addresses = await registry.getAddresses();
+
+    // The Sealevel warp adapters require the Mailbox address, so we
+    // get mailboxes for all chains and merge them with the chain metadata.
+    const mailboxes = objMap(addresses, (_, { mailbox }) => ({ mailbox }));
+
+    // Fetch warp route config FIRST to get chain list
+    const warpCoreConfig =
+      warpCoreConfigOverride ??
+      (await registry.getWarpRoute(config.warpRouteId));
+    if (!warpCoreConfig) {
+      throw new Error(
+        `Warp route config for ${config.warpRouteId} not found in registry`,
+      );
+    }
+
+    // Force-initialize providers for EVM warp route chains only.
+    // This ensures fromMultiProvider() snapshots actual provider instances.
+    // Non-EVM chains (StarkNet, Sealevel, etc.) don't use ethers providers
+    // and would crash if we tried to build one (e.g. non-numeric chainId).
+    const warpChains = [
+      ...new Set(warpCoreConfig.tokens.map((t) => t.chainName)),
+    ];
+    for (const chain of warpChains) {
+      if (multiProvider.getProtocol(chain) !== ProtocolType.Ethereum) {
+        logger.debug({ chain }, 'Skipping provider init for non-EVM chain');
+        continue;
+      }
+      multiProvider.getProvider(chain);
+    }
+
+    // Create MultiProtocolProvider (convert from MultiProvider if not provided)
+    const mpp =
+      multiProtocolProvider ??
+      MultiProtocolProvider.fromMultiProvider(multiProvider);
+    const extendedMultiProtocolProvider = mpp.extendChainMetadata(mailboxes);
+
+    const warpCore = WarpCore.FromConfig(
+      extendedMultiProtocolProvider,
+      warpCoreConfig,
+    );
+    const tokensByChainName = Object.fromEntries(
+      warpCore.tokens.map((t) => [t.chainName, t]),
+    );
+
+    logger.debug(
+      {
+        warpRouteId: config.warpRouteId,
+      },
+      'RebalancerContextFactory created successfully',
+    );
+    return new RebalancerContextFactory(
+      config,
+      warpCore,
+      tokensByChainName,
+      multiProvider,
+      extendedMultiProtocolProvider,
+      registry,
+      logger,
+      inventorySignerKeysByProtocol,
+    );
+  }
+
+  public getWarpCore(): WarpCore {
+    return this.warpCore;
+  }
+
+  public getTokenForChain(chainName: string): Token | undefined {
+    return this.tokensByChainName[chainName];
+  }
+
+  public async createMetrics(coingeckoApiKey?: string): Promise<Metrics> {
+    this.logger.debug(
+      { warpRouteId: this.config.warpRouteId },
+      'Creating Metrics',
+    );
+    const tokenPriceGetter = PriceGetter.create(
+      this.multiProvider.metadata,
+      this.logger,
+      coingeckoApiKey,
+    );
+    const warpDeployConfig = await this.registry.getWarpDeployConfig(
+      this.config.warpRouteId,
+    );
+
+    return new Metrics(
+      tokenPriceGetter,
+      warpDeployConfig,
+      this.warpCore,
+      this.config.warpRouteId,
+      this.logger,
+    );
+  }
+
+  public createMonitor(
+    checkFrequency: number,
+    inventoryConfig?: InventoryMonitorConfig,
+  ): Monitor {
+    this.logger.debug(
+      {
+        warpRouteId: this.config.warpRouteId,
+        checkFrequency: checkFrequency,
+      },
+      'Creating Monitor',
+    );
+    return new Monitor(
+      checkFrequency,
+      this.warpCore,
+      this.logger,
+      inventoryConfig,
+    );
+  }
+
+  public async createStrategy(metrics?: Metrics): Promise<IStrategy> {
+    const strategyTypes = this.config.strategyConfig.map(
+      (s) => s.rebalanceStrategy,
+    );
+    this.logger.debug(
+      {
+        warpRouteId: this.config.warpRouteId,
+        strategyTypes,
+        strategyCount: this.config.strategyConfig.length,
+      },
+      'Creating Strategy',
+    );
+
+    // Build minAmountsByChain from chain configs
+    const chainNames = getStrategyChainNames(this.config.strategyConfig);
+    const minAmountsByChain: ChainMap<bigint> = {};
+
+    for (const chainName of chainNames) {
+      const chainConfig = getStrategyChainConfig(
+        this.config.strategyConfig,
+        chainName,
+      );
+      if (chainConfig?.bridgeMinAcceptedAmount) {
+        const token = this.tokensByChainName[chainName];
+        const decimals = token?.decimals ?? 18;
+        minAmountsByChain[chainName] = BigInt(
+          toWei(chainConfig.bridgeMinAcceptedAmount, decimals),
+        );
+      }
+    }
+
+    this.logger.debug(
+      {
+        minAmountsByChain: Object.fromEntries(
+          Object.entries(minAmountsByChain).map(([k, v]) => [k, v.toString()]),
+        ),
+      },
+      'Built minimum amounts by chain for strategy',
+    );
+
+    return StrategyFactory.createStrategy(
+      this.config.strategyConfig,
+      this.tokensByChainName,
+      await this.getInitialTotalCollateral(),
+      this.logger,
+      metrics,
+      minAmountsByChain,
+    );
+  }
+
+  private createMovableCollateralRebalancer(
+    actionTracker: IActionTracker,
+    metrics?: Metrics,
+  ): IRebalancer {
+    this.logger.debug(
+      { warpRouteId: this.config.warpRouteId },
+      'Creating Rebalancer',
+    );
+
+    const rebalancer = new Rebalancer(
+      this.warpCore,
+      this.multiProvider.metadata,
+      this.tokensByChainName,
+      this.multiProvider,
+      actionTracker,
+      this.logger,
+      metrics,
+    );
+
+    return rebalancer;
+  }
+
+  public async createActionTracker(
+    explorerUrlOrClient: string | IExplorerClient = DEFAULT_EXPLORER_URL,
+  ): Promise<{
+    tracker: IActionTracker;
+    adapter: InflightContextAdapter;
+  }> {
+    this.logger.debug(
+      { warpRouteId: this.config.warpRouteId },
+      'Creating ActionTracker',
+    );
+
+    const transferStore = new InMemoryStore<Transfer, TransferStatus>();
+    const intentStore = new InMemoryStore<
+      RebalanceIntent,
+      RebalanceIntentStatus
+    >();
+    const actionStore = new InMemoryStore<
+      RebalanceAction,
+      RebalanceActionStatus
+    >();
+
+    const explorerClient =
+      typeof explorerUrlOrClient === 'string'
+        ? new ExplorerClient(explorerUrlOrClient, (domain) =>
+            this.multiProvider.getProtocol(domain),
+          )
+        : explorerUrlOrClient;
+
+    // 3. Get MultiProtocolCore from registry (supports all VM types)
+    // Only fetch/validate addresses for warp route chains (not all registry chains)
+    const warpRouteChains = new Set(
+      this.warpCore.tokens.map((t) => t.chainName),
+    );
+    const coreAddresses: ChainMap<CoreAddresses> = {};
+    for (const chain of warpRouteChains) {
+      const addrs = await this.registry.getChainAddresses(chain);
+      if (!addrs?.mailbox) {
+        throw new Error(
+          `Missing mailbox address for chain ${chain} in registry`,
+        );
+      }
+      coreAddresses[chain] = addrs as CoreAddresses;
+    }
+    const multiProtocolCore = MultiProtocolCore.fromAddressesMap(
+      coreAddresses,
+      this.multiProtocolProvider,
+    );
+
+    // 4. Get rebalancer address from signer
+    // Use the first chain in the strategy to get the signer address
+    const chainNames = getStrategyChainNames(this.config.strategyConfig);
+    if (chainNames.length === 0) {
+      throw new Error('No chains configured in strategy');
+    }
+    const signer = this.multiProvider.getSigner(chainNames[0]);
+    const rebalancerAddress = await signer.getAddress();
+
+    const bridges = getAllBridges(this.config.strategyConfig);
+
+    // Build router→domain mapping (source of truth for routers and domains)
+    const routersByDomain: Record<number, string> = {};
+    for (const token of this.warpCore.tokens) {
+      const domain = this.multiProvider.getDomainId(token.chainName);
+      routersByDomain[domain] = token.addressOrDenom;
+    }
+
+    const trackerConfig: ActionTrackerConfig = {
+      routersByDomain,
+      bridges,
+      rebalancerAddress,
+      inventorySignerAddresses: this.config.inventorySigners
+        ? (Object.entries(this.config.inventorySigners)
+            .filter(([protocol]) => protocol === ProtocolType.Ethereum)
+            .map(([, signerConfig]) => signerConfig)
+            .map((s) => s.address)
+            .filter(Boolean) as Address[])
+        : undefined,
+      intentTTL: this.config.intentTTL,
+    };
+
+    // 6. Create ActionTracker
+    const tracker = new ActionTracker(
+      transferStore,
+      intentStore,
+      actionStore,
+      explorerClient,
+      multiProtocolCore,
+      trackerConfig,
+      this.logger,
+    );
+
+    // 7. Create InflightContextAdapter
+    const adapter = new InflightContextAdapter(tracker, this.multiProvider);
+
+    this.logger.debug(
+      {
+        warpRouteId: this.config.warpRouteId,
+        routerCount: Object.keys(routersByDomain).length,
+        bridgeCount: bridges.length,
+        domainCount: Object.keys(routersByDomain).length,
+      },
+      'ActionTracker created successfully',
+    );
+
+    return { tracker, adapter };
+  }
+
+  /**
+   * Creates inventory components for inventory-based rebalancing.
+   * Returns null if inventory config is not available.
+   *
+   * @param actionTracker - ActionTracker instance for tracking inventory actions
+   * @param externalBridgeRegistryOverride - Optional override for external bridge registry (for testing)
+   */
+  private async createInventoryRebalancerAndConfig(
+    actionTracker: IActionTracker,
+    externalBridgeRegistryOverride?: Partial<ExternalBridgeRegistry>,
+  ): Promise<{
+    inventoryRebalancer: IRebalancer;
+    externalBridgeRegistry: Partial<ExternalBridgeRegistry>;
+    inventoryConfig: InventoryMonitorConfig;
+  } | null> {
+    const { inventorySigners } = this.config;
+
+    if (!inventorySigners || Object.keys(inventorySigners).length === 0) {
+      this.logger.debug(
+        'Inventory config not available, skipping inventory components creation',
+      );
+      return null;
+    }
+
+    const redactedInventorySigners = Object.fromEntries(
+      Object.entries(inventorySigners).map(([protocol, signerConfig]) => [
+        protocol,
+        signerConfig ? { address: signerConfig.address } : signerConfig,
+      ]),
+    );
+
+    this.logger.debug(
+      {
+        warpRouteId: this.config.warpRouteId,
+        inventorySigners: redactedInventorySigners,
+      },
+      'Creating inventory components',
+    );
+
+    const inventoryChains = getInventoryChainNames(this.config.strategyConfig);
+    const inventoryOriginChains = getInventoryOriginChainNames(
+      this.config.strategyConfig,
+    );
+    const allRelevantChains = Array.from(
+      new Set([...inventoryChains, ...inventoryOriginChains]),
+    );
+
+    if (allRelevantChains.length === 0) {
+      this.logger.debug('No inventory chains configured');
+      return null;
+    }
+
+    const requiredProtocols = new Set(
+      allRelevantChains.map((chain) => {
+        const metadata = this.warpCore.multiProvider.getChainMetadata(chain);
+        assert(
+          metadata?.protocol,
+          `No protocol in chain metadata for ${chain}`,
+        );
+        return metadata.protocol;
+      }),
+    );
+    const SUPPORTED_INVENTORY_PROTOCOLS = new Set([
+      ProtocolType.Ethereum,
+      ProtocolType.Sealevel,
+    ]);
+    for (const protocol of requiredProtocols) {
+      const chainsForProtocol = allRelevantChains.filter(
+        (chain) =>
+          this.warpCore.multiProvider.getChainMetadata(chain).protocol ===
+          protocol,
+      );
+      assert(
+        SUPPORTED_INVENTORY_PROTOCOLS.has(protocol),
+        `Inventory rebalancing does not support protocol '${protocol}' (chains: ${chainsForProtocol.join(', ')}). Supported: ethereum, sealevel`,
+      );
+    }
+    for (const protocol of requiredProtocols) {
+      const chainsForProtocol = allRelevantChains.filter(
+        (chain) =>
+          this.warpCore.multiProvider.getChainMetadata(chain).protocol ===
+          protocol,
+      );
+      assert(
+        this.config.inventorySigners?.[protocol]?.key ??
+          this.inventorySignerKeysByProtocol?.[protocol],
+        `Missing inventory signer key for protocol ${protocol} (required by inventory chains: ${chainsForProtocol.join(', ')})`,
+      );
+    }
+
+    // Validate inventory address coverage for all required protocols
+    for (const protocol of requiredProtocols) {
+      const chainsForProtocol = allRelevantChains.filter(
+        (chain) =>
+          this.warpCore.multiProvider.getChainMetadata(chain).protocol ===
+          protocol,
+      );
+      assert(
+        inventorySigners[protocol]?.address,
+        `Missing inventory address for protocol ${protocol} (required by inventory chains: ${chainsForProtocol.join(', ')})`,
+      );
+    }
+
+    const externalBridgeRegistry: Partial<ExternalBridgeRegistry> =
+      externalBridgeRegistryOverride ?? this.buildExternalBridgeRegistry();
+
+    if (Object.keys(externalBridgeRegistry).length === 0) {
+      if (externalBridgeRegistryOverride !== undefined) {
+        this.logger.debug(
+          'No external bridges in override registry, skipping inventory components',
+        );
+      } else {
+        this.logger.debug(
+          'No external bridges configured, skipping inventory components',
+        );
+      }
+      const inventoryAddresses = Object.fromEntries(
+        Object.entries(inventorySigners).map(([protocol, cfg]) => [
+          protocol,
+          cfg.address,
+        ]),
+      ) as Partial<Record<ProtocolType, Address>>;
+      const inventoryConfig: InventoryMonitorConfig = {
+        inventoryAddresses,
+        chains: allRelevantChains,
+      };
+      // Merge config addresses with runtime keys
+      const mergedSigners: Partial<
+        Record<ProtocolType, InventorySignerConfig>
+      > = {};
+      for (const [protocol, cfg] of Object.entries(inventorySigners)) {
+        const protocolKey = protocol as ProtocolType;
+        mergedSigners[protocolKey] = {
+          address: cfg.address,
+          key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocolKey],
+        };
+      }
+      const inventoryRebalancer = new InventoryRebalancer(
+        {
+          inventorySigners: mergedSigners,
+          inventoryChains,
+        },
+        actionTracker,
+        externalBridgeRegistryOverride ?? {},
+        this.warpCore,
+        this.multiProvider,
+        this.logger,
+      );
+      return {
+        inventoryRebalancer,
+        externalBridgeRegistry: externalBridgeRegistryOverride ?? {},
+        inventoryConfig,
+      };
+    }
+
+    // 3. Build inventory config
+    const inventoryAddresses = Object.fromEntries(
+      Object.entries(inventorySigners).map(([protocol, cfg]) => [
+        protocol,
+        cfg.address,
+      ]),
+    ) as Partial<Record<ProtocolType, Address>>;
+    const inventoryConfig: InventoryMonitorConfig = {
+      inventoryAddresses,
+      chains: allRelevantChains,
+    };
+
+    // 4. Create InventoryRebalancer
+    // Merge config addresses with runtime keys
+    const mergedSigners: Partial<Record<ProtocolType, InventorySignerConfig>> =
+      {};
+    for (const [protocol, cfg] of Object.entries(inventorySigners)) {
+      const protocolKey = protocol as ProtocolType;
+      mergedSigners[protocolKey] = {
+        address: cfg.address,
+        key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocolKey],
+      };
+    }
+    const inventoryRebalancer = new InventoryRebalancer(
+      {
+        inventorySigners: mergedSigners,
+        inventoryChains,
+      },
+      actionTracker,
+      externalBridgeRegistry,
+      this.warpCore,
+      this.multiProvider,
+      this.logger,
+    );
+
+    this.logger.info(
+      {
+        inventoryChains,
+        inventorySigners: redactedInventorySigners,
+      },
+      'Inventory components created successfully',
+    );
+
+    return { inventoryRebalancer, externalBridgeRegistry, inventoryConfig };
+  }
+
+  private buildExternalBridgeRegistry(): Partial<ExternalBridgeRegistry> {
+    const { externalBridges } = this.config;
+    const registry: Partial<ExternalBridgeRegistry> = {};
+
+    for (const bridgeType of Object.values(ExternalBridgeType)) {
+      switch (bridgeType) {
+        case ExternalBridgeType.LiFi: {
+          const lifiConfig = externalBridges?.lifi;
+          if (lifiConfig?.integrator) {
+            registry[ExternalBridgeType.LiFi] = new LiFiBridge(
+              {
+                integrator: lifiConfig.integrator,
+                defaultSlippage: lifiConfig.defaultSlippage,
+                chainMetadata: this.multiProvider.metadata,
+              },
+              this.logger,
+            );
+          }
+          break;
+        }
+        default: {
+          // Exhaustive check - TypeScript will error if new enum value added
+          const _exhaustive: never = bridgeType;
+          throw new Error(`Unknown bridge type: ${_exhaustive}`);
+        }
+      }
+    }
+
+    return registry;
+  }
+
+  /**
+   * Creates all rebalancers based on config execution types.
+   * Returns an array of rebalancers (movableCollateral and/or inventory)
+   * along with metadata needed for monitor and orchestrator.
+   *
+   * @param actionTracker - ActionTracker instance for tracking actions
+   * @param metrics - Optional Metrics instance
+   * @param externalBridgeRegistryOverride - Optional override for external bridge registry (for testing)
+   */
+  public async createRebalancers(
+    actionTracker: IActionTracker,
+    metrics?: Metrics,
+    externalBridgeRegistryOverride?: Partial<ExternalBridgeRegistry>,
+  ): Promise<{
+    rebalancers: IRebalancer[];
+    externalBridgeRegistry: Partial<ExternalBridgeRegistry>;
+    inventoryConfig?: InventoryMonitorConfig;
+  }> {
+    const rebalancers: IRebalancer[] = [];
+    let externalBridgeRegistry: Partial<ExternalBridgeRegistry> = {};
+    let inventoryConfig: InventoryMonitorConfig | undefined;
+
+    // Check if any chains use movableCollateral execution type
+    const hasMovableCollateral = this.hasMovableCollateralChains();
+    if (hasMovableCollateral) {
+      const rebalancer = this.createMovableCollateralRebalancer(
+        actionTracker,
+        metrics,
+      );
+      rebalancers.push(rebalancer);
+    }
+
+    // Check if any chains use inventory execution type
+    const inventoryComponents = await this.createInventoryRebalancerAndConfig(
+      actionTracker,
+      externalBridgeRegistryOverride,
+    );
+    if (inventoryComponents) {
+      rebalancers.push(inventoryComponents.inventoryRebalancer);
+      externalBridgeRegistry = inventoryComponents.externalBridgeRegistry;
+      inventoryConfig = inventoryComponents.inventoryConfig;
+    }
+
+    return { rebalancers, externalBridgeRegistry, inventoryConfig };
+  }
+
+  /**
+   * Creates a RebalancerOrchestrator with all required dependencies.
+   */
+  public createOrchestrator(options: {
+    strategy: IStrategy;
+    actionTracker: IActionTracker;
+    inflightContextAdapter: InflightContextAdapter;
+    rebalancers: IRebalancer[];
+    externalBridgeRegistry: Partial<ExternalBridgeRegistry>;
+    metrics?: Metrics;
+  }): RebalancerOrchestrator {
+    this.logger.debug(
+      { warpRouteId: this.config.warpRouteId },
+      'Creating RebalancerOrchestrator',
+    );
+
+    return new RebalancerOrchestrator({
+      strategy: options.strategy,
+      actionTracker: options.actionTracker,
+      inflightContextAdapter: options.inflightContextAdapter,
+      rebalancerConfig: this.config,
+      logger: this.logger,
+      rebalancers: options.rebalancers,
+      externalBridgeRegistry: options.externalBridgeRegistry,
+      metrics: options.metrics,
+    });
+  }
+
+  private hasMovableCollateralChains(): boolean {
+    return getStrategyChainNames(this.config.strategyConfig).some(
+      (chainName) => {
+        const chainConfig = getStrategyChainConfig(
+          this.config.strategyConfig,
+          chainName,
+        );
+        if (
+          (chainConfig?.executionType ?? ExecutionType.MovableCollateral) ===
+          ExecutionType.MovableCollateral
+        ) {
+          return true;
+        }
+
+        if (!chainConfig?.override) {
+          return false;
+        }
+
+        return Object.values(chainConfig.override).some((overrideConfig) => {
+          const overrideExecutionType =
+            getOverrideExecutionType(overrideConfig);
+
+          return (
+            (overrideExecutionType ??
+              chainConfig.executionType ??
+              ExecutionType.MovableCollateral) ===
+            ExecutionType.MovableCollateral
+          );
+        });
+      },
+    );
+  }
+
+  private async getInitialTotalCollateral(): Promise<bigint> {
+    let initialTotalCollateral = 0n;
+
+    const chainNames = new Set(
+      getStrategyChainNames(this.config.strategyConfig),
+    );
+
+    await Promise.all(
+      this.warpCore.tokens.map(async (token) => {
+        if (
+          isCollateralizedTokenEligibleForRebalancing(token) &&
+          chainNames.has(token.chainName)
+        ) {
+          const adapter = token.getHypAdapter(this.warpCore.multiProvider);
+          const bridgedSupply = await adapter.getBridgedSupply();
+          initialTotalCollateral += bridgedSupply ?? 0n;
+        }
+      }),
+    );
+
+    return initialTotalCollateral;
+  }
+}