fix: meet pr changes requirements

Author: valentinpollart

contracts/Ballot.sol

@@ -5,11 +5,11 @@ pragma solidity ^0.8.0;
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
-import "./VotingProxy.sol";
+import "./VotingDelegation.sol";
 
 contract Ballot is Ownable, Initializable {
     IERC20Metadata public immutable DPS;
-    VotingProxy public proxy;
+    VotingDelegation public proxy;
 
     struct Vote {
         uint32 choiceIndex;
@@ -18,25 +18,26 @@ contract Ballot is Ownable, Initializable {
 
     string public subject;
     bool public closed;
-    uint32 public tagIndex;
+    string public topic;
     string[] public choices;
     uint256[] public resultStorage;
+    uint256 immutable votingLimit = 25e3 * 1e18;
 
     address[] internal voters;
     mapping(address => Vote) internal votes;
 
     constructor(
         IERC20Metadata _DPS,
-        VotingProxy _proxy
+        VotingDelegation _proxy
     ) {
         require(address(_DPS) != address(0), "Vote: DPS address is zero.");
         DPS = _DPS;
         proxy = _proxy;
     }
 
-    function init(string memory _subject, uint32 _tagIndex, string[] memory _choices) public initializer {
+    function init(string memory _subject, string memory _topic, string[] memory _choices) public initializer {
         subject = _subject;
-        tagIndex = _tagIndex;
+        topic = _topic;
         closed = false;
         choices = _choices;
         resultStorage = new uint256[](choices.length);
@@ -54,9 +55,9 @@ contract Ballot is Ownable, Initializable {
         require(!closed, "Voting: Ballot is closed.");
         require(choices.length > choiceIndex, "Voting: Choice index is too high.");
 
-        require(!proxy.hasDelegated(msg.sender,tagIndex), "Voting: Vote is delegated."); // Verify that voter has not granted proxy to somebody.
+        require(!proxy.hasDelegated(msg.sender,topic), "Voting: Vote is delegated."); // Verify that voter has not granted proxy to somebody.
 
-        require(DPS.balanceOf(msg.sender) >= 25e3 * 1e18, "Voting: Not enough DPS to vote."); // 25k DPS limit
+        require(DPS.balanceOf(msg.sender) >= votingLimit, "Voting: Not enough DPS to vote."); // 25k DPS limit
 
         if(!votes[msg.sender].hasVoted) {
             votes[msg.sender].hasVoted = true;
@@ -66,14 +67,14 @@ contract Ballot is Ownable, Initializable {
         votes[msg.sender].choiceIndex = choiceIndex;
     }
 
-    function closeBallot() external onlyOwner {
+    function close() external onlyOwner {
         require(!closed, "Voting: Ballot already closed.");
 
         closed = true;
 
         for(uint i = 0; i < voters.length; i++) { // if A has granted proxy to B
             address voter = voters[i];
-            resultStorage[votes[voter].choiceIndex] += DPS.balanceOf(voter) + proxy.proxyAmount(voter, tagIndex);
+            resultStorage[votes[voter].choiceIndex] += DPS.balanceOf(voter) + proxy.delegationAmount(voter, topic);
         }
     }
 

contracts/BallotTagManager.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./factories/BallotFactory.sol";
+
+contract VotingDelegation is Ownable {
+    IERC20Metadata public immutable DPS;
+    BallotFactory public ballotFactory;
+
+    struct Grants {
+        mapping(address => uint256) indexes;
+        address[] delegators;
+    }
+
+    uint256 immutable delegatingLimit = 25e3 * 1e18;
+
+    mapping(address => mapping(bytes32 => Grants)) internal delegates; // proxy => tag => voters
+
+    mapping(address => mapping(bytes32 => address)) internal proxyVoters; // voter => tag => proxy
+
+    constructor(IERC20Metadata _DPS) {
+        require(address(_DPS) != address(0), "VotingDelegation: DPS address is zero.");
+
+        DPS = _DPS;
+    }
+
+    function delegate(address to, string memory topic) external {
+        require(DPS.balanceOf(to) >= delegatingLimit || to == address(0), "VotingDelegation: Proxy has not enough DPS.");
+        bytes32 topicHash = keccak256(bytes(topic));
+
+        if(proxyVoters[msg.sender][topicHash] != address(0)) {
+            Grants storage formerDelegateGrants = delegates[proxyVoters[msg.sender][topicHash]][topicHash];
+            uint256 senderIndex = formerDelegateGrants.indexes[msg.sender];
+            formerDelegateGrants.delegators[senderIndex] = formerDelegateGrants.delegators[formerDelegateGrants.delegators.length - 1];
+            formerDelegateGrants.delegators.pop();
+            formerDelegateGrants.indexes[msg.sender] = 0;
+        }
+
+        proxyVoters[msg.sender][topicHash] = to;
+
+        if(to != address(0)) {
+            Grants storage newDelegateGrants = delegates[to][topicHash];
+            newDelegateGrants.indexes[msg.sender] = newDelegateGrants.delegators.length;
+            newDelegateGrants.delegators.push(msg.sender);
+        }
+    }
+
+    function delegationAmount(address voter, string memory topic) public view returns (uint256) {
+        uint256 total;
+        bytes32 topicHash = keccak256(bytes(topic));
+        for(uint32 i = 0; i < delegates[voter][topicHash].delegators.length; i++) {
+            total += DPS.balanceOf(delegates[voter][topicHash].delegators[i]);
+        }
+        return total;
+    }
+
+    function hasDelegated(address voter, string memory topic) external view returns (bool) {
+        return proxyVoters[voter][keccak256(bytes(topic))] != address(0);
+    }
+
+    function delegators(address to, string memory topic) external view returns(address[] memory) {
+        bytes32 topicHash = keccak256(bytes(topic));
+        address[] memory proxies = new address[](delegates[to][topicHash].delegators.length);
+        for(uint32 i = 0; i < delegates[to][topicHash].delegators.length; i++) {
+            proxies[i] = delegates[to][topicHash].delegators[i];
+        }
+        return proxies;
+    }
+
+    function representative(address from, string memory topic) external view returns(address) {
+        return proxyVoters[from][keccak256(bytes(topic))];
+    }
+}

contracts/VotingDelegation.sol

@@ -5,28 +5,22 @@ pragma solidity ^0.8.0;
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/proxy/Clones.sol";
 import "../Ballot.sol";
-import "../VotingProxy.sol";
-import "../BallotTagManager.sol";
+import "../VotingDelegation.sol";
 
 contract BallotFactory is Ownable {
     address[] public ballotAddresses;
     address public implementationAddress;
-    BallotTagManager public ballotTagManager;
 
     event BallotCreated(address ballotAddress);
 
-    constructor(address _implementationAddress, BallotTagManager _ballotTagManager){
+    constructor(address _implementationAddress){
         require(_implementationAddress != address(0), "BallotFactory: Implementation address should not be zero address");
-        require(address(_ballotTagManager) != address(0), "BallotFactory: Ballot tag manager address should not be zero address");
         implementationAddress = _implementationAddress;
-        ballotTagManager = _ballotTagManager;
     }
 
-    function createBallot(string memory subject, uint32 tagIndex, string[] memory _choices) external onlyOwner {
-        require(ballotTagManager.getTags().length > tagIndex, "BallotFactory: Tag index is too high.");
-
+    function createBallot(string memory subject, string memory topic, string[] memory _choices) external onlyOwner {
         address cloneAddress = Clones.clone(implementationAddress);
-        Ballot(cloneAddress).init(subject, tagIndex, _choices);
+        Ballot(cloneAddress).init(subject, topic, _choices);
 
         ballotAddresses.push(cloneAddress);
         emit BallotCreated(cloneAddress);

contracts/VotingProxy.sol

@@ -6,7 +6,7 @@ import "../Ballot.sol";
 
 contract ExposedBallot is Ballot {
 
-    constructor(IERC20Metadata _DPS, VotingProxy _proxy) Ballot(_DPS, _proxy) {}
+    constructor(IERC20Metadata _DPS, VotingDelegation _proxy) Ballot(_DPS, _proxy) {}
 
     struct ResultSample {
         address voter;

contracts/factories/BallotFactory.sol

@@ -3,7 +3,7 @@ import { BigNumber } from '@ethersproject/bignumber';
 import { parseUnits } from '@ethersproject/units';
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
 import { ZERO_ADDRESS } from '../lib/constants';
-import { BallotTagManager, DeepSquare, ExposedBallot, ExposedBallot__factory, ExposedVotingProxy } from '../typings';
+import { DeepSquare, ExposedBallot, ExposedBallot__factory, VotingDelegation } from '../typings';
 import { ERC20Agent } from './testing/ERC20Agent';
 import setup from './testing/setup';
 import setupVoting from './testing/setupVoting';
@@ -14,51 +14,49 @@ describe('Ballot', () => {
   let DPS: DeepSquare;
   let ballot: ExposedBallot;
   let agentDPS: ERC20Agent;
-  let ballotTagManager: BallotTagManager;
-  let votingProxy: ExposedVotingProxy;
+  let votingDelegation: VotingDelegation;
 
   beforeEach(async () => {
     ({ owner, accounts, DPS, agentDPS } = await setup());
-    ({ ballotTagManager, votingProxy } = await setupVoting(owner, DPS));
+    ({ votingDelegation } = await setupVoting(owner, DPS));
 
-    ballot = await new ExposedBallot__factory(owner).deploy(DPS.address, votingProxy.address);
+    ballot = await new ExposedBallot__factory(owner).deploy(DPS.address, votingDelegation.address);
   });
 
   describe('constructor', () => {
     it('should revert if the DPS contract is the zero address', async () => {
-      await expect(new ExposedBallot__factory(owner).deploy(ZERO_ADDRESS, votingProxy.address)).to.be.revertedWith(
+      await expect(new ExposedBallot__factory(owner).deploy(ZERO_ADDRESS, votingDelegation.address)).to.be.revertedWith(
         'Vote: DPS address is zero.',
       );
     });
   });
 
   describe('init', () => {
     it('should initialize ballot state variables', async () => {
-      await ballot.init('foo', BigNumber.from(0), ['bar', 'baz']);
+      await ballot.init('foo', 'bar', ['baz', 'qux']);
       expect(await ballot.subject()).to.equals('foo');
-      expect(await ballot.tagIndex()).to.equals(BigNumber.from(0));
-      expect(await ballot.getChoices()).to.deep.equals(['bar', 'baz']);
+      expect(await ballot.topic()).to.equals('bar');
+      expect(await ballot.getChoices()).to.deep.equals(['baz', 'qux']);
       expect(await ballot.getResults()).to.deep.equals([BigNumber.from(0), BigNumber.from(0)]);
     });
   });
 
   describe('vote', () => {
     beforeEach(async () => {
-      await ballotTagManager.addTag('foo');
-      await ballot.init('foo', BigNumber.from(0), ['bar', 'baz']);
+      await ballot.init('foo', 'qux', ['bar', 'baz']);
     });
     it('should throw if ballot is closed', async () => {
-      await ballot.closeBallot();
+      await ballot.close();
       await expect(ballot.connect(accounts[0]).vote(BigNumber.from(0))).to.revertedWith('Voting: Ballot is closed.');
     });
     it('should throw if proposal does not exist', async () => {
       await expect(ballot.connect(accounts[0]).vote(BigNumber.from(2))).to.revertedWith(
         'Voting: Choice index is too high.',
       );
     });
-    it('should throw if voter has granted proxy on the tag', async () => {
+    it('should throw if voter has granted proxy on the topic', async () => {
       await agentDPS.transfer(accounts[1], 25000, 18);
-      await votingProxy.connect(accounts[0]).grantProxy(accounts[1].address, BigNumber.from(0));
+      await votingDelegation.connect(accounts[0]).delegate(accounts[1].address, 'qux');
       await expect(ballot.connect(accounts[0]).vote(BigNumber.from(0))).to.revertedWith('Voting: Vote is delegated.');
     });
     it('should throw if voter has less than 25k DPS', async () => {
@@ -77,21 +75,20 @@ describe('Ballot', () => {
 
   describe('closeBallot', async () => {
     beforeEach(async () => {
-      await ballotTagManager.addTag('foo');
-      await ballot.init('foo', BigNumber.from(0), ['bar', 'baz']);
+      await ballot.init('foo', 'qux', ['bar', 'baz']);
     });
     it('should throw if ballot is not closed', async () => {
-      await ballot.closeBallot();
-      await expect(ballot.closeBallot()).to.revertedWith('Voting: Ballot already closed.');
+      await ballot.close();
+      await expect(ballot.close()).to.revertedWith('Voting: Ballot already closed.');
     });
     it('should show results', async () => {
       await agentDPS.transfer(accounts[0], 25000, 18);
       await agentDPS.transfer(accounts[1], 25000, 18);
       await agentDPS.transfer(accounts[2], 25000, 18);
-      await votingProxy.connect(accounts[2]).grantProxy(accounts[1].address, BigNumber.from(0));
+      await votingDelegation.connect(accounts[2]).delegate(accounts[1].address, 'qux');
       await ballot.connect(accounts[0]).vote(BigNumber.from(0));
       await ballot.connect(accounts[1]).vote(BigNumber.from(1));
-      await ballot.closeBallot();
+      await ballot.close();
       expect(await ballot.getResults()).to.deep.equals([parseUnits('25000', 18), parseUnits('50000', 18)]);
     });
   });