@hyperlane-xyz/rebalancer 2.0.0 → 3.0.0

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' };
+  }
+}

package/src/tracking/ActionTracker.test.ts

@@ -148,6 +148,7 @@ describe('ActionTracker', () => {
       // Pre-create action
       await rebalanceActionStore.save({
         id: '0xmsg1',
+        type: 'rebalance_message',
         status: 'in_progress',
         intentId: 'existing-intent',
         messageId: '0xmsg1',
@@ -269,18 +270,32 @@ describe('ActionTracker', () => {
 
   describe('syncRebalanceIntents', () => {
     it('should mark intents as complete when fully fulfilled', async () => {
+      // Intent derives completion from action states, so we need a complete action
       const intent: RebalanceIntent = {
         id: 'intent-1',
         status: 'in_progress',
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 100n,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      };
+
+      const action: RebalanceAction = {
+        id: 'action-1',
+        type: 'rebalance_message',
+        status: 'complete',
+        intentId: 'intent-1',
+        messageId: '0xmsg1',
+        origin: 1,
+        destination: 2,
+        amount: 100n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
 
       await rebalanceIntentStore.save(intent);
+      await rebalanceActionStore.save(action);
 
       await tracker.syncRebalanceIntents();
 
@@ -289,18 +304,32 @@ describe('ActionTracker', () => {
     });
 
     it('should not mark intents as complete if not fully fulfilled', async () => {
+      // Intent with only partial completion via actions
       const intent: RebalanceIntent = {
         id: 'intent-1',
         status: 'in_progress',
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 50n,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      };
+
+      const action: RebalanceAction = {
+        id: 'action-1',
+        type: 'rebalance_message',
+        status: 'complete',
+        intentId: 'intent-1',
+        messageId: '0xmsg1',
+        origin: 1,
+        destination: 2,
+        amount: 50n, // Only partial
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
 
       await rebalanceIntentStore.save(intent);
+      await rebalanceActionStore.save(action);
 
       await tracker.syncRebalanceIntents();
 
@@ -317,13 +346,13 @@ describe('ActionTracker', () => {
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 0n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
 
       const action: RebalanceAction = {
         id: 'action-1',
+        type: 'rebalance_message',
         status: 'in_progress',
         intentId: 'intent-1',
         messageId: '0xmsg1',
@@ -345,15 +374,15 @@ describe('ActionTracker', () => {
       const updatedAction = await rebalanceActionStore.get('action-1');
       expect(updatedAction?.status).to.equal('complete');
 
-      // Intent should be updated and complete
+      // Intent should be complete (derived from completed action amounts)
       const updatedIntent = await rebalanceIntentStore.get('intent-1');
-      expect(updatedIntent?.fulfilledAmount).to.equal(100n);
       expect(updatedIntent?.status).to.equal('complete');
     });
 
     it('should not mark actions as complete if not delivered', async () => {
       const action: RebalanceAction = {
         id: 'action-1',
+        type: 'rebalance_message',
         status: 'in_progress',
         intentId: 'intent-1',
         messageId: '0xmsg1',
@@ -417,7 +446,6 @@ describe('ActionTracker', () => {
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 0n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       });
@@ -428,7 +456,6 @@ describe('ActionTracker', () => {
         origin: 2,
         destination: 3,
         amount: 200n,
-        fulfilledAmount: 50n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       });
@@ -439,7 +466,6 @@ describe('ActionTracker', () => {
         origin: 3,
         destination: 1,
         amount: 300n,
-        fulfilledAmount: 300n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       });
@@ -452,6 +478,85 @@ describe('ActionTracker', () => {
     });
   });
 
+  describe('getPartiallyFulfilledInventoryIntents', () => {
+    it('returns not_started inventory intents', async () => {
+      // Create a not_started inventory intent (simulates failed execution before any action created)
+      await rebalanceIntentStore.save({
+        id: 'stuck-intent',
+        status: 'not_started',
+        origin: 1,
+        destination: 2,
+        amount: 1000000000000000000n, // 1 ETH
+        executionMethod: 'inventory',
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      // Should be returned even though status is 'not_started'
+      const partialIntents =
+        await tracker.getPartiallyFulfilledInventoryIntents();
+
+      expect(partialIntents).to.have.lengthOf(1);
+      expect(partialIntents[0].intent.id).to.equal('stuck-intent');
+      expect(partialIntents[0].completedAmount).to.equal(0n);
+      expect(partialIntents[0].remaining).to.equal(1000000000000000000n);
+    });
+
+    it('returns in_progress inventory intents with partial completion', async () => {
+      // Create an in_progress inventory intent with a completed action
+      await rebalanceIntentStore.save({
+        id: 'partial-intent',
+        status: 'in_progress',
+        origin: 1,
+        destination: 2,
+        amount: 1000000000000000000n, // 1 ETH
+        executionMethod: 'inventory',
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      // Create a completed inventory_deposit action for partial amount
+      await rebalanceActionStore.save({
+        id: 'action-1',
+        type: 'inventory_deposit',
+        status: 'complete',
+        intentId: 'partial-intent',
+        origin: 1,
+        destination: 2,
+        amount: 400000000000000000n, // 0.4 ETH completed
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      const partialIntents =
+        await tracker.getPartiallyFulfilledInventoryIntents();
+
+      expect(partialIntents).to.have.lengthOf(1);
+      expect(partialIntents[0].intent.id).to.equal('partial-intent');
+      expect(partialIntents[0].completedAmount).to.equal(400000000000000000n);
+      expect(partialIntents[0].remaining).to.equal(600000000000000000n); // 0.6 ETH remaining
+    });
+
+    it('does not return non-inventory intents', async () => {
+      // Create a not_started intent without executionMethod: 'inventory'
+      await rebalanceIntentStore.save({
+        id: 'non-inventory-intent',
+        status: 'not_started',
+        origin: 1,
+        destination: 2,
+        amount: 1000000000000000000n,
+        // executionMethod is undefined - not an inventory intent
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      const partialIntents =
+        await tracker.getPartiallyFulfilledInventoryIntents();
+
+      expect(partialIntents).to.have.lengthOf(0);
+    });
+  });
+
   describe('createRebalanceIntent', () => {
     it('should create a new intent with status not_started', async () => {
       const result = await tracker.createRebalanceIntent({
@@ -466,7 +571,6 @@ describe('ActionTracker', () => {
       expect(result.origin).to.equal(1);
       expect(result.destination).to.equal(2);
       expect(result.amount).to.equal(100n);
-      expect(result.fulfilledAmount).to.equal(0n);
       expect(result.priority).to.equal(1);
       expect(result.strategyType).to.equal('MinAmountStrategy');
 
@@ -483,7 +587,6 @@ describe('ActionTracker', () => {
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 0n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
@@ -491,6 +594,7 @@ describe('ActionTracker', () => {
       await rebalanceIntentStore.save(intent);
 
       const result = await tracker.createRebalanceAction({
+        type: 'rebalance_message',
         intentId: 'intent-1',
         origin: 1,
         destination: 2,
@@ -514,7 +618,6 @@ describe('ActionTracker', () => {
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 50n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
@@ -522,6 +625,7 @@ describe('ActionTracker', () => {
       await rebalanceIntentStore.save(intent);
 
       await tracker.createRebalanceAction({
+        type: 'rebalance_message',
         intentId: 'intent-1',
         origin: 1,
         destination: 2,
@@ -532,25 +636,24 @@ describe('ActionTracker', () => {
 
       const updatedIntent = await rebalanceIntentStore.get('intent-1');
       expect(updatedIntent?.status).to.equal('in_progress');
-      expect(updatedIntent?.fulfilledAmount).to.equal(50n); // Should not change
     });
   });
 
   describe('completeRebalanceAction', () => {
-    it('should mark action as complete and update parent intent fulfilledAmount', async () => {
+    it('should mark action as complete and mark parent intent complete if fully fulfilled', async () => {
       const intent: RebalanceIntent = {
         id: 'intent-1',
         status: 'in_progress',
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 0n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
 
       const action: RebalanceAction = {
         id: 'action-1',
+        type: 'rebalance_message',
         status: 'in_progress',
         intentId: 'intent-1',
         messageId: '0xmsg1',
@@ -569,8 +672,8 @@ describe('ActionTracker', () => {
       const updatedAction = await rebalanceActionStore.get('action-1');
       expect(updatedAction?.status).to.equal('complete');
 
+      // Intent should be complete (derived from completed action amounts)
       const updatedIntent = await rebalanceIntentStore.get('intent-1');
-      expect(updatedIntent?.fulfilledAmount).to.equal(100n);
       expect(updatedIntent?.status).to.equal('complete');
     });
 
@@ -589,7 +692,6 @@ describe('ActionTracker', () => {
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 0n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
@@ -607,6 +709,7 @@ describe('ActionTracker', () => {
     it('should mark action as failed', async () => {
       const action: RebalanceAction = {
         id: 'action-1',
+        type: 'rebalance_message',
         status: 'in_progress',
         intentId: 'intent-1',
         messageId: '0xmsg1',
@@ -653,7 +756,7 @@ describe('ActionTracker', () => {
 
       const params = call.args[0];
       expect(params.routersByDomain).to.deep.equal(config.routersByDomain);
-      expect(params.excludeTxSender).to.equal(config.rebalancerAddress);
+      expect(params.excludeTxSenders).to.deep.equal([config.rebalancerAddress]);
     });
   });
 
@@ -692,13 +795,13 @@ describe('ActionTracker', () => {
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 0n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
 
       const action: RebalanceAction = {
         id: 'action-1',
+        type: 'rebalance_message',
         status: 'in_progress',
         intentId: 'intent-1',
         messageId: '0xmsg1',
@@ -806,7 +909,6 @@ describe('ActionTracker', () => {
         origin: 1,
         destination: 2,
         amount: 100n,
-        fulfilledAmount: 0n,
         createdAt: Date.now(),
         updatedAt: Date.now(),
       };
@@ -814,6 +916,7 @@ describe('ActionTracker', () => {
       const action: RebalanceAction = {
         id: 'action-1',
         status: 'in_progress',
+        type: 'rebalance_message',
         intentId: 'intent-1',
         messageId: '0xmsg1',
         origin: 1,