@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2

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

@@ -0,0 +1,313 @@
+import { expect } from 'chai';
+import { BigNumber, providers } from 'ethers';
+
+import {
+  HyperlaneCore,
+  MultiProvider,
+  snapshot,
+} from '@humanode-hyperlane/sdk';
+
+import {
+  RebalancerMinAmountType,
+  RebalancerStrategyOptions,
+  type StrategyConfig,
+} from '../config/types.js';
+
+import {
+  DOMAIN_IDS,
+  type DeployedAddresses,
+  TEST_CHAINS,
+} from './fixtures/routes.js';
+import { getAllCollateralBalances } from './harness/BridgeSetup.js';
+import { type LocalDeploymentContext } from './harness/BaseLocalDeploymentManager.js';
+import { Erc20LocalDeploymentManager } from './harness/Erc20LocalDeploymentManager.js';
+import { resetSnapshotsAndRefreshProviders } from './harness/SnapshotHelper.js';
+import { getFirstMonitorEvent } from './harness/TestHelpers.js';
+import { TestRebalancer } from './harness/TestRebalancer.js';
+import { tryRelayMessage } from './harness/TransferHelper.js';
+
+describe('MinAmountStrategy E2E', function () {
+  this.timeout(300_000);
+
+  let deploymentManager: Erc20LocalDeploymentManager;
+  let multiProvider: MultiProvider;
+  let localProviders: Map<string, providers.JsonRpcProvider>;
+  let snapshotIds: Map<string, string>;
+  let hyperlaneCore: HyperlaneCore;
+  let deployedAddresses: DeployedAddresses;
+  let minAmountStrategyConfig: StrategyConfig[];
+
+  before(async function () {
+    deploymentManager = new Erc20LocalDeploymentManager();
+    const ctx: LocalDeploymentContext<DeployedAddresses> =
+      await deploymentManager.start();
+    multiProvider = ctx.multiProvider;
+    localProviders = ctx.providers;
+    deployedAddresses = ctx.deployedAddresses;
+
+    const coreAddresses: Record<string, Record<string, string>> = {};
+    for (const chain of TEST_CHAINS) {
+      coreAddresses[chain] = {
+        mailbox: deployedAddresses.chains[chain].mailbox,
+        interchainSecurityModule: deployedAddresses.chains[chain].ism,
+      };
+    }
+    hyperlaneCore = HyperlaneCore.fromAddressesMap(
+      coreAddresses,
+      multiProvider,
+    );
+
+    minAmountStrategyConfig = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.MinAmount,
+        chains: {
+          anvil1: {
+            minAmount: {
+              min: '100',
+              target: '120',
+              type: RebalancerMinAmountType.Absolute,
+            },
+            bridge: deployedAddresses.bridgeRoute1.anvil1,
+          },
+          anvil2: {
+            minAmount: {
+              min: '100',
+              target: '120',
+              type: RebalancerMinAmountType.Absolute,
+            },
+            bridge: deployedAddresses.bridgeRoute1.anvil2,
+          },
+          anvil3: {
+            minAmount: {
+              min: '100',
+              target: '120',
+              type: RebalancerMinAmountType.Absolute,
+            },
+            bridge: deployedAddresses.bridgeRoute1.anvil3,
+          },
+        },
+      },
+    ];
+
+    snapshotIds = new Map();
+    for (const [chain, provider] of localProviders) {
+      snapshotIds.set(chain, await snapshot(provider));
+    }
+  });
+
+  afterEach(async function () {
+    await resetSnapshotsAndRefreshProviders({
+      localProviders,
+      multiProvider,
+      snapshotIds,
+    });
+  });
+
+  after(async function () {
+    if (deploymentManager) {
+      await deploymentManager.stop();
+    }
+  });
+
+  it('should propose rebalance routes when chain is below minimum', async function () {
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(minAmountStrategyConfig)
+      .withBalances('BELOW_MIN_ARB')
+      .withExecutionMode('execute')
+      .build();
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+
+    await context.orchestrator.executeCycle(event);
+
+    // Assert: ethereum→arbitrum, amount=70 USDC to reach 120 target from 50
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(1);
+    expect(activeIntents[0].origin).to.equal(DOMAIN_IDS.anvil1);
+    expect(activeIntents[0].destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(activeIntents[0].amount).to.equal(70000000n);
+  });
+
+  it('should not propose routes when all chains at or above minimum', async function () {
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(minAmountStrategyConfig)
+      .withBalances('BALANCED')
+      .withExecutionMode('execute')
+      .build();
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+
+    await context.orchestrator.executeCycle(event);
+
+    // Assert: No routes - all chains have 5000 USDC, well above 100 min
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.equal(0);
+  });
+
+  it('should execute full rebalance cycle with actual transfers', async function () {
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(minAmountStrategyConfig)
+      .withBalances('BELOW_MIN_ARB')
+      .withExecutionMode('execute')
+      .build();
+
+    const initialCollateralBalances = await getAllCollateralBalances(
+      localProviders,
+      TEST_CHAINS,
+      deployedAddresses.monitoredRoute,
+      deployedAddresses.tokens,
+    );
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+    await context.orchestrator.executeCycle(event);
+
+    // Assert: Rebalance intent was created with correct fields
+    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(70000000n);
+
+    // Assert: Rebalance action was created
+    const inProgressActions = await context.tracker.getInProgressActions();
+    expect(inProgressActions.length).to.equal(1);
+
+    const actionToArbitrum = inProgressActions[0];
+    expect(actionToArbitrum.destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(actionToArbitrum.amount).to.equal(70000000n);
+
+    // Assert: Monitored route collateral on origin DECREASED (sent to bridge)
+    const balancesAfterRebalance = await getAllCollateralBalances(
+      localProviders,
+      TEST_CHAINS,
+      deployedAddresses.monitoredRoute,
+      deployedAddresses.tokens,
+    );
+
+    // Assert: ethereum balance decreased by 70 USDC
+    const expectedDecrease = BigNumber.from(70000000);
+    expect(
+      initialCollateralBalances.anvil1.sub(expectedDecrease).toString(),
+    ).to.equal(balancesAfterRebalance.anvil1.toString());
+
+    // Relay the rebalance message to destination
+    const ethProvider = localProviders.get('anvil1')!;
+    const rebalanceTxReceipt = await ethProvider.getTransactionReceipt(
+      actionToArbitrum.txHash!,
+    );
+    const rebalanceRelayResult = await tryRelayMessage(
+      multiProvider,
+      hyperlaneCore,
+      {
+        dispatchTx: rebalanceTxReceipt,
+        messageId: actionToArbitrum.messageId!,
+        origin: 'anvil1',
+        destination: 'anvil2',
+      },
+    );
+    expect(
+      rebalanceRelayResult.success,
+      `Rebalance relay should succeed: ${rebalanceRelayResult.error}`,
+    ).to.be.true;
+
+    // Sync actions to detect delivery and mark complete
+    const blockTags = await context.getConfirmedBlockTags();
+    await context.tracker.syncRebalanceActions(blockTags);
+
+    // Assert: Action is now complete
+    const completedAction = await context.tracker.getRebalanceAction(
+      actionToArbitrum.id,
+    );
+    expect(completedAction!.status).to.equal('complete');
+
+    // Assert: Intent is now complete
+    const completedIntent = await context.tracker.getRebalanceIntent(
+      activeIntents[0].id,
+    );
+    expect(completedIntent!.status).to.equal('complete');
+  });
+
+  it('should handle stuck transfer and propose routes to destination', async function () {
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(minAmountStrategyConfig)
+      .withBalances('BELOW_MIN_ARB')
+      .withExecutionMode('execute')
+      .build();
+
+    // ===== CYCLE 1: Execute to create inflight eth→arb =====
+    // Initial: eth=6000, arb=50 (below 100 min), base=4000
+    // MinAmount will trigger: arb needs 100, so propose ~70 USDC from eth
+    const monitor1 = context.createMonitor(0);
+    const event1 = await getFirstMonitorEvent(monitor1);
+    await context.orchestrator.executeCycle(event1);
+
+    const blockTags1 = await context.getConfirmedBlockTags();
+    await context.tracker.syncRebalanceActions(blockTags1);
+
+    const inProgress = await context.tracker.getInProgressActions();
+    expect(
+      inProgress.length,
+      'Cycle 1 should create inflight action',
+    ).to.be.greaterThan(0);
+
+    const inflightToArb = inProgress.find(
+      (a) =>
+        a.destination === DOMAIN_IDS.anvil2 && a.origin === DOMAIN_IDS.anvil1,
+    );
+    expect(inflightToArb, 'Should have inflight action eth→arb').to.exist;
+
+    // ===== CYCLE 2: Execute again - should account for inflight =====
+    // Strategy sees: arb effective = 50 + inflight ≈ 120 (target)
+    // Should propose reduced amount or nothing to arb (within tolerance)
+    const monitor2 = context.createMonitor(0);
+    const event2 = await getFirstMonitorEvent(monitor2);
+    await context.orchestrator.executeCycle(event2);
+
+    const blockTags = await context.getConfirmedBlockTags();
+    await context.tracker.syncRebalanceActions(blockTags);
+
+    // Check if new routes to arb were proposed
+    const inProgressAfterCycle2 = await context.tracker.getInProgressActions();
+    const newActionsToArb = inProgressAfterCycle2.filter(
+      (a) =>
+        a.destination === DOMAIN_IDS.anvil2 &&
+        a.id !== inflightToArb!.id &&
+        a.status === 'in_progress',
+    );
+
+    if (newActionsToArb.length > 0) {
+      // If route was proposed, should be much smaller than original ~70 USDC
+      const proposedAmount = BigNumber.from(
+        newActionsToArb[0].amount,
+      ).toBigInt();
+      expect(
+        proposedAmount < 50000000n,
+        `Amount to arb (${proposedAmount}) should be reduced accounting for inflight`,
+      ).to.be.true;
+    }
+    // If no new route to arb, that's valid (within tolerance after inflight)
+
+    // Verify inflight still exists and action tracking is working
+    const finalInProgress = await context.tracker.getInProgressActions();
+    const inflightStillActive = finalInProgress.find(
+      (a) => a.id === inflightToArb!.id,
+    );
+    expect(inflightStillActive, 'Inflight action should still be tracked').to
+      .exist;
+    expect(inflightStillActive!.status).to.equal('in_progress');
+  });
+});

