etherGC.sol +reputationGC.sol

contracts/globalConstraints/EtherGC.sol

@@ -0,0 +1,84 @@
+pragma solidity 0.5.17;
+
+import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
+import "./GlobalConstraintInterface.sol";
+import "openzeppelin-solidity/contracts/math/SafeMath.sol";
+
+
+/**
+ * @title EtherGC ether constraint per period
+ */
+contract EtherGC {
+    using SafeMath for uint256;
+
+    uint256 public constraintPeriodWindow; //a static window
+    uint256 public amountAllowedPerPeriod;
+    address public avatar;
+    uint256 public latestEthBalance;
+    mapping(uint256=>uint256) public totalAmountSentForPeriods;
+    uint256 public startBlock;
+    address public controller;
+    uint256 public avatarBalanceBefore;
+
+  /**
+   * @dev initialize
+   * @param _avatar the avatar to mint reputation from
+   * @param _constraintPeriodWindow the constraintPeriodWindow in blocks units
+   * @param _amountAllowedPerPeriod the amount of eth to constraint for each period
+   */
+    function initialize(
+        address _avatar,
+        uint256 _constraintPeriodWindow,
+        uint256 _amountAllowedPerPeriod,
+        address _controller
+    )
+    external
+    {
+        require(avatar == address(0), "can be called only one time");
+        require(_avatar != address(0), "avatar cannot be zero");
+        avatar = _avatar;
+        constraintPeriodWindow = _constraintPeriodWindow;
+        amountAllowedPerPeriod = _amountAllowedPerPeriod;
+        latestEthBalance = avatar.balance;
+        startBlock = block.number;
+        controller = _controller;
+    }
+
+    /**
+     * @dev check the constraint before the action.
+     * @return true
+     */
+    function pre(address, bytes32, bytes32) public returns(bool) {
+        require(msg.sender == controller, "only controller is authorize to call");
+        avatarBalanceBefore = avatar.balance;
+        return true;
+    }
+
+    /**
+     * @dev check the allowance of ether sent per period.
+     * @return bool which represents a success
+     */
+    function post(address, bytes32, bytes32) public returns(bool) {
+        require(msg.sender == controller, "only controller is authorize to call");
+        uint256 currentPeriodIndex = (block.number - startBlock)/constraintPeriodWindow;
+        if ((block.number - startBlock) % constraintPeriodWindow > 0) {
+            currentPeriodIndex = currentPeriodIndex.add(1);
+        }
+        if (avatarBalanceBefore >= avatar.balance) {
+            uint256 ethSentAmount = avatarBalanceBefore.sub(avatar.balance);
+            totalAmountSentForPeriods[currentPeriodIndex] =
+            totalAmountSentForPeriods[currentPeriodIndex].add(ethSentAmount);
+            require(totalAmountSentForPeriods[currentPeriodIndex] <= amountAllowedPerPeriod,
+            "exceed the amount allowed");
+        } 
+        return true;
+    }
+
+    /**
+     * @dev when return if this globalConstraints is pre, post or both.
+     * @return CallPhase enum indication  Pre, Post or PreAndPost.
+     */
+    function when() public pure returns(GlobalConstraintInterface.CallPhase) {
+        return GlobalConstraintInterface.CallPhase.PreAndPost;
+    }
+}

test/etherGC.js

@@ -0,0 +1,75 @@
+import * as helpers from './helpers';
+const DAOToken   = artifacts.require("./DAOToken.sol");
+const EtherGC = artifacts.require('./globalConstraints/EtherGC.sol');
+const Controller = artifacts.require("./Controller.sol");
+const Reputation = artifacts.require("./Reputation.sol");
+const Avatar = artifacts.require("./Avatar.sol");
+var constants = require('../test/constants');
+
+
+let reputation, avatar,token,controller,etherGC;
+const setup = async function (permission='0') {
+  var _controller;
+  token  = await DAOToken.new("TEST","TST",0);
+  // set up a reputation system
+  reputation = await Reputation.new();
+  avatar = await Avatar.new('name', token.address, reputation.address);
+  if (permission !== '0'){
+    _controller = await Controller.new(avatar.address,{from:accounts[1],gas: constants.ARC_GAS_LIMIT});
+    await _controller.registerScheme(accounts[0],0,permission,0,{from:accounts[1]});
+    await _controller.unregisterSelf(0,{from:accounts[1]});
+  }
+  else {
+    _controller = await Controller.new(avatar.address,{gas: constants.ARC_GAS_LIMIT});
+  }
+  controller = _controller;
+  await avatar.transferOwnership(controller.address);
+  etherGC = await EtherGC.new();
+  await etherGC.initialize(avatar.address,10,web3.utils.toWei('5', "ether"),controller.address); //10 blocks ,5 eth
+  return _controller;
+};
+
+contract('EtherGC', accounts =>  {
+    it("initialize", async () => {
+      await setup();
+      assert.equal(await etherGC.avatar(),avatar.address);
+      assert.equal(await etherGC.amountAllowedPerPeriod(),web3.utils.toWei('5', "ether"));
+      assert.equal(await etherGC.constraintPeriodWindow(),10);
+    });
+
+  it("send ether check", async () => {
+
+    await setup();
+    try {
+     await etherGC.initialize(avatar.address,20,web3.utils.toWei('5', "ether"),controller.address); //10 blocks ,5 eth
+     assert(false,"cannpt init twice ");
+   }   catch(ex){
+     helpers.assertVMException(ex);
+    }
+    await controller.addGlobalConstraint(etherGC.address,helpers.NULL_HASH,avatar.address);
+    //move 10 ether to avatar
+    await web3.eth.sendTransaction({from:accounts[0],to:avatar.address, value: web3.utils.toWei('10', "ether")});
+    await controller.sendEther(web3.utils.toWei('1', "ether"), accounts[2],avatar.address);
+    await controller.sendEther(web3.utils.toWei('4', "ether"), accounts[2],avatar.address);
+
+    try {
+      await controller.sendEther(web3.utils.toWei('1', "ether"), accounts[2],avatar.address);
+      assert(false,"sendEther should fail due to the etherGC global constraint ");
+    }
+    catch(ex){
+      helpers.assertVMException(ex);
+    }
+    for (var i = 0 ;i< 21;i++) {
+      //increment 21 blocks in ganache
+      await Reputation.new();
+
+    }
+
+    await controller.sendEther(web3.utils.toWei('1', "ether"), accounts[2],avatar.address);
+    await controller.sendEther(web3.utils.toWei('4', "ether"), accounts[2],avatar.address);
+    //send more than 10 eth
+    await web3.eth.sendTransaction({from:accounts[0],to:avatar.address, value: web3.utils.toWei('10', "ether")});
+    await controller.sendEther(web3.utils.toWei('4', "ether"), accounts[2],avatar.address);
+
+    });
+});