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

package/src/e2e/harness/MixedLocalDeploymentManager.ts

@@ -0,0 +1,196 @@
+import { ethers, providers } from 'ethers';
+
+import {
+  ERC20Test__factory,
+  HypERC20Collateral__factory,
+} from '@humanode-hyperlane/core';
+
+import { ExecutionType, ExternalBridgeType } from '../../config/types.js';
+import {
+  type Erc20InventoryChainDeployment,
+  type Erc20InventoryDeployedAddresses,
+  TEST_CHAIN_CONFIGS,
+  type TestChain,
+} from '../fixtures/routes.js';
+
+import { BaseLocalDeploymentManager } from './BaseLocalDeploymentManager.js';
+
+const TOKEN_SCALE = ethers.BigNumber.from(1);
+const USDC_INITIAL_SUPPLY = '100000000000000';
+const USDC_DECIMALS = 6;
+const INVENTORY_INITIAL_ETH_BALANCE = '20000000000000000000';
+const INVENTORY_INITIAL_ERC20_BALANCE = '20000000000';
+const INVENTORY_ERC20_BRIDGE_SEED = '10000000000';
+
+export const MIXED_MOVABLE_CHAINS: readonly TestChain[] = ['anvil1', 'anvil2'];
+export const MIXED_INVENTORY_CHAIN: TestChain = 'anvil3';
+
+export const MIXED_INVENTORY_OVERRIDE = {
+  executionType: ExecutionType.Inventory,
+  externalBridge: ExternalBridgeType.LiFi,
+} as const;
+
+export class MixedLocalDeploymentManager extends BaseLocalDeploymentManager<Erc20InventoryDeployedAddresses> {
+  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<Erc20InventoryDeployedAddresses> {
+    const deployerAddress = deployerWallet.address;
+    const chainDeployments = {} as Record<
+      TestChain,
+      Erc20InventoryChainDeployment
+    >;
+    const monitoredRouters = {} as Record<TestChain, ethers.Contract>;
+    const bridgeRouters = {} as Record<TestChain, ethers.Contract>;
+    const tokens = {} 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_ETH_BALANCE),
+        ),
+      ]);
+
+      const deployer = deployerWallet.connect(provider);
+
+      const token = await new ERC20Test__factory(deployer).deploy(
+        'USDC',
+        'USDC',
+        USDC_INITIAL_SUPPLY,
+        USDC_DECIMALS,
+      );
+      await token.deployed();
+
+      const monitoredRoute = await new HypERC20Collateral__factory(
+        deployer,
+      ).deploy(
+        token.address,
+        TOKEN_SCALE,
+        TOKEN_SCALE,
+        chainInfra[config.name].mailbox,
+      );
+      await monitoredRoute.deployed();
+      await monitoredRoute.initialize(
+        ethers.constants.AddressZero,
+        chainInfra[config.name].ism,
+        deployerAddress,
+      );
+
+      const bridgeRoute = await new HypERC20Collateral__factory(
+        deployer,
+      ).deploy(
+        token.address,
+        TOKEN_SCALE,
+        TOKEN_SCALE,
+        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,
+        token: token.address,
+      };
+
+      tokens[config.name] = token;
+      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);
+      if (chain.name === MIXED_INVENTORY_CHAIN) {
+        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_ERC20_BRIDGE_SEED);
+    const signerErc20Amount = ethers.BigNumber.from(
+      INVENTORY_INITIAL_ERC20_BALANCE,
+    );
+    for (const chain of TEST_CHAIN_CONFIGS) {
+      const provider = providersByChain.get(chain.name)!;
+      const deployer = deployerWallet.connect(provider);
+      const token = ERC20Test__factory.connect(
+        tokens[chain.name].address,
+        deployer,
+      );
+      const tx1 = await token.transfer(
+        bridgeRouters[chain.name].address,
+        bridgeSeedAmount,
+      );
+      await tx1.wait();
+      const tx2 = await token.transfer(
+        this.inventorySignerAddress,
+        signerErc20Amount,
+      );
+      await tx2.wait();
+    }
+
+    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,
+      },
+      tokens: {
+        anvil1: tokens.anvil1.address,
+        anvil2: tokens.anvil2.address,
+        anvil3: tokens.anvil3.address,
+      },
+    };
+  }
+}
+
+export default MixedLocalDeploymentManager;

