chore: change governor script

Author: jaybuidl

contracts/hardhat.config.ts

@@ -16,6 +16,7 @@ import "hardhat-tracer";
 require("./scripts/simulations/tasks");
 require("./scripts/populatePolicyRegistry");
 require("./scripts/populateCourts");
+require("./scripts/changeGovernor");
 
 dotenv.config();
 

contracts/scripts/changeGovernor.ts

@@ -0,0 +1,67 @@
+import { task } from "hardhat/config";
+import { prompt, print } from "gluegun";
+import { Cores, getContracts } from "./utils/contracts";
+
+const { bold } = print.colors;
+
+task("change-governor", "Changes the governor for all the contracts")
+  .addPositionalParam("newGovernor", "The address of the new governor")
+  .addOptionalParam(
+    "coreType",
+    "The type of core to use between base, neo, university (default: base)",
+    Cores.BASE.toString()
+  )
+  .setAction(async (taskArgs, hre) => {
+    const newGovernor = taskArgs.newGovernor;
+    print.highlight(`💣 Changing governor to ${bold(newGovernor)}`);
+
+    const { confirm } = await prompt.ask({
+      type: "confirm",
+      name: "confirm",
+      message: "Are you sure you want to proceed?",
+    });
+    if (!confirm) {
+      console.log("Operation cancelled by user.");
+      return;
+    }
+
+    let coreType = Cores.BASE;
+    coreType = Cores[taskArgs.coreType.toUpperCase() as keyof typeof Cores];
+    if (coreType === undefined) {
+      console.error("Invalid core type, must be one of base, neo, university");
+      return;
+    }
+    console.log("Using core type %s", Cores[coreType]);
+
+    const { core, disputeKitClassic, disputeResolver, disputeTemplateRegistry, chainlinkRng, randomizerRng } =
+      await getContracts(hre, coreType);
+
+    const updateGovernor = async (contractName: string, contractInstance: any) => {
+      print.info(`Changing governor for ${contractName}`);
+
+      const spinner = print.spin(`Executing transaction for ${contractName}...`);
+      try {
+        const tx = await contractInstance.changeGovernor(newGovernor);
+        await tx.wait();
+        spinner.succeed(`Governor changed for ${contractName}, tx hash: ${tx.hash}`);
+      } catch (error) {
+        if (error instanceof Error) {
+          spinner.fail(`Failed to change governor for ${contractName}: ${error.message}`);
+        } else {
+          spinner.fail(`Failed to change governor for ${contractName}: ${String(error)}`);
+        }
+      }
+    };
+
+    // TODO: upgrade and add changeGovernor!
+    // await updateGovernor("Sortition", sortition)
+
+    await updateGovernor("KlerosCore", core);
+    await updateGovernor("DisputeKitClassic", disputeKitClassic);
+    await updateGovernor("DisputeResolver", disputeResolver);
+    await updateGovernor("DisputeTemplateRegistry", disputeTemplateRegistry);
+    if (chainlinkRng) await updateGovernor("ChainlinkRNG", chainlinkRng);
+    if (randomizerRng) await updateGovernor("RandomizerRNG", randomizerRng);
+
+    print.success("Governor changed successfully");
+  });

contracts/scripts/utils/contracts.ts

@@ -0,0 +1,65 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import {
+  BlockHashRNG,
+  ChainlinkRNG,
+  DisputeKitClassic,
+  DisputeResolver,
+  DisputeTemplateRegistry,
+  KlerosCore,
+  KlerosCoreNeo,
+  PNK,
+  RandomizerRNG,
+  SortitionModule,
+  SortitionModuleNeo,
+  TransactionBatcher,
+} from "../../typechain-types";
+
+export enum Cores {
+  BASE,
+  NEO,
+  UNIVERSITY,
+}
+
+export const getContracts = async (hre: HardhatRuntimeEnvironment, coreType: Cores) => {
+  const { ethers } = hre;
+  let core: KlerosCore | KlerosCoreNeo;
+  let sortition: SortitionModule | SortitionModuleNeo;
+  let disputeKitClassic: DisputeKitClassic;
+  let disputeResolver: DisputeResolver;
+  switch (coreType) {
+    case Cores.NEO:
+      core = (await ethers.getContract("KlerosCoreNeo")) as KlerosCoreNeo;
+      sortition = (await ethers.getContract("SortitionModuleNeo")) as SortitionModuleNeo;
+      disputeKitClassic = (await ethers.getContract("DisputeKitClassicNeo")) as DisputeKitClassic;
+      disputeResolver = (await ethers.getContract("DisputeResolverNeo")) as DisputeResolver;
+      break;
+    case Cores.BASE:
+      core = (await ethers.getContract("KlerosCore")) as KlerosCore;
+      sortition = (await ethers.getContract("SortitionModule")) as SortitionModule;
+      disputeKitClassic = (await ethers.getContract("DisputeKitClassic")) as DisputeKitClassic;
+      disputeResolver = (await ethers.getContract("DisputeResolver")) as DisputeResolver;
+      break;
+    case Cores.UNIVERSITY:
+      throw new Error("University core is not supported");
+    default:
+      throw new Error("Invalid core type, must be one of base, neo");
+  }
+  const disputeTemplateRegistry = (await ethers.getContract("DisputeTemplateRegistry")) as DisputeTemplateRegistry;
+  const batcher = (await ethers.getContract("TransactionBatcher")) as TransactionBatcher;
+  const chainlinkRng = await ethers.getContractOrNull<ChainlinkRNG>("ChainlinkRNG");
+  const randomizerRng = await ethers.getContractOrNull<RandomizerRNG>("RandomizerRNG");
+  const blockHashRNG = await ethers.getContractOrNull<BlockHashRNG>("BlockHashRNG");
+  const pnk = (await ethers.getContract("PNK")) as PNK;
+  return {
+    core,
+    sortition,
+    disputeKitClassic,
+    disputeResolver,
+    disputeTemplateRegistry,
+    chainlinkRng,
+    randomizerRng,
+    blockHashRNG,
+    pnk,
+    batcher,
+  };
+};