307 lines
12 KiB
Solidity
307 lines
12 KiB
Solidity
// SPDX-License-Identifier: Unlicense
|
|
pragma solidity ^0.8.24;
|
|
|
|
import "./DAO.sol";
|
|
import "./IOnValidate.sol";
|
|
|
|
import "hardhat/console.sol";
|
|
|
|
contract Proposals is DAOContract, IOnValidate {
|
|
enum Stage {
|
|
Proposal,
|
|
Referendum0,
|
|
Referendum1,
|
|
Referendum100,
|
|
Failed,
|
|
Accepted
|
|
}
|
|
|
|
struct Pool {
|
|
uint poolIndex;
|
|
bool started;
|
|
bool completed;
|
|
uint stakedFor;
|
|
uint stakedAgainst;
|
|
bool votePasses;
|
|
bool quorumMet;
|
|
}
|
|
|
|
struct Referendum {
|
|
uint duration;
|
|
// Each referendum may retry up to 3x
|
|
Pool[3] pools;
|
|
uint retryCount;
|
|
}
|
|
|
|
struct Proposal {
|
|
address sender;
|
|
uint fee;
|
|
uint remainingFee;
|
|
uint postIndex;
|
|
uint startTime;
|
|
Stage stage;
|
|
mapping(address => uint) attestations;
|
|
uint attestationTotal;
|
|
Referendum[3] referenda;
|
|
bool callbackOnValidate;
|
|
bytes callbackData;
|
|
}
|
|
|
|
mapping(uint => Proposal) public proposals;
|
|
uint public proposalCount;
|
|
|
|
event NewProposal(uint proposalIndex);
|
|
event Attestation(uint proposalIndex);
|
|
event ReferendumStarted(uint proposalIndex, uint poolIndex);
|
|
event ProposalFailed(uint proposalIndex, string reason);
|
|
event ProposalAccepted(uint proposalIndex);
|
|
|
|
constructor(DAO dao) DAOContract(dao) {}
|
|
|
|
// TODO receive : we want to be able to accept refunds from validation pools
|
|
|
|
function propose(
|
|
string calldata contentId,
|
|
uint referendum0Duration,
|
|
uint referendum1Duration,
|
|
uint referendum100Duration,
|
|
bool callbackOnValidate,
|
|
bytes calldata callbackData
|
|
) external payable returns (uint proposalIndex) {
|
|
// TODO: Consider taking author as a parameter,
|
|
// or else accepting a postIndex instead of contentId,
|
|
// or support post lookup by contentId
|
|
uint postIndex = dao.addPost(msg.sender, contentId);
|
|
proposalIndex = proposalCount++;
|
|
Proposal storage proposal = proposals[proposalIndex];
|
|
proposal.postIndex = postIndex;
|
|
proposal.startTime = block.timestamp;
|
|
proposal.referenda[0].duration = referendum0Duration;
|
|
proposal.referenda[1].duration = referendum1Duration;
|
|
proposal.referenda[2].duration = referendum100Duration;
|
|
proposal.fee = msg.value;
|
|
proposal.remainingFee = proposal.fee;
|
|
proposal.callbackOnValidate = callbackOnValidate;
|
|
proposal.callbackData = callbackData;
|
|
emit NewProposal(proposalIndex);
|
|
}
|
|
|
|
function getPools(
|
|
uint proposalIndex
|
|
) public view returns (Pool[3][3] memory pools) {
|
|
Proposal storage proposal = proposals[proposalIndex];
|
|
pools[0] = proposal.referenda[0].pools;
|
|
pools[1] = proposal.referenda[1].pools;
|
|
pools[2] = proposal.referenda[2].pools;
|
|
}
|
|
|
|
// TODO: function getProposals()
|
|
// Enumerate timing so clients can render it
|
|
|
|
/// External function for reputation holders to attest toward a given proposal;
|
|
/// This is non-binding and non-encumbering, so it does not transfer any reputation.
|
|
function attest(uint proposalIndex, uint amount) external {
|
|
// Since this is non-binding, non-encumbering, we only need to verify that
|
|
// the sender actually has the rep they claim to stake.
|
|
require(
|
|
dao.balanceOf(msg.sender) >= amount,
|
|
"Sender has insufficient REP balance"
|
|
);
|
|
Proposal storage proposal = proposals[proposalIndex];
|
|
proposal.attestationTotal -= proposal.attestations[msg.sender];
|
|
proposal.attestations[msg.sender] = amount;
|
|
proposal.attestationTotal += amount;
|
|
emit Attestation(proposalIndex);
|
|
}
|
|
|
|
// --- Sequences of validation pool parameters ---
|
|
// Percentage that each referendum is binding
|
|
uint[3] referendaBindingPercent = [0, 1, 100];
|
|
// Whether to redistribute the binding portion of losing stakes in each referendum
|
|
bool[3] referendaRedistributeLosingStakes = [false, false, true];
|
|
// For each referendum, a numerator-denominator pair representing its quorum
|
|
uint[2][3] referendaQuora = [[1, 10], [1, 10], [1, 10]];
|
|
// Win ratios
|
|
uint[2][3] referendaWinRatio = [[2, 3], [2, 3], [2, 3]];
|
|
|
|
/// Internal convenience function to wrap our call to dao.initiateValidationPool
|
|
/// and to emit an event
|
|
function initiateValidationPool(
|
|
uint proposalIndex,
|
|
uint referendumIndex,
|
|
uint fee
|
|
) internal {
|
|
Proposal storage proposal = proposals[proposalIndex];
|
|
proposal.remainingFee -= fee;
|
|
uint poolIndex = dao.initiateValidationPool{value: fee}(
|
|
proposal.postIndex,
|
|
proposal.referenda[referendumIndex].duration,
|
|
referendaQuora[referendumIndex],
|
|
referendaWinRatio[referendumIndex],
|
|
referendaBindingPercent[referendumIndex],
|
|
referendaRedistributeLosingStakes[referendumIndex],
|
|
true,
|
|
abi.encode(proposalIndex, referendumIndex, fee)
|
|
);
|
|
Referendum storage referendum = proposal.referenda[referendumIndex];
|
|
Pool storage pool = referendum.pools[referendum.retryCount];
|
|
pool.poolIndex = poolIndex;
|
|
pool.started = true;
|
|
emit ReferendumStarted(proposalIndex, poolIndex);
|
|
}
|
|
|
|
/// Callback to be executed when referenda pools complete
|
|
function onValidate(
|
|
bool votePasses,
|
|
bool quorumMet,
|
|
uint stakedFor,
|
|
uint stakedAgainst,
|
|
bytes calldata callbackData
|
|
) external {
|
|
require(
|
|
msg.sender == address(dao),
|
|
"onValidate may only be called by the DAO contract"
|
|
);
|
|
(uint proposalIndex, uint referendumIndex, uint fee) = abi.decode(
|
|
callbackData,
|
|
(uint, uint, uint)
|
|
);
|
|
Proposal storage proposal = proposals[proposalIndex];
|
|
Referendum storage referendum = proposal.referenda[referendumIndex];
|
|
Pool storage pool = referendum.pools[referendum.retryCount];
|
|
|
|
// Make a record of this result
|
|
pool.completed = true;
|
|
pool.stakedFor = stakedFor;
|
|
pool.stakedAgainst = stakedAgainst;
|
|
pool.quorumMet = quorumMet;
|
|
pool.votePasses = votePasses;
|
|
|
|
if (!quorumMet) {
|
|
proposal.stage = Stage.Failed;
|
|
emit ProposalFailed(proposalIndex, "Quorum not met");
|
|
proposal.remainingFee += fee;
|
|
return;
|
|
}
|
|
|
|
// Participation threshold of 50%
|
|
bool participationAboveThreshold = 2 * (stakedFor + stakedAgainst) >=
|
|
dao.totalSupply();
|
|
|
|
// Handle Referendum 0%
|
|
if (proposal.stage == Stage.Referendum0) {
|
|
require(referendumIndex == 0, "Stage 0 index mismatch");
|
|
// If vote passes (2/3 majority) and has >= 50% participation
|
|
if (votePasses && participationAboveThreshold) {
|
|
proposal.stage = Stage.Referendum1;
|
|
} else if (referendum.retryCount >= 2) {
|
|
proposal.stage = Stage.Failed;
|
|
emit ProposalFailed(proposalIndex, "Retry count exceeded");
|
|
} else {
|
|
referendum.retryCount += 1;
|
|
}
|
|
// Handle Referendum 1%
|
|
} else if (proposal.stage == Stage.Referendum1) {
|
|
require(referendumIndex == 1, "Stage 1 index mismatch");
|
|
if (votePasses && participationAboveThreshold) {
|
|
proposal.stage = Stage.Referendum100;
|
|
} else if (referendum.retryCount >= 2) {
|
|
proposal.stage = Stage.Failed;
|
|
emit ProposalFailed(proposalIndex, "Retry count exceeded");
|
|
} else {
|
|
referendum.retryCount += 1;
|
|
}
|
|
// Handle Referendum 100%
|
|
} else if (proposal.stage == Stage.Referendum100) {
|
|
require(referendumIndex == 2, "Stage 2 index mismatch");
|
|
// Note that no retries are attempted for referendum 100%
|
|
if (votePasses && participationAboveThreshold) {
|
|
// The proposal has passed all referenda and should become "law"
|
|
proposal.stage = Stage.Accepted;
|
|
// This is an opportunity for some actions to occur
|
|
// We should at least emit an event
|
|
emit ProposalAccepted(proposalIndex);
|
|
// We also execute a callback, if requested
|
|
if (proposal.callbackOnValidate) {
|
|
try
|
|
// Note: We're directly reusing the onValidate hook we established for valdiation pools.
|
|
// if any contracts want to use both callbacks, distinct interfaces should be defined.
|
|
IOnValidate(proposal.sender).onValidate(
|
|
votePasses,
|
|
false,
|
|
stakedFor,
|
|
stakedAgainst,
|
|
proposal.callbackData
|
|
)
|
|
{
|
|
console.log("proposal callbackOnValidate succeed");
|
|
} catch Error(string memory reason) {
|
|
console.log(
|
|
"proposal callbackOnValidate failed:",
|
|
reason
|
|
);
|
|
}
|
|
}
|
|
} else if (referendum.retryCount >= 2) {
|
|
proposal.stage = Stage.Failed;
|
|
emit ProposalFailed(proposalIndex, "Retry count exceeded");
|
|
} else {
|
|
referendum.retryCount += 1;
|
|
}
|
|
}
|
|
if (proposal.stage == Stage.Referendum0) {
|
|
initiateValidationPool(proposalIndex, 0, proposal.fee / 10);
|
|
} else if (proposal.stage == Stage.Referendum1) {
|
|
initiateValidationPool(proposalIndex, 1, proposal.fee / 10);
|
|
} else if (proposal.stage == Stage.Referendum100) {
|
|
initiateValidationPool(proposalIndex, 2, proposal.fee / 10);
|
|
}
|
|
}
|
|
|
|
/// External function that will advance a proposal to the referendum process
|
|
/// if attestation threshold has been reached
|
|
function evaluateAttestation(uint proposalIndex) external returns (bool) {
|
|
Proposal storage proposal = proposals[proposalIndex];
|
|
require(
|
|
proposal.stage == Stage.Proposal,
|
|
"Attestation only pertains to Proposal stage"
|
|
);
|
|
bool meetsAttestation = 10 * proposal.attestationTotal >=
|
|
dao.totalSupply();
|
|
bool expired = block.timestamp > proposal.startTime + 365 days;
|
|
if (!meetsAttestation) {
|
|
if (expired) {
|
|
// Expired without meeting attestation threshold
|
|
proposal.stage = Stage.Failed;
|
|
emit ProposalFailed(
|
|
proposalIndex,
|
|
"Expired without meeting attestation threshold"
|
|
);
|
|
return false;
|
|
}
|
|
// Not yet expired, but has not met attestation threshold
|
|
return false;
|
|
}
|
|
|
|
// Attestation threshold is met.
|
|
// Note that this may succeed even after expiry
|
|
// It can only happen once because the stage advances, and we required it above.
|
|
proposal.stage = Stage.Referendum0;
|
|
// Initiate validation pool
|
|
initiateValidationPool(proposalIndex, 0, proposal.fee / 10);
|
|
return true;
|
|
}
|
|
|
|
/// External function to reclaim remaining fees after a proposal has completed all referenda
|
|
function reclaimRemainingFee(uint proposalIndex) external {
|
|
Proposal storage proposal = proposals[proposalIndex];
|
|
require(
|
|
proposal.stage == Stage.Failed || proposal.stage == Stage.Accepted,
|
|
"Remaining fees can only be reclaimed when proposal has been accepted or failed"
|
|
);
|
|
uint amount = proposal.remainingFee;
|
|
proposal.remainingFee = 0;
|
|
payable(msg.sender).transfer(amount);
|
|
}
|
|
}
|