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

package/src/e2e/inventory-erc20-minAmount.e2e-test.ts

@@ -0,0 +1,735 @@
+import { expect } from 'chai';
+import { ethers, providers } from 'ethers';
+
+import {
+  HyperlaneCore,
+  MultiProvider,
+  snapshot,
+} from '@humanode-hyperlane/sdk';
+
+import { ExternalBridgeType } from '../config/types.js';
+
+import {
+  ANVIL_USER_PRIVATE_KEY,
+  DOMAIN_IDS,
+  ERC20_INVENTORY_MIN_AMOUNT_TARGET_RAW,
+  type Erc20InventoryDeployedAddresses,
+  TEST_CHAINS,
+  buildErc20InventoryMinAmountStrategyConfig,
+} from './fixtures/routes.js';
+import { Erc20InventoryLocalDeploymentManager } from './harness/Erc20InventoryLocalDeploymentManager.js';
+import { MockExternalBridge } from './harness/MockExternalBridge.js';
+import { resetSnapshotsAndRefreshProviders } from './harness/SnapshotHelper.js';
+import {
+  classifyChains,
+  getErc20RouterBalances,
+  getFirstMonitorEvent,
+  relayInProgressInventoryDeposits,
+} from './harness/TestHelpers.js';
+import {
+  TestRebalancerBuilder,
+  type TestRebalancerContext,
+} from './harness/TestRebalancer.js';
+
+describe('Erc20 InventoryMinAmountStrategy E2E', function () {
+  this.timeout(300_000);
+
+  let deploymentManager: Erc20InventoryLocalDeploymentManager;
+  let multiProvider: MultiProvider;
+  let localProviders: Map<string, providers.JsonRpcProvider>;
+  let snapshotIds: Map<string, string>;
+  let hyperlaneCore: HyperlaneCore;
+  let erc20DeployedAddresses: Erc20InventoryDeployedAddresses;
+  let mockBridge: MockExternalBridge;
+
+  const inventorySignerAddress = new ethers.Wallet(ANVIL_USER_PRIVATE_KEY)
+    .address;
+  // Expected deficit when a chain's router balance is 0:
+  // target (from strategy config) - 0 = target.
+  const expectedDeficit = ERC20_INVENTORY_MIN_AMOUNT_TARGET_RAW.toBigInt();
+
+  async function executeCycle(context: TestRebalancerContext): Promise<void> {
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+    await context.orchestrator.executeCycle(event);
+  }
+
+  before(async function () {
+    deploymentManager = new Erc20InventoryLocalDeploymentManager(
+      inventorySignerAddress,
+    );
+    const ctx = await deploymentManager.start();
+    multiProvider = ctx.multiProvider;
+    localProviders = ctx.providers;
+    erc20DeployedAddresses = ctx.deployedAddresses;
+
+    const coreAddresses: Record<string, Record<string, string>> = {};
+    for (const chain of TEST_CHAINS) {
+      coreAddresses[chain] = {
+        mailbox: erc20DeployedAddresses.chains[chain].mailbox,
+        interchainSecurityModule: erc20DeployedAddresses.chains[chain].ism,
+      };
+    }
+    hyperlaneCore = HyperlaneCore.fromAddressesMap(
+      coreAddresses,
+      multiProvider,
+    );
+
+    mockBridge = new MockExternalBridge(
+      erc20DeployedAddresses,
+      multiProvider,
+      hyperlaneCore,
+      'erc20',
+    );
+
+    snapshotIds = new Map();
+    for (const [chain, provider] of localProviders) {
+      snapshotIds.set(chain, await snapshot(provider));
+    }
+  });
+
+  afterEach(async function () {
+    mockBridge.reset();
+    await resetSnapshotsAndRefreshProviders({
+      localProviders,
+      multiProvider,
+      snapshotIds,
+    });
+  });
+
+  after(async function () {
+    if (deploymentManager) await deploymentManager.stop();
+  });
+
+  it('executes transferRemote when destination collateral is below minimum and inventory exists locally', async function () {
+    const context = await new TestRebalancerBuilder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(
+        buildErc20InventoryMinAmountStrategyConfig(erc20DeployedAddresses),
+      )
+      .withErc20InventoryConfig({
+        inventorySignerKey: ANVIL_USER_PRIVATE_KEY,
+        erc20DeployedAddresses,
+      })
+      .withMockExternalBridge(mockBridge)
+      .withBalances('ERC20_INVENTORY_EMPTY_DEST')
+      .withExecutionMode('execute')
+      .build();
+
+    const initialBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+
+    await executeCycle(context);
+
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(activeIntents[0].amount).to.equal(expectedDeficit);
+
+    const inProgressActions = await context.tracker.getInProgressActions();
+    expect(inProgressActions.length).to.equal(1);
+    const depositAction = inProgressActions.find(
+      (a) => a.type === 'inventory_deposit',
+    );
+    expect(depositAction).to.exist;
+
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    const completedAction = await context.tracker.getRebalanceAction(
+      depositAction!.id,
+    );
+    expect(completedAction!.status).to.equal('complete');
+
+    const completedIntent = await context.tracker.getRebalanceIntent(
+      activeIntents[0].id,
+    );
+    expect(completedIntent!.status).to.equal('complete');
+
+    const finalBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+
+    const { surplusChain, neutralChain } = classifyChains(
+      'anvil2',
+      depositAction!,
+    );
+
+    expect(
+      finalBalances.anvil2.gt(initialBalances.anvil2),
+      'Destination router balance should increase',
+    ).to.be.true;
+    expect(
+      finalBalances[surplusChain].lt(initialBalances[surplusChain]),
+      `Surplus router (${surplusChain}) balance should decrease`,
+    ).to.be.true;
+    if (neutralChain) {
+      expect(
+        finalBalances[neutralChain].eq(initialBalances[neutralChain]),
+        'Uninvolved router balance should remain unchanged',
+      ).to.be.true;
+    }
+  });
+
+  it('handles partial deposit, bridges inventory, then completes final deposit', async function () {
+    const context = await new TestRebalancerBuilder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(
+        buildErc20InventoryMinAmountStrategyConfig(erc20DeployedAddresses),
+      )
+      .withErc20InventoryConfig({
+        inventorySignerKey: ANVIL_USER_PRIVATE_KEY,
+        erc20DeployedAddresses,
+      })
+      .withMockExternalBridge(mockBridge)
+      .withBalances('ERC20_INVENTORY_EMPTY_DEST')
+      .withInventorySignerBalances('ERC20_SIGNER_PARTIAL_ANVIL2')
+      .withExecutionMode('execute')
+      .build();
+
+    const initialBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+
+    await executeCycle(context);
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    const partialIntents =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialIntents.length).to.equal(1);
+    expect(partialIntents[0].completedAmount > 0n).to.be.true;
+    expect(partialIntents[0].remaining > 0n).to.be.true;
+    expect(
+      partialIntents[0].completedAmount + partialIntents[0].remaining,
+    ).to.equal(expectedDeficit);
+    expect(partialIntents[0].intent.amount).to.equal(expectedDeficit);
+    expect(partialIntents[0].intent.destination).to.equal(DOMAIN_IDS.anvil2);
+
+    const deposits = await context.tracker.getActionsForIntent(
+      partialIntents[0].intent.id,
+    );
+    expect(deposits.length).to.equal(1);
+    expect(deposits[0].type).to.equal('inventory_deposit');
+    expect(deposits[0].origin).to.equal(DOMAIN_IDS.anvil2);
+    expect(deposits[0].amount).to.equal(partialIntents[0].completedAmount);
+
+    await executeCycle(context);
+
+    const preSync = await context.tracker.getInProgressActions();
+    expect(preSync.length).to.equal(1);
+    const preSyncMovement = preSync.find(
+      (a) => a.type === 'inventory_movement',
+    );
+    expect(preSyncMovement).to.exist;
+    expect(preSyncMovement!.status).to.equal('in_progress');
+
+    // executeCycle calls syncActionTracker at the START of each cycle, so
+    // bridge actions created DURING the cycle above aren't synced yet.
+    // In production the next cycle's sync picks them up; in tests we
+    // sync manually to assert against the results between cycles.
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+
+    const movementState = await context.tracker.getRebalanceAction(
+      preSyncMovement!.id,
+    );
+    expect(movementState?.status).to.equal('complete');
+
+    const activeIntent = partialIntents[0].intent;
+    const actionsAfterBridge = await context.tracker.getActionsForIntent(
+      activeIntent.id,
+    );
+    expect(actionsAfterBridge.length).to.equal(2);
+    const movementAction = actionsAfterBridge.find(
+      (a) => a.type === 'inventory_movement',
+    );
+    expect(movementAction).to.exist;
+    expect(movementAction!.origin).to.equal(DOMAIN_IDS.anvil1);
+    expect(movementAction!.destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(movementAction!.status).to.equal('complete');
+    expect(movementAction!.amount >= partialIntents[0].remaining).to.be.true;
+
+    await executeCycle(context);
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    const completedIntent = await context.tracker.getRebalanceIntent(
+      activeIntent.id,
+    );
+    expect(completedIntent!.status).to.equal('complete');
+
+    const partialAfterFinalCycle =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialAfterFinalCycle.length).to.equal(0);
+    const finalActions = await context.tracker.getActionsForIntent(
+      activeIntent.id,
+    );
+    expect(finalActions.length).to.equal(3);
+    const allDeposits = finalActions.filter(
+      (a) => a.type === 'inventory_deposit',
+    );
+    expect(allDeposits.length).to.equal(2);
+    const totalDeposited = allDeposits.reduce((sum, a) => sum + a.amount, 0n);
+    expect(totalDeposited).to.equal(activeIntent.amount);
+
+    const finalBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+
+    const { surplusChain, neutralChain } = classifyChains(
+      'anvil2',
+      allDeposits[0],
+    );
+
+    expect(
+      finalBalances.anvil2.gt(initialBalances.anvil2),
+      'Destination router balance should increase',
+    ).to.be.true;
+    expect(
+      finalBalances[surplusChain].lt(initialBalances[surplusChain]),
+      `Surplus router (${surplusChain}) balance should decrease`,
+    ).to.be.true;
+    if (neutralChain) {
+      expect(
+        finalBalances[neutralChain].eq(initialBalances[neutralChain]),
+        'Uninvolved router balance should remain unchanged',
+      ).to.be.true;
+    }
+  });
+
+  it('loops across multiple cycles with partial fills before final completion', async function () {
+    const context = await new TestRebalancerBuilder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(
+        buildErc20InventoryMinAmountStrategyConfig(erc20DeployedAddresses),
+      )
+      .withErc20InventoryConfig({
+        inventorySignerKey: ANVIL_USER_PRIVATE_KEY,
+        erc20DeployedAddresses,
+      })
+      .withMockExternalBridge(mockBridge)
+      .withBalances('ERC20_INVENTORY_EMPTY_DEST')
+      .withInventorySignerBalances('ERC20_SIGNER_LOW_ALL')
+      .withExecutionMode('execute')
+      .build();
+
+    // Cycle 1: partial deposit from local signer inventory on anvil2
+    await executeCycle(context);
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    let activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(activeIntents[0].amount).to.equal(expectedDeficit);
+    const targetIntentId = activeIntents[0].id;
+
+    let partialIntents =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialIntents.length).to.equal(1);
+    expect(partialIntents[0].completedAmount > 0n).to.be.true;
+    expect(partialIntents[0].remaining > 0n).to.be.true;
+    expect(
+      partialIntents[0].completedAmount + partialIntents[0].remaining,
+    ).to.equal(expectedDeficit);
+    const c1Amount = partialIntents[0].completedAmount;
+
+    let actions = await context.tracker.getActionsForIntent(targetIntentId);
+    let movementActions = actions.filter(
+      (a) => a.type === 'inventory_movement',
+    );
+    let depositActions = actions.filter((a) => a.type === 'inventory_deposit');
+    expect(actions.length).to.equal(1);
+    expect(movementActions.length).to.equal(0);
+    expect(depositActions.length).to.equal(1);
+
+    // Cycle 2: bridge movements from anvil1 + anvil3 — completedAmount unchanged (movements pending relay)
+    await executeCycle(context);
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    partialIntents =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialIntents.length).to.equal(1);
+    expect(
+      partialIntents[0].completedAmount + partialIntents[0].remaining,
+    ).to.equal(expectedDeficit);
+    expect(partialIntents[0].completedAmount).to.equal(c1Amount);
+
+    actions = await context.tracker.getActionsForIntent(targetIntentId);
+    movementActions = actions.filter((a) => a.type === 'inventory_movement');
+    depositActions = actions.filter((a) => a.type === 'inventory_deposit');
+    expect(actions.length).to.equal(3);
+    expect(movementActions.length).to.equal(2);
+    expect(depositActions.length).to.equal(1);
+    const origins = new Set(movementActions.map((a) => a.origin));
+    expect(origins.has(DOMAIN_IDS.anvil1)).to.be.true;
+    expect(origins.has(DOMAIN_IDS.anvil3)).to.be.true;
+    movementActions.forEach((a) => {
+      expect(a.destination).to.equal(DOMAIN_IDS.anvil2);
+      expect(a.status).to.equal('complete');
+    });
+
+    // Cycle 3: final deposit covers remaining amount — intent completes
+    await executeCycle(context);
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(0);
+    partialIntents =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialIntents.length).to.equal(0);
+
+    actions = await context.tracker.getActionsForIntent(targetIntentId);
+    movementActions = actions.filter((a) => a.type === 'inventory_movement');
+    depositActions = actions.filter((a) => a.type === 'inventory_deposit');
+    expect(actions.length).to.equal(4);
+    expect(movementActions.length).to.equal(2);
+    expect(depositActions.length).to.equal(2);
+
+    const finalIntent =
+      await context.tracker.getRebalanceIntent(targetIntentId);
+    expect(finalIntent!.status).to.equal('complete');
+  });
+
+  it('retries after bridge execution failure', async function () {
+    const context = await new TestRebalancerBuilder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(
+        buildErc20InventoryMinAmountStrategyConfig(erc20DeployedAddresses),
+      )
+      .withErc20InventoryConfig({
+        inventorySignerKey: ANVIL_USER_PRIVATE_KEY,
+        erc20DeployedAddresses,
+      })
+      .withMockExternalBridge(mockBridge)
+      .withBalances('ERC20_INVENTORY_EMPTY_DEST')
+      .withInventorySignerBalances('ERC20_SIGNER_FUNDED_ANVIL1')
+      .withExecutionMode('execute')
+      .build();
+
+    const initialBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+
+    // Cycle 1: Bridge fails — intent created but stays not_started, no actions
+    mockBridge.failNextExecute();
+    await executeCycle(context);
+
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(0);
+
+    const partialIntents =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialIntents.length).to.equal(1);
+    expect(partialIntents[0].intent.status).to.equal('not_started');
+    expect(partialIntents[0].completedAmount).to.equal(0n);
+    expect(partialIntents[0].remaining).to.equal(expectedDeficit);
+
+    const intentId = partialIntents[0].intent.id;
+    const actionsAfterFailure =
+      await context.tracker.getActionsForIntent(intentId);
+    expect(actionsAfterFailure.length).to.equal(0);
+
+    // Cycle 2: Bridge succeeds — creates movement, intent becomes in_progress
+    await executeCycle(context);
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    const cycle2Active = await context.tracker.getActiveRebalanceIntents();
+    expect(cycle2Active.length).to.equal(1);
+    const cycle2Partial =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(cycle2Partial.length).to.equal(1);
+
+    const cycle2Actions = await context.tracker.getActionsForIntent(intentId);
+    expect(cycle2Actions.length).to.equal(1);
+    const movementAction = cycle2Actions.find(
+      (a) => a.type === 'inventory_movement',
+    );
+    expect(movementAction).to.exist;
+    expect(movementAction!.status).to.equal('complete');
+
+    const cycle2Intent = await context.tracker.getRebalanceIntent(intentId);
+    expect(cycle2Intent!.status).to.equal('in_progress');
+
+    // Cycle 3: Deposit completes the intent
+    await executeCycle(context);
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    const completedIntent = await context.tracker.getRebalanceIntent(intentId);
+    expect(completedIntent!.status).to.equal('complete');
+
+    const finalActions = await context.tracker.getActionsForIntent(intentId);
+    expect(finalActions.length).to.equal(2);
+    const finalMovement = finalActions.find(
+      (a) => a.type === 'inventory_movement',
+    );
+    expect(finalMovement).to.exist;
+    const depositAction = finalActions.find(
+      (a) => a.type === 'inventory_deposit',
+    );
+    expect(depositAction).to.exist;
+
+    const finalBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+    const { surplusChain, neutralChain } = classifyChains(
+      'anvil2',
+      depositAction!,
+    );
+
+    expect(
+      finalBalances.anvil2.gt(initialBalances.anvil2),
+      'Destination router balance should increase',
+    ).to.be.true;
+    expect(
+      finalBalances[surplusChain].lt(initialBalances[surplusChain]),
+      `Surplus router (${surplusChain}) balance should decrease`,
+    ).to.be.true;
+    if (neutralChain) {
+      expect(
+        finalBalances[neutralChain].eq(initialBalances[neutralChain]),
+        'Uninvolved router balance should remain unchanged',
+      ).to.be.true;
+    }
+  });
+
+  it('enforces single active inventory intent when multiple deficit chains exist', async function () {
+    const context = await new TestRebalancerBuilder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(
+        buildErc20InventoryMinAmountStrategyConfig(erc20DeployedAddresses),
+      )
+      .withErc20InventoryConfig({
+        inventorySignerKey: ANVIL_USER_PRIVATE_KEY,
+        erc20DeployedAddresses,
+      })
+      .withMockExternalBridge(mockBridge)
+      .withBalances('ERC20_INVENTORY_MULTI_DEFICIT')
+      .withExecutionMode('execute')
+      .build();
+
+    const initialBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+
+    await executeCycle(context);
+
+    let activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(activeIntents[0].amount).to.equal(expectedDeficit);
+    const firstIntentId = activeIntents[0].id;
+
+    const partialIntents =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialIntents.length).to.equal(1);
+    expect(partialIntents[0].hasInflightDeposit).to.equal(true);
+
+    const actions = await context.tracker.getActionsForIntent(firstIntentId);
+    expect(actions.length).to.equal(1);
+    expect(
+      actions.filter((a) => a.type === 'inventory_movement').length,
+    ).to.equal(0);
+    expect(
+      actions.filter((a) => a.type === 'inventory_deposit').length,
+    ).to.equal(1);
+
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    const completedFirstIntent =
+      await context.tracker.getRebalanceIntent(firstIntentId);
+    expect(completedFirstIntent!.status).to.equal('complete');
+
+    const depositAction = actions.find((a) => a.type === 'inventory_deposit');
+    const midBalances = await getErc20RouterBalances(
+      localProviders,
+      erc20DeployedAddresses,
+    );
+    const { surplusChain, neutralChain } = classifyChains(
+      'anvil2',
+      depositAction!,
+    );
+
+    expect(
+      midBalances.anvil2.gt(initialBalances.anvil2),
+      'Deficit router (anvil2) balance should increase',
+    ).to.be.true;
+    expect(
+      midBalances[surplusChain].lt(initialBalances[surplusChain]),
+      `Surplus router (${surplusChain}) balance should decrease`,
+    ).to.be.true;
+    if (neutralChain) {
+      expect(
+        midBalances[neutralChain].eq(initialBalances[neutralChain]),
+        'Uninvolved router balance should remain unchanged',
+      ).to.be.true;
+    }
+
+    await executeCycle(context);
+    activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil3);
+    expect(activeIntents[0].amount).to.equal(expectedDeficit);
+  });
+
+  it('uses multiple bridge movements from different sources before completing deposit', async function () {
+    const context = await new TestRebalancerBuilder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(
+        buildErc20InventoryMinAmountStrategyConfig(erc20DeployedAddresses),
+      )
+      .withErc20InventoryConfig({
+        inventorySignerKey: ANVIL_USER_PRIVATE_KEY,
+        erc20DeployedAddresses,
+      })
+      .withMockExternalBridge(mockBridge)
+      .withBalances('ERC20_INVENTORY_EMPTY_DEST')
+      .withInventorySignerBalances('ERC20_SIGNER_SPLIT_SOURCES')
+      .withExecutionMode('execute')
+      .build();
+
+    // Cycle 1: creates intent + both bridge movements from anvil1 and anvil3
+    await executeCycle(context);
+
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(activeIntents[0].amount).to.equal(expectedDeficit);
+    const intentId = activeIntents[0].id;
+
+    // Sync: both movements should be complete after a single cycle
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+
+    let actions = await context.tracker.getActionsForIntent(intentId);
+    expect(actions.length).to.equal(2);
+    const movementActions = actions.filter(
+      (a) => a.type === 'inventory_movement',
+    );
+    expect(movementActions.length).to.equal(2);
+
+    // Verify movements from different sources, both targeting anvil2
+    const origins = new Set(movementActions.map((a) => a.origin));
+    expect(origins.has(DOMAIN_IDS.anvil1)).to.be.true;
+    expect(origins.has(DOMAIN_IDS.anvil3)).to.be.true;
+    movementActions.forEach((a) => {
+      expect(a.destination).to.equal(DOMAIN_IDS.anvil2);
+      expect(a.status).to.equal('complete');
+    });
+
+    // Cycle 2: deposit from bridged funds completes the intent
+    await executeCycle(context);
+    await context.tracker.syncInventoryMovementActions({
+      [ExternalBridgeType.LiFi]: mockBridge,
+    });
+    await relayInProgressInventoryDeposits(
+      context,
+      localProviders,
+      multiProvider,
+      hyperlaneCore,
+    );
+
+    const finalActiveIntents =
+      await context.tracker.getActiveRebalanceIntents();
+    expect(finalActiveIntents.length).to.equal(0);
+    const partialIntents =
+      await context.tracker.getPartiallyFulfilledInventoryIntents();
+    expect(partialIntents.length).to.equal(0);
+
+    actions = await context.tracker.getActionsForIntent(intentId);
+    expect(actions.length).to.equal(3);
+    expect(
+      actions.filter((a) => a.type === 'inventory_movement').length,
+    ).to.equal(2);
+    expect(
+      actions.filter((a) => a.type === 'inventory_deposit').length,
+    ).to.equal(1);
+
+    const finalIntent = await context.tracker.getRebalanceIntent(intentId);
+    expect(finalIntent!.status).to.equal('complete');
+  });
+});