kleros/kleros-v2

import { expect } from "chai";
import { deployments, ethers } from "hardhat";
import { BigNumber } from "ethers";
import { DisputeResolver, KlerosCoreRuler } from "../../typechain-types";
import { anyValue } from "@nomicfoundation/hardhat-chai-matchers/withArgs";

describe("KlerosCoreRuler", async () => {
  // eslint-disable-next-line no-unused-vars
  let deployer;
  let core: KlerosCoreRuler;
  let resolver: DisputeResolver;

  enum RulingMode {
    uninitialized,
    manual, // executeRuling() is called manually.
    automaticRandom, // The ruling is given randomly automatically.
    automaticPreset, // The ruling is given automatically with a preset value.
  }

  const extraData =
    "0x" +
    "0000000000000000000000000000000000000000000000000000000000000001" + // courtId 1
    "0000000000000000000000000000000000000000000000000000000000000003"; // minJurors 3

  before("Deploying", async () => {
    [deployer] = await ethers.getSigners();
    [core, resolver] = await deployContracts(deployer);
  });

  it("Should have initialized the Arbitrator", async () => {
    // Reminder: the Forking court will be added which will break these expectations.
    let events = await core.queryFilter(core.filters.CourtCreated());
    expect(events.length).to.equal(1);
    expect(events[0].args._courtID).to.equal(1);
    expect(events[0].args._parent).to.equal(0);
    expect(events[0].args._alpha).to.equal(10000);
    expect(events[0].args._feeForJuror).to.equal(BigNumber.from(10).pow(17));
    expect(events[0].args._jurorsForCourtJump).to.equal(16);
  });

  it("Should fail to create a dispute without setting the RulingMode first", async () => {
    await expect(
      resolver.createDisputeForTemplate(extraData, "", "", 3, { value: ethers.utils.parseEther("0.3") })
    ).to.be.revertedWithCustomError(core, "RulingModeNotSet");
  });

  it("Should create a dispute and automatically execute a random ruling", async () => {
    await expect(core.changeRulingModeToAutomaticRandom(resolver.address))
      .to.emit(core, "RulerSettingsChanged")
      .withArgs(resolver.address, [RulingMode.automaticRandom, 0, false, false]);

    const disputeID = 0;

    await expect(resolver.createDisputeForTemplate(extraData, "", "", 3, { value: ethers.utils.parseEther("0.3") }))
      .to.emit(core, "DisputeCreation")
      .withArgs(disputeID, resolver.address)
      .and.to.emit(core, "AutoRuled")
      .withArgs(resolver.address, RulingMode.automaticRandom, disputeID, anyValue, anyValue, anyValue)
      .and.to.emit(core, "Ruling")
      .withArgs(resolver.address, disputeID, anyValue)
      .and.to.emit(core, "TokenAndETHShift")
      .withArgs(deployer.address, disputeID, 0, 1, 0, anyValue, ethers.constants.AddressZero)
      .and.to.emit(resolver, "DisputeRequest")
      .withArgs(core.address, disputeID, disputeID, disputeID, "")
      .and.to.emit(resolver, "Ruling")
      .withArgs(core.address, disputeID, anyValue);
  });

  it("Should create a dispute and automatically execute a preset ruling", async () => {
    await expect(core.changeRulingModeToAutomaticPreset(resolver.address, 2, true, false))
      .to.emit(core, "RulerSettingsChanged")
      .withArgs(resolver.address, [RulingMode.automaticPreset, 2, true, false]);

    const disputeID = 1;

    await expect(resolver.createDisputeForTemplate(extraData, "", "", 3, { value: ethers.utils.parseEther("0.3") }))
      .to.emit(core, "DisputeCreation")
      .withArgs(disputeID, resolver.address)
      .and.to.emit(core, "AutoRuled")
      .withArgs(resolver.address, RulingMode.automaticPreset, disputeID, 2, true, false)
      .and.to.emit(core, "Ruling")
      .withArgs(resolver.address, disputeID, 2)
      .and.to.emit(core, "TokenAndETHShift")
      .withArgs(deployer.address, disputeID, 0, 1, 0, anyValue, ethers.constants.AddressZero)
      .and.to.emit(resolver, "DisputeRequest")
      .withArgs(core.address, disputeID, disputeID, disputeID, "")
      .and.to.emit(resolver, "Ruling")
      .withArgs(core.address, disputeID, 2);
  });

  it("Should create a dispute and manually execute a ruling", async () => {
    await expect(core.changeRulingModeToManual(resolver.address))
      .to.emit(core, "RulerSettingsChanged")
      .withArgs(resolver.address, [RulingMode.manual, 0, false, false]);

    const disputeID = 2;

    await expect(resolver.createDisputeForTemplate(extraData, "", "", 3, { value: ethers.utils.parseEther("0.3") }))
      .to.emit(core, "DisputeCreation")
      .withArgs(disputeID, resolver.address)
      .and.to.emit(resolver, "DisputeRequest")
      .withArgs(core.address, disputeID, disputeID, disputeID, "");

    await expect(core.executeRuling(disputeID, 3, true, true))
      .and.to.emit(core, "Ruling")
      .withArgs(resolver.address, disputeID, 3)
      .and.to.emit(resolver, "Ruling")
      .withArgs(core.address, disputeID, 3);

    await expect(core.execute(disputeID, 0))
      .and.to.emit(core, "TokenAndETHShift")
      .withArgs(deployer.address, disputeID, 0, 1, 0, anyValue, ethers.constants.AddressZero);
  });
});

async function deployContracts(deployer): Promise<[KlerosCoreRuler, DisputeResolver]> {
  await deployments.fixture(["ArbitrationRuler"], {
    fallbackToGlobal: true,
    keepExistingDeployments: false,
  });
  const resolver = (await ethers.getContract("DisputeResolverRuler")) as DisputeResolver;
  const core = (await ethers.getContract("KlerosCoreRuler")) as KlerosCoreRuler;
  return [core, resolver];
}