Merge pull request #6 from 1Hive/proposal-vote-check

[feat] Proposal vote check

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "lib/allo-v2"]
 	path = lib/allo-v2
 	url = https://github.com/allo-protocol/allo-v2
+[submodule "lib/safe-contracts"]
+	path = lib/safe-contracts
+	url = https://github.com/safe-global/safe-contracts

apps/web/next.config.js

@@ -1,6 +1,9 @@
 /** @type {import('next').NextConfig} */
 module.exports = {
   reactStrictMode: true,
+  experimental:{
+    appDir: true,
+  },
   webpack: (config) => {
     config.externals.push("pino-pretty", "lokijs", "encoding");
     return config;

apps/web/package.json

@@ -4,9 +4,9 @@
   "private": true,
   "scripts": {
     "dev": "next dev",
-    "build": "next build",
+    "build_": "next build",
     "start": "next start",
-    "lint": "next lint"
+    "lint_": "next lint"
   },
   "dependencies": {
     "@headlessui/react": "^1.7.17",

foundry.toml

@@ -1,6 +1,6 @@
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#default-profile
 [profile.default]
-solc-version = "0.8.19"
+# solc-version = "0.8.19"
 src = 'pkg/contracts/src'
 test = 'pkg/contracts/test'
 out = 'pkg/contracts/out'

pkg/contracts/src/CVStrategy.sol

@@ -25,6 +25,10 @@ contract CVStrategy is BaseStrategy, IWithdrawMember {
     error NotEnoughPointsToSupport(uint256 pointsSupport, uint256 pointsBalance);
     error TokenCannotBeZero();
     error ProposalSupportDuplicated(uint256 _proposalId, uint256 index);
+    /*|--------------------------------------------|*/
+    /*|              CUSTOM EVENTS                 |*/
+    /*|--------------------------------------------|*/
+    event InitializedCV(uint256 poolId, bytes data);
     /*|--------------------------------------------|*o
     /*|              STRUCTS/ENUMS                 |*/
     /*|--------------------------------------------|*/
@@ -125,7 +129,7 @@ contract CVStrategy is BaseStrategy, IWithdrawMember {
         weight = ip.weight;
         minThresholdStakePercentage = ip.minThresholdStakePercentage;
 
-        emit Initialized(_poolId, _data);
+        emit InitializedCV(_poolId, _data);
     }
     /*|--------------------------------------------|*/
     /*|                 FALLBACK                  |*/
@@ -442,8 +446,15 @@ contract CVStrategy is BaseStrategy, IWithdrawMember {
             uint256 stakedAmount = convertPctToTokens(stakedPointsPct);
             console.log("stakedAmount", stakedAmount);
             proposal.voterStake[_sender] = stakedAmount;
-            proposal.stakedAmount += proposal.voterStake[_sender];
-
+            // proposal.stakedAmount += stakedAmount;
+            // uint256 diff =_diffStakedTokens(previousStakedAmount, stakedAmount);
+            if (previousStakedAmount <= stakedAmount) {
+                totalStaked += stakedAmount - previousStakedAmount;
+                proposal.stakedAmount += stakedAmount - previousStakedAmount;
+            } else {
+                totalStaked -= previousStakedAmount - stakedAmount;
+                proposal.stakedAmount -= previousStakedAmount - stakedAmount;
+            }
             //@todo: should emit event
             if (proposal.blockLast == 0) {
                 proposal.blockLast = block.number;
@@ -482,7 +493,7 @@ contract CVStrategy is BaseStrategy, IWithdrawMember {
         //        @audit-ok they use 2^128 as the container for the result of the _pow function
 
         //        uint256 atTWO_128 = _pow((decay << 128).div(D), t);
-        uint256 atTWO_128 = ((decay << 128) / D) ** t;
+        uint256 atTWO_128 = _pow((decay << 128) / D, t);
         // solium-disable-previous-line
         // conviction = (atTWO_128 * _lastConv + _oldAmount * D * (2^128 - atTWO_128) / (D - aD) + 2^127) / 2^128
         //        return (atTWO_128.mul(_lastConv).add(_oldAmount.mul(D).mul(TWO_128.sub(atTWO_128)).div(D - decay))).add(TWO_127)
@@ -512,7 +523,7 @@ contract CVStrategy is BaseStrategy, IWithdrawMember {
         uint256 funds = poolAmount;
         //        require(maxRatio.mul(funds) > _requestedAmount.mul(D), ERROR_AMOUNT_OVER_MAX_RATIO);
         // console.log("maxRatio", maxRatio);
-        // console.log("funds", funds);
+        // console.log("funds/poolAmount", funds);
         // console.log("_requestedAmount", _requestedAmount);
         // console.log("D", D);
         // console.log("maxRatio * funds", maxRatio * funds);
@@ -530,7 +541,10 @@ contract CVStrategy is BaseStrategy, IWithdrawMember {
         //        _threshold =
         //            ((weight << 128).div(D).div(denom.mul(denom) >> 64)).mul(D).div(D.sub(decay)).mul(_totalStaked()) >> 64;
         //        _threshold = (((weight << 128) / D) / (denom.mul(denom) >> 64)) * D / (D - decay) * (_totalStaked()) >> 64;
-        _threshold = ((weight * 2 ** 128 / D / (denom * denom >> 64)) * D / (D - decay) * _totalStaked()) >> 64;
+        // _threshold = ((weight * 2 ** 128 / D / (denom * denom >> 64)) * D / (D - decay) * _totalStaked()) >> 64;
+
+        // _threshold = (  (weight << 128).div(D).div(denom.mul(denom) >> 64)).mul(D).div(D.sub(decay)).mul(_totalStaked()) >> 64;
+        _threshold = ((((((weight << 128) / D) / ((denom * denom) >> 64)) * D) / (D - decay)) * _totalStaked()) >> 64;
         // console.log("_threshold", _threshold);
     }
 
@@ -596,11 +610,12 @@ contract CVStrategy is BaseStrategy, IWithdrawMember {
         if (address(registryGardens.gardenToken()) == address(0)) {
             revert TokenCannotBeZero();
         }
-        // console.log("totalStaked", totalStaked);
         // console.log("registryGardens.gardenToken.totalSupply()", registryGardens.gardenToken().totalSupply());
         // console.log("minThresholdStakePercentage", minThresholdStakePercentage);
         uint256 minTotalStake =
             (registryGardens.gardenToken().totalSupply() * minThresholdStakePercentage) / ONE_HUNDRED_PERCENT;
+        // console.log("minTotalStake", minTotalStake);
+        // console.log("totalStaked", totalStaked);
         return totalStaked < minTotalStake ? minTotalStake : totalStaked;
     }
 }

pkg/contracts/src/RegistryGardens.sol

@@ -2,49 +2,50 @@
 pragma solidity ^0.8.19;
 
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/access/AccessControl.sol";
 import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
 import {IAllo, Metadata} from "allo-v2-contracts/core/interfaces/IAllo.sol";
 import {IRegistry} from "allo-v2-contracts/core/interfaces/IRegistry.sol";
-import {ISafe} from "./interfaces/ISafe.sol";
 
-contract RegistryGardens is ReentrancyGuard {
-
+import {Safe} from "safe-contracts/contracts/Safe.sol";
+
+contract RegistryGardens is ReentrancyGuard, AccessControl {
+    /*|--------------------------------------------|*/
+    /*|                 ROLES                      |*/
+    /*|--------------------------------------------|*/
+    bytes32 public constant COUNCIL_MEMBER_CHANGE = keccak256("COUNCIL_MEMBER_CHANGE");
     /*|--------------------------------------------|*/
     /*|                 EVENTS                     |*/
     /*|--------------------------------------------|*/
+
     event StrategyAdded(address _strategy);
     event StrategyRemoved(address _strategy);
     event MemberRegistered(address _member, uint256 _amountStaked);
     event MemberUnregistered(address _member, uint256 _amountReturned);
     event StakeAmountUpdated(address _member, uint256 _newAmount);
-    event CouncilMemberSet(address [] _councilMembers);
     event CouncilSafeSet(address _safe);
+    event CouncilSafeChangeStarted(address _safeOwner, address _newSafeOwner);
     event ProtocolFeeUpdated(uint256 _newFee);
     event AlloSet(address _allo);
     /*|--------------------------------------------|*/
     /*|              MODIFIERS                     |*/
     /*|--------------------------------------------|*/
+
     modifier onlyCouncilMember() {
-        if(!isCouncilMember(msg.sender)) {
+        if (!hasRole(COUNCIL_MEMBER_CHANGE, msg.sender)) {
             revert UserNotInCouncil();
         }
         _;
     }
 
-    modifier onlyRegistryMember(){
-        if(!isMember(msg.sender)) {
-        revert UserNotInRegistry();
-        } 
-        _;
-    }
-
-    modifier onlyGardenOwner(){
-        if(msg.sender!=gardenOwner) {
-            revert UserNotGardenOwner();
+    modifier onlyRegistryMember() {
+        if (!isMember(msg.sender)) {
+            revert UserNotInRegistry();
         }
         _;
     }
 
+
     /*|--------------------------------------------|*/
     /*|              CUSTOM ERRORS                 |*/
     /*|--------------------------------------------|*/
@@ -54,7 +55,8 @@ contract RegistryGardens is ReentrancyGuard {
     error UserNotInRegistry();
     error UserNotGardenOwner();
     error StrategyExists();
-
+    error CallerIsNotNewOnwer();
+
     /*|--------------------------------------------|*o
     /*|              STRUCTS/ENUMS                 |*/
     /*|--------------------------------------------|*/
@@ -71,6 +73,7 @@ contract RegistryGardens is ReentrancyGuard {
         uint256 _protocolFee;
         uint256 _nonce;
         Metadata _metadata;
+        address payable _councilSafe;
     }
 
     //TODO: can change to uint32 with optimized storage order
@@ -81,60 +84,79 @@ contract RegistryGardens is ReentrancyGuard {
     IERC20 public gardenToken;
     uint256 public protocolFee;
     string private covenantIpfsHash;
-    address private gardenOwner;
     bytes32 public profileId;
 
-    ISafe public councilSafe;
-    mapping(address => bool) public councilMembers;
+    address payable public pendingCouncilSafe;
+    Safe public councilSafe;
 
     mapping(address => bool) public tribunalMembers;
 
     mapping(address => Member) public addressToMemberInfo;
     mapping(address => bool) public enabledStrategies;
 
-    constructor() {}
+    constructor() {
+        // _grantRole(DEFAULT_ADMIN_ROLE, address(this));
+        _setRoleAdmin(COUNCIL_MEMBER_CHANGE, DEFAULT_ADMIN_ROLE);
+    }
 
     function initialize(RegistryGardens.InitializeParams memory params) public {
         allo = IAllo(params._allo);
         gardenToken = params._gardenToken;
         minimumStakeAmount = params._minimumStakeAmount;
         protocolFee = params._protocolFee;
-        gardenOwner = msg.sender;
+        if (params._councilSafe == address(0)) {
+            revert AddressCannotBeZero();
+        }
+        councilSafe = Safe(params._councilSafe);
+        _grantRole(COUNCIL_MEMBER_CHANGE, params._councilSafe);
+
+        // gardenOwner = msg.sender; //@todo: RegistryFactory is the onwer of that contract, that need be able to change the owner
+        // gardenOwner = params.owner; //@todo: check if address(0) is a valid owner
         registry = IRegistry(allo.getRegistry());
         address[] memory initialmembers = new address[](0);
         profileId = registry.createProfile(params._nonce, communityName, params._metadata, msg.sender, initialmembers);
     }
 
-    function setCouncilMembers(address[] memory _members) public {}
-
-    function addStrategy(address _newStrategy) public onlyRegistryMember{        
+    function addStrategy(address _newStrategy) public onlyRegistryMember {
         if (enabledStrategies[_newStrategy]) {
             revert StrategyExists();
         }
         enabledStrategies[_newStrategy] = true;
         emit StrategyAdded(_newStrategy);
     }
+
     function revertZeroAddress(address _address) internal pure {
-        if(_address == address(0)) revert AddressCannotBeZero();
+        if (_address == address(0)) revert AddressCannotBeZero();
     }
-    function removeStrategy(address _strategy) public onlyCouncilMember{
+
+    function removeStrategy(address _strategy) public onlyCouncilMember {
         revertZeroAddress(_strategy);
         enabledStrategies[_strategy] = false;
         emit StrategyRemoved(_strategy);
-
     }
-    function setAllo(address _allo) public {
 
+    function setAllo(address _allo) public {
         allo = IAllo(_allo);
         emit AlloSet(_allo);
     }
 
-    function setCouncilSafe(address _safe) public {
-        require(msg.sender == gardenOwner, "Only the owner can call this method.");
-        councilSafe = ISafe(_safe);
-        emit CouncilSafeSet(_safe);
+    function setCouncilSafe(address payable _safe) public onlyCouncilMember {
+        pendingCouncilSafe = _safe;
+        emit CouncilSafeChangeStarted(address(councilSafe), pendingCouncilSafe);
+    }
+
+    function _changeCouncilSafe() internal {
+        councilSafe = Safe(pendingCouncilSafe);
+        delete pendingCouncilSafe;
+        emit CouncilSafeSet(pendingCouncilSafe);
     }
 
+    function acceptCouncilSafe() public {
+        if (msg.sender != pendingCouncilSafe){
+            revert CallerIsNotNewOnwer();
+        }
+        _changeCouncilSafe();
+    }
 
     function isMember(address _member) public view returns (bool _isMember) {
         Member memory newMember = addressToMemberInfo[_member];
@@ -147,18 +169,19 @@ contract RegistryGardens is ReentrancyGuard {
         Member storage newMember = addressToMemberInfo[msg.sender];
         require(
             //If fee percentage => minimumStakeAmount*protocolFee/100
-            gardenToken.balanceOf(msg.sender) >= minimumStakeAmount+ protocolFee,
+            gardenToken.balanceOf(msg.sender) >= minimumStakeAmount + protocolFee,
             "[Registry]: Amount staked must be greater than minimum staked amount"
         );
-        if(newMember.stakedAmount>= minimumStakeAmount){revert("already Staked");}
+        if (newMember.stakedAmount >= minimumStakeAmount) revert("already Staked");
         //Check if already member
         newMember.isRegistered = true;
         newMember.stakedAmount = minimumStakeAmount;
         gardenToken.transferFrom(msg.sender, address(this), minimumStakeAmount);
         emit MemberRegistered(msg.sender, minimumStakeAmount);
     }
     //Check use of payable and msg.value
-    function modifyStakeAmount(uint256 newTotalAmount) public payable nonReentrant onlyRegistryMember{
+
+    function modifyStakeAmount(uint256 newTotalAmount) public payable nonReentrant onlyRegistryMember {
         Member storage member = addressToMemberInfo[msg.sender];
         uint256 oldAmount = member.stakedAmount;
         member.stakedAmount = newTotalAmount;
@@ -171,30 +194,32 @@ contract RegistryGardens is ReentrancyGuard {
             gardenToken.transferFrom(address(this), msg.sender, oldAmount - newTotalAmount);
         }
 
-        emit StakeAmountUpdated(msg.sender,newTotalAmount);
+        emit StakeAmountUpdated(msg.sender, newTotalAmount);
     }
 
     function getBasisStakedAmount() external view returns (uint256) {
         return minimumStakeAmount;
     }
 
-    function updateProtocolFee(uint256 _newProtocolFee) public{
-        if(!isCouncilMember(msg.sender)) {
-            revert("Must be in council safe");
-        }
+    function setBasisStakedAmount(uint256 _newAmount) external onlyCouncilMember {
+        minimumStakeAmount = _newAmount;
+    }
+
+    function updateProtocolFee(uint256 _newProtocolFee) public onlyCouncilMember {
         protocolFee = _newProtocolFee;
         emit ProtocolFeeUpdated(_newProtocolFee);
     }
     //function updateMinimumStake()
+
     function isCouncilMember(address _member) public view returns (bool) {
-        return councilMembers[_member];
+        return hasRole(COUNCIL_MEMBER_CHANGE, _member);
     }
 
     function unregisterMember(address _member) public nonReentrant {
         require(isMember(_member) || isCouncilMember(msg.sender), "[Registry]: Must be active member to unregister");
         Member memory member = addressToMemberInfo[msg.sender];
         delete addressToMemberInfo[msg.sender];
-        gardenToken.transfer( msg.sender, member.stakedAmount);
+        gardenToken.transfer(msg.sender, member.stakedAmount);
         emit MemberUnregistered(msg.sender, member.stakedAmount);
     }
 }