@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2

package/src/e2e/harness/BaseLocalDeploymentManager.ts

@@ -0,0 +1,246 @@
+import { ethers, providers } from 'ethers';
+import { type Logger, pino } from 'pino';
+import {
+  GenericContainer,
+  type StartedTestContainer,
+  Wait,
+} from 'testcontainers';
+
+import {
+  Mailbox__factory,
+  MerkleTreeHook__factory,
+  TrustedRelayerIsm__factory,
+} from '@humanode-hyperlane/core';
+import { type IRegistry, PartialRegistry } from '@humanode-hyperlane/registry';
+import {
+  type ChainMetadata,
+  type ChainName,
+  MultiProvider,
+} from '@humanode-hyperlane/sdk';
+import { ProtocolType, retryAsync } from '@humanode-hyperlane/utils';
+
+import {
+  ANVIL_TEST_PRIVATE_KEY,
+  TEST_CHAIN_CONFIGS,
+} from '../fixtures/routes.js';
+
+export interface LocalDeploymentContext<
+  TDeployedAddresses extends {
+    chains: Record<string, { mailbox: string; ism: string }>;
+  },
+> {
+  providers: Map<string, providers.JsonRpcProvider>;
+  registry: IRegistry;
+  multiProvider: MultiProvider;
+  deployedAddresses: TDeployedAddresses;
+}
+
+const ANVIL_DEPLOYER_BALANCE_HEX = '0x56BC75E2D63100000';
+
+export abstract class BaseLocalDeploymentManager<
+  TDeployedAddresses extends {
+    chains: Record<string, { mailbox: string; ism: string }>;
+  },
+> {
+  private context?: LocalDeploymentContext<TDeployedAddresses>;
+  private containers: Map<string, StartedTestContainer> = new Map();
+  private readonly logger: Logger;
+
+  constructor() {
+    this.logger = pino({ level: 'debug' }).child({
+      module: 'BaseLocalDeploymentManager',
+    });
+  }
+
+  async start(): Promise<LocalDeploymentContext<TDeployedAddresses>> {
+    if (this.context) {
+      throw new Error('LocalDeploymentManager already started');
+    }
+
+    const providersByChain = new Map<string, providers.JsonRpcProvider>();
+    const deployerWallet = new ethers.Wallet(ANVIL_TEST_PRIVATE_KEY);
+    const deployerAddress = deployerWallet.address;
+    const chainInfra: Record<
+      string,
+      { mailbox: string; ism: string; merkleHook: string; endpoint: string }
+    > = {};
+
+    try {
+      for (let i = 0; i < TEST_CHAIN_CONFIGS.length; i++) {
+        const config = TEST_CHAIN_CONFIGS[i];
+
+        const container = await retryAsync(
+          () =>
+            new GenericContainer('ghcr.io/foundry-rs/foundry:latest')
+              .withEntrypoint([
+                'anvil',
+                '--host',
+                '0.0.0.0',
+                '-p',
+                '8545',
+                '--chain-id',
+                config.chainId.toString(),
+              ])
+              .withExposedPorts(8545)
+              .withWaitStrategy(
+                Wait.forAll([
+                  Wait.forListeningPorts(),
+                  Wait.forLogMessage(/Listening on/),
+                ]),
+              )
+              .start(),
+          3,
+          5000,
+        );
+        this.containers.set(config.name, container);
+        const endpoint = `http://${container.getHost()}:${container.getMappedPort(8545)}`;
+        const provider = new providers.JsonRpcProvider(endpoint);
+        providersByChain.set(config.name, provider);
+
+        await provider.send('anvil_setBalance', [
+          deployerAddress,
+          ANVIL_DEPLOYER_BALANCE_HEX,
+        ]);
+
+        const deployer = deployerWallet.connect(provider);
+
+        const mailbox = await new Mailbox__factory(deployer).deploy(
+          config.domainId,
+        );
+        await mailbox.deployed();
+
+        const ism = await new TrustedRelayerIsm__factory(deployer).deploy(
+          mailbox.address,
+          deployerAddress,
+        );
+        await ism.deployed();
+
+        const merkleHook = await new MerkleTreeHook__factory(deployer).deploy(
+          mailbox.address,
+        );
+        await merkleHook.deployed();
+
+        await mailbox.initialize(
+          deployerAddress,
+          ism.address,
+          merkleHook.address,
+          merkleHook.address,
+        );
+
+        chainInfra[config.name] = {
+          mailbox: mailbox.address,
+          ism: ism.address,
+          merkleHook: merkleHook.address,
+          endpoint,
+        };
+      }
+
+      const deployedAddresses = await this.deployRoutes(
+        deployerWallet,
+        providersByChain,
+        chainInfra,
+      );
+
+      const chainMetadata: Record<string, Partial<ChainMetadata>> = {};
+      const chainAddresses: Record<string, Record<string, string>> = {};
+
+      for (const config of TEST_CHAIN_CONFIGS) {
+        chainMetadata[config.name] = {
+          name: config.name,
+          chainId: config.chainId,
+          domainId: config.domainId,
+          protocol: ProtocolType.Ethereum,
+          rpcUrls: [{ http: chainInfra[config.name].endpoint }],
+          blocks: { confirmations: 0, reorgPeriod: 0 },
+          nativeToken: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+          isTestnet: true,
+        };
+
+        chainAddresses[config.name] = {
+          mailbox: chainInfra[config.name].mailbox,
+          interchainSecurityModule: chainInfra[config.name].ism,
+        };
+      }
+
+      const registry = new PartialRegistry({
+        chainMetadata,
+        chainAddresses,
+      });
+      const multiProvider = new MultiProvider(
+        chainMetadata as Record<ChainName, ChainMetadata>,
+      );
+
+      const signerWallet = new ethers.Wallet(ANVIL_TEST_PRIVATE_KEY);
+      for (const config of TEST_CHAIN_CONFIGS) {
+        const provider = providersByChain.get(config.name)!;
+        multiProvider.setProvider(config.name, provider);
+        multiProvider.setSigner(config.name, signerWallet.connect(provider));
+      }
+
+      this.context = {
+        providers: providersByChain,
+        registry,
+        multiProvider,
+        deployedAddresses,
+      };
+
+      return this.context;
+    } catch (error) {
+      await this.stopContainers();
+      this.containers.clear();
+      throw error;
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.context && this.containers.size === 0) {
+      return;
+    }
+
+    await this.stopContainers();
+    this.containers.clear();
+    this.context = undefined;
+  }
+
+  getContext(): LocalDeploymentContext<TDeployedAddresses> {
+    if (!this.context) {
+      throw new Error('LocalDeploymentManager not started');
+    }
+    return this.context;
+  }
+
+  getProvider(chain: string): providers.JsonRpcProvider | undefined {
+    return this.getContext().providers.get(chain);
+  }
+
+  getMultiProvider(): MultiProvider {
+    return this.getContext().multiProvider;
+  }
+
+  getRegistry(): IRegistry {
+    return this.getContext().registry;
+  }
+
+  protected abstract deployRoutes(
+    deployerWallet: ethers.Wallet,
+    providersByChain: Map<string, providers.JsonRpcProvider>,
+    chainInfra: Record<
+      string,
+      { mailbox: string; ism: string; merkleHook: string }
+    >,
+  ): Promise<TDeployedAddresses>;
+
+  private async stopContainers(): Promise<void> {
+    const stopPromises = Array.from(this.containers.entries()).map(
+      ([chain, container]) =>
+        container.stop().catch((err: unknown) => {
+          const message = err instanceof Error ? err.message : String(err);
+          this.logger.debug(
+            { chain, error: message },
+            'Container stop failed (may already be dead)',
+          );
+        }),
+    );
+    await Promise.all(stopPromises);
+  }
+}

