@hyperlane-xyz/rebalancer 2.0.0 → 3.1.0

package/src/core/Rebalancer.test.ts

@@ -7,12 +7,49 @@ import Sinon from 'sinon';
 import { HyperlaneCore } from '@hyperlane-xyz/sdk';
 
 import {
-  buildTestRebalanceRoute,
+  buildTestMovableCollateralRoute,
   createRebalancerTestContext,
 } from '../test/helpers.js';
+import type { IActionTracker } from '../tracking/IActionTracker.js';
 
 import { Rebalancer } from './Rebalancer.js';
 
+function createMockActionTracker(): IActionTracker {
+  return {
+    initialize: Sinon.stub().resolves(),
+    createRebalanceIntent: Sinon.stub().callsFake(async () => ({
+      id: `intent-${Date.now()}`,
+      status: 'not_started',
+    })),
+    createRebalanceAction: Sinon.stub().resolves(),
+    completeRebalanceAction: Sinon.stub().resolves(),
+    failRebalanceAction: Sinon.stub().resolves(),
+    completeRebalanceIntent: Sinon.stub().resolves(),
+    cancelRebalanceIntent: Sinon.stub().resolves(),
+    failRebalanceIntent: Sinon.stub().resolves(),
+    syncTransfers: Sinon.stub().resolves(),
+    syncRebalanceIntents: Sinon.stub().resolves(),
+    syncRebalanceActions: Sinon.stub().resolves(),
+    syncInventoryMovementActions: Sinon.stub().resolves({
+      completed: 0,
+      failed: 0,
+    }),
+    logStoreContents: Sinon.stub().resolves(),
+    getInProgressTransfers: Sinon.stub().resolves([]),
+    getActiveRebalanceIntents: Sinon.stub().resolves([]),
+    getTransfersByDestination: Sinon.stub().resolves([]),
+    getRebalanceIntentsByDestination: Sinon.stub().resolves([]),
+    getTransfer: Sinon.stub().resolves(undefined),
+    getRebalanceIntent: Sinon.stub().resolves(undefined),
+    getRebalanceAction: Sinon.stub().resolves(undefined),
+    getInProgressActions: Sinon.stub().resolves([]),
+    getPartiallyFulfilledInventoryIntents: Sinon.stub().resolves([]),
+    getActionsByType: Sinon.stub().resolves([]),
+    getActionsForIntent: Sinon.stub().resolves([]),
+    getInflightInventoryMovements: Sinon.stub().resolves(0n),
+  };
+}
+
 chai.use(chaiAsPromised);
 
 const testLogger = pino({ level: 'silent' });
@@ -36,6 +73,7 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
@@ -58,19 +96,18 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute({
+      const route = buildTestMovableCollateralRoute({
         origin: 'ethereum',
         destination: 'arbitrum',
       });
-
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
       expect(results[0].success).to.be.true;
-      expect(results[0].route).to.deep.equal(route);
     });
 
     it('should return failure results for routes that fail preparation', async () => {
@@ -83,15 +120,15 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
       expect(results[0].success).to.be.false;
-      expect(results[0].route).to.deep.equal(route);
     });
 
     it('should handle mixed success and failure results', async () => {
@@ -121,15 +158,16 @@ describe('Rebalancer', () => {
         },
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
       const routes = [
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'ethereum',
           destination: 'arbitrum',
         }),
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'optimism',
           destination: 'arbitrum',
         }),
@@ -154,10 +192,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute({
+      const route = buildTestMovableCollateralRoute({
         origin: 'ethereum',
         destination: 'arbitrum',
       });
@@ -176,10 +215,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute({
+      const route = buildTestMovableCollateralRoute({
         origin: 'ethereum',
         destination: 'arbitrum',
       });
@@ -199,10 +239,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -221,10 +262,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -241,10 +283,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -263,10 +306,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -283,10 +327,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -312,10 +357,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -357,15 +403,16 @@ describe('Rebalancer', () => {
         },
         { ...ctx.tokensByChainName, optimism: ctx.tokensByChainName.ethereum },
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
       const routes = [
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'ethereum',
           destination: 'arbitrum',
         }),
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'optimism',
           destination: 'arbitrum',
         }),
@@ -408,19 +455,20 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
       const routes = [
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'ethereum',
           destination: 'arbitrum',
         }),
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'ethereum',
           destination: 'optimism',
         }),
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'optimism',
           destination: 'arbitrum',
         }),
