Initial commit with 🏗️ create-eth @ 2.0.4

packages/hardhat/deploy/00_deploy_whitelist.ts

@@ -0,0 +1,121 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+import { decodeEventLog } from "viem";
+import { fetchPriceFromUniswap } from "../scripts/fetchPriceFromUniswap";
+
+/**
+ * Deploys a WhitelistOracle contract and creates SimpleOracle instances through it
+ *
+ * @param hre HardhatRuntimeEnvironment object.
+ */
+const deployWhitelistOracleContracts: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployer } = await hre.getNamedAccounts();
+  const { deploy } = hre.deployments;
+  const { viem } = hre;
+
+  const publicClient = await viem.getPublicClient();
+
+  console.log("Deploying WhitelistOracle contract...");
+  const whitelistOracleDeployment = await deploy("WhitelistOracle", {
+    from: deployer,
+    args: [],
+    log: true,
+    autoMine: false,
+  });
+  const whitelistOracleAddress = whitelistOracleDeployment.address as `0x${string}`;
+  const whitelistOracleAbi = whitelistOracleDeployment.abi;
+
+  // Skip the rest of the setup if we are on a live network
+  if (hre.network.name === "localhost") {
+    // Get 10 wallet clients (accounts) to be oracle owners
+    const accounts = await viem.getWalletClients();
+    const nodeAccounts = accounts.slice(0, 10);
+
+    console.log("Creating SimpleOracle instances through WhitelistOracle...");
+    const deployerAccount = accounts.find(a => a.account.address.toLowerCase() === deployer.toLowerCase());
+    if (!deployerAccount) throw new Error("Deployer account not found in wallet clients");
+
+    // Create SimpleOracle instances through WhitelistOracle.addOracle() sequentially
+    // (parallel nonce assignment doesn't work reliably with automining)
+    const addOracleReceipts = [];
+    for (let i = 0; i < nodeAccounts.length; i++) {
+      const ownerAddress = nodeAccounts[i].account.address;
+      console.log(`Creating SimpleOracle ${i + 1}/10 with owner: ${ownerAddress}`);
+      const txHash = await deployerAccount.writeContract({
+        address: whitelistOracleAddress,
+        abi: whitelistOracleAbi,
+        functionName: "addOracle",
+        args: [ownerAddress],
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+      addOracleReceipts.push(receipt);
+    }
+
+    // Map owner => created oracle address from events
+    const ownerToOracleAddress = new Map<string, string>();
+    for (const receipt of addOracleReceipts) {
+      const oracleAddedEvent = receipt.logs.find(log => {
+        try {
+          const decoded = decodeEventLog({
+            abi: whitelistOracleAbi,
+            data: log.data,
+            topics: log.topics,
+          }) as { eventName: string; args: { oracleAddress: string; oracleOwner: string } };
+          return decoded.eventName === "OracleAdded";
+        } catch {
+          return false;
+        }
+      });
+      if (!oracleAddedEvent) continue;
+      const decoded = decodeEventLog({
+        abi: whitelistOracleAbi,
+        data: oracleAddedEvent.data,
+        topics: oracleAddedEvent.topics,
+      }) as { eventName: string; args: { oracleAddress: string; oracleOwner: string } };
+      ownerToOracleAddress.set(decoded.args.oracleOwner.toLowerCase(), decoded.args.oracleAddress);
+      console.log(`✅ Created SimpleOracle at: ${decoded.args.oracleAddress}`);
+    }
+
+    const createdOracleAddresses: string[] = nodeAccounts.map(acc => {
+      const addr = ownerToOracleAddress.get(acc.account.address.toLowerCase());
+      if (!addr) throw new Error(`Missing oracle address for owner ${acc.account.address}`);
+      return addr;
+    });
+
+    // Set initial prices for each created SimpleOracle
+    console.log("Setting initial prices for each SimpleOracle...");
+    const initialPrice = await fetchPriceFromUniswap();
+    // Get SimpleOracle ABI from deployments
+    const simpleOracleDeployment = await hre.deployments.getArtifact("SimpleOracle");
+    const simpleOracleAbi = simpleOracleDeployment.abi;
+    // Fire all setPrice transactions concurrently from each node owner
+    const setPriceTxPromises = nodeAccounts.map((account, i) => {
+      const oracleAddress = createdOracleAddresses[i];
+      return account.writeContract({
+        address: oracleAddress as `0x${string}`,
+        abi: simpleOracleAbi,
+        functionName: "setPrice",
+        args: [initialPrice],
+      });
+    });
+    const setPriceTxHashes = await Promise.all(setPriceTxPromises);
+    await Promise.all(setPriceTxHashes.map(hash => publicClient.waitForTransactionReceipt({ hash })));
+    for (let i = 0; i < createdOracleAddresses.length; i++) {
+      console.log(`Set price for SimpleOracle ${i + 1} to: ${initialPrice}`);
+    }
+
+    // Calculate initial median price
+    console.log("Calculating initial median price...");
+    const medianPrice = await publicClient.readContract({
+      address: whitelistOracleAddress,
+      abi: whitelistOracleAbi,
+      functionName: "getPrice",
+      args: [],
+    });
+    console.log(`Initial median price: ${medianPrice?.toString()}`);
+  }
+  console.log("WhitelistOracle contract deployed and configured successfully!");
+};
+
+export default deployWhitelistOracleContracts;
+deployWhitelistOracleContracts.tags = ["Oracles"];