package/src/e2e/harness/MockExplorerClient.ts

@@ -0,0 +1,94 @@
+import type { Logger } from 'pino';
+
+import type { ConfirmedBlockTags } from '../../interfaces/IMonitor.js';
+import type {
+  ExplorerMessage,
+  IExplorerClient,
+  RebalanceActionQueryParams,
+  UserTransferQueryParams,
+} from '../../utils/ExplorerClient.js';
+
+import type { ForkIndexer } from './ForkIndexer.js';
+
+export interface MockExplorerConfig {
+  userTransfers?: ExplorerMessage[];
+  rebalanceActions?: ExplorerMessage[];
+}
+
+export class MockExplorerClient implements IExplorerClient {
+  private userTransfers: ExplorerMessage[];
+  private rebalanceActions: ExplorerMessage[];
+
+  constructor(
+    config: MockExplorerConfig = {},
+    private readonly forkIndexer?: ForkIndexer,
+    private readonly getBlockTags?: () => Promise<ConfirmedBlockTags>,
+  ) {
+    this.userTransfers = config.userTransfers ?? [];
+    this.rebalanceActions = config.rebalanceActions ?? [];
+  }
+
+  async getInflightUserTransfers(
+    _params: UserTransferQueryParams,
+    _logger?: Logger,
+  ): Promise<ExplorerMessage[]> {
+    if (this.forkIndexer && this.getBlockTags) {
+      await this.forkIndexer.sync(await this.getBlockTags());
+      const indexedTransfers = this.forkIndexer
+        .getUserTransfers()
+        .filter((msg) => !msg.is_delivered);
+      const configTransfers = this.userTransfers.filter(
+        (msg) => !msg.is_delivered,
+      );
+      return [...configTransfers, ...indexedTransfers];
+    }
+    return this.userTransfers.filter((msg) => !msg.is_delivered);
+  }
+
+  async getInflightRebalanceActions(
+    _params: RebalanceActionQueryParams,
+    _logger?: Logger,
+  ): Promise<ExplorerMessage[]> {
+    if (this.forkIndexer && this.getBlockTags) {
+      await this.forkIndexer.sync(await this.getBlockTags());
+      const indexedActions = this.forkIndexer
+        .getRebalanceActions()
+        .filter((msg) => !msg.is_delivered);
+      const configActions = this.rebalanceActions.filter(
+        (msg) => !msg.is_delivered,
+      );
+      return [...configActions, ...indexedActions];
+    }
+    return this.rebalanceActions.filter((msg) => !msg.is_delivered);
+  }
+
+  addUserTransfer(transfer: ExplorerMessage): void {
+    this.userTransfers.push(transfer);
+  }
+
+  addRebalanceAction(action: ExplorerMessage): void {
+    this.rebalanceActions.push(action);
+  }
+
+  updateTransfer(messageId: string, updates: Partial<ExplorerMessage>): void {
+    const transfer = this.userTransfers.find((t) => t.msg_id === messageId);
+    if (transfer) {
+      Object.assign(transfer, updates);
+    }
+  }
+
+  updateRebalanceAction(
+    messageId: string,
+    updates: Partial<ExplorerMessage>,
+  ): void {
+    const action = this.rebalanceActions.find((a) => a.msg_id === messageId);
+    if (action) {
+      Object.assign(action, updates);
+    }
+  }
+
+  clearAll(): void {
+    this.userTransfers.length = 0;
+    this.rebalanceActions.length = 0;
+  }
+}

package/src/e2e/harness/MockExternalBridge.ts

