Add fee manager for erc-to-erc bridge in POSDAO chain

REWARD_MANAGEMENT.md

@@ -19,3 +19,13 @@ Fees are calculated and distributed on Home network. Validators will receive nat
 ### Home to Foreign transfer
 Fees are calculated and distributed on Home network. Validators will receive native coins.
 ![erc-native-hometoforeign](https://user-images.githubusercontent.com/4614574/51607508-96f47480-1ef3-11e9-93a1-0f1111793f2a.png)
+
+## ERC-TO-ERC
+
+### Foreign to Home transfer
+Fees are calculated and distributed on Home network. Validators will receive ERC20 tokens.
+![ERC-ERC-ForeignToHome (1)](https://user-images.githubusercontent.com/4614574/56502412-98c8d680-64e8-11e9-8eea-5bcd545d74d9.png)
+
+### Home to Foreign transfer
+Fees are calculated and distributed on Home network. Validators will receive ERC20 tokens.
+![ERC-ERC-HomeToForeign (1)](https://user-images.githubusercontent.com/4614574/56502454-b8f89580-64e8-11e9-84ae-d9a1c229e0c4.png)

contracts/IBlockReward.sol

@@ -6,4 +6,5 @@ interface IBlockReward {
     function mintedTotally() public view returns (uint256);
     function mintedTotallyByBridge(address _bridge) public view returns(uint256);
     function bridgesAllowedLength() external view returns(uint256);
+    function addBridgeTokenFeeReceivers(uint256 _amount) external;
 }

contracts/test/BlockReward.sol

@@ -7,9 +7,12 @@ import "../libraries/SafeMath.sol";
 contract BlockReward is IBlockReward {
     using SafeMath for uint256;
 
+    address[] public validatorList;
     uint256 public mintedCoins = 0;
+    uint256 public feeAmount = 0;
     mapping(bytes32 => uint256) internal uintStorage;
     bytes32 internal constant MINTED_TOTALLY_BY_BRIDGE = "mintedTotallyByBridge";
+    address public token;
 
     function () external payable {
     }
@@ -40,4 +43,40 @@ contract BlockReward is IBlockReward {
         bytes32 hash = keccak256(abi.encode(MINTED_TOTALLY_BY_BRIDGE, _bridge));
         uintStorage[hash] = uintStorage[hash].add(_amount);
     }
+
+    function setValidatorsRewards(address[] _initialValidators) external {
+        validatorList = _initialValidators;
+    }
+
+    function setToken(address _token) external {
+        token = _token;
+    }
+
+    function addBridgeTokenFeeReceivers(uint256 _amount) external {
+        address[] memory receivers = new address[](validatorList.length);
+        uint256[] memory rewards = new uint256[](validatorList.length);
+        feeAmount = _amount;
+        uint256 feePerValidator = _amount.div(validatorList.length);
+
+        uint256 randomValidatorIndex;
+        uint256 diff = _amount.sub(feePerValidator.mul(validatorList.length));
+        if (diff > 0) {
+            randomValidatorIndex = random(validatorList.length);
+        }
+
+        for (uint256 i = 0; i < validatorList.length; i++) {
+            uint256 feeToDistribute = feePerValidator;
+            if (diff > 0 && randomValidatorIndex == i) {
+                feeToDistribute = feeToDistribute.add(diff);
+            }
+            receivers[i] = validatorList[i];
+            rewards[i] = feeToDistribute;
+        }
+
+        require(token.call(abi.encodeWithSignature("mintReward(address[],uint256[])", receivers, rewards)));
+    }
+
+    function random(uint256 _count) public view returns(uint256) {
+        return uint256(blockhash(block.number.sub(1))) % _count;
+    }
 }

contracts/upgradeable_contracts/BaseFeeManager.sol

@@ -9,10 +9,6 @@ import "./FeeTypes.sol";
 contract BaseFeeManager is EternalStorage, FeeTypes {
     using SafeMath for uint256;
 
-    bytes32 public constant REWARD_FOR_TRANSFERRING_FROM_HOME = keccak256(abi.encodePacked("reward-transferring-from-home"));
-
-    bytes32 public constant REWARD_FOR_TRANSFERRING_FROM_FOREIGN = keccak256(abi.encodePacked("reward-transferring-from-foreign"));
-
     event HomeFeeUpdated(uint256 fee);
     event ForeignFeeUpdated(uint256 fee);
 
@@ -43,54 +39,13 @@ contract BaseFeeManager is EternalStorage, FeeTypes {
         return uintStorage[keccak256(abi.encodePacked("foreignFee"))];
     }
 
-    function distributeFeeFromAffirmation(uint256 _fee) external {
-        distributeFeeProportionally(_fee, REWARD_FOR_TRANSFERRING_FROM_FOREIGN);
-    }
+    function distributeFeeFromAffirmation(uint256 _fee) external;
 
-    function distributeFeeFromSignatures(uint256 _fee) external {
-        distributeFeeProportionally(_fee, REWARD_FOR_TRANSFERRING_FROM_HOME);
-    }
+    function distributeFeeFromSignatures(uint256 _fee) external;
 
     function getFeeManagerMode() public pure returns(bytes4);
 
     function random(uint256 _count) public view returns(uint256) {
         return uint256(blockhash(block.number.sub(1))) % _count;
     }
-
-    function distributeFeeProportionally(uint256 _fee, bytes32 _direction) internal {
-        IRewardableValidators validators = rewardableValidatorContract();
-        address[] memory validatorList = validators.validatorList();
-        uint256 feePerValidator = _fee.div(validatorList.length);
-
-        uint256 randomValidatorIndex;
-        uint256 diff = _fee.sub(feePerValidator.mul(validatorList.length));
-        if (diff > 0) {
-            randomValidatorIndex = random(validatorList.length);
-        }
-
-        for (uint256 i = 0; i < validatorList.length; i++) {
-            uint256 feeToDistribute = feePerValidator;
-            if (diff > 0 && randomValidatorIndex == i) {
-                feeToDistribute = feeToDistribute.add(diff);
-            }
-            address rewardAddress = validators.getValidatorRewardAddress(validatorList[i]);
-            onFeeDistribution(rewardAddress, feeToDistribute, _direction);
-        }
-    }
-
-    function onFeeDistribution(address _rewardAddress, uint256 _fee, bytes32 _direction) internal {
-        if (_direction == REWARD_FOR_TRANSFERRING_FROM_FOREIGN) {
-            onAffirmationFeeDistribution(_rewardAddress, _fee);
-        } else {
-            onSignatureFeeDistribution(_rewardAddress, _fee);
-        }
-    }
-
-    function onAffirmationFeeDistribution(address _rewardAddress, uint256 _fee) internal;
-
-    function onSignatureFeeDistribution(address _rewardAddress, uint256 _fee) internal;
-
-    function rewardableValidatorContract() public view returns(IRewardableValidators) {
-        return IRewardableValidators(addressStorage[keccak256(abi.encodePacked("validatorContract"))]);
-    }
 }

contracts/upgradeable_contracts/BlockRewardFeeManager.sol

@@ -0,0 +1,24 @@
+pragma solidity 0.4.24;
+
+import "./BaseFeeManager.sol";
+import "../IBlockReward.sol";
+
+contract BlockRewardFeeManager is BaseFeeManager {
+
+    function distributeFeeFromAffirmation(uint256 _fee) external {
+        distributeFeeFromBlockReward(_fee);
+    }
+
+    function distributeFeeFromSignatures(uint256 _fee) external {
+        distributeFeeFromBlockReward(_fee);
+    }
+
+    function distributeFeeFromBlockReward(uint256 _fee) internal {
+        IBlockReward blockReward = _blockRewardContract();
+        blockReward.addBridgeTokenFeeReceivers(_fee);
+    }
+
+    function _blockRewardContract() internal view returns(IBlockReward) {
+        return IBlockReward(addressStorage[keccak256(abi.encodePacked("blockRewardContract"))]);
+    }
+}

contracts/upgradeable_contracts/ValidatorsFeeManager.sol

@@ -0,0 +1,56 @@
+pragma solidity 0.4.24;
+
+import "./BaseFeeManager.sol";
+import "../IRewardableValidators.sol";
+
+contract ValidatorsFeeManager is BaseFeeManager {
+
+    bytes32 public constant REWARD_FOR_TRANSFERRING_FROM_HOME = keccak256(abi.encodePacked("reward-transferring-from-home"));
+
+    bytes32 public constant REWARD_FOR_TRANSFERRING_FROM_FOREIGN = keccak256(abi.encodePacked("reward-transferring-from-foreign"));
+
+    function distributeFeeFromAffirmation(uint256 _fee) external {
+        distributeFeeProportionally(_fee, REWARD_FOR_TRANSFERRING_FROM_FOREIGN);
+    }
+
+    function distributeFeeFromSignatures(uint256 _fee) external {
+        distributeFeeProportionally(_fee, REWARD_FOR_TRANSFERRING_FROM_HOME);
+    }
+
+    function rewardableValidatorContract() internal view returns(IRewardableValidators) {
+        return IRewardableValidators(addressStorage[keccak256(abi.encodePacked("validatorContract"))]);
+    }
+
+    function distributeFeeProportionally(uint256 _fee, bytes32 _direction) internal {
+        IRewardableValidators validators = rewardableValidatorContract();
+        address[] memory validatorList = validators.validatorList();
+        uint256 feePerValidator = _fee.div(validatorList.length);
+
+        uint256 randomValidatorIndex;
+        uint256 diff = _fee.sub(feePerValidator.mul(validatorList.length));
+        if (diff > 0) {
+            randomValidatorIndex = random(validatorList.length);
+        }
+
+        for (uint256 i = 0; i < validatorList.length; i++) {
+            uint256 feeToDistribute = feePerValidator;
+            if (diff > 0 && randomValidatorIndex == i) {
+                feeToDistribute = feeToDistribute.add(diff);
+            }
+            address rewardAddress = validators.getValidatorRewardAddress(validatorList[i]);
+            onFeeDistribution(rewardAddress, feeToDistribute, _direction);
+        }
+    }
+
+    function onFeeDistribution(address _rewardAddress, uint256 _fee, bytes32 _direction) internal {
+        if (_direction == REWARD_FOR_TRANSFERRING_FROM_FOREIGN) {
+            onAffirmationFeeDistribution(_rewardAddress, _fee);
+        } else {
+            onSignatureFeeDistribution(_rewardAddress, _fee);
+        }
+    }
+
+    function onAffirmationFeeDistribution(address _rewardAddress, uint256 _fee) internal;
+
+    function onSignatureFeeDistribution(address _rewardAddress, uint256 _fee) internal;
+}

contracts/upgradeable_contracts/erc20_to_erc20/FeeManagerErcToErcPOSDAO.sol

@@ -0,0 +1,26 @@
+pragma solidity 0.4.24;
+
+import "../BlockRewardFeeManager.sol";
+
+contract FeeManagerErcToErcPOSDAO is BlockRewardFeeManager {
+
+    function getFeeManagerMode() public pure returns(bytes4) {
+        return bytes4(keccak256(abi.encodePacked("manages-both-directions")));
+    }
+
+    function blockRewardContract() public view returns(address) {
+        return _blockRewardContract();
+    }
+
+    function setBlockRewardContract(address _blockReward) external {
+        require(_blockReward != address(0) && isContract(_blockReward) && (IBlockReward(_blockReward).bridgesAllowedLength() != 0));
+        addressStorage[keccak256(abi.encodePacked("blockRewardContract"))] = _blockReward;
+    }
+
+    function isContract(address _addr) internal view returns (bool)
+    {
+        uint length;
+        assembly { length := extcodesize(_addr) }
+        return length > 0;
+    }
+}