package/src/e2e/harness/BridgeSetup.ts

@@ -0,0 +1,95 @@
+import { BigNumber, ethers, providers } from 'ethers';
+
+import {
+  ERC20__factory,
+  MovableCollateralRouter__factory,
+} from '@humanode-hyperlane/core';
+
+export async function setupCollateralBalances(
+  providers: Map<string, providers.JsonRpcProvider>,
+  balancesByChain: Record<string, BigNumber>,
+  routersByChain: Record<string, string>,
+  tokensByChain: Record<string, string>,
+  deployerKey: string,
+): Promise<void> {
+  for (const [chain, targetBalance] of Object.entries(balancesByChain)) {
+    const provider = providers.get(chain);
+    if (!provider) throw new Error(`No provider for chain ${chain}`);
+
+    const deployer = new ethers.Wallet(deployerKey, provider);
+    const token = ERC20__factory.connect(tokensByChain[chain], deployer);
+
+    // First check current balance of the router
+    const currentBalance = await token.balanceOf(routersByChain[chain]);
+
+    // Transfer the target amount to the router (deployer has plenty from initial supply)
+    // We need to set the exact balance, so transfer (targetBalance - currentBalance) if needed
+    if (targetBalance.gt(currentBalance)) {
+      const diff = targetBalance.sub(currentBalance);
+      const tx = await token.transfer(routersByChain[chain], diff);
+      await tx.wait();
+    }
+
+    // Verify
+    const verifyBalance = await token.balanceOf(routersByChain[chain]);
+    if (!verifyBalance.eq(targetBalance)) {
+      throw new Error(
+        `Balance verification failed for ${chain}: expected ${targetBalance.toString()}, got ${verifyBalance.toString()}`,
+      );
+    }
+  }
+}
+
+export async function getCollateralBalance(
+  provider: providers.JsonRpcProvider,
+  routerAddress: string,
+  tokenAddress: string,
+): Promise<BigNumber> {
+  const token = ERC20__factory.connect(tokenAddress, provider);
+  return token.balanceOf(routerAddress);
+}
+
+export async function getAllCollateralBalances(
+  providers: Map<string, providers.JsonRpcProvider>,
+  chains: readonly string[],
+  routersByChain: Record<string, string>,
+  tokensByChain: Record<string, string>,
+): Promise<Record<string, BigNumber>> {
+  const balances: Record<string, BigNumber> = {};
+  for (const chain of chains) {
+    const provider = providers.get(chain);
+    if (!provider) {
+      throw new Error(`No provider for chain ${chain}`);
+    }
+    balances[chain] = await getCollateralBalance(
+      provider,
+      routersByChain[chain],
+      tokensByChain[chain],
+    );
+  }
+  return balances;
+}
+
+export interface AllowedBridgeConfig {
+  monitoredRouterAddress: string;
+  bridgeAddress: string;
+  destinationDomain: number;
+}
+
+export async function configureAllowedBridges(
+  provider: providers.JsonRpcProvider,
+  configs: AllowedBridgeConfig[],
+  deployerKey: string,
+): Promise<void> {
+  if (configs.length === 0) return;
+
+  const deployer = new ethers.Wallet(deployerKey, provider);
+  const router = MovableCollateralRouter__factory.connect(
+    configs[0].monitoredRouterAddress,
+    deployer,
+  );
+
+  for (const config of configs) {
+    await router.addBridge(config.destinationDomain, config.bridgeAddress);
+  }
+}

