@hyperlane-xyz/rebalancer 2.0.0 → 3.1.0

package/src/strategy/StrategyFactory.ts

@@ -3,12 +3,17 @@ import { type Logger } from 'pino';
 import { type ChainMap, type Token } from '@hyperlane-xyz/sdk';
 
 import {
+  ExecutionType,
   RebalancerStrategyOptions,
   type StrategyConfig,
 } from '../config/types.js';
 import { type IStrategy } from '../interfaces/IStrategy.js';
 import { type Metrics } from '../metrics/Metrics.js';
-import type { BridgeConfigWithOverride } from '../utils/bridgeUtils.js';
+import type {
+  BridgeConfigWithOverride,
+  InventoryBridgeConfig,
+  MovableCollateralBridgeConfig,
+} from '../utils/bridgeUtils.js';
 
 import { CollateralDeficitStrategy } from './CollateralDeficitStrategy.js';
 import { CompositeStrategy } from './CompositeStrategy.js';
@@ -26,6 +31,7 @@ export class StrategyFactory {
    * @param initialTotalCollateral The initial total collateral of the rebalancer
    * @param logger The logger to use for the strategy
    * @param metrics The metrics to use for the strategy
+   * @param minAmountsByChain Optional minimum amounts per chain for filtering routes
    * @returns A concrete strategy implementation
    */
   static createStrategy(
@@ -34,6 +40,7 @@ export class StrategyFactory {
     initialTotalCollateral: bigint,
     logger: Logger,
     metrics?: Metrics,
+    minAmountsByChain?: ChainMap<bigint>,
   ): IStrategy {
     if (strategyConfigs.length === 0) {
       throw new Error('At least one strategy must be configured');
@@ -47,6 +54,7 @@ export class StrategyFactory {
         initialTotalCollateral,
         logger,
         metrics,
+        minAmountsByChain,
       );
     }
 
@@ -58,6 +66,7 @@ export class StrategyFactory {
         initialTotalCollateral,
         logger,
         metrics,
+        minAmountsByChain,
       ),
     );
     return new CompositeStrategy(subStrategies, logger);
@@ -72,6 +81,7 @@ export class StrategyFactory {
     initialTotalCollateral: bigint,
     logger: Logger,
     metrics?: Metrics,
+    _minAmountsByChain?: ChainMap<bigint>,
   ): IStrategy {
     const bridgeConfigs = this.extractBridgeConfigs(strategyConfig);
 
@@ -116,13 +126,30 @@ export class StrategyFactory {
     const bridgeConfigs: ChainMap<BridgeConfigWithOverride> = {};
 
     for (const [chain, config] of Object.entries(strategyConfig.chains)) {
-      bridgeConfigs[chain] = {
-        bridge: config.bridge,
+      const baseConfig = {
         bridgeMinAcceptedAmount: config.bridgeMinAcceptedAmount ?? 0,
-        override: config.override as ChainMap<
-          Partial<{ bridge: string; bridgeMinAcceptedAmount: string | number }>
-        >,
       };
+
+      const executionType =
+        config.executionType ?? ExecutionType.MovableCollateral;
+
+      if (executionType === ExecutionType.Inventory) {
+        bridgeConfigs[chain] = {
+          ...baseConfig,
+          executionType: 'inventory',
+          externalBridge: config.externalBridge!, // Validated by config schema
+          override: config.override as ChainMap<Partial<InventoryBridgeConfig>>,
+        };
+      } else {
+        bridgeConfigs[chain] = {
+          ...baseConfig,
+          executionType: 'movableCollateral',
+          bridge: config.bridge!, // Validated by config schema
+          override: config.override as ChainMap<
+            Partial<MovableCollateralBridgeConfig>
+          >,
+        };
+      }
     }
 
     return bridgeConfigs;

package/src/strategy/WeightedStrategy.test.ts

@@ -258,6 +258,7 @@ describe('WeightedStrategy', () => {
           destination: chain1,
           amount: ethers.utils.parseEther('50').toBigInt(),
           bridge: ethers.constants.AddressZero,
+          executionType: 'movableCollateral',
         },
       ]);
     });
@@ -325,6 +326,7 @@ describe('WeightedStrategy', () => {
           destination: chain1,
           amount: ethers.utils.parseEther('100').toBigInt(),
           bridge: ethers.constants.AddressZero,
+          executionType: 'movableCollateral',
         },
       ]);
     });
@@ -363,12 +365,14 @@ describe('WeightedStrategy', () => {
           destination: chain1,
           amount: 133333333333333333333n,
           bridge: ethers.constants.AddressZero,
+          executionType: 'movableCollateral',
         },
         {
           origin: chain3,
           destination: chain2,
           amount: 133333333333333333333n,
           bridge: ethers.constants.AddressZero,
+          executionType: 'movableCollateral',
         },
       ]);
     });
