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

package/src/e2e/harness/TransferHelper.ts

@@ -0,0 +1,188 @@
+import { BigNumber, type ContractReceipt, ethers, providers } from 'ethers';
+
+import {
+  ERC20__factory,
+  HypERC20Collateral__factory,
+  MovableCollateralRouter__factory,
+} from '@humanode-hyperlane/core';
+import { HyperlaneRelayer } from '@humanode-hyperlane/relayer';
+import {
+  HyperlaneCore,
+  type MultiProvider,
+  impersonateAccounts,
+  setBalance,
+} from '@humanode-hyperlane/sdk';
+import { addressToBytes32, retryAsync } from '@humanode-hyperlane/utils';
+
+export interface WarpTransferParams {
+  originChain: string;
+  destinationChain: string;
+  routerAddress: string;
+  tokenAddress: string;
+  amount: BigNumber;
+  recipient: string;
+  senderAddress?: string;
+}
+
+export interface WarpTransferResult {
+  dispatchTx: ContractReceipt;
+  messageId: string;
+  origin: string;
+  destination: string;
+}
+
+export async function executeWarpTransfer(
+  multiProvider: MultiProvider,
+  params: WarpTransferParams,
+  forkedProvider?: providers.JsonRpcProvider,
+): Promise<WarpTransferResult> {
+  const {
+    originChain,
+    destinationChain,
+    routerAddress,
+    tokenAddress,
+    amount,
+    recipient,
+    senderAddress,
+  } = params;
+
+  const provider =
+    forkedProvider ??
+    (multiProvider.getProvider(originChain) as providers.JsonRpcProvider);
+  const destinationDomain = multiProvider.getDomainId(destinationChain);
+
+  let sender: string;
+  if (senderAddress) {
+    sender = senderAddress;
+    await provider.send('anvil_impersonateAccount', [sender]);
+  } else {
+    sender = await multiProvider.getSigner(originChain).getAddress();
+  }
+
+  await provider.send('anvil_setBalance', [
+    sender,
+    ethers.utils.parseEther('100').toHexString(),
+  ]);
+
+  const signer = provider.getSigner(sender);
+
+  const token = ERC20__factory.connect(tokenAddress, signer);
+  const router = HypERC20Collateral__factory.connect(routerAddress, signer);
+
+  const currentAllowance = await token.allowance(sender, routerAddress);
+  if (currentAllowance.lt(amount)) {
+    const approveTx = await token.approve(
+      routerAddress,
+      ethers.constants.MaxUint256,
+      { gasLimit: 100000 },
+    );
+    await approveTx.wait();
+  }
+
+  const recipientBytes32 = addressToBytes32(recipient);
+
+  const gasQuote = await router.quoteGasPayment(destinationDomain);
+
+  const tx = await router.transferRemote(
+    destinationDomain,
+    recipientBytes32,
+    amount,
+    { gasLimit: 500000, value: gasQuote },
+  );
+  const receipt = await tx.wait();
+
+  if (senderAddress) {
+    await provider.send('anvil_stopImpersonatingAccount', [senderAddress]);
+  }
+
+  const dispatchedMessages = HyperlaneCore.getDispatchedMessages(receipt);
+  if (dispatchedMessages.length === 0) {
+    throw new Error('No messages dispatched');
+  }
+
+  return {
+    dispatchTx: receipt,
+    messageId: dispatchedMessages[0].id,
+    origin: originChain,
+    destination: destinationChain,
+  };
+}
+
+export async function relayMessage(
+  multiProvider: MultiProvider,
+  core: HyperlaneCore,
+  transferResult: WarpTransferResult,
+): Promise<ContractReceipt> {
+  return retryAsync(
+    async () => {
+      const relayer = new HyperlaneRelayer({ core });
+      const receipts = await relayer.relayAll(transferResult.dispatchTx);
+      // relayAll keys receipts by domain ID, so look up by domain ID or chain name
+      const destinationDomain = core.multiProvider.getDomainId(
+        transferResult.destination,
+      );
+      const destinationReceipts =
+        receipts[transferResult.destination] ?? receipts[destinationDomain];
+      if (!destinationReceipts || destinationReceipts.length === 0) {
+        throw new Error('Message relay failed');
+      }
+      return destinationReceipts[0];
+    },
+    3,
+    1000,
+  );
+}
+
+export async function executeWarpTransferAndRelay(
+  multiProvider: MultiProvider,
+  core: HyperlaneCore,
+  params: WarpTransferParams,
+): Promise<{
+  transferResult: WarpTransferResult;
+  relayReceipt: ContractReceipt;
+}> {
+  const transferResult = await executeWarpTransfer(multiProvider, params);
+  const relayReceipt = await relayMessage(multiProvider, core, transferResult);
+  return { transferResult, relayReceipt };
+}
+
+export async function getRebalancerAddress(
+  provider: providers.JsonRpcProvider,
+  routerAddress: string,
+): Promise<string> {
+  const movable = MovableCollateralRouter__factory.connect(
+    routerAddress,
+    provider,
+  );
+  const rebalancers = await movable.allowedRebalancers();
+  if (rebalancers.length === 0) {
+    throw new Error(`No rebalancers found for router ${routerAddress}`);
+  }
+  return rebalancers[0];
+}
+
+export async function impersonateRebalancer(
+  provider: providers.JsonRpcProvider,
+  routerAddress: string,
+): Promise<{ rebalancerAddress: string; signer: providers.JsonRpcSigner }> {
+  const rebalancerAddress = await getRebalancerAddress(provider, routerAddress);
+  await impersonateAccounts(provider, [rebalancerAddress]);
+  await setBalance(provider, rebalancerAddress, '0x56BC75E2D63100000');
+  return {
+    rebalancerAddress,
+    signer: provider.getSigner(rebalancerAddress),
+  };
+}
+
+export async function tryRelayMessage(
+  multiProvider: MultiProvider,
+  core: HyperlaneCore,
+  transferResult: WarpTransferResult,
+): Promise<{ success: boolean; receipt?: ContractReceipt; error?: string }> {
+  try {
+    const receipt = await relayMessage(multiProvider, core, transferResult);
+    return { success: true, receipt };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}