Tapioca DAO - DelerRH's results

it('Should add Singularity & exucute market function correctly', async () => {
    const { bar } = await loadFixture(register);

    // Register new MC
    const mediumRiskSingularityMC = await (
        await ethers.getContractFactory('Singularity')
    ).deploy();
    await mediumRiskSingularityMC.deployed();
    const mcLengthBefore = await bar.singularityMasterContractLength();
    await (
        await bar.registerSingularityMasterContract(mediumRiskSingularityMC.address, 1)
    ).wait();
    const mcLength = await bar.singularityMasterContractLength();
    expect(mcLength.eq(mcLengthBefore.add(1))).to.be.true;

    // Register new singularity market
    // Random address (It's not important to deploy real sg market for this test)
    const sgMarket = "0x6716E4A2268d4feca147Ea3e26fe2665730BA81F";

    expect(await bar.addSingularity(mediumRiskSingularityMC.address, sgMarket)).to.not.be.reverted;
    expect(await bar.isMarketRegistered(sgMarket)).to.be.true;

    // expect(await bar.masterContractOf(sgMarket)).equals(mediumRiskSingularityMC.address);

    await expect(bar.executeMarketFn(
        [sgMarket],
        [ethers.utils.toUtf8Bytes('')],
        true,
    )).to.not.be.rejectedWith("Penrose: MC not registered");
});

function addSingularity(
        address mc,
        address _contract
    ) external onlyOwner registeredSingularityMasterContract(mc) {
        isMarketRegistered[_contract] = true;
        clonesOf[mc].push(_contract);
+       masterContractOf[_contract] = mc;
        emit RegisterSingularity(_contract, mc);
    }

it('Can add BigBang & exucute market function', async () => {
    const { bar } = await loadFixture(register);

    // Register new MC
    const mediumBigBangMC = await (
        await ethers.getContractFactory('BigBang')
    ).deploy();
    await mediumBigBangMC.deployed();
    const mcLengthBefore = await bar.bigBangMasterContractLength();
    await (
        await bar.registerBigBangMasterContract(mediumBigBangMC.address, 1)
    ).wait();
    const mcLength = await bar.bigBangMasterContractLength();
    expect(mcLength.eq(mcLengthBefore.add(1))).to.be.true;

    // Register new Bigbang market
    // Random address (It's not important to deploy real Bigbang market for this test)
    const BigBangMarket = "0x6716E4A2268d4feca147Ea3e26fe2665730BA81F";

    expect(await bar.addBigBang(mediumBigBangMC.address, BigBangMarket)).to.not.be.reverted;
    expect(await bar.isMarketRegistered(BigBangMarket)).to.be.true;

    // expect(await bar.masterContractOf(BigBangMarket)).equals(mediumBigBangMC.address);

    await expect(bar.executeMarketFn(
        [BigBangMarket],
        [ethers.utils.toUtf8Bytes('')],
        true,
    )).to.not.be.rejectedWith("Penrose: MC not registered");
});

    function addBigBang(
        address mc,
        address _contract
    ) external onlyOwner registeredBigBangMasterContract(mc) {
        isMarketRegistered[_contract] = true;
        clonesOf[mc].push(_contract);
+       masterContractOf[_contract] = mc;
        emit RegisterBigBang(_contract, mc);
    }