@@ -408,12 +412,14 @@ describe('WeightedStrategy', () => {
           destination: chain1,
           amount: ethers.utils.parseEther('25').toBigInt(),
           bridge: ethers.constants.AddressZero,
+          executionType: 'movableCollateral',
         },
         {
           origin: chain3,
           destination: chain1,
           amount: ethers.utils.parseEther('25').toBigInt(),
           bridge: ethers.constants.AddressZero,
+          executionType: 'movableCollateral',
         },
       ]);
     });

package/src/test/helpers.ts

@@ -16,18 +16,24 @@ import {
 import type { RebalancerConfig } from '../config/RebalancerConfig.js';
 import { RebalancerStrategyOptions } from '../config/types.js';
 import type {
+  ExecutionResult,
   IRebalancer,
+  MovableCollateralExecutionResult,
   PreparedTransaction,
-  RebalanceExecutionResult,
-  RebalanceRoute,
+  RebalancerType,
 } from '../interfaces/IRebalancer.js';
-import type { StrategyRoute } from '../interfaces/IStrategy.js';
-import type { BridgeConfigWithOverride } from '../utils/index.js';
+import type {
+  MovableCollateralRoute,
+  StrategyRoute,
+} from '../interfaces/IStrategy.js';
+import type { BridgeConfigWithOverride } from '../utils/bridgeUtils.js';
 
 // === Mock Classes ===
 
 export class MockRebalancer implements IRebalancer {
-  rebalance(_routes: RebalanceRoute[]): Promise<RebalanceExecutionResult[]> {
+  readonly rebalancerType: RebalancerType = 'movableCollateral';
+
+  rebalance(_routes: MovableCollateralRoute[]): Promise<ExecutionResult[]> {
     return Promise.resolve([]);
   }
 }
@@ -36,33 +42,45 @@ export class MockRebalancer implements IRebalancer {
 
 export function buildTestRoute(
   overrides: Partial<StrategyRoute> = {},
+  executionType: 'movableCollateral' | 'inventory' = 'movableCollateral',
 ): StrategyRoute {
+  if (executionType === 'inventory') {
+    return {
+      origin: 'ethereum',
+      destination: 'arbitrum',
+      amount: ethers.utils.parseEther('100').toBigInt(),
+      executionType: 'inventory',
+      externalBridge: 'lifi',
+      ...overrides,
+    } as StrategyRoute;
+  }
   return {
     origin: 'ethereum',
     destination: 'arbitrum',
     amount: ethers.utils.parseEther('100').toBigInt(),
+    executionType: 'movableCollateral',
     bridge: TEST_ADDRESSES.bridge,
     ...overrides,
-  };
+  } as StrategyRoute;
 }
 
-export function buildTestRebalanceRoute(
-  overrides: Partial<RebalanceRoute> = {},
-): RebalanceRoute {
+export function buildTestMovableCollateralRoute(
+  overrides: Partial<MovableCollateralRoute> = {},
+): MovableCollateralRoute {
   return {
-    intentId: overrides.intentId ?? `test-route-${Date.now()}`,
     origin: 'ethereum',
     destination: 'arbitrum',
     amount: ethers.utils.parseEther('100').toBigInt(),
+    executionType: 'movableCollateral',
     bridge: TEST_ADDRESSES.bridge,
     ...overrides,
   };
 }
 
 export function buildTestResult(
-  overrides: Partial<RebalanceExecutionResult> = {},
-): RebalanceExecutionResult {
-  const route = overrides.route ?? buildTestRebalanceRoute();
+  overrides: Partial<MovableCollateralExecutionResult> = {},
+): MovableCollateralExecutionResult {
+  const route = overrides.route ?? buildTestMovableCollateralRoute();
   return {
     route,
     success: true,
@@ -77,7 +95,12 @@ export function buildTestResult(
 export function buildTestPreparedTransaction(
   overrides: Partial<PreparedTransaction> = {},
 ): PreparedTransaction {
-  const route = overrides.route ?? buildTestRebalanceRoute();
+  const route =
+    overrides.route ??
+    ({
+      ...buildTestMovableCollateralRoute(),
+      intentId: 'test-intent',
+    } as MovableCollateralRoute & { intentId: string });
   return {
     populatedTx: {
       to: TEST_ADDRESSES.token,
@@ -272,6 +295,7 @@ export function buildTestBridges(
 ): ChainMap<BridgeConfigWithOverride> {
   return chains.reduce((acc, chain) => {
     acc[chain] = {
+      executionType: 'movableCollateral',
       bridge: TEST_ADDRESSES.bridge,
       bridgeMinAcceptedAmount: 0,
     };
@@ -291,6 +315,7 @@ export function extractBridgeConfigs(
 ): ChainMap<BridgeConfigWithOverride> {
   return Object.entries(chainConfig).reduce((acc, [chain, config]) => {
     acc[chain] = {
+      executionType: 'movableCollateral',
       bridge: config.bridge,
       bridgeMinAcceptedAmount: config.bridgeMinAcceptedAmount ?? 0,
     };

package/src/test/lifiMocks.ts

@@ -0,0 +1,174 @@
+import Sinon, { type SinonStub } from 'sinon';
+
+import type {
+  BridgeQuote,
+  BridgeTransferStatus,
+} from '../interfaces/IExternalBridge.js';
+
+/**
+ * Create mock functions for LiFi SDK.
+ */
+export function createLiFiSdkMocks() {
+  return {
+    createConfig: Sinon.stub(),
+    getQuote: Sinon.stub(),
+    executeRoute: Sinon.stub(),
+    getStatus: Sinon.stub(),
+    convertQuoteToRoute: Sinon.stub().callsFake((quote: unknown) => {
+      const q = quote as Record<string, unknown> & {
+        action?: { fromChainId?: number; toChainId?: number };
+      };
+      return {
+        ...q,
+        fromChainId: q.action?.fromChainId ?? 42161,
+        toChainId: q.action?.toChainId ?? 1399811149,
+        steps: [],
+      };
+    }),
+  };
+}
+
+/**
+ * Configure a mock getQuote to return a successful quote.
+ */
+export function mockSuccessfulQuote(
+  stub: SinonStub,
+  overrides?: Partial<{
+    id: string;
+    tool: string;
+    fromAmount: string;
+    toAmount: string;
+    toAmountMin: string;
+    executionDuration: number;
+    fromChainId: number;
+    toChainId: number;
+  }>,
+) {
+  const fromChainId = overrides?.fromChainId ?? 42161;
+  const toChainId = overrides?.toChainId ?? 1399811149;
+  const fromAmount = overrides?.fromAmount ?? '10000000000';
+  const toAmount = overrides?.toAmount ?? '9950000000';
+  const toAmountMin = overrides?.toAmountMin ?? '9900000000';
+
+  stub.resolves({
+    id: overrides?.id ?? 'quote-123',
+    tool: overrides?.tool ?? 'across',
+    action: {
+      fromAmount,
+      fromChainId,
+      toChainId,
+    },
+    estimate: {
+      toAmount,
+      toAmountMin,
+      executionDuration: overrides?.executionDuration ?? 300,
+    },
+  });
+}
+
+/**
+ * Configure a mock executeRoute to return a successful execution.
+ */
+export function mockSuccessfulExecution(stub: SinonStub, txHash: string) {
+  stub.resolves({
+    steps: [
+      {
+        execution: {
+          process: [{ txHash }],
+        },
+      },
+    ],
+  });
+}
+
+/**
+ * Configure a mock getStatus to return a specific status.
+ */
+export function mockLiFiStatus(
+  stub: SinonStub,
+  status: 'DONE' | 'PENDING' | 'FAILED' | 'NOT_FOUND',
+  overrides?: Partial<{
+    receivingTxHash: string;
+    amount: string;
+    substatus: string;
+  }>,
+) {
+  const responses: Record<string, unknown> = {
+    DONE: {
+      status: 'DONE',
+      receiving: {
+        txHash: overrides?.receivingTxHash ?? '0xReceivingTxHash',
+        amount: overrides?.amount ?? '9950000000',
+      },
+    },
+    PENDING: {
+      status: 'PENDING',
+      substatus: overrides?.substatus ?? 'WAIT_SOURCE_CONFIRMATIONS',
+    },
+    FAILED: {
+      status: 'FAILED',
+      substatus: overrides?.substatus ?? 'BRIDGE_CALL_FAILED',
+    },
+    NOT_FOUND: {
+      status: 'NOT_FOUND',
+    },
+  };
+
+  stub.resolves(responses[status]);
+}
+
+/**
+ * Create a mock BridgeQuote for testing.
+ */
+export function createMockBridgeQuote(
+  overrides?: Partial<BridgeQuote>,
+): BridgeQuote {
+  return {
+    id: 'quote-123',
+    tool: 'across',
+    fromAmount: 10000000000n,
+    toAmount: 9950000000n,
+    toAmountMin: 9900000000n,
+    executionDuration: 300,
+    gasCosts: 50000000n, // Default mock gas costs
+    feeCosts: 0n, // Default mock fee costs
+    route: {
+      action: { fromChainId: 42161, toChainId: 1399811149 },
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock BridgeTransferStatus for testing.
+ */
+export function createMockBridgeStatus(
+  status: 'pending' | 'complete' | 'failed' | 'not_found',
+  overrides?: Partial<{
+    substatus: string;
+    receivingTxHash: string;
+    receivedAmount: bigint;
+    error: string;
+  }>,
+): BridgeTransferStatus {
+  switch (status) {
+    case 'pending':
+      return {
+        status: 'pending',
+        substatus: overrides?.substatus,
+      };
+    case 'complete':
+      return {
+        status: 'complete',
+        receivingTxHash: overrides?.receivingTxHash ?? '0xReceivingTxHash',
+        receivedAmount: overrides?.receivedAmount ?? 9950000000n,
+      };
+    case 'failed':
+      return {
+        status: 'failed',
+        error: overrides?.error,
+      };
+    case 'not_found':
+      return { status: 'not_found' };
+  }
+}