@@ -444,10 +492,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -483,14 +532,15 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
       const routes = [
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           amount: ethers.utils.parseEther('100').toBigInt(),
         }),
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           amount: ethers.utils.parseEther('200').toBigInt(),
         }),
       ];
@@ -533,16 +583,17 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
       const routes = [
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'ethereum',
           destination: 'arbitrum',
           amount: ethers.utils.parseEther('100').toBigInt(),
         }),
-        buildTestRebalanceRoute({
+        buildTestMovableCollateralRoute({
           origin: 'ethereum',
           destination: 'optimism',
           amount: ethers.utils.parseEther('200').toBigInt(),
@@ -570,10 +621,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
@@ -591,16 +643,17 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);
       expect(results[0].success).to.be.false;
       expect(results[0].error).to.include('no Dispatch event found');
-      expect(results[0].messageId).to.be.undefined;
+      expect(results[0].messageId).to.equal('');
     });
 
     it('should include txHash in result', async () => {
@@ -619,10 +672,11 @@ describe('Rebalancer', () => {
         ctx.chainMetadata,
         ctx.tokensByChainName,
         ctx.multiProvider as any,
+        createMockActionTracker(),
         testLogger,
       );
 
-      const route = buildTestRebalanceRoute();
+      const route = buildTestMovableCollateralRoute();
       const results = await rebalancer.rebalance([route]);
 
       expect(results).to.have.lengthOf(1);

package/src/core/Rebalancer.ts

@@ -16,20 +16,33 @@ import {
 import { eqAddress, isNullish, mapAllSettled } from '@hyperlane-xyz/utils';
 
 import type {
-  IRebalancer,
+  IMovableCollateralRebalancer,
+  MovableCollateralExecutionResult,
   PreparedTransaction,
-  RebalanceExecutionResult,
-  RebalanceRoute,
+  RebalancerType,
 } from '../interfaces/IRebalancer.js';
+import { MovableCollateralRoute } from '../interfaces/IStrategy.js';
 import { type Metrics } from '../metrics/Metrics.js';
+import type { IActionTracker } from '../tracking/IActionTracker.js';
+import type { RebalanceIntent } from '../tracking/types.js';
 
-export class Rebalancer implements IRebalancer {
+// Internal types with intentId for tracking
+type InternalExecutionResult = MovableCollateralExecutionResult & {
+  intentId: string;
+};
+
+type InternalRoute = MovableCollateralRoute & { intentId: string };
+
+export class Rebalancer implements IMovableCollateralRebalancer {
+  public readonly rebalancerType: RebalancerType = 'movableCollateral';
   private readonly logger: Logger;
+
   constructor(
     private readonly warpCore: WarpCore,
     private readonly chainMetadata: ChainMap<ChainMetadata>,
     private readonly tokensByChainName: ChainMap<Token>,
     private readonly multiProvider: MultiProvider,
+    private readonly actionTracker: IActionTracker,
     logger: Logger,
     private readonly metrics?: Metrics,
   ) {
@@ -37,8 +50,8 @@ export class Rebalancer implements IRebalancer {
   }
 
   async rebalance(
-    routes: RebalanceRoute[],
-  ): Promise<RebalanceExecutionResult[]> {
+    routes: MovableCollateralRoute[],
+  ): Promise<MovableCollateralExecutionResult[]> {
     if (routes.length === 0) {
       this.logger.info('No routes to execute, exiting');
       return [];
@@ -46,20 +59,45 @@ export class Rebalancer implements IRebalancer {
 
     this.logger.info({ numberOfRoutes: routes.length }, 'Rebalance initiated');
 
+    const invalidRoutes = routes.filter((r) => !r.bridge);
+    if (invalidRoutes.length > 0) {
+      this.logger.error(
+        { count: invalidRoutes.length },
+        'Routes missing required bridge address',
+      );
+      return routes.map((r) => ({
+        route: r,
+        success: false,
+        error: r.bridge ? undefined : 'Missing required bridge address',
+        messageId: '', // Required by MovableCollateralExecutionResult, empty for validation failures
+      }));
+    }
+
+    const intents = await this.createIntents(routes);
+
+    const internalRoutes: InternalRoute[] = routes.map((route, idx) => ({
+      ...route,
+      bridge: route.bridge!,
+      intentId: intents[idx].id,
+    }));
+
     const { preparedTransactions, preparationFailureResults } =
-      await this.prepareTransactions(routes);
+      await this.prepareTransactions(internalRoutes);
 
-    let executionResults: RebalanceExecutionResult[] = [];
+    let executionResults: InternalExecutionResult[] = [];
 
     if (preparedTransactions.length > 0) {
       executionResults = await this.executeTransactions(preparedTransactions);
     }
 
-    // Combine preparation failures with execution results
-    const allResults = [...preparationFailureResults, ...executionResults];
+    const allInternalResults = [
+      ...preparationFailureResults,
+      ...executionResults,
+    ];
 
-    // Record metrics for successful transactions
-    const successfulResults = allResults.filter((r) => r.success);
+    await this.processResults(allInternalResults);
+
+    const successfulResults = allInternalResults.filter((r) => r.success);
     if (this.metrics && successfulResults.length > 0) {
       for (const result of successfulResults) {
         const token = this.tokensByChainName[result.route.origin];
@@ -72,22 +110,94 @@ export class Rebalancer implements IRebalancer {
       }
     }
 
-    const failures = allResults.filter((r) => !r.success);
+    const failures = allInternalResults.filter((r) => !r.success);
     if (failures.length > 0) {
       this.logger.error(
         { failureCount: failures.length, totalRoutes: routes.length },
         'Some rebalance operations failed.',
       );
     } else {
-      this.logger.info('✅ Rebalance successful');
+      this.logger.info('Rebalance successful');
+    }
+
+    return this.toPublicResults(allInternalResults);
+  }
+
+  private async createIntents(
+    routes: MovableCollateralRoute[],
+  ): Promise<RebalanceIntent[]> {
+    return Promise.all(
+      routes.map((route) =>
+        this.actionTracker.createRebalanceIntent({
+          origin: this.multiProvider.getDomainId(route.origin),
+          destination: this.multiProvider.getDomainId(route.destination),
+          amount: route.amount,
+          bridge: route.bridge,
+          executionMethod: 'movable_collateral',
+        }),
+      ),
+    );
+  }
+
+  private async processResults(
+    results: InternalExecutionResult[],
+  ): Promise<void> {
+    for (const result of results) {
+      const intentId = result.intentId;
+
+      if (result.success && result.messageId) {
+        await this.actionTracker.createRebalanceAction({
+          intentId,
+          origin: this.multiProvider.getDomainId(result.route.origin),
+          destination: this.multiProvider.getDomainId(result.route.destination),
+          amount: result.route.amount,
+          type: 'rebalance_message',
+          messageId: result.messageId,
+          txHash: result.txHash,
+        });
+
+        this.logger.info(
+          {
+            intentId,
+            messageId: result.messageId,
+            txHash: result.txHash,
+            origin: result.route.origin,
+            destination: result.route.destination,
+          },
+          'Rebalance action created successfully',
+        );
+      } else {
+        await this.actionTracker.failRebalanceIntent(intentId);
+
+        this.logger.warn(
+          {
+            intentId,
+            success: result.success,
+            error: result.error,
+            origin: result.route.origin,
+            destination: result.route.destination,
+          },
+          'Rebalance intent marked as failed',
+        );
+      }
     }
+  }
 
-    return allResults;
+  private toPublicResults(
+    internalResults: InternalExecutionResult[],
+  ): MovableCollateralExecutionResult[] {
+    return internalResults.map((internal) => ({
+      route: internal.route,
+      success: internal.success,
+      error: internal.error,
+      messageId: internal.messageId || '', // Ensure messageId is always a string
+      txHash: internal.txHash,
+    }));
   }
 
-  private async prepareTransactions(routes: RebalanceRoute[]): Promise<{
+  private async prepareTransactions(routes: InternalRoute[]): Promise<{
     preparedTransactions: PreparedTransaction[];
-    preparationFailureResults: RebalanceExecutionResult[];
+    preparationFailureResults: InternalExecutionResult[];
   }> {
     this.logger.info(
       { numRoutes: routes.length },
@@ -105,12 +215,14 @@ export class Rebalancer implements IRebalancer {
     );
 
     // Create failure results for tracking
-    const preparationFailureResults: RebalanceExecutionResult[] = [];
+    const preparationFailureResults: InternalExecutionResult[] = [];
     for (const [i, error] of rejected) {
       preparationFailureResults.push({
         route: routes[i],
+        intentId: routes[i].intentId,
         success: false,
         error: String(error),
+        messageId: '', // Required by MovableCollateralExecutionResult, empty for failures
       });
     }
     // Also track null results (validation failures)
@@ -118,8 +230,10 @@ export class Rebalancer implements IRebalancer {
       if (isNullish(tx)) {
         preparationFailureResults.push({
           route: routes[i],
+          intentId: routes[i].intentId,
           success: false,
           error: 'Preparation returned null',
+          messageId: '', // Required by MovableCollateralExecutionResult, empty for failures
         });
       }
     });
@@ -128,7 +242,7 @@ export class Rebalancer implements IRebalancer {
   }
 
   private async prepareTransaction(
-    route: RebalanceRoute,
+    route: InternalRoute,
   ): Promise<PreparedTransaction | null> {
     const { origin, destination, amount } = route;
 
@@ -209,7 +323,7 @@ export class Rebalancer implements IRebalancer {
     return { populatedTx, route, originTokenAmount };
   }
 
-  private async validateRoute(route: RebalanceRoute): Promise<boolean> {
+  private async validateRoute(route: InternalRoute): Promise<boolean> {
     const { origin, destination, amount } = route;
     const originToken = this.tokensByChainName[origin];
     const destinationToken = this.tokensByChainName[destination];
@@ -322,13 +436,13 @@ export class Rebalancer implements IRebalancer {
 
   private async executeTransactions(
     transactions: PreparedTransaction[],
-  ): Promise<RebalanceExecutionResult[]> {
+  ): Promise<InternalExecutionResult[]> {
     this.logger.info(
       { numTransactions: transactions.length },
       'Estimating gas for all prepared transactions.',
     );
 
-    const results: RebalanceExecutionResult[] = [];
+    const results: InternalExecutionResult[] = [];
 
     // 1. Estimate gas for rebalance transactions
     const gasEstimateResults = await Promise.allSettled(
@@ -361,8 +475,10 @@ export class Rebalancer implements IRebalancer {
         );
         results.push({
           route: failedTransaction.route,
+          intentId: failedTransaction.route.intentId,
           success: false,
           error: `Gas estimation failed: ${String(result.reason)}`,
+          messageId: '', // Required by MovableCollateralExecutionResult, empty for failures
         });
       }
     });
@@ -411,8 +527,10 @@ export class Rebalancer implements IRebalancer {
           } else {
             results.push({
               route: txResult.transaction.route,
+              intentId: txResult.transaction.route.intentId,
               success: false,
               error: `Transaction send failed: ${txResult.error}`,
+              messageId: '', // Required by MovableCollateralExecutionResult, empty for failures
             });
             this.metrics?.recordActionAttempt(
               txResult.transaction.route,
@@ -533,7 +651,7 @@ export class Rebalancer implements IRebalancer {
   private buildResult(
     transaction: PreparedTransaction,
     receipt: providers.TransactionReceipt,
-  ): RebalanceExecutionResult {
+  ): InternalExecutionResult {
     const { origin, destination } = transaction.route;
     const dispatchedMessages = HyperlaneCore.getDispatchedMessages(receipt);
 
@@ -544,14 +662,17 @@ export class Rebalancer implements IRebalancer {
       );
       return {
         route: transaction.route,
+        intentId: transaction.route.intentId,
         success: false,
         error: `Transaction confirmed but no Dispatch event found`,
+        messageId: '', // Required by MovableCollateralExecutionResult, empty for failures
         txHash: receipt.transactionHash,
       };
     }
 
     return {
       route: transaction.route,
+      intentId: transaction.route.intentId,
       success: true,
       messageId: dispatchedMessages[0].id,
       txHash: receipt.transactionHash,