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

package/src/e2e/collateral-deficit.e2e-test.ts

@@ -0,0 +1,403 @@
+import { expect } from 'chai';
+import { BigNumber, ethers, providers } from 'ethers';
+
+import {
+  HyperlaneCore,
+  MultiProvider,
+  snapshot,
+} from '@humanode-hyperlane/sdk';
+import { toWei } from '@humanode-hyperlane/utils';
+
+import {
+  RebalancerStrategyOptions,
+  type StrategyConfig,
+} from '../config/types.js';
+
+import {
+  ANVIL_TEST_PRIVATE_KEY,
+  ANVIL_USER_PRIVATE_KEY,
+  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 {
+  executeWarpTransfer,
+  tryRelayMessage,
+} from './harness/TransferHelper.js';
+
+const USDC_DECIMALS = 6;
+
+describe('Collateral Deficit E2E', function () {
+  this.timeout(300_000);
+
+  let deploymentManager: Erc20LocalDeploymentManager;
+  let multiProvider: MultiProvider;
+  let localProviders: Map<string, providers.JsonRpcProvider>;
+  let userAddress: string;
+  let snapshotIds: Map<string, string>;
+  let hyperlaneCore: HyperlaneCore;
+  let deployedAddresses: DeployedAddresses;
+  let collateralDeficitStrategyConfig: StrategyConfig[];
+
+  before(async function () {
+    const wallet = new ethers.Wallet(ANVIL_USER_PRIVATE_KEY);
+    userAddress = wallet.address;
+
+    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,
+    );
+
+    collateralDeficitStrategyConfig = [
+      {
+        rebalanceStrategy: RebalancerStrategyOptions.CollateralDeficit,
+        chains: {
+          anvil1: {
+            buffer: '0',
+            bridge: deployedAddresses.bridgeRoute1.anvil1,
+          },
+          anvil2: {
+            buffer: '0',
+            bridge: deployedAddresses.bridgeRoute1.anvil2,
+          },
+          anvil3: {
+            buffer: '0',
+            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 route when pending transfer creates collateral deficit', async function () {
+    const transferAmount = BigNumber.from(toWei('500', USDC_DECIMALS));
+
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(collateralDeficitStrategyConfig)
+      .withBalances('DEFICIT_ARB')
+      .withPendingTransfer({
+        from: 'anvil1',
+        to: 'anvil2',
+        amount: transferAmount,
+        warpRecipient: userAddress,
+      })
+      .withExecutionMode('execute')
+      .build();
+
+    const monitor = context.createMonitor(0);
+    const event = await getFirstMonitorEvent(monitor);
+
+    await context.orchestrator.executeCycle(event);
+
+    // Assert: Strategy created rebalance intents for the deficit chain
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(activeIntents.length).to.be.greaterThan(0);
+
+    const intentToArbitrum = activeIntents.find(
+      (i) => i.destination === DOMAIN_IDS.anvil2,
+    );
+    expect(intentToArbitrum, 'Should have intent destined for arbitrum').to
+      .exist;
+    expect(intentToArbitrum!.amount).to.equal(400000000n);
+    expect(intentToArbitrum!.origin).to.equal(DOMAIN_IDS.anvil1);
+  });
+
+  it('should execute full rebalance cycle with actual transfers', async function () {
+    const transferAmount = BigNumber.from(toWei('500', USDC_DECIMALS));
+
+    const context = await TestRebalancer.builder(
+      deploymentManager,
+      multiProvider,
+    )
+      .withStrategy(collateralDeficitStrategyConfig)
+      .withBalances('DEFICIT_ARB')
+      .withExecutionMode('execute')
+      .build();
+
+    const initialCollateralBalances = await getAllCollateralBalances(
+      localProviders,
+      TEST_CHAINS,
+      deployedAddresses.monitoredRoute,
+      deployedAddresses.tokens,
+    );
+
+    const ethProvider = localProviders.get('anvil1')!;
+    const deployer = new ethers.Wallet(ANVIL_TEST_PRIVATE_KEY, ethProvider);
+    const token = (
+      await import('@humanode-hyperlane/core')
+    ).ERC20__factory.connect(deployedAddresses.tokens.anvil1, deployer);
+    const tx = await token.transfer(userAddress, transferAmount.mul(2));
+    await tx.wait();
+
+    const transferResult = await executeWarpTransfer(
+      context.multiProvider,
+      {
+        originChain: 'anvil1',
+        destinationChain: 'anvil2',
+        routerAddress: deployedAddresses.monitoredRoute.anvil1,
+        tokenAddress: deployedAddresses.tokens.anvil1,
+        amount: transferAmount,
+        recipient: userAddress,
+        senderAddress: userAddress,
+      },
+      ethProvider,
+    );
+
+    // Get collateral balances after user transfer dispatch
+    const balancesAfterUserTransfer = await getAllCollateralBalances(
+      localProviders,
+      TEST_CHAINS,
+      deployedAddresses.monitoredRoute,
+      deployedAddresses.tokens,
+    );
+
+    // Assert: Origin collateral INCREASED by exactly the transfer amount (user deposited tokens into router)
+    const expectedCollateralAfterDeposit =
+      initialCollateralBalances.anvil1.add(transferAmount);
+    expect(
+      balancesAfterUserTransfer.anvil1.eq(expectedCollateralAfterDeposit),
+      `Origin (anvil1) collateral should increase by transfer amount. ` +
+        `Expected: ${expectedCollateralAfterDeposit.toString()}, Actual: ${balancesAfterUserTransfer.anvil1.toString()}`,
+    ).to.be.true;
+
+    const userTransferRelay1 = await tryRelayMessage(
+      context.multiProvider,
+      hyperlaneCore,
+      transferResult,
+    );
+
+    // Assert: Relay fails due to insufficient collateral on destination
+    expect(userTransferRelay1.success).to.be.false;
+
+    // Assert: Destination collateral UNCHANGED (transfer not delivered)
+    expect(
+      balancesAfterUserTransfer.anvil2.eq(initialCollateralBalances.anvil2),
+      `Destination (anvil2) collateral should be unchanged before delivery. ` +
+        `Before: ${initialCollateralBalances.anvil2.toString()}, After: ${balancesAfterUserTransfer.anvil2.toString()}`,
+    ).to.be.true;
+
+    const blockTags = await context.getConfirmedBlockTags();
+    await context.tracker.syncTransfers(blockTags);
+
+    // Assert: User transfer exists in action tracker with correct fields
+    const transfersBeforeRebalance =
+      await context.tracker.getInProgressTransfers();
+    expect(transfersBeforeRebalance.length).to.equal(
+      1,
+      'Should have exactly 1 in-progress transfer',
+    );
+
+    const trackedTransfer = transfersBeforeRebalance[0];
+    // Assert all Transfer fields (except createdAt, updatedAt, messageId, txHash)
+    expect(trackedTransfer.id).to.be.a('string').and.not.be.empty;
+    expect(trackedTransfer.origin).to.equal(
+      DOMAIN_IDS.anvil1,
+      'Transfer origin should be ethereum',
+    );
+    expect(trackedTransfer.destination).to.equal(
+      DOMAIN_IDS.anvil2,
+      'Transfer destination should be arbitrum',
+    );
+    expect(trackedTransfer.amount.toString()).to.equal(
+      transferAmount.toString(),
+      'Transfer amount should match',
+    );
+    expect(trackedTransfer.status).to.equal(
+      'in_progress',
+      'Transfer status should be in_progress',
+    );
+    expect(trackedTransfer.messageId).to.equal(
+      transferResult.messageId,
+      'Transfer messageId should match dispatched message',
+    );
+    expect(trackedTransfer.sender.toLowerCase()).to.equal(
+      deployedAddresses.monitoredRoute.anvil1.toLowerCase(),
+      'Transfer sender should be the warp route router',
+    );
+    expect(trackedTransfer.recipient.toLowerCase()).to.equal(
+      deployedAddresses.monitoredRoute.anvil2.toLowerCase(),
+      'Transfer recipient should be the destination warp route router',
+    );
+
+    const monitor1 = context.createMonitor(0);
+    const event1 = await getFirstMonitorEvent(monitor1);
+    await context.orchestrator.executeCycle(event1);
+
+    // Assert: Rebalance intent was created with correct fields
+    const activeIntents = await context.tracker.getActiveRebalanceIntents();
+    expect(
+      activeIntents.length,
+      'Should have exactly 1 active rebalance intent',
+    ).to.equal(1);
+
+    const intentToArbitrum = activeIntents.find(
+      (i) => i.destination === DOMAIN_IDS.anvil2,
+    );
+    expect(intentToArbitrum, 'Should have intent destined for arbitrum').to
+      .exist;
+
+    // Assert all RebalanceIntent fields (except createdAt, updatedAt)
+    expect(intentToArbitrum!.id).to.be.a('string').and.not.be.empty;
+    expect(intentToArbitrum!.origin).to.equal(DOMAIN_IDS.anvil1);
+    expect(intentToArbitrum!.destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(intentToArbitrum!.amount).to.equal(400000000n);
+    expect(intentToArbitrum!.status).to.equal('in_progress');
+
+    // Capture intent ID for completion verification
+    const rebalanceIntentId = intentToArbitrum!.id;
+
+    // Assert: Rebalance action was created with correct fields
+    const inProgressActions = await context.tracker.getInProgressActions();
+    expect(
+      inProgressActions.length,
+      'Should have at least 1 in-progress action',
+    ).to.be.greaterThan(0);
+
+    const actionToArbitrum = inProgressActions.find(
+      (a) => a.destination === DOMAIN_IDS.anvil2,
+    );
+    expect(actionToArbitrum, 'Should have action destined for arbitrum').to
+      .exist;
+
+    // Assert all RebalanceAction fields (except createdAt, updatedAt, messageId, txHash)
+    expect(actionToArbitrum!.id).to.be.a('string').and.not.be.empty;
+    expect(actionToArbitrum!.intentId).to.equal(rebalanceIntentId);
+    expect(actionToArbitrum!.origin).to.equal(DOMAIN_IDS.anvil1);
+    expect(actionToArbitrum!.destination).to.equal(DOMAIN_IDS.anvil2);
+    expect(actionToArbitrum!.amount).to.equal(400000000n);
+    expect(actionToArbitrum!.status).to.equal('in_progress');
+    expect(actionToArbitrum!.messageId).to.be.a('string').and.not.be.empty;
+
+    // Assert: Monitored route collateral on origin DECREASED (sent to bridge)
+    const balancesAfterRebalance = await getAllCollateralBalances(
+      localProviders,
+      TEST_CHAINS,
+      deployedAddresses.monitoredRoute,
+      deployedAddresses.tokens,
+    );
+
+    // Assert exact balance: initial 10000 + user deposit 500 - rebalance 400 = 10100 USDC
+    expect(
+      balancesAfterRebalance.anvil1.toString(),
+      'anvil1 collateral should be 10100 USDC after rebalance',
+    ).to.equal('10100000000');
+
+    // Verify entities can be retrieved by ID and have correct status
+    const retrievedTransfer = await context.tracker.getTransfer(
+      trackedTransfer.id,
+    );
+    expect(retrievedTransfer, 'Transfer should be retrievable by ID').to.exist;
+    expect(retrievedTransfer!.id).to.equal(trackedTransfer.id);
+    expect(retrievedTransfer!.status).to.equal('in_progress');
+
+    const retrievedIntent =
+      await context.tracker.getRebalanceIntent(rebalanceIntentId);
+    expect(retrievedIntent, 'Intent should be retrievable by ID').to.exist;
+    expect(retrievedIntent!.id).to.equal(rebalanceIntentId);
+    expect(retrievedIntent!.status).to.equal('in_progress');
+
+    const retrievedAction = await context.tracker.getRebalanceAction(
+      actionToArbitrum!.id,
+    );
+    expect(retrievedAction, 'Action should be retrievable by ID').to.exist;
+    expect(retrievedAction!.id).to.equal(actionToArbitrum!.id);
+    expect(retrievedAction!.status).to.equal('in_progress');
+
+    // Relay the rebalance message to destination (use global multiProvider which has signers on all chains)
+    expect(actionToArbitrum!.txHash, 'Action should have txHash').to.exist;
+    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;
+
+    const userTransferRelay2 = await tryRelayMessage(
+      context.multiProvider,
+      hyperlaneCore,
+      transferResult,
+    );
+    expect(
+      userTransferRelay2.success,
+      `User transfer relay should succeed: ${userTransferRelay2.error}`,
+    ).to.be.true;
+
+    // Sync actions to detect delivery and mark complete
+    const blockTags2 = await context.getConfirmedBlockTags();
+    await context.tracker.syncRebalanceActions(blockTags2);
+    await context.tracker.syncTransfers(blockTags2);
+
+    // 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(rebalanceIntentId);
+    expect(completedIntent!.status).to.equal('complete');
+
+    // Assert: No more in-progress actions
+    const remainingActions = await context.tracker.getInProgressActions();
+    expect(remainingActions.length).to.equal(0);
+
+    const completedTransfer = await context.tracker.getTransfer(
+      transferResult.messageId,
+    );
+    expect(completedTransfer!.status).to.equal('complete');
+  });
+});