@@ -0,0 +1,411 @@
+import { BigNumber, ethers, type providers } from 'ethers';
+import { pino, type Logger } from 'pino';
+
+import {
+  ERC20Test__factory,
+  HypERC20Collateral__factory,
+  HypNative__factory,
+} from '@humanode-hyperlane/core';
+import { HyperlaneRelayer } from '@humanode-hyperlane/relayer';
+import { HyperlaneCore, type MultiProvider } from '@humanode-hyperlane/sdk';
+import { assert, ProtocolType } from '@humanode-hyperlane/utils';
+
+import type {
+  BridgeQuote,
+  BridgeQuoteParams,
+  BridgeTransferResult,
+  BridgeTransferStatus,
+  IExternalBridge,
+} from '../../interfaces/IExternalBridge.js';
+import type {
+  Erc20InventoryDeployedAddresses,
+  NativeDeployedAddresses,
+  TestChain,
+} from '../fixtures/routes.js';
+
+type MockBridgeRoute = {
+  fromChain: number;
+  toChain: number;
+  fromAddress: string;
+  toAddress: string;
+  tokenType: 'native' | 'erc20';
+};
+
+export class MockExternalBridge implements IExternalBridge {
+  readonly externalBridgeId = 'mock-bridge';
+  readonly logger: Logger;
+
+  private readonly failStatusOverrides = new Map<
+    string,
+    BridgeTransferStatus
+  >();
+  private _failNextExecute = false;
+  private readonly deployedAddresses:
+    | NativeDeployedAddresses
+    | Erc20InventoryDeployedAddresses;
+  private readonly tokenType: 'native' | 'erc20';
+
+  constructor(
+    deployedAddresses:
+      | NativeDeployedAddresses
+      | Erc20InventoryDeployedAddresses,
+    private readonly multiProvider: MultiProvider,
+    private readonly core: HyperlaneCore,
+    tokenType: 'native' | 'erc20' = 'native',
+    logger?: Logger,
+  ) {
+    this.deployedAddresses = deployedAddresses;
+    this.tokenType = tokenType;
+    this.logger =
+      logger ??
+      pino({ level: 'silent' }).child({
+        module: 'MockExternalBridge',
+      });
+  }
+
+  getNativeTokenAddress(): string {
+    return '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+  }
+
+  async quote(params: BridgeQuoteParams): Promise<BridgeQuote> {
+    if (params.fromAmount !== undefined && params.toAmount !== undefined) {
+      throw new Error(
+        'Cannot specify both fromAmount and toAmount - provide exactly one',
+      );
+    }
+    if (params.fromAmount === undefined && params.toAmount === undefined) {
+      throw new Error('Must specify either fromAmount or toAmount');
+    }
+
+    const amount = params.fromAmount ?? params.toAmount!;
+    const toAddress = params.toAddress ?? params.fromAddress;
+
+    const gasCosts = await this.estimateGasCosts(
+      params.fromChain,
+      params.toChain,
+      toAddress,
+      params.fromAddress,
+    );
+
+    const route: MockBridgeRoute = {
+      fromChain: params.fromChain,
+      toChain: params.toChain,
+      fromAddress: params.fromAddress,
+      toAddress,
+      tokenType: this.tokenType,
+    };
+
+    return {
+      id: `mock-quote-${Date.now()}`,
+      tool: this.externalBridgeId,
+      fromAmount: amount,
+      toAmount: amount,
+      toAmountMin: amount,
+      executionDuration: 1,
+      gasCosts,
+      feeCosts: 0n,
+      route,
+      requestParams: params,
+    };
+  }
+
+  async execute(
+    quote: BridgeQuote,
+    privateKeys: Partial<Record<ProtocolType, string>>,
+  ): Promise<BridgeTransferResult> {
+    if (this._failNextExecute) {
+      this._failNextExecute = false;
+      throw new Error('MockExternalBridge execute failure injected');
+    }
+
+    const route = this.parseRoute(quote.route);
+    const fromChain = route.fromChain;
+    const toChain = route.toChain;
+
+    const fromChainName = this.resolveChainName(fromChain);
+    const toChainName = this.resolveChainName(toChain);
+
+    const bridgeRouteAddress =
+      this.deployedAddresses.bridgeRoute[fromChainName];
+    const destinationDomain = this.multiProvider.getDomainId(toChainName);
+
+    const provider = this.multiProvider.getProvider(fromChainName);
+    const evmKey = privateKeys[ProtocolType.Ethereum];
+    assert(evmKey, 'Missing Ethereum private key for MockExternalBridge');
+    const signer = new ethers.Wallet(evmKey, provider);
+
+    const recipientBytes32 = ethers.utils.hexZeroPad(
+      ethers.utils.hexlify(route.toAddress),
+      32,
+    );
+
+    let tx;
+    if (this.tokenType === 'erc20') {
+      assert(
+        'tokens' in this.deployedAddresses,
+        'Expected ERC20 deployed addresses',
+      );
+      const tokenAddress = (
+        this.deployedAddresses as Erc20InventoryDeployedAddresses
+      ).tokens[fromChainName];
+      const token = ERC20Test__factory.connect(tokenAddress, signer);
+      await token.approve(bridgeRouteAddress, quote.fromAmount);
+
+      const bridgeRoute = HypERC20Collateral__factory.connect(
+        bridgeRouteAddress,
+        signer,
+      );
+      tx = await bridgeRoute.transferRemote(
+        destinationDomain,
+        recipientBytes32,
+        quote.fromAmount,
+      );
+    } else {
+      const bridgeRoute = HypNative__factory.connect(
+        bridgeRouteAddress,
+        signer,
+      );
+      tx = await bridgeRoute.transferRemote(
+        destinationDomain,
+        recipientBytes32,
+        quote.fromAmount,
+        { value: quote.fromAmount },
+      );
+    }
+
+    // Wait for the transaction to be mined so that getStatus() can always
+    // find the receipt via getTransactionReceipt().  Without this, there is
+    // a race on automined anvil where the receipt is not yet available.
+    await tx.wait();
+
+    return {
+      txHash: tx.hash,
+      fromChain,
+      toChain,
+    };
+  }
+
+  async getStatus(
+    txHash: string,
+    fromChain: number,
+    toChain: number,
+  ): Promise<BridgeTransferStatus> {
+    const override = this.failStatusOverrides.get(txHash);
+    if (override) {
+      return override;
+    }
+
+    try {
+      const fromChainName = this.resolveChainName(fromChain);
+      const toChainName = this.resolveChainName(toChain);
+      const provider = this.multiProvider.getProvider(fromChainName);
+      const dispatchTxReceipt = await provider.getTransactionReceipt(txHash);
+
+      if (!dispatchTxReceipt) {
+        return { status: 'not_found' };
+      }
+
+      const dispatchedMessages =
+        HyperlaneCore.getDispatchedMessages(dispatchTxReceipt);
+      assert(
+        dispatchedMessages.length === 1,
+        `Expected exactly 1 dispatched message, got ${dispatchedMessages.length} for tx ${txHash}`,
+      );
+      const dispatchedMsgId = dispatchedMessages[0].id;
+
+      const relayer = new HyperlaneRelayer({ core: this.core });
+      const receipts = await relayer.relayAll(dispatchTxReceipt);
+
+      const destinationDomain = this.multiProvider.getDomainId(toChainName);
+      const destinationReceipts =
+        receipts[toChainName] ??
+        receipts[toChain] ??
+        receipts[destinationDomain];
+
+      // If relayAll didn't produce receipts (e.g. message already delivered),
+      // fall back to checking on-chain delivery status directly.
+      if (!destinationReceipts || destinationReceipts.length === 0) {
+        const destMailbox = this.core.getContracts(toChainName).mailbox;
+        const isDelivered = await destMailbox.delivered(dispatchedMsgId);
+        if (isDelivered) {
+          const receivedAmount = await this.getTransferredAmount(
+            provider,
+            dispatchTxReceipt,
+          );
+          // Find the actual destination chain process tx
+          const processEvents = await destMailbox.queryFilter(
+            destMailbox.filters.ProcessId(dispatchedMsgId),
+          );
+          assert(
+            processEvents.length > 0,
+            `No ProcessId event found for message ${dispatchedMsgId} on ${toChainName}`,
+          );
+          return {
+            status: 'complete',
+            receivingTxHash: processEvents[0].transactionHash,
+            receivedAmount,
+          };
+        }
+        return { status: 'not_found' };
+      }
+
+      const receivedAmount = await this.getTransferredAmount(
+        provider,
+        dispatchTxReceipt,
+      );
+
+      return {
+        status: 'complete',
+        receivingTxHash: destinationReceipts[0].transactionHash,
+        receivedAmount,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: 'failed', error: message };
+    }
+  }
+
+  failStatusFor(
+    txHash: string,
+    status: BridgeTransferStatus = { status: 'failed' },
+  ): void {
+    this.failStatusOverrides.set(txHash, status);
+  }
+
+  failNextExecute(): void {
+    this._failNextExecute = true;
+  }
+
+  reset(): void {
+    this.failStatusOverrides.clear();
+    this._failNextExecute = false;
+  }
+
+  /**
+   * Estimates gas costs for a transferRemote call on the bridge route.
+   * Uses a small amount (1 wei) to avoid balance-related estimation failures.
+   */
+  private async estimateGasCosts(
+    fromChain: number,
+    toChain: number,
+    toAddress: string,
+    fromAddress: string,
+  ): Promise<bigint> {
+    const fromChainName = this.resolveChainName(fromChain);
+    const toChainName = this.resolveChainName(toChain);
+
+    const bridgeRouteAddress =
+      this.deployedAddresses.bridgeRoute[fromChainName];
+    const destinationDomain = this.multiProvider.getDomainId(toChainName);
+    const provider = this.multiProvider.getProvider(fromChainName);
+
+    const recipientBytes32 = ethers.utils.hexZeroPad(
+      ethers.utils.hexlify(toAddress),
+      32,
+    );
+
+    // Use 1 wei for estimation — gas usage doesn't depend on transfer amount
+    const estimateAmount = 1n;
+    if (this.tokenType === 'erc20') {
+      // ERC20 transferRemote requires token approval which isn't set up during estimation.
+      // Return 0n as a mock — gas costs don't affect test logic.
+      return 0n;
+    } else {
+      const bridgeRoute = HypNative__factory.connect(
+        bridgeRouteAddress,
+        provider,
+      );
+      const gasEstimate = await bridgeRoute.estimateGas.transferRemote(
+        destinationDomain,
+        recipientBytes32,
+        estimateAmount,
+        { value: estimateAmount, from: fromAddress },
+      );
+      const gasPrice = await provider.getGasPrice();
+      return gasEstimate.mul(gasPrice).toBigInt();
+    }
+  }
+
+  private parseRoute(route: unknown): MockBridgeRoute {
+    if (!route || typeof route !== 'object') {
+      throw new Error('Mock quote route is missing');
+    }
+
+    const parsed = route as Partial<MockBridgeRoute>;
+
+    if (
+      typeof parsed.fromChain !== 'number' ||
+      typeof parsed.toChain !== 'number' ||
+      typeof parsed.fromAddress !== 'string' ||
+      typeof parsed.toAddress !== 'string' ||
+      (parsed.tokenType !== 'native' && parsed.tokenType !== 'erc20')
+    ) {
+      throw new Error('Mock quote route is invalid');
+    }
+
+    return {
+      fromChain: parsed.fromChain,
+      toChain: parsed.toChain,
+      fromAddress: parsed.fromAddress,
+      toAddress: parsed.toAddress,
+      tokenType: parsed.tokenType,
+    };
+  }
+
+  private resolveChainName(chainRef: number): TestChain {
+    const chainNames = Object.keys(
+      this.deployedAddresses.chains,
+    ) as TestChain[];
+
+    for (const chainName of chainNames) {
+      const chainId = Number(this.multiProvider.getChainId(chainName));
+      const domainId = this.multiProvider.getDomainId(chainName);
+      if (chainId === chainRef || domainId === chainRef) {
+        return chainName;
+      }
+    }
+
+    throw new Error(`Chain not found for id/domain ${chainRef}`);
+  }
+
+  private async getTransferredAmount(
+    provider: providers.Provider,
+    receipt: providers.TransactionReceipt,
+  ): Promise<bigint> {
+    const tx = await provider.getTransaction(receipt.transactionHash);
+    if (!tx) {
+      throw new Error(
+        `Transaction ${receipt.transactionHash} not found on provider`,
+      );
+    }
+
+    try {
+      const parsed = HypNative__factory.createInterface().parseTransaction({
+        data: tx.data,
+        value: tx.value,
+      });
+
+      if (!parsed || parsed.name !== 'transferRemote') {
+        throw new Error(
+          `Expected transferRemote tx, got: ${parsed?.name ?? 'unparseable'}`,
+        );
+      }
+
+      const amount = parsed.args[2];
+      if (BigNumber.isBigNumber(amount)) {
+        return amount.toBigInt();
+      }
+      if (typeof amount === 'bigint') {
+        return amount;
+      }
+      return BigInt(String(amount));
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(
+        { txHash: receipt.transactionHash, error: message },
+        'Failed to parse transferRemote amount from tx',
+      );
+      throw new Error(`Failed to parse transferred amount: ${message}`);
+    }
+  }
+}