@hyperlane-xyz/rebalancer 2.0.0 → 3.0.0

package/src/config/RebalancerConfig.ts

@@ -1,18 +1,24 @@
+import type { z } from 'zod';
 import { fromZodError } from 'zod-validation-error';
 
 import { readYamlOrJson } from '@hyperlane-xyz/utils/fs';
 
 import {
+  type ExternalBridgesConfigSchema,
   type RebalancerConfigFileInput,
   RebalancerConfigSchema,
   type StrategyConfig,
   getStrategyChainNames,
 } from './types.js';
 
+type ExternalBridgesConfig = z.infer<typeof ExternalBridgesConfigSchema>;
+
 export class RebalancerConfig {
   constructor(
     public readonly warpRouteId: string,
     public readonly strategyConfig: StrategyConfig[],
+    public readonly inventorySigner?: string,
+    public readonly externalBridges?: ExternalBridgesConfig,
   ) {}
 
   /**
@@ -28,14 +34,19 @@ export class RebalancerConfig {
       throw new Error(fromZodError(validationResult.error).message);
     }
 
-    const { warpRouteId, strategy } = validationResult.data;
+    const { warpRouteId, strategy, inventorySigner, externalBridges } =
+      validationResult.data;
 
-    // Check that at least one chain is configured across all strategies
     const chainNames = getStrategyChainNames(strategy);
     if (chainNames.length === 0) {
       throw new Error('No chains configured');
     }
 
-    return new RebalancerConfig(warpRouteId, strategy);
+    return new RebalancerConfig(
+      warpRouteId,
+      strategy,
+      inventorySigner,
+      externalBridges,
+    );
   }
 }

package/src/config/types.ts

@@ -23,22 +23,39 @@ export enum RebalancerMinAmountType {
   Relative = 'relative',
 }
 
+/**
+ * Execution type for rebalancing on a chain:
+ * - `movableCollateral`: Uses MovableCollateralRouter.rebalance() on-chain (requires bridge address)
+ * - `inventory`: Uses external bridges (LiFi) + transferRemote (no bridge address needed)
+ */
+export enum ExecutionType {
+  MovableCollateral = 'movableCollateral',
+  Inventory = 'inventory',
+}
+
+export enum ExternalBridgeType {
+  LiFi = 'lifi',
+}
+
 export const RebalancerMinAmountConfigSchema = z.object({
   min: z.string().or(z.number()),
   target: z.string().or(z.number()),
   type: z.nativeEnum(RebalancerMinAmountType),
 });
 
-// Base chain config with common properties
 const RebalancerBridgeConfigSchema = z.object({
-  bridge: z.string().regex(/0x[a-fA-F0-9]{40}/),
+  bridge: z
+    .string()
+    .regex(/0x[a-fA-F0-9]{40}/)
+    .optional(),
+  executionType: z.nativeEnum(ExecutionType).optional(),
+  externalBridge: z.nativeEnum(ExternalBridgeType).optional(),
   bridgeMinAcceptedAmount: z.string().or(z.number()).optional(),
   bridgeLockTime: z
     .number()
     .positive()
     .transform((val) => val * 1_000)
-    .optional()
-    .describe('Expected time in seconds for bridge to process a transfer'),
+    .optional(),
 });
 
 export const RebalancerBaseChainConfigSchema =
@@ -94,19 +111,28 @@ export const StrategyConfigSchema = z.discriminatedUnion('rebalanceStrategy', [
   CollateralDeficitStrategySchema,
 ]);
 
-// Accept either a single strategy (backwards compatible) or an array of strategies
-// Normalizes to array internally so the rest of the code doesn't need to change
 export const RebalancerStrategySchema = z
-  .union([
-    StrategyConfigSchema, // Old format: single object
-    z.array(StrategyConfigSchema).min(1), // New format: array
-  ])
+  .union([StrategyConfigSchema, z.array(StrategyConfigSchema).min(1)])
   .transform((val) => (Array.isArray(val) ? val : [val]));
 
+export const LiFiBridgeConfigSchema = z.object({
+  integrator: z.string(),
+  defaultSlippage: z.number().optional(),
+});
+
+export const ExternalBridgesConfigSchema = z.object({
+  lifi: LiFiBridgeConfigSchema.optional(),
+});
+
 export const RebalancerConfigSchema = z
   .object({
     warpRouteId: z.string(),
     strategy: RebalancerStrategySchema,
+    inventorySigner: z
+      .string()
+      .regex(/0x[a-fA-F0-9]{40}/)
+      .optional(),
+    externalBridges: ExternalBridgesConfigSchema.optional(),
   })
   .superRefine((config, ctx) => {
     // CollateralDeficitStrategy must be first in composite if it is used
@@ -189,6 +215,83 @@ export const RebalancerConfigSchema = z
           });
         }
       }
