const { time, loadFixture, } = require('@nomicfoundation/hardhat-toolbox/network-helpers'); const { expect } = require('chai'); const { ethers } = require('hardhat'); const deployDAO = require('./util/deploy-dao'); describe('Validation Pools', () => { async function deploy() { const [account1, account2] = await ethers.getSigners(); const { dao, forum } = await deployDAO(); return { dao, forum, account1, account2, }; } let dao; let forum; let account1; let account2; const POOL_DURATION = 3600; // 1 hour const POOL_FEE = 100; const emptyCallbackData = ethers.AbiCoder.defaultAbiCoder().encode([], []); const initiateValidationPool = ({ postId, duration, quorum, winRatio, bindingPercent, redistributeLosingStakes, callbackOnValidate, callbackData, fee, } = {}) => dao.initiateValidationPool( postId ?? 'content-id', duration ?? POOL_DURATION, quorum ?? [1, 3], winRatio ?? [1, 2], bindingPercent ?? 100, redistributeLosingStakes ?? true, callbackOnValidate ?? false, callbackData ?? emptyCallbackData, { value: fee ?? POOL_FEE }, ); beforeEach(async () => { ({ dao, forum, account1, account2, } = await loadFixture(deploy)); await forum.addPost([{ weightPPM: 1000000, authorAddress: account1 }], 'content-id', []); const init = () => initiateValidationPool({ fee: POOL_FEE }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(0); expect(await dao.getValidationPoolCount()).to.equal(1); expect(await dao.memberCount()).to.equal(0); expect(await dao.balanceOf(account1)).to.equal(0); expect(await dao.totalSupply()).to.equal(POOL_FEE); }); describe('Initiate', () => { it('should be able to initiate a validation pool without a fee', async () => { const init = () => initiateValidationPool({ fee: 0 }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated'); }); it('should not be able to initiate a validation pool with a quorum below the minimum', async () => { const init = () => initiateValidationPool({ quorum: [1, 11] }); await expect(init()).to.be.revertedWith('Quorum is below minimum'); }); it('should not be able to initiate a validation pool with a quorum greater than 1', async () => { const init = () => initiateValidationPool({ quorum: [11, 10] }); await expect(init()).to.be.revertedWith('Quorum is greater than one'); }); it('should not be able to initiate a validation pool with duration below minimum', async () => { const init = () => initiateValidationPool({ duration: 0 }); await expect(init()).to.be.revertedWith('Duration is too short'); }); it('should not be able to initiate a validation pool with duration above maximum', async () => { const init = () => initiateValidationPool({ duration: 40000000000000 }); await expect(init()).to.be.revertedWith('Duration is too long'); }); it('should not be able to initiate a validation pool with bindingPercent above 100', async () => { const init = () => initiateValidationPool({ bindingPercent: 101 }); await expect(init()).to.be.revertedWith('Binding percent must be <= 100'); }); it('should be able to initiate a second validation pool', async () => { const init = () => initiateValidationPool(); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); expect(await dao.getValidationPoolCount()).to.equal(2); }); it('Should be able to fetch pool instance', async () => { const pool = await dao.getValidationPool(0); expect(pool).to.exist; expect(pool.params.duration).to.equal(POOL_DURATION); expect(pool.props.postId).to.equal('content-id'); expect(pool.props.resolved).to.be.false; expect(pool.sender).to.equal(account1); }); }); describe('Stake', async () => { beforeEach(async () => { time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(0); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(0); await initiateValidationPool(); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); }); it('should be able to stake before validation pool has elapsed', async () => { await dao.stakeOnValidationPool(1, 10, true); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(1)).to.emit(dao, 'ValidationPoolResolved').withArgs(1, true, true); expect(await dao.balanceOf(account1)).to.equal(200); expect(await dao.balanceOf(dao.target)).to.equal(0); }); it('should not be able to stake after validation pool has elapsed', async () => { time.increase(POOL_DURATION + 1); await expect(dao.stakeOnValidationPool(1, 10, true)).to.be.revertedWith('Pool end time has passed'); }); it('should be able to stake against a validation pool', async () => { await dao.stakeOnValidationPool(1, 10, false); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(1)).to.emit(dao, 'ValidationPoolResolved').withArgs(1, false, true); expect(await dao.balanceOf(account1)).to.equal(200); expect(await dao.balanceOf(dao.target)).to.equal(0); const pool = await dao.getValidationPool(1); expect(pool.props.outcome).to.be.false; }); it('should not be able to stake more REP than the sender owns', async () => { await expect(dao.stakeOnValidationPool(1, 200, true)).to.be.revertedWith('Insufficient REP balance to cover stake'); }); }); describe('Delegated stake', () => { it('should stake the lesser of the allowed amount or the owner\'s remaining balance', async () => { // TODO: owner delegates stake and then loses rep }); }); describe('Evaluate outcome', () => { it('should not be able to evaluate outcome before duration has elapsed if not all rep has been staked', async () => { time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(0)); await initiateValidationPool({ fee: 100 }); await expect(dao.evaluateOutcome(1)).to.be.revertedWith('Pool end time has not yet arrived'); }); it('should not be able to evaluate outcome before duration has elapsed unless all rep has been staked', async () => { time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(0)); await initiateValidationPool({ fee: 100 }); await dao.stakeOnValidationPool(1, 100, true); await expect(dao.evaluateOutcome(1)).to.emit(dao, 'ValidationPoolResolved').withArgs(1, true, true); }); it('should be able to evaluate outcome after duration has elapsed', async () => { expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(0)).to.emit(dao, 'ValidationPoolResolved').withArgs(0, true, true); expect(await dao.memberCount()).to.equal(1); expect(await dao.balanceOf(account1)).to.equal(100); const pool = await dao.getValidationPool(0); expect(pool.props.resolved).to.be.true; expect(pool.props.outcome).to.be.true; }); it('should not be able to evaluate outcome more than once', async () => { time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(0)).to.emit(dao, 'ValidationPoolResolved').withArgs(0, true, true); await expect(dao.evaluateOutcome(0)).to.be.revertedWith('Pool is already resolved'); }); it('should be able to evaluate outcome of second validation pool', async () => { const init = () => initiateValidationPool(); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); expect(await dao.getValidationPoolCount()).to.equal(2); time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(0)).to.emit(dao, 'ValidationPoolResolved').withArgs(0, true, true); expect(await dao.balanceOf(account1)).to.equal(100); await expect(dao.evaluateOutcome(1)).to.emit(dao, 'ValidationPoolResolved').withArgs(1, true, true); expect(await dao.balanceOf(account1)).to.equal(200); }); it('should not be able to evaluate outcome if quorum is not met', async () => { time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(0)).to.emit(dao, 'ValidationPoolResolved').withArgs(0, true, true); const init = () => initiateValidationPool({ quorum: [1, 1] }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); expect(await dao.getValidationPoolCount()).to.equal(2); time.increase(POOL_DURATION + 1); await expect(dao.evaluateOutcome(1)).to.emit(dao, 'ValidationPoolResolved').withArgs(1, false, false); }); describe('Validation pool options', () => { beforeEach(async () => { time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(0); await forum.addPost([{ weightPPM: 1000000, authorAddress: account2 }], 'content-id-2', []); const init = () => initiateValidationPool({ postId: 'content-id-2' }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(1); }); it('Binding validation pool should redistribute stakes', async () => { const init = () => initiateValidationPool(); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(2); await dao.connect(account1).stakeOnValidationPool(2, 10, true); await dao.connect(account2).stakeOnValidationPool(2, 10, false); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(account2)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(2); expect(await dao.balanceOf(account1)).to.equal(210); expect(await dao.balanceOf(account2)).to.equal(90); expect(await dao.balanceOf(dao.target)).to.equal(0); }); it('Non binding validation pool should not redistribute stakes', async () => { const init = () => initiateValidationPool({ bindingPercent: 0 }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(2); await dao.connect(account1).stakeOnValidationPool(2, 10, true); await dao.connect(account2).stakeOnValidationPool(2, 10, false); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(account2)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(2); expect(await dao.balanceOf(account1)).to.equal(200); expect(await dao.balanceOf(account2)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(0); }); it('Partially binding validation pool should redistribute some stakes', async () => { const init = () => initiateValidationPool({ bindingPercent: 50 }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(2); await dao.connect(account1).stakeOnValidationPool(2, 10, true); await dao.connect(account2).stakeOnValidationPool(2, 10, false); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(account2)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(2); expect(await dao.balanceOf(account1)).to.equal(205); expect(await dao.balanceOf(account2)).to.equal(95); expect(await dao.balanceOf(dao.target)).to.equal(0); expect(await dao.totalSupply()).to.equal(300); }); it('If redistributeLosingStakes is false, validation pool should burn binding portion of losing stakes', async () => { const init = () => initiateValidationPool({ bindingPercent: 50, redistributeLosingStakes: false, }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(2); await dao.connect(account1).stakeOnValidationPool(2, 10, true); await dao.connect(account2).stakeOnValidationPool(2, 10, false); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(account2)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(2); expect(await dao.balanceOf(account1)).to.equal(200); expect(await dao.balanceOf(account2)).to.equal(95); expect(await dao.balanceOf(dao.target)).to.equal(0); expect(await dao.totalSupply()).to.equal(295); }); it('If redistributeLosingStakes is false and bindingPercent is 0, accounts should recover initial balances', async () => { const init = () => initiateValidationPool({ bindingPercent: 0, redistributeLosingStakes: false, }); await expect(init()).to.emit(dao, 'ValidationPoolInitiated').withArgs(2); await dao.connect(account1).stakeOnValidationPool(2, 10, true); await dao.connect(account2).stakeOnValidationPool(2, 10, false); expect(await dao.balanceOf(account1)).to.equal(100); expect(await dao.balanceOf(account2)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(100); time.increase(POOL_DURATION + 1); await dao.evaluateOutcome(2); expect(await dao.balanceOf(account1)).to.equal(200); expect(await dao.balanceOf(account2)).to.equal(100); expect(await dao.balanceOf(dao.target)).to.equal(0); expect(await dao.totalSupply()).to.equal(300); }); }); }); });