文件 1 的 1：Contest.sol
pragma solidity ^0.8.0 ^0.8.1 ^0.8.19;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
abstract contract GovernorSorting {
uint256 public sortingEnabled;
uint256 public rankLimit;
uint256[] public sortedRanks;
constructor(uint256 sortingEnabled_, uint256 rankLimit_) {
sortingEnabled = sortingEnabled_;
rankLimit = rankLimit_;
}
function getNumProposalsWithThisManyForVotes(uint256 forVotes) public view virtual returns (uint256 count);
function getSortedRanks() public view returns (uint256[] memory sortedRanksArray) {
return sortedRanks;
}
function _insertRank(
uint256 oldValue,
uint256 newValue,
uint256 sortedRanksLength,
uint256[] memory sortedRanksMemVar
) internal {
uint256 insertingIndex;
for (uint256 index = 0; index < sortedRanksLength; index++) {
if (newValue == sortedRanksMemVar[index]) {
return;
}
if (newValue > sortedRanksMemVar[index]) {
insertingIndex = index;
break;
}
}
bool checkForOldValue = (oldValue > 0) && (getNumProposalsWithThisManyForVotes(oldValue) == 0);
bool haveFoundOldValue = false;
if (!(checkForOldValue && (sortedRanksMemVar[insertingIndex] == oldValue))) {
if (!(insertingIndex == sortedRanksLength - 1)) {
for (uint256 index = insertingIndex + 1; index < sortedRanksLength; index++) {
sortedRanks[index] = sortedRanksMemVar[index - 1];
if (checkForOldValue && (sortedRanksMemVar[index] == oldValue)) {
haveFoundOldValue = true;
break;
}
}
}
if (!haveFoundOldValue && (sortedRanksLength < rankLimit)) {
sortedRanks.push(sortedRanksMemVar[sortedRanksLength - 1]);
}
}
sortedRanks[insertingIndex] = newValue;
}
function _updateRanks(uint256 oldValue, uint256 newValue) internal {
uint256 sortedRanksLength = sortedRanks.length;
uint256[] memory sortedRanksMemVar = sortedRanks;
if (sortedRanksLength == 0) {
sortedRanks.push(newValue);
return;
}
if (newValue < sortedRanksMemVar[sortedRanksLength - 1]) {
if (sortedRanksLength == rankLimit) {
return;
} else {
sortedRanks.push(newValue);
return;
}
}
_insertRank(oldValue, newValue, sortedRanksLength, sortedRanksMemVar);
}
}
abstract contract GovernorMerkleVotes {
bytes32 public submissionMerkleRoot;
bytes32 public votingMerkleRoot;
error NotInMerkle();
constructor(bytes32 _submissionMerkleRoot, bytes32 _votingMerkleRoot) {
submissionMerkleRoot = _submissionMerkleRoot;
votingMerkleRoot = _votingMerkleRoot;
}
function checkProof(address addressToCheck, uint256 amount, bytes32[] calldata proof, bool voting)
public
view
returns (bool verified)
{
bytes32 leaf = keccak256(abi.encodePacked(addressToCheck, amount));
bool isValidLeaf = voting
? MerkleProof.verify(proof, votingMerkleRoot, leaf)
: MerkleProof.verify(proof, submissionMerkleRoot, leaf);
if (!isValidLeaf) revert NotInMerkle();
return true;
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
abstract contract Governor is GovernorSorting, GovernorMerkleVotes {
using SafeCast for uint256;
enum ContestState {
NotStarted,
Active,
Canceled,
Queued,
Completed
}
enum Metadatas {
Target,
Safe,
Fields
}
enum Actions {
Submit,
Vote
}
struct IntConstructorArgs {
uint256 contestStart;
uint256 votingDelay;
uint256 votingPeriod;
uint256 numAllowedProposalSubmissions;
uint256 maxProposalCount;
uint256 downvotingAllowed;
uint256 sortingEnabled;
uint256 rankLimit;
uint256 percentageToCreator;
uint256 costToPropose;
uint256 costToVote;
uint256 payPerVote;
}
struct ConstructorArgs {
IntConstructorArgs intConstructorArgs;
address creatorSplitDestination;
address jkLabsSplitDestination;
string metadataFieldsSchema;
}
struct TargetMetadata {
address targetAddress;
}
struct SafeMetadata {
address[] signers;
uint256 threshold;
}
struct FieldsMetadata {
address[] addressArray;
string[] stringArray;
uint256[] uintArray;
}
struct ProposalCore {
address author;
bool exists;
string description;
TargetMetadata targetMetadata;
SafeMetadata safeMetadata;
FieldsMetadata fieldsMetadata;
}
event JokeraceCreated(
string version,
string name,
string prompt,
address creator,
uint256 contestStart,
uint256 votingDelay,
uint256 votingPeriod
);
event ProposalCreated(uint256 proposalId, address proposer, string proposalDescription);
event ProposalsDeleted(uint256[] proposalIds);
event ContestCanceled();
event VoteCast(address indexed voter, uint256 proposalId, uint8 support, uint256 numVotes);
event CreatorPaymentReleased(address to, uint256 amount);
event JkLabsPaymentReleased(address to, uint256 amount);
uint256 public constant METADATAS_COUNT = uint256(type(Metadatas).max) + 1;
uint256 public constant MAX_FIELDS_METADATA_LENGTH = 10;
uint256 public constant AMOUNT_FOR_SUMBITTER_PROOF = 10000000000000000000;
address public constant JK_LABS_ADDRESS = 0xDc652C746A8F85e18Ce632d97c6118e8a52fa738;
string private constant VERSION = "4.33";
string public name;
string public prompt;
address public creator;
uint256 public contestStart;
uint256 public votingDelay;
uint256 public votingPeriod;
uint256 public numAllowedProposalSubmissions;
uint256 public maxProposalCount;
uint256 public downvotingAllowed;
uint256 public percentageToCreator;
uint256 public costToPropose;
uint256 public costToVote;
uint256 public payPerVote;
address public creatorSplitDestination;
address public jkLabsSplitDestination;
string public metadataFieldsSchema;
uint256[] public proposalIds;
uint256[] public deletedProposalIds;
mapping(uint256 => bool) public proposalIsDeleted;
bool public canceled;
mapping(uint256 => ProposalCore) public proposals;
mapping(address => uint256) public numSubmissions;
address[] public proposalAuthors;
address[] public addressesThatHaveVoted;
mapping(address => uint256) public addressTotalVotes;
mapping(address => bool) public addressTotalVotesVerified;
mapping(address => bool) public addressSubmitterVerified;
error AuthorIsNotSender(address author, address sender);
error ZeroSignersInSafeMetadata();
error ZeroThresholdInSafeMetadata();
error AddressFieldMetadataArrayTooLong();
error StringFieldMetadataArrayTooLong();
error UintFieldMetadataArrayTooLong();
error UnexpectedMetadata(Metadatas unexpectedMetadata);
error EmptyProposalDescription();
error IncorrectCostSent(uint256 msgValue, uint256 costToVote);
error AddressNotPermissionedToSubmit();
error ContestMustBeQueuedToPropose(ContestState currentState);
error ContestMustBeActiveToVote(ContestState currentState);
error SenderSubmissionLimitReached(uint256 numAllowedProposalSubmissions);
error ContestSubmissionLimitReached(uint256 maxProposalCount);
error DuplicateSubmission(uint256 proposalId);
error CannotVoteOnDeletedProposal();
error NeedAtLeastOneVoteToVote();
error CannotVoteLessThanOneVoteInPayPerVote();
error NeedToSubmitWithProofFirst();
error NeedToVoteWithProofFirst();
error OnlyCreatorCanDelete();
error CannotDeleteWhenCompletedOrCanceled();
error OnlyJkLabsOrCreatorCanCancel();
error ContestAlreadyCanceled();
error CannotUpdateWhenCompletedOrCanceled();
error OnlyJkLabsCanAmend();
error OnlyCreatorCanAmend();
constructor(string memory name_, string memory prompt_, ConstructorArgs memory constructorArgs_) {
name = name_;
prompt = prompt_;
creator = msg.sender;
contestStart = constructorArgs_.intConstructorArgs.contestStart;
votingDelay = constructorArgs_.intConstructorArgs.votingDelay;
votingPeriod = constructorArgs_.intConstructorArgs.votingPeriod;
numAllowedProposalSubmissions = constructorArgs_.intConstructorArgs.numAllowedProposalSubmissions;
maxProposalCount = constructorArgs_.intConstructorArgs.maxProposalCount;
downvotingAllowed = constructorArgs_.intConstructorArgs.downvotingAllowed;
percentageToCreator = constructorArgs_.intConstructorArgs.percentageToCreator;
costToPropose = constructorArgs_.intConstructorArgs.costToPropose;
costToVote = constructorArgs_.intConstructorArgs.costToVote;
payPerVote = constructorArgs_.intConstructorArgs.payPerVote;
creatorSplitDestination = constructorArgs_.creatorSplitDestination;
jkLabsSplitDestination = constructorArgs_.jkLabsSplitDestination;
metadataFieldsSchema = constructorArgs_.metadataFieldsSchema;
emit JokeraceCreated(
VERSION,
name_,
prompt_,
msg.sender,
constructorArgs_.intConstructorArgs.contestStart,
constructorArgs_.intConstructorArgs.votingDelay,
constructorArgs_.intConstructorArgs.votingPeriod
);
}
function version() public pure returns (string memory) {
return VERSION;
}
function hashProposal(ProposalCore memory proposal) public pure returns (uint256) {
return uint256(keccak256(abi.encode(proposal)));
}
function state() public view returns (ContestState) {
if (canceled) {
return ContestState.Canceled;
}
if (contestStart >= block.timestamp) {
return ContestState.NotStarted;
}
if (voteStart() >= block.timestamp) {
return ContestState.Queued;
}
if (contestDeadline() >= block.timestamp) {
return ContestState.Active;
}
return ContestState.Completed;
}
function getAllProposalIds() public view returns (uint256[] memory) {
return proposalIds;
}
function getAllProposalAuthors() public view returns (address[] memory) {
return proposalAuthors;
}
function getAllAddressesThatHaveVoted() public view returns (address[] memory) {
return addressesThatHaveVoted;
}
function getAllDeletedProposalIds() public view returns (uint256[] memory) {
return deletedProposalIds;
}
function getAllAuthorsOfDeletedProposals() public view returns (address[] memory) {
uint256[] memory deletedProposalIdsMemVar = deletedProposalIds;
address[] memory authorsArray = new address[](deletedProposalIdsMemVar.length);
for (uint256 i = 0; i < deletedProposalIdsMemVar.length; i++) {
authorsArray[i] = proposals[deletedProposalIdsMemVar[i]].author;
}
return authorsArray;
}
function voteStart() public view returns (uint256) {
return contestStart + votingDelay;
}
function contestDeadline() public view returns (uint256) {
return voteStart() + votingPeriod;
}
function getProposal(uint256 proposalId) public view returns (ProposalCore memory) {
return proposals[proposalId];
}
function _multiRmProposalIdFromForVotesMap(uint256[] calldata proposalIds) internal virtual;
function _countVote(uint256 proposalId, address account, uint8 support, uint256 numVotes, uint256 totalVotes)
internal
virtual;
function verifyProposer(address account, bytes32[] calldata proof) public {
if (!addressSubmitterVerified[account]) {
if (submissionMerkleRoot == 0) {
return;
}
checkProof(account, AMOUNT_FOR_SUMBITTER_PROOF, proof, false);
addressSubmitterVerified[account] = true;
}
}
function validateProposalData(ProposalCore memory proposal) public view {
if (proposal.author != msg.sender) revert AuthorIsNotSender(proposal.author, msg.sender);
for (uint256 index = 0; index < METADATAS_COUNT; index++) {
Metadatas currentMetadata = Metadatas(index);
if (currentMetadata == Metadatas.Target) {
continue;
} else if (currentMetadata == Metadatas.Safe) {
if (proposal.safeMetadata.signers.length == 0) revert ZeroSignersInSafeMetadata();
if (proposal.safeMetadata.threshold == 0) revert ZeroThresholdInSafeMetadata();
} else if (currentMetadata == Metadatas.Fields) {
if (proposal.fieldsMetadata.addressArray.length > MAX_FIELDS_METADATA_LENGTH) {
revert AddressFieldMetadataArrayTooLong();
}
if (proposal.fieldsMetadata.stringArray.length > MAX_FIELDS_METADATA_LENGTH) {
revert StringFieldMetadataArrayTooLong();
}
if (proposal.fieldsMetadata.uintArray.length > MAX_FIELDS_METADATA_LENGTH) {
revert UintFieldMetadataArrayTooLong();
}
} else {
revert UnexpectedMetadata(currentMetadata);
}
}
if (bytes(proposal.description).length == 0) revert EmptyProposalDescription();
}
function _determineCorrectAmountSent(Actions currentAction, uint256 numVotes) internal returns (uint256) {
uint256 actionCost;
if (currentAction == Actions.Submit) {
actionCost = costToPropose;
} else if (currentAction == Actions.Vote) {
if (payPerVote == 1) {
if (numVotes < 1 ether) revert CannotVoteLessThanOneVoteInPayPerVote();
actionCost = costToVote * (numVotes / 1 ether);
} else {
actionCost = costToVote;
}
} else {
actionCost = 0;
}
if (msg.value != actionCost) revert IncorrectCostSent(msg.value, actionCost);
return actionCost;
}
function _distributeCost(uint256 actionCost) internal {
if (actionCost > 0) {
uint256 sendingToJkLabs = (msg.value * (100 - percentageToCreator)) / 100;
if (sendingToJkLabs > 0) {
Address.sendValue(payable(jkLabsSplitDestination), sendingToJkLabs);
emit JkLabsPaymentReleased(jkLabsSplitDestination, sendingToJkLabs);
}
uint256 sendingToCreator = msg.value - sendingToJkLabs;
if (sendingToCreator > 0) {
Address.sendValue(payable(creatorSplitDestination), sendingToCreator);
emit CreatorPaymentReleased(creator, sendingToCreator);
}
}
}
function propose(ProposalCore calldata proposal, bytes32[] calldata proof) public payable returns (uint256) {
uint256 actionCost = _determineCorrectAmountSent(Actions.Submit, 0);
verifyProposer(msg.sender, proof);
validateProposalData(proposal);
uint256 proposalId = _castProposal(proposal);
_distributeCost(actionCost);
return proposalId;
}
function proposeWithoutProof(ProposalCore calldata proposal) public payable returns (uint256) {
uint256 actionCost = _determineCorrectAmountSent(Actions.Submit, 0);
if (submissionMerkleRoot != 0) {
if (!addressSubmitterVerified[msg.sender]) revert NeedToSubmitWithProofFirst();
}
validateProposalData(proposal);
uint256 proposalId = _castProposal(proposal);
_distributeCost(actionCost);
return proposalId;
}
function _castProposal(ProposalCore memory proposal) internal returns (uint256) {
if (state() != ContestState.Queued) revert ContestMustBeQueuedToPropose(state());
if (numSubmissions[msg.sender] == numAllowedProposalSubmissions) {
revert SenderSubmissionLimitReached(numAllowedProposalSubmissions);
}
if ((proposalIds.length - deletedProposalIds.length) == maxProposalCount) {
revert ContestSubmissionLimitReached(maxProposalCount);
}
uint256 proposalId = hashProposal(proposal);
if (proposals[proposalId].exists) revert DuplicateSubmission(proposalId);
proposalIds.push(proposalId);
proposals[proposalId] = proposal;
numSubmissions[msg.sender] += 1;
proposalAuthors.push(msg.sender);
emit ProposalCreated(proposalId, msg.sender, proposal.description);
return proposalId;
}
function deleteProposals(uint256[] calldata proposalIdsToDelete) public {
if (msg.sender != creator) revert OnlyCreatorCanDelete();
if (state() == ContestState.Completed || state() == ContestState.Canceled) {
revert CannotDeleteWhenCompletedOrCanceled();
}
for (uint256 index = 0; index < proposalIdsToDelete.length; index++) {
uint256 currentProposalId = proposalIdsToDelete[index];
if (!proposalIsDeleted[currentProposalId]) {
proposalIsDeleted[currentProposalId] = true;
deletedProposalIds.push(currentProposalId);
}
}
if (downvotingAllowed == 0 && sortingEnabled == 1) {
_multiRmProposalIdFromForVotesMap(proposalIdsToDelete);
}
emit ProposalsDeleted(proposalIds);
}
function cancel() public {
if (((msg.sender != creator) && (msg.sender != JK_LABS_ADDRESS))) revert OnlyJkLabsOrCreatorCanCancel();
ContestState status = state();
if (status == ContestState.Canceled) revert ContestAlreadyCanceled();
canceled = true;
emit ContestCanceled();
}
function verifyVoter(address account, uint256 totalVotes, bytes32[] calldata proof) public {
if (votingMerkleRoot != 0 && !addressTotalVotesVerified[account]) {
checkProof(account, totalVotes, proof, true);
addressTotalVotes[account] = totalVotes;
addressTotalVotesVerified[account] = true;
}
}
function castVote(uint256 proposalId, uint8 support, uint256 totalVotes, uint256 numVotes, bytes32[] calldata proof)
public
payable
returns (uint256)
{
uint256 actionCost = _determineCorrectAmountSent(Actions.Vote, numVotes);
if (proposalIsDeleted[proposalId]) revert CannotVoteOnDeletedProposal();
verifyVoter(msg.sender, totalVotes, proof);
_distributeCost(actionCost);
return _castVote(proposalId, msg.sender, support, numVotes);
}
function castVoteWithoutProof(uint256 proposalId, uint8 support, uint256 numVotes)
public
payable
returns (uint256)
{
uint256 actionCost = _determineCorrectAmountSent(Actions.Vote, numVotes);
if (proposalIsDeleted[proposalId]) revert CannotVoteOnDeletedProposal();
if (votingMerkleRoot != 0 && !addressTotalVotesVerified[msg.sender]) revert NeedToVoteWithProofFirst();
_distributeCost(actionCost);
return _castVote(proposalId, msg.sender, support, numVotes);
}
function _castVote(uint256 proposalId, address account, uint8 support, uint256 numVotes)
internal
returns (uint256)
{
if (state() != ContestState.Active) revert ContestMustBeActiveToVote(state());
if (numVotes == 0) revert NeedAtLeastOneVoteToVote();
_countVote(proposalId, account, support, numVotes, addressTotalVotes[account]);
addressesThatHaveVoted.push(msg.sender);
emit VoteCast(account, proposalId, support, numVotes);
return addressTotalVotes[account];
}
function setSubmissionMerkleRoot(bytes32 newSubmissionMerkleRoot) public {
if (msg.sender != JK_LABS_ADDRESS) revert OnlyJkLabsCanAmend();
if (state() == ContestState.Completed || state() == ContestState.Canceled) {
revert CannotUpdateWhenCompletedOrCanceled();
}
submissionMerkleRoot = newSubmissionMerkleRoot;
}
function setVotingMerkleRoot(bytes32 newVotingMerkleRoot) public {
if (msg.sender != JK_LABS_ADDRESS) revert OnlyJkLabsCanAmend();
if (state() == ContestState.Completed || state() == ContestState.Canceled) {
revert CannotUpdateWhenCompletedOrCanceled();
}
votingMerkleRoot = newVotingMerkleRoot;
}
function setCreatorSplitDestination(address newCreatorSplitDestination) public {
if (msg.sender != creator) revert OnlyCreatorCanAmend();
if (state() == ContestState.Completed || state() == ContestState.Canceled) {
revert CannotUpdateWhenCompletedOrCanceled();
}
creatorSplitDestination = newCreatorSplitDestination;
}
}
abstract contract GovernorCountingSimple is Governor {
enum VoteType {
For,
Against
}
struct VoteCounts {
uint256 forVotes;
uint256 againstVotes;
}
struct ProposalVote {
VoteCounts proposalVoteCounts;
address[] addressesVoted;
mapping(address => VoteCounts) addressVoteCounts;
}
uint256 public totalVotesCast;
mapping(address => uint256) public addressTotalCastVoteCounts;
mapping(uint256 => ProposalVote) public proposalVotesStructs;
mapping(uint256 => uint256[]) public forVotesToProposalIds;
error MoreThanOneProposalWithThisManyVotes();
error NotEnoughVotesLeft();
error DownvotingNotEnabled();
error InvalidVoteType();
error RankCannotBeZero();
error RankIsNotInSortedRanks();
error IndexHasNotBeenPopulated();
function proposalVotes(uint256 proposalId) public view returns (uint256 forVotes, uint256 againstVotes) {
ProposalVote storage proposalvote = proposalVotesStructs[proposalId];
return (proposalvote.proposalVoteCounts.forVotes, proposalvote.proposalVoteCounts.againstVotes);
}
function proposalAddressVotes(uint256 proposalId, address userAddress)
public
view
returns (uint256 forVotes, uint256 againstVotes)
{
ProposalVote storage proposalvote = proposalVotesStructs[proposalId];
return (
proposalvote.addressVoteCounts[userAddress].forVotes,
proposalvote.addressVoteCounts[userAddress].againstVotes
);
}
function proposalAddressesHaveVoted(uint256 proposalId) public view returns (address[] memory) {
ProposalVote storage proposalvote = proposalVotesStructs[proposalId];
return proposalvote.addressesVoted;
}
function contestAddressTotalVotesCast(address userAddress) public view returns (uint256 userTotalVotesCast) {
return addressTotalCastVoteCounts[userAddress];
}
function allProposalTotalVotes()
public
view
returns (uint256[] memory proposalIdsReturn, VoteCounts[] memory proposalVoteCountsArrayReturn)
{
uint256[] memory proposalIdsMemVar = getAllProposalIds();
VoteCounts[] memory proposalVoteCountsArray = new VoteCounts[](proposalIdsMemVar.length);
for (uint256 i = 0; i < proposalIdsMemVar.length; i++) {
proposalVoteCountsArray[i] = proposalVotesStructs[proposalIdsMemVar[i]].proposalVoteCounts;
}
return (proposalIdsMemVar, proposalVoteCountsArray);
}
function getProposalsWithThisManyForVotes(uint256 forVotes)
public
view
returns (uint256[] memory proposalsWithThisManyForVotes)
{
return forVotesToProposalIds[forVotes];
}
function getNumProposalsWithThisManyForVotes(uint256 forVotes) public view override returns (uint256 count) {
return forVotesToProposalIds[forVotes].length;
}
function getOnlyProposalIdWithThisManyForVotes(uint256 forVotes) public view returns (uint256 proposalId) {
if (forVotesToProposalIds[forVotes].length != 1) revert MoreThanOneProposalWithThisManyVotes();
return forVotesToProposalIds[forVotes][0];
}
function getRankIndex(uint256 rank) public view returns (uint256 rankIndex) {
if (rank == 0) revert RankCannotBeZero();
uint256 sortedRanksLength = sortedRanks.length;
uint256[] memory sortedRanksMemVar = sortedRanks;
uint256 counter = 1;
for (uint256 index = 0; index < sortedRanksLength; index++) {
if (getNumProposalsWithThisManyForVotes(sortedRanksMemVar[index]) == 0) {
continue;
}
if (counter == rank) {
return index;
}
counter++;
}
revert RankIsNotInSortedRanks();
}
function isOrIsBelowTiedRank(uint256 idx) public view returns (bool atOrBelowTiedRank) {
if (idx > sortedRanks.length - 1) {
revert IndexHasNotBeenPopulated();
}
for (uint256 index = 0; index < idx + 1; index++) {
if (getNumProposalsWithThisManyForVotes(sortedRanks[index]) > 1) {
return true;
}
}
return false;
}
function _rmProposalIdFromForVotesMap(uint256 proposalId, uint256 forVotes) internal {
uint256[] memory forVotesToPropIdMemVar = forVotesToProposalIds[forVotes];
for (uint256 i = 0; i < forVotesToPropIdMemVar.length; i++) {
if (forVotesToPropIdMemVar[i] == proposalId) {
forVotesToProposalIds[forVotes][i] = forVotesToPropIdMemVar[forVotesToPropIdMemVar.length - 1];
forVotesToProposalIds[forVotes].pop();
break;
}
}
}
function _multiRmProposalIdFromForVotesMap(uint256[] calldata proposalIdsToDelete) internal override {
for (uint256 i = 0; i < proposalIdsToDelete.length; i++) {
uint256 currentProposalId = proposalIdsToDelete[i];
uint256 currentProposalsForVotes = proposalVotesStructs[currentProposalId].proposalVoteCounts.forVotes;
_rmProposalIdFromForVotesMap(currentProposalId, currentProposalsForVotes);
}
}
function _countVote(uint256 proposalId, address account, uint8 support, uint256 numVotes, uint256 totalVotes)
internal
override
{
ProposalVote storage proposalvote = proposalVotesStructs[proposalId];
if ((votingMerkleRoot != 0) && (numVotes > (totalVotes - addressTotalCastVoteCounts[account]))) {
revert NotEnoughVotesLeft();
}
bool firstTimeVoting = (
proposalvote.addressVoteCounts[account].forVotes == 0
&& proposalvote.addressVoteCounts[account].againstVotes == 0
);
if (support == uint8(VoteType.For)) {
proposalvote.proposalVoteCounts.forVotes += numVotes;
proposalvote.addressVoteCounts[account].forVotes += numVotes;
} else if (support == uint8(VoteType.Against)) {
if (downvotingAllowed != 1) revert DownvotingNotEnabled();
proposalvote.proposalVoteCounts.againstVotes += numVotes;
proposalvote.addressVoteCounts[account].againstVotes += numVotes;
} else {
revert InvalidVoteType();
}
if (firstTimeVoting) {
proposalvote.addressesVoted.push(account);
}
addressTotalCastVoteCounts[account] += numVotes;
totalVotesCast += numVotes;
if ((downvotingAllowed == 0) && (sortingEnabled == 1)) {
uint256 newForVotes = proposalvote.proposalVoteCounts.forVotes;
uint256 oldForVotes = newForVotes - numVotes;
if (oldForVotes > 0) {
_rmProposalIdFromForVotesMap(proposalId, oldForVotes);
}
forVotesToProposalIds[newForVotes].push(proposalId);
_updateRanks(oldForVotes, newForVotes);
}
}
}
abstract contract GovernorEngagement is Governor {
struct CommentCore {
address author;
uint256 timestamp;
uint256 proposalId;
string commentContent;
}
event CommentCreated(uint256 commentId);
event CommentsDeleted(uint256[] commentIds);
uint256[] public commentIds;
uint256[] public deletedCommentIds;
mapping(uint256 => CommentCore) public comments;
mapping(uint256 => uint256[]) public proposalComments;
mapping(uint256 => bool) public commentIsDeleted;
error OnlyCreatorOrAuthorCanDeleteComments(uint256 failedToDeleteCommentId);
function hashComment(CommentCore memory commentObj) public pure returns (uint256) {
return uint256(keccak256(abi.encode(commentObj)));
}
function getAllCommentIds() public view returns (uint256[] memory) {
return commentIds;
}
function getAllDeletedCommentIds() public view returns (uint256[] memory) {
return deletedCommentIds;
}
function getComment(uint256 commentId) public view returns (CommentCore memory) {
return comments[commentId];
}
function getProposalComments(uint256 proposalId) public view returns (uint256[] memory) {
return proposalComments[proposalId];
}
function comment(uint256 proposalId, string memory commentContent) public returns (uint256) {
CommentCore memory commentObject = CommentCore({
author: msg.sender,
timestamp: block.timestamp,
proposalId: proposalId,
commentContent: commentContent
});
uint256 commentId = hashComment(commentObject);
commentIds.push(commentId);
comments[commentId] = commentObject;
proposalComments[proposalId].push(commentId);
emit CommentCreated(commentId);
return commentId;
}
function deleteComments(uint256[] memory commentIdsParam) public {
uint256 commentIdsParamMemVar = commentIdsParam.length;
for (uint256 index = 0; index < commentIdsParamMemVar; index++) {
uint256 currentCommentId = commentIdsParam[index];
if ((msg.sender != creator) && (msg.sender != comments[currentCommentId].author)) {
revert OnlyCreatorOrAuthorCanDeleteComments(currentCommentId);
}
if (!commentIsDeleted[currentCommentId]) {
commentIsDeleted[currentCommentId] = true;
deletedCommentIds.push(currentCommentId);
}
}
emit CommentsDeleted(commentIdsParam);
}
}
contract RewardsModule {
event PayeeAdded(uint256 ranking, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
event RewardWithdrawn(address by, uint256 amount);
event ERC20RewardWithdrawn(IERC20 indexed token, address by, uint256 amount);
uint256 public totalShares;
uint256 public totalReleased;
mapping(uint256 => uint256) public shares;
mapping(uint256 => uint256) public released;
uint256[] public payees;
string private constant VERSION = "4.33";
mapping(IERC20 => uint256) public erc20TotalReleased;
mapping(IERC20 => mapping(uint256 => uint256)) public erc20Released;
GovernorCountingSimple public underlyingContest;
address public creator;
bool public paysOutTarget;
bool public canceled;
error PayeesSharesLengthMismatch();
error MustHaveAtLeastOnePayee();
error TotalSharesCannotBeZero();
error MustHaveDownvotingDisabled();
error MustHaveSortingEnabled();
error ContestMustBeCompleted();
error PayoutRankCannotBeZero();
error RankingHasNoShares();
error AccountNotDueNativePayment();
error CannotPayOutToZeroAddress();
error AccountNotDueERC20Payment();
error OnlyCreatorCanWithdraw();
error RankingCannotBeZero();
error SharesCannotBeZero();
error AccountAlreadyHasShares();
error CannotReleaseCanceledModule();
error MustBeCanceledToWithdraw();
constructor(
uint256[] memory payees_,
uint256[] memory shares_,
GovernorCountingSimple underlyingContest_,
bool paysOutTarget_
) payable {
if (payees_.length != shares_.length) revert PayeesSharesLengthMismatch();
if (payees_.length == 0) revert MustHaveAtLeastOnePayee();
for (uint256 i = 0; i < payees_.length; i++) {
_addPayee(payees_[i], shares_[i]);
}
if (totalShares == 0) revert TotalSharesCannotBeZero();
paysOutTarget = paysOutTarget_;
underlyingContest = underlyingContest_;
creator = msg.sender;
}
receive() external payable {
emit PaymentReceived(msg.sender, msg.value);
}
function version() public pure returns (string memory) {
return VERSION;
}
function getPayees() public view returns (uint256[] memory) {
return payees;
}
function getUnderlyingContest() public view returns (GovernorCountingSimple) {
return underlyingContest;
}
function releasable(uint256 ranking) public view returns (uint256) {
uint256 totalReceived = address(this).balance + totalReleased;
return _pendingPayment(ranking, totalReceived, released[ranking]);
}
function releasable(IERC20 token, uint256 ranking) public view returns (uint256) {
uint256 totalReceived = token.balanceOf(address(this)) + erc20TotalReleased[token];
return _pendingPayment(ranking, totalReceived, erc20Released[token][ranking]);
}
function runReleaseChecks(uint256 ranking) public view {
if (underlyingContest.downvotingAllowed() != 0) revert MustHaveDownvotingDisabled();
if (underlyingContest.sortingEnabled() != 1) revert MustHaveSortingEnabled();
if (underlyingContest.state() != Governor.ContestState.Completed) revert ContestMustBeCompleted();
if (ranking == 0) revert PayoutRankCannotBeZero();
if (shares[ranking] == 0) revert RankingHasNoShares();
if (canceled == true) revert CannotReleaseCanceledModule();
}
function getAddressToPayOut(uint256 ranking) public view returns (address) {
address addressToPayOut;
uint256 determinedRankingIdxInSortedRanks = underlyingContest.getRankIndex(ranking);
if (underlyingContest.isOrIsBelowTiedRank(determinedRankingIdxInSortedRanks)) {
addressToPayOut = creator;
}
else {
uint256 rankValue = underlyingContest.sortedRanks(determinedRankingIdxInSortedRanks);
Governor.ProposalCore memory rankingProposal = underlyingContest.getProposal(
underlyingContest.getOnlyProposalIdWithThisManyForVotes(rankValue)
);
addressToPayOut = paysOutTarget ? rankingProposal.targetMetadata.targetAddress : rankingProposal.author;
}
return addressToPayOut;
}
function cancel() public {
canceled = true;
}
function release(uint256 ranking) public {
runReleaseChecks(ranking);
uint256 payment = releasable(ranking);
if (payment == 0) revert AccountNotDueNativePayment();
totalReleased += payment;
unchecked {
released[ranking] += payment;
}
address payable addressToPayOut = payable(getAddressToPayOut(ranking));
if (addressToPayOut == address(0)) revert CannotPayOutToZeroAddress();
emit PaymentReleased(addressToPayOut, payment);
Address.sendValue(addressToPayOut, payment);
}
function release(IERC20 token, uint256 ranking) public {
runReleaseChecks(ranking);
uint256 payment = releasable(token, ranking);
if (payment == 0) revert AccountNotDueERC20Payment();
erc20TotalReleased[token] += payment;
unchecked {
erc20Released[token][ranking] += payment;
}
address payable addressToPayOut = payable(getAddressToPayOut(ranking));
if (addressToPayOut == address(0)) revert CannotPayOutToZeroAddress();
emit ERC20PaymentReleased(token, addressToPayOut, payment);
SafeERC20.safeTransfer(token, addressToPayOut, payment);
}
function withdrawRewards() public {
if (msg.sender != creator) revert OnlyCreatorCanWithdraw();
if (canceled != true) revert MustBeCanceledToWithdraw();
emit RewardWithdrawn(creator, address(this).balance);
Address.sendValue(payable(creator), address(this).balance);
}
function withdrawRewards(IERC20 token) public {
if (msg.sender != creator) revert OnlyCreatorCanWithdraw();
emit ERC20RewardWithdrawn(token, creator, token.balanceOf(address(this)));
SafeERC20.safeTransfer(token, payable(creator), token.balanceOf(address(this)));
}
function _pendingPayment(uint256 ranking, uint256 totalReceived, uint256 alreadyReleased)
private
view
returns (uint256)
{
return (totalReceived * shares[ranking]) / totalShares - alreadyReleased;
}
function _addPayee(uint256 ranking, uint256 shares_) private {
if (ranking == 0) revert RankingCannotBeZero();
if (shares_ == 0) revert SharesCannotBeZero();
if (shares[ranking] != 0) revert AccountAlreadyHasShares();
payees.push(ranking);
shares[ranking] = shares_;
totalShares = totalShares + shares_;
emit PayeeAdded(ranking, shares_);
}
}
abstract contract GovernorModuleRegistry is Governor {
event OfficialRewardsModuleSet(RewardsModule oldOfficialRewardsModule, RewardsModule newOfficialRewardsModule);
RewardsModule public officialRewardsModule;
error OnlyCreatorCanSetRewardsModule();
function setOfficialRewardsModule(RewardsModule officialRewardsModule_) public {
if (msg.sender != creator) revert OnlyCreatorCanSetRewardsModule();
RewardsModule oldOfficialRewardsModule = officialRewardsModule;
officialRewardsModule = officialRewardsModule_;
emit OfficialRewardsModuleSet(oldOfficialRewardsModule, officialRewardsModule_);
}
}
contract Contest is GovernorCountingSimple, GovernorModuleRegistry, GovernorEngagement {
error SortingAndDownvotingCannotBothBeEnabled();
error PayPerVoteMustBeEnabledForAnyoneCanVote();
constructor(
string memory _name,
string memory _prompt,
bytes32 _submissionMerkleRoot,
bytes32 _votingMerkleRoot,
ConstructorArgs memory _constructorArgs
)
Governor(_name, _prompt, _constructorArgs)
GovernorSorting(_constructorArgs.intConstructorArgs.sortingEnabled, _constructorArgs.intConstructorArgs.rankLimit)
GovernorMerkleVotes(_submissionMerkleRoot, _votingMerkleRoot)
{
if (
_constructorArgs.intConstructorArgs.sortingEnabled == 1
&& _constructorArgs.intConstructorArgs.downvotingAllowed == 1
) {
revert SortingAndDownvotingCannotBothBeEnabled();
}
if (_votingMerkleRoot == 0 && _constructorArgs.intConstructorArgs.payPerVote == 0) {
revert PayPerVoteMustBeEnabledForAnyoneCanVote();
}
}
}
