Votium

1// SPDX-License-Identifier: MIT
2// Votium Bribe
3
4pragma solidity ^0.8.0;
5
6import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
7import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
8import "@openzeppelin/contracts/utils/math/Math.sol";
9
10import "./Ownable.sol";
11
12contract VotiumBribe is Ownable {
13
14  using SafeERC20 for IERC20;
15
16  /* ========== STATE VARIABLES ========== */
17
18    // accepted tokens registry
19    struct Token {
20      bool whitelist;
21      address distributor;
22    }
23
24    // proposal data
25    struct Proposal {
26      uint256 deadline;
27      uint256 maxIndex;
28    }
29
30    mapping(bytes32 => Proposal) public proposalInfo;  // bytes32 of snapshot IPFS hash id for a given proposal
31    mapping(address => Token) public tokenInfo;        // bribe token registry data
32
33    mapping(bytes32 => bool) public delegationHash;    // approved hashes for EIP1271 delegated vote
34    mapping(address => bool) public approvedTeam;      // for team functions that do not require multi-sig security
35
36    address public feeAddress = 0xe39b8617D571CEe5e75e1EC6B2bb40DdC8CF6Fa3; // Votium multisig
37    uint256 public platformFee = 400;             // 4%
38    uint256 public constant DENOMINATOR = 10000;  // denominates weights 10000 = 100%
39
40    bool public requireWhitelist = true;  // begin with erc20 whitelist in effect
41
42
43
44  /* ========== CONSTRUCTOR ========== */
45
46    constructor() {
47      approvedTeam[msg.sender] = true;
48      approvedTeam[0x540815B1892F888875E800d2f7027CECf883496a] = true;
49    }
50
51  /* ========== PUBLIC FUNCTIONS ========== */
52
53    // Deposit bribe
54    function depositBribe(address _token, uint256 _amount, bytes32 _proposal, uint256 _choiceIndex) public {
55      if(requireWhitelist == true) {
56        require(tokenInfo[_token].whitelist == true, "!whitelist");
57      }
58      require(proposalInfo[_proposal].deadline > block.timestamp, "invalid proposal");
59      require(proposalInfo[_proposal].maxIndex >= _choiceIndex, "invalid choice");
60      uint256 fee = _amount*platformFee/DENOMINATOR;
61      uint256 bribeTotal = _amount-fee;
62      IERC20(_token).safeTransferFrom(msg.sender, feeAddress, fee);
63      if(tokenInfo[_token].distributor == address(0)) {
64        IERC20(_token).safeTransferFrom(msg.sender, address(this), bribeTotal);  // if distributor contract is not set, store in this contract until ready
65      } else {
66        IERC20(_token).safeTransferFrom(msg.sender, tokenInfo[_token].distributor, bribeTotal); // if distributor contract is set, send directly to distributor
67      }
68      emit Bribed(_token, bribeTotal, _proposal, _choiceIndex);
69    }
70
71    // called by vote proxy contract as part of EIP1271 contract signing for delegated votes
72    function isWinningSignature(bytes32 _hash, bytes memory _signature) public view returns (bool) {
73      return delegationHash[_hash];
74    }
75
76  /* ========== APPROVED TEAM FUNCTIONS ========== */
77
78    // initiate proposal for bribes
79    function initiateProposal(bytes32 _proposal, uint256 _deadline, uint256 _maxIndex) public onlyTeam {
80      require(proposalInfo[_proposal].deadline == 0, "exists");
81      require(_deadline > block.timestamp, "invalid deadline");
82      proposalInfo[_proposal].deadline = _deadline;
83      proposalInfo[_proposal].maxIndex = _maxIndex;
84      emit Initiated(_proposal);
85    }
86
87    // approve EIP1271 vote hash for delegated vlCVX
88    function approveDelegationVote(bytes32 _hash) public onlyTeam {
89      delegationHash[_hash] = true;
90    }
91
92    // transfer stored bribes to distributor (only pertains to bribes made before a token distributor has been set)
93    function transferToDistributor(address _token) public onlyTeam {
94      require(tokenInfo[_token].distributor != address(0), "no distributor");
95      uint256 bal = IERC20(_token).balanceOf(address(this));
96      IERC20(_token).safeTransfer(tokenInfo[_token].distributor, bal);
97    }
98
99    // whitelist token
100    function whitelistToken(address _token) public onlyTeam {
101      tokenInfo[_token].whitelist = true;
102      emit Whitelisted(_token);
103    }
104
105    // whitelist multiple tokens
106    function whitelistTokens(address[] memory _tokens) public onlyTeam {
107      for(uint256 i=0;i<_tokens.length;i++) {
108        tokenInfo[_tokens[i]].whitelist = true;
109        emit Whitelisted(_tokens[i]);
110      }
111    }
112
113  /* ========== MUTLI-SIG FUNCTIONS ========== */
114
115    // toggle whitelist requirement
116    function setWhitelistRequired(bool _requireWhitelist) public onlyOwner {
117      requireWhitelist = _requireWhitelist;
118      emit WhitelistRequirement(_requireWhitelist);
119    }
120
121    // update fee address
122    function updateFeeAddress(address _feeAddress) public onlyOwner {
123      feeAddress = _feeAddress;
124    }
125
126    // update fee amount
127    function updateFeeAmount(uint256 _feeAmount) public onlyOwner {
128      require(_feeAmount < 400, "max fee"); // Max fee 4%
129      platformFee = _feeAmount;
130      emit UpdatedFee(_feeAmount);
131    }
132
133    // add or remove address from team functions
134    function modifyTeam(address _member, bool _approval) public onlyOwner {
135      approvedTeam[_member] = _approval;
136      emit ModifiedTeam(_member, _approval);
137    }
138
139    // update token distributor address
140    function updateDistributor(address _token, address _distributor) public onlyOwner {
141      // can be changed for future use in case of cheaper gas options than current merkle approach
142      tokenInfo[_token].distributor = _distributor;
143      emit UpdatedDistributor(_token, _distributor);
144    }
145
146  /* ========== MODIFIERS ========== */
147
148    modifier onlyTeam() {
149      require(approvedTeam[msg.sender] == true, "Team only");
150      _;
151    }
152
153  /* ========== EVENTS ========== */
154
155    event Bribed(address _token, uint256 _amount, bytes32 indexed _proposal, uint256 _choiceIndex);
156    event Initiated(bytes32 _proposal);
157    event Whitelisted(address _token);
158    event WhitelistRequirement(bool _requireWhitelist);
159    event UpdatedFee(uint256 _feeAmount);
160    event ModifiedTeam(address _member, bool _approval);
161    event UpdatedDistributor(address indexed _token, address _distributor);
162
163}