package/src/e2e/mixed-weighted.e2e-test.ts

@@ -0,0 +1,267 @@
+import { expect } from 'chai';
+import { BigNumber, Wallet, providers } from 'ethers';
+
+import {
+  HyperlaneCore,
+  MultiProvider,
+  revertToSnapshot,
+  snapshot,
+} from '@humanode-hyperlane/sdk';
+
+import {
+  ExecutionType,
+  ExternalBridgeType,
+  RebalancerConfigSchema,
+  RebalancerStrategyOptions,
+  type StrategyConfig,
+} from '../config/types.js';
+
+import {
+  ANVIL_USER_PRIVATE_KEY,
+  type Erc20InventoryDeployedAddresses,
+  TEST_CHAINS,
+} from './fixtures/routes.js';
+import {
+  MIXED_INVENTORY_CHAIN,
+  MIXED_INVENTORY_OVERRIDE,
+  MIXED_MOVABLE_CHAINS,
+  MixedLocalDeploymentManager,
+} from './harness/MixedLocalDeploymentManager.js';
+import { MockExternalBridge } from './harness/MockExternalBridge.js';
+import { getFirstMonitorEvent } from './harness/TestHelpers.js';
+import {
+  type TestRebalancerContext,
+  TestRebalancerBuilder,
+} from './harness/TestRebalancer.js';
+
+function buildMixedWeightedStrategyConfig(
+  addresses: Erc20InventoryDeployedAddresses,
+): StrategyConfig[] {
+  return [
+    {
+      rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+      chains: {
+        anvil1: {
+          weighted: { weight: 60n, tolerance: 5n },
+          bridge: addresses.bridgeRoute.anvil1,
+          executionType: ExecutionType.MovableCollateral,
+          override: {
+            [MIXED_INVENTORY_CHAIN]: {
+              ...MIXED_INVENTORY_OVERRIDE,
+            },
+          },
+        },
+        anvil2: {
+          weighted: { weight: 20n, tolerance: 5n },
+          bridge: addresses.bridgeRoute.anvil2,
+          executionType: ExecutionType.MovableCollateral,
+          override: {
+            [MIXED_INVENTORY_CHAIN]: {
+              ...MIXED_INVENTORY_OVERRIDE,
+            },
+          },
+        },
+        anvil3: {
+          weighted: { weight: 20n, tolerance: 5n },
+          bridge: addresses.bridgeRoute.anvil3,
+          executionType: ExecutionType.MovableCollateral,
+        },
+      },
+    },
+  ];
+}
+
+describe('Mixed WeightedStrategy E2E', function () {
+  this.timeout(300_000);
+
+  let deploymentManager: MixedLocalDeploymentManager;
+  let multiProvider: MultiProvider;
+  let localProviders: Map<string, providers.JsonRpcProvider>;
+  let snapshotIds: Map<string, string>;
+  let hyperlaneCore: HyperlaneCore;
+  let deployedAddresses: Erc20InventoryDeployedAddresses;
+  let mixedStrategyConfig: StrategyConfig[];
+  let mockBridge: MockExternalBridge;
+
+  const inventorySignerAddress = new Wallet(ANVIL_USER_PRIVATE_KEY).address;
+
+  async function buildContext(
+    inventoryBalances: string | Record<string, BigNumber>,
+  ): Promise<TestRebalancerContext> {
+    return new TestRebalancerBuilder(deploymentManager, multiProvider)
+      .withStrategy(mixedStrategyConfig)
+      .withExecutionMode('execute')
+      .withErc20InventoryConfig({
+        inventorySignerKey: ANVIL_USER_PRIVATE_KEY,
+        erc20DeployedAddresses: deployedAddresses,
+      })
+      .withMockExternalBridge(mockBridge)
+      .withBalances(inventoryBalances)
+      .build();
+  }
+
+  before(async function () {
+    deploymentManager = new MixedLocalDeploymentManager(inventorySignerAddress);
+    const ctx = await deploymentManager.start();
+    multiProvider = ctx.multiProvider;
+    localProviders = ctx.providers;
+    deployedAddresses = ctx.deployedAddresses;
+
+    const coreAddresses: Record<string, Record<string, string>> = {};
+    for (const chain of TEST_CHAINS) {
+      coreAddresses[chain] = {
+        mailbox: deployedAddresses.chains[chain].mailbox,
+        interchainSecurityModule: deployedAddresses.chains[chain].ism,
+      };
+    }
+    hyperlaneCore = HyperlaneCore.fromAddressesMap(
+      coreAddresses,
+      multiProvider,
+    );
+
+    mixedStrategyConfig = buildMixedWeightedStrategyConfig(deployedAddresses);
+    mockBridge = new MockExternalBridge(
+      deployedAddresses,
+      multiProvider,
+      hyperlaneCore,
+      'erc20',
+    );
+
+    snapshotIds = new Map();
+    for (const [chain, provider] of localProviders) {
+      snapshotIds.set(chain, await snapshot(provider));
+    }
+  });
+
+  afterEach(async function () {
+    mockBridge.reset();
+    for (const [chain, provider] of localProviders) {
+      const id = snapshotIds.get(chain)!;
+      await revertToSnapshot(provider, id);
+      snapshotIds.set(chain, await snapshot(provider));
+      Reflect.set(provider, '_maxInternalBlockNumber', -1);
+      Reflect.set(provider, '_internalBlockNumber', null);
+    }
+  });
+
+  after(async function () {
+    if (deploymentManager) {
+      await deploymentManager.stop();
+    }
+  });
+
+  it('accepts mixed movable + inventory override config in schema', function () {
+    const configResult = RebalancerConfigSchema.safeParse({
+      warpRouteId: 'USDC/test-mixed-weighted',
+      strategy: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+          chains: {
+            anvil1: {
+              weighted: { weight: 60, tolerance: 5 },
+              bridge: deployedAddresses.bridgeRoute.anvil1,
+              executionType: ExecutionType.MovableCollateral,
+              override: {
+                [MIXED_INVENTORY_CHAIN]: {
+                  ...MIXED_INVENTORY_OVERRIDE,
+                },
+              },
+            },
+            anvil2: {
+              weighted: { weight: 20, tolerance: 5 },
+              bridge: deployedAddresses.bridgeRoute.anvil2,
+              executionType: ExecutionType.MovableCollateral,
+              override: {
+                [MIXED_INVENTORY_CHAIN]: {
+                  ...MIXED_INVENTORY_OVERRIDE,
+                },
+              },
+            },
+            anvil3: {
+              weighted: { weight: 20, tolerance: 5 },
+              bridge: deployedAddresses.bridgeRoute.anvil3,
+              executionType: ExecutionType.MovableCollateral,
+            },
+          },
+        },
+      ],
+      inventorySigners: {
+        ethereum: inventorySignerAddress,
+      },
+      externalBridges: {
+        lifi: {
+          integrator: 'test',
+        },
+      },
+    });
+
+    expect(configResult.success).to.equal(true);
+  });
+
+  it('includes override-only inventory chain and creates both rebalancers', async function () {
+    const context = await buildContext('ERC20_INVENTORY_BALANCED');
+
+    const { rebalancers, inventoryConfig } =
+      await context.contextFactory.createRebalancers(
+        context.tracker,
+        undefined,
+        {
+          [ExternalBridgeType.LiFi]: mockBridge,
+        },
+      );
+
+    expect(inventoryConfig).to.exist;
+    expect(inventoryConfig!.chains).to.have.members([
+      MIXED_INVENTORY_CHAIN,
+      ...MIXED_MOVABLE_CHAINS,
+    ]);
+    expect(rebalancers.map((r) => r.rebalancerType).sort()).to.deep.equal([
+      'inventory',
+      'movableCollateral',
+    ]);
+  });
+
+  it('routes inventory destination through inventory and movable destination through movable collateral', async function () {
+    const context = await buildContext({
+      anvil1: BigNumber.from('10000000000'),
+      anvil2: BigNumber.from('0'),
+      anvil3: BigNumber.from('0'),
+    });
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+    const cycleResult = await context.orchestrator.executeCycle(event);
+
+    const routeToInventory = cycleResult.proposedRoutes.find(
+      (route) => route.destination === MIXED_INVENTORY_CHAIN,
+    );
+    expect(routeToInventory).to.exist;
+    expect(routeToInventory!.executionType).to.equal(ExecutionType.Inventory);
+
+    const movableDestination = MIXED_MOVABLE_CHAINS.find(
+      (chain) => chain !== 'anvil1',
+    )!;
+    const routeToMovable = cycleResult.proposedRoutes.find(
+      (route) => route.destination === movableDestination,
+    );
+    expect(routeToMovable).to.exist;
+    expect(routeToMovable!.executionType).to.equal(
+      ExecutionType.MovableCollateral,
+    );
+
+    const inProgressActions = await context.tracker.getInProgressActions();
+    const hasInventoryExecution = inProgressActions.some(
+      (action) =>
+        action.type === 'inventory_deposit' &&
+        multiProvider.getChainName(action.origin) === MIXED_INVENTORY_CHAIN,
+    );
+    const hasMovableExecution = inProgressActions.some(
+      (action) =>
+        action.type === 'rebalance_message' &&
+        multiProvider.getChainName(action.destination) === movableDestination,
+    );
+
+    expect(hasInventoryExecution).to.equal(true);
+    expect(hasMovableExecution).to.equal(true);
+  });
+});