@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2

package/src/e2e/harness/NativeLocalDeploymentManager.ts

@@ -0,0 +1,138 @@
+import { ethers, providers } from 'ethers';
+
+import { HypNative__factory } from '@humanode-hyperlane/core';
+
+import {
+  type NativeChainDeployment,
+  type NativeDeployedAddresses,
+  TEST_CHAIN_CONFIGS,
+  type TestChain,
+} from '../fixtures/routes.js';
+
+import { BaseLocalDeploymentManager } from './BaseLocalDeploymentManager.js';
+
+const TOKEN_SCALE_NUMERATOR = ethers.BigNumber.from(1);
+const TOKEN_SCALE_DENOMINATOR = ethers.BigNumber.from(1);
+const INVENTORY_INITIAL_BALANCE = '20000000000000000000';
+const INVENTORY_BRIDGE_SEED = '10000000000000000000';
+
+export class NativeLocalDeploymentManager extends BaseLocalDeploymentManager<NativeDeployedAddresses> {
+  constructor(private readonly inventorySignerAddress: string) {
+    super();
+  }
+
+  protected async deployRoutes(
+    deployerWallet: ethers.Wallet,
+    providersByChain: Map<string, providers.JsonRpcProvider>,
+    chainInfra: Record<
+      string,
+      { mailbox: string; ism: string; merkleHook: string }
+    >,
+  ): Promise<NativeDeployedAddresses> {
+    const deployerAddress = deployerWallet.address;
+    const chainDeployments = {} as Record<TestChain, NativeChainDeployment>;
+    const monitoredRouters = {} as Record<TestChain, ethers.Contract>;
+    const bridgeRouters = {} as Record<TestChain, ethers.Contract>;
+
+    for (const config of TEST_CHAIN_CONFIGS) {
+      const provider = providersByChain.get(config.name)!;
+      await provider.send('anvil_setBalance', [
+        this.inventorySignerAddress,
+        ethers.utils.hexValue(ethers.BigNumber.from(INVENTORY_INITIAL_BALANCE)),
+      ]);
+
+      const deployer = deployerWallet.connect(provider);
+
+      const monitoredRoute = await new HypNative__factory(deployer).deploy(
+        TOKEN_SCALE_NUMERATOR,
+        TOKEN_SCALE_DENOMINATOR,
+        chainInfra[config.name].mailbox,
+      );
+      await monitoredRoute.deployed();
+      await monitoredRoute.initialize(
+        ethers.constants.AddressZero,
+        chainInfra[config.name].ism,
+        deployerAddress,
+      );
+
+      const bridgeRoute = await new HypNative__factory(deployer).deploy(
+        TOKEN_SCALE_NUMERATOR,
+        TOKEN_SCALE_DENOMINATOR,
+        chainInfra[config.name].mailbox,
+      );
+      await bridgeRoute.deployed();
+      await bridgeRoute.initialize(
+        ethers.constants.AddressZero,
+        chainInfra[config.name].ism,
+        deployerAddress,
+      );
+
+      chainDeployments[config.name] = {
+        mailbox: chainInfra[config.name].mailbox,
+        ism: chainInfra[config.name].ism,
+        monitoredRouter: monitoredRoute.address,
+        bridgeRouter: bridgeRoute.address,
+      };
+
+      monitoredRouters[config.name] = monitoredRoute;
+      bridgeRouters[config.name] = bridgeRoute;
+    }
+
+    const routeGroups = [monitoredRouters, bridgeRouters];
+    for (const routeMap of routeGroups) {
+      for (const chain of TEST_CHAIN_CONFIGS) {
+        const localRoute = routeMap[chain.name];
+        const remoteDomains: number[] = [];
+        const remoteRouters: string[] = [];
+
+        for (const remote of TEST_CHAIN_CONFIGS) {
+          if (remote.name === chain.name) continue;
+          remoteDomains.push(remote.domainId);
+          remoteRouters.push(
+            ethers.utils.hexZeroPad(routeMap[remote.name].address, 32),
+          );
+        }
+
+        await localRoute.enrollRemoteRouters(remoteDomains, remoteRouters);
+      }
+    }
+
+    for (const chain of TEST_CHAIN_CONFIGS) {
+      const monitoredRoute = monitoredRouters[chain.name];
+      await monitoredRoute.addRebalancer(deployerAddress);
+      await monitoredRoute.addRebalancer(this.inventorySignerAddress);
+
+      for (const destination of TEST_CHAIN_CONFIGS) {
+        if (destination.name === chain.name) continue;
+        await monitoredRoute.addBridge(
+          destination.domainId,
+          bridgeRouters[chain.name].address,
+        );
+      }
+    }
+
+    const bridgeSeedAmount = ethers.BigNumber.from(INVENTORY_BRIDGE_SEED);
+    for (const chain of TEST_CHAIN_CONFIGS) {
+      const provider = providersByChain.get(chain.name)!;
+      const deployer = deployerWallet.connect(provider);
+      await deployer.sendTransaction({
+        to: bridgeRouters[chain.name].address,
+        value: bridgeSeedAmount,
+      });
+    }
+
+    return {
+      chains: chainDeployments,
+      monitoredRoute: {
+        anvil1: monitoredRouters.anvil1.address,
+        anvil2: monitoredRouters.anvil2.address,
+        anvil3: monitoredRouters.anvil3.address,
+      },
+      bridgeRoute: {
+        anvil1: bridgeRouters.anvil1.address,
+        anvil2: bridgeRouters.anvil2.address,
+        anvil3: bridgeRouters.anvil3.address,
+      },
+    };
+  }
+}

