Single Trade Volume Restriction

contracts/modules/TransferManager/SingleTradeVolumeRestrictionManager.sol

@@ -0,0 +1,111 @@
+pragma solidity ^0.4.24;
+import "./ITransferManager.sol";
+
+/////////////////////
+// Module permissions
+/////////////////////
+//                           Owner       ADMIN
+// changeGlobalLimit           X           X
+// addExemptWallet             X           X
+// removeExemptWallet          X           X
+// setTransferLimitForWallet   X           X
+// removeTransferLimitForWallet X          X
+
+contract SingleTradeVolumeRestrictionManager is ITransferManager {
+  using SafeMath for uint256;
+
+  bool public globalTransferLimitInPercentage;
+
+  uint256 public globalTransferLimit;
+
+  mapping(address=>bool) public exemptWallets;
+
+  mapping(address => bool) public specialTransferLimitWallets;
+
+  mapping(address => uint) public specialTransferLimits;
+
+  bytes32 constant public ADMIN = "ADMIN";
+
+  constructor(address _securityToken, address _polyAddress) public
+  IModule(_securityToken, _polyAddress)
+  {
+
+  }
+
+  function verifyTransfer(address _from, address _to, uint256 _amount, bool /* _isTransfer */) public returns(Result) {
+    bool validTransfer;
+
+    if(paused) {
+      return Result.NA;
+    }
+
+    if(exemptWallets[_from]) return Result.NA;
+
+    if(specialTransferLimitWallets[_from]) {
+      if(globalTransferLimitInPercentage) {
+        validTransfer = (_amount.mul(100).div(ISecurityToken(securityToken).totalSupply())) <= specialTransferLimits[_from];
+      } else {
+        validTransfer = _amount <= specialTransferLimits[_from];
+      }
+    } else {
+      if(globalTransferLimitInPercentage) {
+        validTransfer = (_amount.mul(100).div(ISecurityToken(securityToken).totalSupply())) <= globalTransferLimit;
+      } else {
+        validTransfer = _amount <= globalTransferLimit;
+      }
+    }
+
+    if(validTransfer) return Result.NA;
+    return Result.INVALID;
+  }
+
+  function configure(bool _globalTransferLimitInPercentage, uint256 _globalTransferLimit) public onlyFactory {
+    globalTransferLimitInPercentage = _globalTransferLimitInPercentage;
+    changeGlobalLimit(_globalTransferLimit);
+  }
+
+  function changeGlobalLimit(uint256 _newGlobalTransferLimit) public withPerm(ADMIN) {
+    if(globalTransferLimitInPercentage) {
+      require(_newGlobalTransferLimit <= 100);
+    }
+    globalTransferLimit = _newGlobalTransferLimit;
+  }
+
+  function addExemptWallet(address _walletAddress) public withPerm(ADMIN) {
+    require(_walletAddress != address(0));
+    exemptWallets[_walletAddress] = true;
+  }
+
+  function removeExemptWallet(address _walletAddress) public withPerm(ADMIN) {
+    require(_walletAddress != address(0));
+    exemptWallets[_walletAddress] = false;
+  }
+
+  function setTransferLimitForWallet(address _walletAddress, uint _transferLimit) public withPerm(ADMIN) {
+    if(globalTransferLimitInPercentage) {
+      require(_transferLimit <= 100);
+    }
+    specialTransferLimitWallets[_walletAddress] = true;
+    specialTransferLimits[_walletAddress] = _transferLimit;
+  }
+
+  function removeTransferLimitForWallet(address _walletAddress) public withPerm(ADMIN) {
+    require(specialTransferLimitWallets[_walletAddress]);
+    specialTransferLimitWallets[_walletAddress] = false;
+    specialTransferLimits[_walletAddress] = 0;
+  }
+
+  /**
+   * @notice This function returns the signature of configure function
+   */
+  function getInitFunction() public pure returns (bytes4) {
+      return bytes4(keccak256("configure(bool, uint256)"));
+  }
+
+  // TO IMPLEMENT
+  function getPermissions() public view returns(bytes32[]) {
+    bytes32[] memory allPermissions = new bytes32[](1);
+    allPermissions[0] = ADMIN;
+    return allPermissions;
+  }
+}

contracts/modules/TransferManager/SingleTradeVolumeRestrictionManagerFactory.sol

@@ -0,0 +1,80 @@
+pragma solidity ^0.4.24;
+
+import "../../interfaces/IModuleFactory.sol";
+import "./SingleTradeVolumeRestrictionManager.sol";
+contract SingleTradeVolumeRestrictionFactory is IModuleFactory {
+
+  /**
+   * @notice Constructor
+   * @param _polyAddress Address of the polytoken
+   * @param _setupCost Setup cost of the module
+   * @param _usageCost Usage cost of the module
+   * @param _subscriptionCost Subscription cost of the module
+   */
+  constructor(address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost) public
+  IModuleFactory(_polyAddress, _setupCost, _usageCost, _subscriptionCost)
+  {
+
+  }
+
+  /**
+   * @notice used to launch the Module with the help of factory
+   * @return address Contract address of the Module
+   */
+  function deploy(bytes _data) external returns(address) {
+      if (setupCost > 0)
+          require(polyToken.transferFrom(msg.sender, owner, setupCost), "Failed transferFrom because of sufficent Allowance is not provided");
+      SingleTradeVolumeRestrictionManager singleTradeVolumeRestrictionManager = new SingleTradeVolumeRestrictionManager(msg.sender, address(polyToken));
+      require(getSig(_data) == singleTradeVolumeRestrictionManager.getInitFunction(), "Provided data is not valid");
+      require(address(singleTradeVolumeRestrictionManager).call(_data), "Un-successfull call");
+      emit LogGenerateModuleFromFactory(address(singleTradeVolumeRestrictionManager), getName(), address(this), msg.sender, now);
+      return address(singleTradeVolumeRestrictionManager);
+  }
+
+  /**
+   * @notice Type of the Module factory
+   */
+  function getType() public view returns(uint8) {
+      return 2;
+  }
+
+  /**
+   * @notice Get the name of the Module
+   */
+  function getName() public view returns(bytes32) {
+      return "SingleTradeVolumeRestriction";
+  }
+
+  /**
+   * @notice Get the description of the Module
+   */
+  function getDescription() public view returns(string) {
+      return "Imposes volume restriction on a single trade";
+  }
+
+  /**
+   * @notice Get the title of the Module
+   */
+  function getTitle() public  view returns(string) {
+      return "Single Trade Volume Restriction";
+  }
+
+  /**
+   * @notice Get the Instructions that help to use the module
+   */
+  function getInstructions() public view returns(string) {
+      return "Allows an issuer to impose volume restriction on a single trade";
+  }
+
+  /**
+   * @notice Get the tags related to the module factory
+   */
+  function getTags() public view returns(bytes32[]) {
+      bytes32[] memory availableTags = new bytes32[](3);
+      availableTags[0] = "Single Trade";
+      availableTags[1] = "Transfer";
+      availableTags[2] = "Volume";
+      return availableTags;
+  }
+
+}