+
+      // Validate bridge requirement based on executionType
+      for (const [chainName, chainConfig] of Object.entries(strategy.chains)) {
+        const executionType =
+          chainConfig.executionType ?? ExecutionType.MovableCollateral;
+
+        // bridge is required for movableCollateral execution type
+        if (
+          executionType === ExecutionType.MovableCollateral &&
+          !chainConfig.bridge
+        ) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Chain '${chainName}' uses movableCollateral execution but has no 'bridge' address`,
+            path: ['strategy', strategyIndex, 'chains', chainName, 'bridge'],
+          });
+        }
+
+        // externalBridge is required for inventory execution type
+        if (
+          executionType === ExecutionType.Inventory &&
+          !chainConfig.externalBridge
+        ) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Chain '${chainName}' uses inventory execution but has no 'externalBridge' configured`,
+            path: [
+              'strategy',
+              strategyIndex,
+              'chains',
+              chainName,
+              'externalBridge',
+            ],
+          });
+        }
+      }
+    }
+
+    const hasInventoryChains = config.strategy.some((strategy) =>
+      Object.values(strategy.chains).some(
+        (chainConfig) => chainConfig.executionType === ExecutionType.Inventory,
+      ),
+    );
+
+    if (hasInventoryChains) {
+      if (!config.inventorySigner) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message:
+            'inventorySigner is required when any chain uses inventory execution type',
+          path: ['inventorySigner'],
+        });
+      }
+
+      if (!config.externalBridges?.lifi?.integrator) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message:
+            'externalBridges.lifi is required when using inventory execution',
+          path: ['externalBridges', 'lifi'],
+        });
+      }
+    }
+
+    for (const strategy of config.strategy) {
+      for (const [chainName, chainConfig] of Object.entries(strategy.chains)) {
+        if (
+          chainConfig.externalBridge === ExternalBridgeType.LiFi &&
+          !config.externalBridges?.lifi?.integrator
+        ) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Chain '${chainName}' uses externalBridge: 'lifi' but externalBridges.lifi is not configured`,
+            path: ['externalBridges', 'lifi'],
+          });
+        }
+      }
     }
   });
 
@@ -261,3 +364,26 @@ export function getAllBridges(strategies: StrategyConfig[]): string[] {
 
   return Array.from(bridges);
 }
+
+/**
+ * Get the execution type for a chain.
+ * Returns the executionType from chain config, or MovableCollateral as default.
+ */
+export function getChainExecutionType(
+  strategies: StrategyConfig[],
+  chainName: string,
+): ExecutionType {
+  const chainConfig = getStrategyChainConfig(strategies, chainName);
+  return chainConfig?.executionType ?? ExecutionType.MovableCollateral;
+}
+
+/**
+ * Check if any chain in the strategies uses inventory execution type.
+ */
+export function hasInventoryChains(strategies: StrategyConfig[]): boolean {
+  return strategies.some((strategy) =>
+    Object.values(strategy.chains).some(
+      (chainConfig) => chainConfig.executionType === ExecutionType.Inventory,
+    ),
+  );
+}