package/src/e2e/harness/SnapshotHelper.ts

@@ -0,0 +1,56 @@
+import { ethers, providers } from 'ethers';
+
+import {
+  MultiProvider,
+  revertToSnapshot,
+  snapshot,
+} from '@humanode-hyperlane/sdk';
+import { assert, retryAsync } from '@humanode-hyperlane/utils';
+
+import { ANVIL_TEST_PRIVATE_KEY, TEST_CHAINS } from '../fixtures/routes.js';
+
+function createFreshProvider(url: string): providers.JsonRpcProvider {
+  return new providers.JsonRpcProvider(url);
+}
+
+/**
+ * Revert all chains to their snapshots, take new snapshots, and refresh
+ * the providers in both localProviders and multiProvider so that ethers v5
+ * internal block-number caches are cleared.
+ */
+export async function resetSnapshotsAndRefreshProviders({
+  localProviders,
+  multiProvider,
+  snapshotIds,
+}: {
+  localProviders: Map<string, providers.JsonRpcProvider>;
+  multiProvider: MultiProvider;
+  snapshotIds: Map<string, string>;
+}): Promise<void> {
+  for (const [chain, provider] of localProviders) {
+    const id = snapshotIds.get(chain);
+    assert(id, `Missing snapshot id for chain ${chain}`);
+    await revertToSnapshot(provider, id);
+    snapshotIds.set(chain, await snapshot(provider));
+  }
+
+  // Replace providers so ethers v5 internal block-number caches are cleared.
+  const signerWallet = new ethers.Wallet(ANVIL_TEST_PRIVATE_KEY);
+
+  for (const [chain, oldProvider] of Array.from(localProviders.entries())) {
+    const url = oldProvider.connection.url;
+    const freshProvider = createFreshProvider(url);
+    localProviders.set(chain, freshProvider);
+    multiProvider.setProvider(chain, freshProvider);
+    multiProvider.setSigner(chain, signerWallet.connect(freshProvider));
+  }
+
+  // Wait until every fresh provider can serve a basic RPC call.
+  await Promise.all(
+    TEST_CHAINS.map((chain) => {
+      const p = localProviders.get(chain);
+      assert(p, `Missing provider for chain ${chain}`);
+      return retryAsync(() => p.send('eth_blockNumber', []), 10, 500);
+    }),
+  );
+}

package/src/e2e/harness/TestHelpers.ts

