Web3 Lending Protocol

async prepareWallets(wallet: address) {
    await this.page.addInitScript(
      (accounts) => {
        (window as any).test_accounts = accounts;
      },
      {
        wallets: [wallet],
      }
    );
  }

//docker-compose.yml
services:
  anvil:
    container_name: ${ANVIL_CONTAINER_NAME}
    build:
      context: .
    ports:
      - "8545:8545"
    environment:
      FORK_URL: ${FORK_URL}
    platform: linux/amd64

//Dockerfile
FROM ghcr.io/foundry-rs/foundry
WORKDIR /anvil
EXPOSE 8545
ENTRYPOINT anvil --fork-url $FORK_URL --host 0.0.0.0

//client.ts
import { createTestClient, http, publicActions, walletActions } from "viem";
import { foundry } from "viem/chains";

// Viem test client for local test node: https://viem.sh/docs/clients/test.html
export const networkClient: any = createTestClient({
  chain: foundry,
  mode: "anvil",
  transport: http(),
})
  .extend(publicActions)
  .extend(walletActions);

//anvil.ts
import {
  createTestClient,
  createWalletClient,
  http,
  publicActions,
  walletActions,
} from "viem";
import {
  baseSepolia,
  arbitrumSepolia,
  optimismSepolia,
  berachainBepolia,
  sonicBlazeTestnet,
  foundry,
} from "viem/chains";
import { monadTestnet, hyperliquidTestnet } from "./customChains";
import { execSync } from "child_process";
import { address, NetworkChain } from "./constants";
import { setTimeout } from "timers/promises";

type chainConfig = {
  url: string;
  network: any;
};

export class Anvil {
  private readonly config: chainConfig;
  private readonly containerName: string;
  readonly networkChain: NetworkChain;

  constructor(chain: NetworkChain) {
    this.networkChain = chain;
    this.config = this.getChainConfig(chain);
    process.env.FORK_URL = this.config.url;
    this.containerName =
      process.env.ANVIL_CONTAINER_NAME ?? "anvil-1";
  }

  private getChainConfig(chain: NetworkChain): chainConfig {
    let url;
    let network;

    switch (chain) {
      case NetworkChain.Arbitrum:
        url = process.env.ARBITRUM_SEPOLIA_RPC_URL ?? "";
        network = arbitrumSepolia;
        break;

      case NetworkChain.Base:
        url = process.env.BASE_SEPOLIA_RPC_URL ?? "";
        network = baseSepolia;
        break;

      case NetworkChain.Optimism:
        url = process.env.OPTIMISM_SEPOLIA_RPC_URL ?? "";
        network = optimismSepolia;
        break;

      case NetworkChain.Berachain:
        url = process.env.BERA_BEPOLIA_RPC_URL ?? "";
        network = berachainBepolia;
        break;

      case NetworkChain.Monad:
        url = process.env.MONAD_TESTNET_RPC_URL ?? "";
        network = monadTestnet;
        break;

      case NetworkChain.SonicBlaze:
        url = process.env.SONIC_BLAZE_TESTNET_RPC_URL ?? "";
        network = sonicBlazeTestnet;
        break;

      default:
        throw Error(`URL Environment variable not set for chain ${chain}`);
    }
    return { url, network };
  }
    

  private getChainId() {
    let chainId = "0";
    try {
      chainId = execSync(
        `docker exec ${this.containerName} cast chain-id --rpc-url http://0.0.0.0:8545`,
        {
          encoding: "utf-8",
        }
      );
    } catch (error: any) {
      // throw error only if its not about container not running
      if (!error.message.toLowerCase().includes("error sending request")) {
        throw new Error(
          `Unknow error when attempting to retrieve chain id of the running local network\nerror: ${error.message}`
        );
      }
    }
    chainId = chainId.includes("\n") ? chainId.split("\n")[0] : chainId;
    return chainId as unknown as number;
  }

   private containerRunning() {
    let status = "";

    try {
      status = execSync(
        `docker inspect --format="{{.State.Running}}" ${this.containerName}`,
        {
          encoding: "utf-8",
        }
      );
    } catch (error: any) {
      // throw error only if its not about container not running
      if (!error.message.toLowerCase().includes("no such object")) {
        throw new Error(
          `Unknow error when inspecting container ${this.containerName}\nerror: ${error.message}`
        );
      }
    }
    return status.includes("true");
  } 

  private async waitForContainerStatus(status: boolean, offset = 10) {
    let timeout = Date.now() + offset * 1000;
    let running = false;

    while (Date.now() < timeout) {
      running = this.containerRunning();
      if (running == status) return;
      await setTimeout(250);
    }
    if (running != status)
      throw new Error(
        `docker container running? Expected: ${status} Actual: ${running}`
      );
  }

  anvilClient() {
    return createTestClient({
      chain: foundry,
      mode: "anvil",
      transport: http(foundry.rpcUrls.default.http[0]),
    })
      .extend(publicActions)
      .extend(walletActions);
  }

  walletClient() {
    return createWalletClient({
      chain: this.config.network,
      transport: http(foundry.rpcUrls.default.http[0]),
    });
  }

  testClient() {
    return createTestClient({
      chain: this.config.network,
      mode: "anvil",
      transport: http(foundry.rpcUrls.default.http[0]),
    })
      .extend(publicActions)
      .extend(walletActions);
  }


  async start() {
    if (this.containerRunning()) {
      const chainId = this.getChainId();
      // return early if the local network is running on the right chain
      if (this.networkChain == chainId) return;

      await this.stop();
    }

    try {
      execSync(`FORK_URL=${this.config.url} docker compose up -d`, {
        stdio: "inherit",
      });
      await this.waitForContainerStatus(true);
    } catch (error: any) {
      throw new Error(`Failed to switch network: ${error.message}`);
    }
  }

  async stop() {
    try {
      execSync(`docker compose down`, { stdio: "inherit" });
    } catch (error: any) {
      throw new Error(`Failed to close container: ${error.message}`);
    }
    await this.waitForContainerStatus(false);
  }

  async wallets() {
    if (!this.containerRunning()) throw new Error("Not running local network");
    let timeout = Date.now() + 10 * 1000;
    let caughtError;

    while (Date.now() < timeout) {
      try {
        const walletAddresses = await this.anvilClient().getAddresses();
        if (walletAddresses.length > 0) return walletAddresses as address[];
      } catch (error) {
        caughtError = error;
        await setTimeout(250);
      }
    }
    throw caughtError;
  }
}