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

package/src/strategy/CollateralDeficitStrategy.ts

@@ -0,0 +1,421 @@
+import { Logger } from 'pino';
+
+import {
+  type ChainMap,
+  type ChainName,
+  type Token,
+} from '@humanode-hyperlane/sdk';
+import { toWei } from '@humanode-hyperlane/utils';
+
+import {
+  type CollateralDeficitStrategyConfig,
+  RebalancerStrategyOptions,
+} from '../config/types.js';
+import type {
+  InflightContext,
+  RawBalances,
+  Route,
+  StrategyRoute,
+} from '../interfaces/IStrategy.js';
+import { Metrics } from '../metrics/Metrics.js';
+import {
+  type BridgeConfigWithOverride,
+  createStrategyRoute,
+  isInventoryConfig,
+  isMovableCollateralConfig,
+} from '../utils/bridgeUtils.js';
+
+import { BaseStrategy, type Delta } from './BaseStrategy.js';
+
+/**
+ * Strategy that detects collateral deficits (negative effective balances)
+ * and proposes JIT rebalances using fast bridges.
+ *
+ * Logic:
+ * 1. Filter pendingRebalances to only those using this strategy's configured bridges
+ * 2. Simulate filtered pending rebalances to get projected balances
+ * 3. Negative simulated balance = deficit (magnitude + buffer)
+ * 4. Positive simulated balance = potential surplus
+ */
+export class CollateralDeficitStrategy extends BaseStrategy {
+  readonly name = RebalancerStrategyOptions.CollateralDeficit;
+  private readonly config: CollateralDeficitStrategyConfig;
+  protected readonly logger: Logger;
+
+  constructor(
+    config: CollateralDeficitStrategyConfig,
+    tokensByChainName: ChainMap<Token>,
+    logger: Logger,
+    bridgeConfigs: ChainMap<BridgeConfigWithOverride>,
+    metrics?: Metrics,
+  ) {
+    const chains = Object.keys(config);
+    const log = logger.child({ class: CollateralDeficitStrategy.name });
+    super(chains, log, bridgeConfigs, metrics, tokensByChainName);
+    this.logger = log;
+    this.config = config;
+    this.logger.info('CollateralDeficitStrategy created');
+  }
+
+  /**
+   * Categorizes balances into surpluses and deficits.
+   *
+   * 1. Filter pendingRebalances/proposedRebalances by configured bridges
+   * 2. Simulate those rebalances to get projected balances
+   * 3. Negative balance = deficit (magnitude + buffer)
+   * 4. Positive balance = potential surplus
+   */
+  protected getCategorizedBalances(
+    rawBalances: RawBalances,
+    pendingRebalances?: Route[],
+    proposedRebalances?: StrategyRoute[],
+  ): {
+    surpluses: Delta[];
+    deficits: Delta[];
+  } {
+    // Filter pending rebalances to only those using this strategy's bridges
+    const filteredPending = this.filterByConfiguredBridges(pendingRebalances);
+    const filteredProposed = this.filterByConfiguredBridges(proposedRebalances);
+
+    this.logger.debug(
+      {
+        context: this.constructor.name,
+        totalPending: pendingRebalances?.length ?? 0,
+        filteredPending: filteredPending.length,
+        totalProposed: proposedRebalances?.length ?? 0,
+        filteredProposed: filteredProposed.length,
+      },
+      'Filtered rebalances by configured bridges',
+    );
+
+    // Step 1: Simulate pending rebalances (in-flight, origin already deducted on-chain)
+    let simulatedBalances = this.simulatePendingRebalances(
+      rawBalances,
+      filteredPending,
+    );
+
+    // Step 2: Simulate proposed rebalances (from earlier strategies, not yet executed)
+    simulatedBalances = this.simulateProposedRebalances(
+      simulatedBalances,
+      filteredProposed,
+    );
+
+    const surpluses: Delta[] = [];
+    const deficits: Delta[] = [];
+
+    for (const chain of this.chains) {
+      const balance = simulatedBalances[chain];
+      const token = this.getTokenByChainName(chain);
+      const bufferWei = BigInt(
+        toWei(this.config[chain].buffer, token.decimals),
+      );
+
+      if (balance < 0n) {
+        // Negative balance indicates deficit
+        const deficitAmount = -balance + bufferWei;
+        deficits.push({ chain, amount: deficitAmount });
+
+        this.logger.debug(
+          {
+            context: this.constructor.name,
+            chain,
+            simulatedBalance: balance.toString(),
+            buffer: bufferWei.toString(),
+            deficitAmount: deficitAmount.toString(),
+          },
+          'Detected collateral deficit',
+        );
+      } else if (balance > 0n) {
+        // Positive balance is potential surplus
+        surpluses.push({ chain, amount: balance });
+      }
+    }
+
+    this.logger.info(
+      {
+        surpluses: surpluses.map((s) => ({
+          chain: s.chain,
+          amount: s.amount.toString(),
+        })),
+        deficits: deficits.map((d) => ({
+          chain: d.chain,
+          amount: d.amount.toString(),
+        })),
+      },
+      'Balance categorization',
+    );
+
+    return { surpluses, deficits };
+  }
+
+  /**
+   * Override to prefer transfer origins when selecting surplus chains.
+   *
+   * When a user transfer creates a deficit, the origin chain of that transfer
+   * is the natural source of funds (user deposited there). This prevents
+   * unnecessarily draining the largest balance (typically ethereum at 70%).
+   */
+  override getRebalancingRoutes(
+    rawBalances: RawBalances,
+    inflightContext?: InflightContext,
+  ): StrategyRoute[] {
+    const pendingRebalances = inflightContext?.pendingRebalances ?? [];
+    const pendingTransfers = inflightContext?.pendingTransfers ?? [];
+
+    this.logger.info(
+      {
+        strategy: this.name,
+        balances: Object.entries(rawBalances).map(([c, b]) => ({
+          chain: c,
+          balance: b.toString(),
+        })),
+        pendingRebalances: pendingRebalances.length,
+        pendingTransfers: pendingTransfers.length,
+      },
+      'Strategy evaluating',
+    );
+    this.validateRawBalances(rawBalances);
+
+    const actualBalances = rawBalances;
+
+    // Step 1: Reserve collateral for pending user transfers
+    const effectiveBalances = this.reserveCollateral(
+      rawBalances,
+      pendingTransfers,
+    );
+
+    // Step 2: Get categorized balances
+    const { surpluses, deficits } = this.getCategorizedBalances(
+      effectiveBalances,
+      pendingRebalances,
+    );
+
+    this.logger.debug(
+      { context: this.constructor.name, surpluses },
+      'Surpluses calculated',
+    );
+    this.logger.debug(
+      { context: this.constructor.name, deficits },
+      'Deficits calculated',
+    );
+
+    const totalSurplus = surpluses.reduce((sum, s) => sum + s.amount, 0n);
+    const totalDeficit = deficits.reduce((sum, d) => sum + d.amount, 0n);
+
+    this.logger.debug(
+      { context: this.constructor.name, totalSurplus: totalSurplus.toString() },
+      'Total surplus calculated',
+    );
+    this.logger.debug(
+      { context: this.constructor.name, totalDeficit: totalDeficit.toString() },
+      'Total deficit calculated',
+    );
+
+    // Scale deficits if needed
+    if (totalSurplus < totalDeficit) {
+      this.logger.warn(
+        {
+          context: this.constructor.name,
+          totalSurplus: totalSurplus.toString(),
+          totalDeficit: totalDeficit.toString(),
+        },
+        'Deficits are greater than surpluses. Scaling deficits',
+      );
+      this.metrics?.recordRebalancerFailure();
+      for (const deficit of deficits) {
+        deficit.amount = (deficit.amount * totalSurplus) / totalDeficit;
+      }
+      this.logger.debug(
+        { context: this.constructor.name, deficits },
+        'Scaled deficits',
+      );
+    }
+
+    // Build transfer origin map for deficit chains
+    const deficitChains = new Set(deficits.map((d) => d.chain));
+    const transferOriginMap = this.buildTransferOriginMap(
+      pendingTransfers,
+      deficitChains,
+    );
+
+    // Sort surpluses with transfer origin preference (KEY CHANGE from base class)
+    this.sortSurplusesWithOriginPreference(surpluses, transferOriginMap);
+
+    // Sort deficits by amount (largest first)
+    deficits.sort((a, b) => (a.amount > b.amount ? -1 : 1));
+
+    const routes: StrategyRoute[] = [];
+
+    // Match surpluses to deficits
+    while (deficits.length > 0 && surpluses.length > 0) {
+      const surplus = surpluses[0];
+      const deficit = deficits[0];
+      const transferAmount =
+        surplus.amount > deficit.amount ? deficit.amount : surplus.amount;
+
+      if (transferAmount > 0n) {
+        const bridgeConfig = this.getBridgeConfigForRoute(
+          surplus.chain,
+          deficit.chain,
+        );
+        routes.push(
+          createStrategyRoute(
+            bridgeConfig,
+            surplus.chain,
+            deficit.chain,
+            transferAmount,
+          ),
+        );
+      }
+
+      deficit.amount -= transferAmount;
+      surplus.amount -= transferAmount;
+
+      if (deficit.amount <= 0n) deficits.shift();
+      if (surplus.amount <= 0n) surpluses.shift();
+    }
+
+    this.logger.debug(
+      { context: this.constructor.name, routes },
+      'Generated routes',
+    );
+    this.logger.info(
+      { context: this.constructor.name, numberOfRoutes: routes.length },
+      'Found rebalancing routes',
+    );
+
+    const filteredRoutes = this.filterRoutes(routes, actualBalances);
+
+    // Record metrics for each intent created
+    for (const route of filteredRoutes) {
+      this.metrics?.recordIntentCreated(route, this.name);
+    }
+
+    this.logger.debug(
+      {
+        context: this.constructor.name,
+        filteredRoutesCount: filteredRoutes.length,
+        droppedCount: routes.length - filteredRoutes.length,
+      },
+      'Filtered rebalancing routes',
+    );
+
+    return filteredRoutes;
+  }
+
+  /**
+   * Filter pending rebalances to only those using this strategy's configured bridges.
+   * A rebalance matches if:
+   * - Its bridge matches the configured bridge (with overrides) for the route, OR
+   * - It has no bridge (recovered from Explorer, can't verify - include to be safe)
+   */
+  private filterByConfiguredBridges(pendingRebalances?: Route[]): Route[] {
+    if (!pendingRebalances || pendingRebalances.length === 0) {
+      return [];
+    }
+
+    return pendingRebalances.filter((rebalance) => {
+      const bridgeConfig = this.getBridgeConfigForRoute(
+        rebalance.origin,
+        rebalance.destination,
+      );
+
+      // For movableCollateral routes: match bridge address
+      if ('bridge' in rebalance && rebalance.bridge) {
+        return (
+          isMovableCollateralConfig(bridgeConfig) &&
+          bridgeConfig.bridge === rebalance.bridge
+        );
+      }
+
+      // For inventory routes: match externalBridge type
+      if ('externalBridge' in rebalance && rebalance.externalBridge) {
+        return (
+          isInventoryConfig(bridgeConfig) &&
+          bridgeConfig.externalBridge === rebalance.externalBridge
+        );
+      }
+
+      // Recovered intents without bridge info - include to be safe
+      this.logger.debug(
+        { origin: rebalance.origin, destination: rebalance.destination },
+        'Including pending rebalance without bridge (recovered intent)',
+      );
+      return true;
+    });
+  }
+
+  /**
+   * Build a map from deficit chains to their transfer origin chains.
+   * This identifies which surplus chains are "natural" sources for each deficit.
+   */
+  private buildTransferOriginMap(
+    pendingTransfers: Route[],
+    deficitChains: Set<ChainName>,
+  ): Map<ChainName, Set<ChainName>> {
+    const originMap = new Map<ChainName, Set<ChainName>>();
+
+    for (const transfer of pendingTransfers) {
+      // Only track transfers TO deficit chains
+      if (deficitChains.has(transfer.destination)) {
+        if (!originMap.has(transfer.destination)) {
+          originMap.set(transfer.destination, new Set());
+        }
+        originMap.get(transfer.destination)!.add(transfer.origin);
+      }
+    }
+
+    return originMap;
+  }
+
+  /**
+   * Sort surpluses to prefer transfer origins over largest balances.
+   *
+   * Sorting priority:
+   * 1. Chains that are origins of transfers TO any deficit chain (preferred)
+   * 2. By amount descending (tiebreaker)
+   */
+  private sortSurplusesWithOriginPreference(
+    surpluses: Delta[],
+    transferOriginMap: Map<ChainName, Set<ChainName>>,
+  ): void {
+    // Collect all origin chains across all deficits
+    const allOriginChains = new Set<ChainName>();
+    for (const origins of transferOriginMap.values()) {
+      for (const origin of origins) {
+        allOriginChains.add(origin);
+      }
+    }
+
+    surpluses.sort((a, b) => {
+      const aIsOrigin = allOriginChains.has(a.chain);
+      const bIsOrigin = allOriginChains.has(b.chain);
+
+      // Prefer transfer origins
+      if (aIsOrigin && !bIsOrigin) return -1;
+      if (!aIsOrigin && bIsOrigin) return 1;
+
+      // Tiebreaker: larger amount first
+      return a.amount > b.amount ? -1 : 1;
+    });
+
+    if (allOriginChains.size > 0) {
+      this.logger.debug(
+        {
+          context: this.constructor.name,
+          preferredOrigins: Array.from(allOriginChains),
+          sortedSurpluses: surpluses.map((s) => s.chain),
+        },
+        'Sorted surpluses with transfer origin preference',
+      );
+    }
+  }
+
+  protected getTokenByChainName(chainName: string): Token {
+    const token = this.tokensByChainName![chainName];
+    if (token === undefined) {
+      throw new Error(`Token not found for chain ${chainName}`);
+    }
+    return token;
+  }
+}