@@ -0,0 +1,169 @@
+import { BigNumber, providers } from 'ethers';
+
+import { HyperlaneCore, MultiProvider } from '@humanode-hyperlane/sdk';
+import { assert } from '@humanode-hyperlane/utils';
+import { ERC20Test__factory } from '@humanode-hyperlane/core';
+import { expect } from 'chai';
+
+import type { RebalanceAction } from '../../tracking/types.js';
+import type { MonitorEvent } from '../../interfaces/IMonitor.js';
+import { MonitorEventType } from '../../interfaces/IMonitor.js';
+import type { Monitor } from '../../monitor/Monitor.js';
+import type { TestRebalancerContext } from './TestRebalancer.js';
+import { tryRelayMessage } from './TransferHelper.js';
+
+import {
+  DOMAIN_IDS,
+  type Erc20InventoryDeployedAddresses,
+  type NativeDeployedAddresses,
+  TEST_CHAINS,
+} from '../fixtures/routes.js';
+
+export async function getFirstMonitorEvent(
+  monitor: Monitor,
+): Promise<MonitorEvent> {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    async function finalize(
+      cb: (v: any) => void, // eslint-disable-line @typescript-eslint/no-explicit-any -- accepts both resolve and reject
+      value: unknown,
+      timer: ReturnType<typeof setTimeout>,
+    ) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      cb(value);
+      try {
+        await monitor.stop();
+      } catch {
+        // stop errors are non-fatal — the event/error has already been delivered
+      }
+    }
+
+    const timeout = setTimeout(() => {
+      void finalize(reject, new Error('Monitor event timeout'), timeout);
+    }, 60_000);
+
+    monitor.on(MonitorEventType.TokenInfo, (event: MonitorEvent) => {
+      void finalize(resolve, event, timeout);
+    });
+
+    monitor.on(MonitorEventType.Error, (error: Error) => {
+      void finalize(reject, error, timeout);
+    });
+
+    void monitor.start();
+  });
+}
+
+export function chainFromDomain(domain: number): string {
+  const found = Object.entries(DOMAIN_IDS).find(([, d]) => d === domain);
+  if (!found) {
+    throw new Error(`Unknown domain: ${domain}`);
+  }
+  return found[0];
+}
+
+export async function getRouterBalances(
+  localProviders: Map<string, providers.JsonRpcProvider>,
+  addresses: NativeDeployedAddresses,
+): Promise<Record<string, BigNumber>> {
+  const balances: Record<string, BigNumber> = {};
+  for (const chain of TEST_CHAINS) {
+    const provider = localProviders.get(chain);
+    assert(provider, `Missing provider for chain ${chain}`);
+    balances[chain] = await provider.getBalance(
+      addresses.monitoredRoute[chain],
+    );
+  }
+  return balances;
+}
+
+export async function getErc20RouterBalances(
+  localProviders: Map<string, providers.JsonRpcProvider>,
+  addresses: Erc20InventoryDeployedAddresses,
+): Promise<Record<string, BigNumber>> {
+  const balances: Record<string, BigNumber> = {};
+  for (const chain of TEST_CHAINS) {
+    const provider = localProviders.get(chain);
+    assert(provider, `Missing provider for chain ${chain}`);
+    const token = ERC20Test__factory.connect(addresses.tokens[chain], provider);
+    balances[chain] = await token.balanceOf(addresses.monitoredRoute[chain]);
+  }
+  return balances;
+}
+
+export interface ChainRoles {
+  deficitChain: string;
+  surplusChain: string;
+  neutralChain?: string;
+}
+
+/**
+ * Classify chains into deficit, surplus, and neutral based on a deposit action.
+ *
+ * For inventory deposits the execution direction is swapped: the action's
+ * destination is the surplus chain (where the router pays out on delivery).
+ */
+export function classifyChains(
+  deficitChain: string,
+  depositAction: RebalanceAction,
+): ChainRoles {
+  const surplusChain = chainFromDomain(depositAction.destination);
+  const neutralChain = TEST_CHAINS.find(
+    (c) => c !== deficitChain && c !== surplusChain,
+  );
+  return { deficitChain, surplusChain, neutralChain };
+}
+
+export async function relayInProgressInventoryDeposits(
+  context: TestRebalancerContext,
+  localProviders: Map<string, providers.JsonRpcProvider>,
+  multiProvider: MultiProvider,
+  hyperlaneCore: HyperlaneCore,
+): Promise<void> {
+  const inProgressActions = await context.tracker.getInProgressActions();
+  const depositActions = inProgressActions.filter(
+    (a) => a.type === 'inventory_deposit' && a.txHash && a.messageId,
+  );
+
+  for (const action of depositActions) {
+    const origin = chainFromDomain(action.origin);
+    const destination = chainFromDomain(action.destination);
+    const provider = localProviders.get(origin);
+    assert(provider, `Missing provider for chain ${origin}`);
+    assert(
+      action.txHash,
+      `Missing txHash for action ${action.origin}->${action.destination}`,
+    );
+    const dispatchTx = await provider.getTransactionReceipt(action.txHash);
+
+    assert(
+      action.messageId,
+      `Missing messageId for action ${action.origin}->${action.destination}`,
+    );
+    const relayResult = await tryRelayMessage(multiProvider, hyperlaneCore, {
+      dispatchTx,
+      messageId: action.messageId,
+      origin,
+      destination,
+    });
+
+    expect(
+      relayResult.success,
+      `Inventory deposit relay should succeed: ${relayResult.error}`,
+    ).to.be.true;
+  }
+
+  // Use provider.send to bypass ethers v5 _maxInternalBlockNumber cache
+  // which refuses to return lower block numbers after evm_revert.
+  const tags: Record<string, number> = {};
+  for (const chain of TEST_CHAINS) {
+    const p = localProviders.get(chain);
+    assert(p, `Missing provider for chain ${chain}`);
+    const hex = await p.send('eth_blockNumber', []);
+    tags[chain] = parseInt(hex, 16);
+  }
+  await context.tracker.syncRebalanceActions(tags);
+}