package/src/e2e/harness/Erc20InventoryLocalDeploymentManager.ts

@@ -0,0 +1,183 @@
+import { ethers, providers } from 'ethers';
+
+import {
+  ERC20Test__factory,
+  HypERC20Collateral__factory,
+} from '@humanode-hyperlane/core';
+
+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'; // 20 ETH for gas/IGP
+const INVENTORY_INITIAL_ERC20_BALANCE = '20000000000'; // 20,000 USDC for signer
+const INVENTORY_ERC20_BRIDGE_SEED = '10000000000'; // 10,000 USDC bridge seed
+
+export class Erc20InventoryLocalDeploymentManager 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);
+      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,
+      },
+    };
+  }
+}

package/src/e2e/harness/Erc20LocalDeploymentManager.ts

@@ -0,0 +1,190 @@
+import { ethers, providers } from 'ethers';
+
+import {
+  ERC20Test__factory,
+  HypERC20Collateral__factory,
+} from '@humanode-hyperlane/core';
+
+import {
+  type ChainDeployment,
+  type DeployedAddresses,
+  TEST_CHAIN_CONFIGS,
+  type TestChain,
+} from '../fixtures/routes.js';
+
+import { BaseLocalDeploymentManager } from './BaseLocalDeploymentManager.js';
+
+const USDC_INITIAL_SUPPLY = '100000000000000';
+const USDC_DECIMALS = 6;
+const TOKEN_SCALE_NUMERATOR = ethers.BigNumber.from(1);
+const TOKEN_SCALE_DENOMINATOR = ethers.BigNumber.from(1);
+
+export class Erc20LocalDeploymentManager extends BaseLocalDeploymentManager<DeployedAddresses> {
+  protected async deployRoutes(
+    deployerWallet: ethers.Wallet,
+    providersByChain: Map<string, providers.JsonRpcProvider>,
+    chainInfra: Record<
+      string,
+      { mailbox: string; ism: string; merkleHook: string }
+    >,
+  ): Promise<DeployedAddresses> {
+    const deployerAddress = deployerWallet.address;
+    const chainDeployments = {} as Record<TestChain, ChainDeployment>;
+    const monitoredRouters = {} as Record<TestChain, ethers.Contract>;
+    const bridgeRouters1 = {} as Record<TestChain, ethers.Contract>;
+    const bridgeRouters2 = {} as Record<TestChain, ethers.Contract>;
+    const tokens = {} as Record<TestChain, ethers.Contract>;
+
+    for (let i = 0; i < TEST_CHAIN_CONFIGS.length; i++) {
+      const config = TEST_CHAIN_CONFIGS[i];
+      const provider = providersByChain.get(config.name)!;
+      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_NUMERATOR,
+        TOKEN_SCALE_DENOMINATOR,
+        chainInfra[config.name].mailbox,
+      );
+      await monitoredRoute.deployed();
+      await monitoredRoute.initialize(
+        ethers.constants.AddressZero,
+        chainInfra[config.name].ism,
+        deployerAddress,
+      );
+
+      const bridgeRoute1 = await new HypERC20Collateral__factory(
+        deployer,
+      ).deploy(
+        token.address,
+        TOKEN_SCALE_NUMERATOR,
+        TOKEN_SCALE_DENOMINATOR,
+        chainInfra[config.name].mailbox,
+      );
+      await bridgeRoute1.deployed();
+      await bridgeRoute1.initialize(
+        ethers.constants.AddressZero,
+        chainInfra[config.name].ism,
+        deployerAddress,
+      );
+
+      const bridgeRoute2 = await new HypERC20Collateral__factory(
+        deployer,
+      ).deploy(
+        token.address,
+        TOKEN_SCALE_NUMERATOR,
+        TOKEN_SCALE_DENOMINATOR,
+        chainInfra[config.name].mailbox,
+      );
+      await bridgeRoute2.deployed();
+      await bridgeRoute2.initialize(
+        ethers.constants.AddressZero,
+        chainInfra[config.name].ism,
+        deployerAddress,
+      );
+
+      chainDeployments[config.name] = {
+        mailbox: chainInfra[config.name].mailbox,
+        ism: chainInfra[config.name].ism,
+        token: token.address,
+        monitoredRouter: monitoredRoute.address,
+        bridgeRouter1: bridgeRoute1.address,
+        bridgeRouter2: bridgeRoute2.address,
+      };
+
+      tokens[config.name] = token;
+      monitoredRouters[config.name] = monitoredRoute;
+      bridgeRouters1[config.name] = bridgeRoute1;
+      bridgeRouters2[config.name] = bridgeRoute2;
+    }
+
+    const routeGroups = [monitoredRouters, bridgeRouters1, bridgeRouters2];
+    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);
+        await localRoute.addRebalancer(deployerAddress);
+      }
+    }
+
+    for (const chain of TEST_CHAIN_CONFIGS) {
+      const monitoredRoute = monitoredRouters[chain.name];
+      for (const destination of TEST_CHAIN_CONFIGS) {
+        if (destination.name === chain.name) continue;
+        await monitoredRoute.addBridge(
+          destination.domainId,
+          bridgeRouters1[chain.name].address,
+        );
+        await monitoredRoute.addBridge(
+          destination.domainId,
+          bridgeRouters2[chain.name].address,
+        );
+      }
+    }
+
+    const bridgeSeedAmount = ethers.BigNumber.from(USDC_INITIAL_SUPPLY).div(10);
+    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(
+        bridgeRouters1[chain.name].address,
+        bridgeSeedAmount,
+      );
+      await tx1.wait();
+      const tx2 = await token.transfer(
+        bridgeRouters2[chain.name].address,
+        bridgeSeedAmount,
+      );
+      await tx2.wait();
+    }
+
+    return {
+      chains: chainDeployments,
+      monitoredRoute: {
+        anvil1: monitoredRouters.anvil1.address,
+        anvil2: monitoredRouters.anvil2.address,
+        anvil3: monitoredRouters.anvil3.address,
+      },
+      bridgeRoute1: {
+        anvil1: bridgeRouters1.anvil1.address,
+        anvil2: bridgeRouters1.anvil2.address,
+        anvil3: bridgeRouters1.anvil3.address,
+      },
+      bridgeRoute2: {
+        anvil1: bridgeRouters2.anvil1.address,
+        anvil2: bridgeRouters2.anvil2.address,
+        anvil3: bridgeRouters2.anvil3.address,
+      },
+      tokens: {
+        anvil1: tokens.anvil1.address,
+        anvil2: tokens.anvil2.address,
+        anvil3: tokens.anvil3.address,
+      },
+    };
+  }
+}