Support multiple module types

contracts/ModuleRegistry.sol

@@ -155,8 +155,18 @@ contract ModuleRegistry is IModuleRegistry, EternalStorage {
         }
         require(getUint(Encoder.getKey('registry', _moduleFactory)) == 0, "Module factory should not be pre-registered");
         IModuleFactory moduleFactory = IModuleFactory(_moduleFactory);
-        uint8 moduleType = moduleFactory.getType();
-        require(moduleType != 0, "Factory moduleType should not equal to 0");
+        //Enforce type uniqueness
+        uint256 i;
+        uint256 j;
+        uint8[] memory moduleTypes = moduleFactory.getTypes();
+        for (i = 1; i < moduleTypes.length; i++) {
+            for (j = 0; j < i; j++) {
+                require(moduleTypes[i] != moduleTypes[j], "Type mismatch");
+            }
+        }
+        require(moduleTypes.length != 0, "Factory must have type");
+        // NB - here we index by the first type of the module.
+        uint8 moduleType = moduleFactory.getTypes()[0];
         set(Encoder.getKey('registry', _moduleFactory), uint256(moduleType));
         set(Encoder.getKey('moduleListIndex', _moduleFactory), uint256(getArrayAddress(Encoder.getKey('moduleList', uint256(moduleType))).length));
         pushArray(Encoder.getKey('moduleList', uint256(moduleType)), _moduleFactory);

contracts/SecurityTokenRegistry.sol

@@ -278,7 +278,7 @@ contract SecurityTokenRegistry is ISecurityTokenRegistry, EternalStorage {
         return true;
     }
 
-    function _tickerStatus(string _ticker) internal returns(bool) {
+    function _tickerStatus(string _ticker) internal view returns(bool) {
         return getBool(Encoder.getKey("registeredTickers_status", _ticker));
     }
 

contracts/interfaces/IModuleFactory.sol

@@ -24,7 +24,7 @@ interface IModuleFactory {
     /**
      * @notice Type of the Module factory
      */
-    function getType() external view returns(uint8);
+    function getTypes() external view returns(uint8[]);
 
     /**
      * @notice Get the name of the Module

contracts/interfaces/ISecurityToken.sol

@@ -33,14 +33,14 @@ interface ISecurityToken {
      * @notice Burn function used to burn the securityToken
      * @param _value No. of tokens that get burned
      */
-    function burn(uint256 _value) external returns (bool success);
+    function burn(uint256 _value) external;
 
     /**
      * @notice Burn function used to burn the securityToken on behalf of someone else
      * @param _from Address for whom to burn tokens
      * @param _value No. of token that get burned
      */
-    function burnFrom(address _from, uint256 _value) external returns (bool success);
+    function burnFrom(address _from, uint256 _value) external;
 
     event Minted(address indexed _to, uint256 _value);
     event Burnt(address indexed _burner, uint256 _value);
@@ -101,7 +101,7 @@ interface ISecurityToken {
      * NB - this length may differ from investorCount if the list has not been pruned of zero-balance investors
      * @return length
      */
-    function getInvestorsLength() external view returns (uint256);
+    function getInvestors() external view returns (address[]);
 
     /**
     * @notice gets current checkpoint ID
@@ -116,12 +116,6 @@ interface ISecurityToken {
     */
     function investors(uint256 _index) external view returns (address);
 
-    /**
-    * @notice gets the number of investors
-    * @return count of investors
-    */
-    function investorCount() external view returns (uint256);
-
     /**
     * @notice allows the owner to withdraw unspent POLY stored by them on the ST.
     * @dev Owner can transfer POLY to the ST which will be used to pay for modules that require a POLY fee.
@@ -180,12 +174,6 @@ interface ISecurityToken {
      */
     function mintMulti(address[] _investors, uint256[] _values) external returns (bool success);
 
-    /**
-     * @notice used to set the token Burner address. It can only be called by the owner
-     * @param _tokenBurner Address of the token burner contract
-     */
-    function setTokenBurner(address _tokenBurner) external;
-
     /**
     * @notice Removes a module attached to the SecurityToken
     * @param _module address of module to archive
@@ -231,7 +219,15 @@ interface ISecurityToken {
      * @param _value amount of tokens to transfer
      * @param _data data attached to the transfer by controller to emit in event
      */
-    function forceTransfer(address _from, address _to, uint256 _value, bytes _data) external returns(bool);
+    function forceTransfer(address _from, address _to, uint256 _value, bytes _data) external;
+
+    /**
+     * @notice Use by a controller to execute a foced burn
+     * @param _from address from which to take tokens
+     * @param _value amount of tokens to transfer
+     * @param _data data attached to the transfer by controller to emit in event
+     */
+    function forceBurn(address _from, uint256 _value, bytes _data) external;
 
     /**
      * @notice Use by the issuer to permanently disable controller functionality
@@ -243,4 +239,9 @@ interface ISecurityToken {
      * @notice Use to get the version of the securityToken
      */
      function getVersion() external view returns(uint8[]);
+
+     /**
+     * @notice gets the investor count
+     */
+     function getInvestorCount() external view returns(uint256);
 }

contracts/libraries/Encoder.sol

@@ -1,30 +1,29 @@
 pragma solidity ^0.4.24;
 
-
 library Encoder {
-    
+
     function getKey(string _key) internal pure returns (bytes32) {
         return bytes32(keccak256(abi.encodePacked(_key)));
     }
 
     function getKey(string _key1, address _key2) internal pure returns (bytes32) {
         return bytes32(keccak256(abi.encodePacked(_key1, _key2)));
     }
-  
+
     function getKey(string _key1, string _key2) internal pure returns (bytes32) {
         return bytes32(keccak256(abi.encodePacked(_key1, _key2)));
     }
-    
+
     function getKey(string _key1, uint256 _key2) internal pure returns (bytes32) {
         return bytes32(keccak256(abi.encodePacked(_key1, _key2)));
     }
-    
+
     function getKey(string _key1, bytes32 _key2) internal pure returns (bytes32) {
         return bytes32(keccak256(abi.encodePacked(_key1, _key2)));
     }
-    
+
     function getKey(string _key1, bool _key2) internal pure returns (bytes32) {
         return bytes32(keccak256(abi.encodePacked(_key1, _key2)));
     }
 
-}
+}

contracts/libraries/TokenLib.sol

@@ -0,0 +1,193 @@
+pragma solidity ^0.4.24;
+
+import "../modules/PermissionManager/IPermissionManager.sol";
+import "./KindMath.sol";
+
+library TokenLib {
+
+    using KindMath for uint256;
+
+    // Struct for module data
+    struct ModuleData {
+        bytes32 name;
+        address module;
+        address moduleFactory;
+        bool isArchived;
+        uint8[] moduleTypes;
+        uint256[] moduleIndexes;
+        uint256 nameIndex;
+    }
+
+    // Structures to maintain checkpoints of balances for governance / dividends
+    struct Checkpoint {
+        uint256 checkpointId;
+        uint256 value;
+    }
+
+    struct InvestorDataStorage {
+        // List of investors (may not be pruned to remove old investors with current zero balances)
+        mapping (address => bool) investorListed;
+        // List of token holders
+        address[] investors;
+        // Total number of non-zero token holders
+        uint256 investorCount;
+    }
+
+    // Emit when Module get archived from the securityToken
+    event ModuleArchived(uint8[] _types, address _module, uint256 _timestamp);
+    // Emit when Module get unarchived from the securityToken
+    event ModuleUnarchived(uint8[] _types, address _module, uint256 _timestamp);
+
+    /**
+    * @notice Archives a module attached to the SecurityToken
+    * @param _moduleData storage data
+    * @param _module address of module to archive
+    */
+    function archiveModule(ModuleData storage _moduleData, address _module) public {
+        require(!_moduleData.isArchived, "Module archived");
+        require(_moduleData.module != address(0), "Module missing");
+        emit ModuleArchived(_moduleData.moduleTypes, _module, now);
+        _moduleData.isArchived = true;
+    }
+
+    /**
+    * @notice Unarchives a module attached to the SecurityToken
+    * @param _moduleData storage data
+    * @param _module address of module to unarchive
+    */
+    function unarchiveModule(ModuleData storage _moduleData, address _module) public {
+        require(_moduleData.isArchived, "Module unarchived");
+        emit ModuleUnarchived(_moduleData.moduleTypes, _module, now);
+        _moduleData.isArchived = false;
+    }
+
+    /**
+     * @notice Validate permissions with PermissionManager if it exists, If no Permission return false
+     * @dev Note that IModule withPerm will allow ST owner all permissions anyway
+     * @dev this allows individual modules to override this logic if needed (to not allow ST owner all permissions)
+     * @param _modules storage data
+     * @param _delegate address of delegate
+     * @param _module address of PermissionManager module
+     * @param _perm the permissions
+     * @return success
+     */
+    function checkPermission(address[] storage _modules, address _delegate, address _module, bytes32 _perm) public view returns(bool) {
+        if (_modules.length == 0) {
+            return false;
+        }
+
+        for (uint8 i = 0; i < _modules.length; i++) {
+            if (IPermissionManager(_modules[i]).checkPermission(_delegate, _module, _perm)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @notice Queries value at a defined checkpoint
+     * @param _checkpoints is array of Checkpoint objects
+     * @param _checkpointId Checkpoint ID to query
+     * @param _currentValue Current value of checkpoint
+     * @return uint256
+     */
+    function getValueAt(Checkpoint[] storage _checkpoints, uint256 _checkpointId, uint256 _currentValue) public view returns(uint256) {
+        //Checkpoint id 0 is when the token is first created - everyone has a zero balance
+        if (_checkpointId == 0) {
+          return 0;
+        }
+        if (_checkpoints.length == 0) {
+            return _currentValue;
+        }
+        if (_checkpoints[0].checkpointId >= _checkpointId) {
+            return _checkpoints[0].value;
+        }
+        if (_checkpoints[_checkpoints.length - 1].checkpointId < _checkpointId) {
+            return _currentValue;
+        }
+        if (_checkpoints[_checkpoints.length - 1].checkpointId == _checkpointId) {
+            return _checkpoints[_checkpoints.length - 1].value;
+        }
+        uint256 min = 0;
+        uint256 max = _checkpoints.length - 1;
+        while (max > min) {
+            uint256 mid = (max + min) / 2;
+            if (_checkpoints[mid].checkpointId == _checkpointId) {
+                max = mid;
+                break;
+            }
+            if (_checkpoints[mid].checkpointId < _checkpointId) {
+                min = mid + 1;
+            } else {
+                max = mid;
+            }
+        }
+        return _checkpoints[max].value;
+    }
+
+    /**
+     * @notice store the changes to the checkpoint objects
+     * @param _checkpoints the affected checkpoint object array
+     * @param _newValue the new value that needs to be stored
+     */
+    function adjustCheckpoints(TokenLib.Checkpoint[] storage _checkpoints, uint256 _newValue, uint256 _currentCheckpointId) public {
+        //No checkpoints set yet
+        if (_currentCheckpointId == 0) {
+            return;
+        }
+        //No new checkpoints since last update
+        if ((_checkpoints.length > 0) && (_checkpoints[_checkpoints.length - 1].checkpointId == _currentCheckpointId)) {
+            return;
+        }
+        //New checkpoint, so record balance
+        _checkpoints.push(
+            TokenLib.Checkpoint({
+                checkpointId: _currentCheckpointId,
+                value: _newValue
+            })
+        );
+    }
+
+    /**
+    * @notice keeps track of the number of non-zero token holders
+    * @param _investorData Date releated to investor metrics
+    * @param _from sender of transfer
+    * @param _to receiver of transfer
+    * @param _value value of transfer
+    * @param _balanceTo balance of the _to address
+    * @param _balanceFrom balance of the _from address
+    */
+    function adjustInvestorCount(InvestorDataStorage storage _investorData, address _from, address _to, uint256 _value, uint256 _balanceTo, uint256 _balanceFrom) public  {
+        if ((_value == 0) || (_from == _to)) {
+            return;
+        }
+        // Check whether receiver is a new token holder
+        if ((_balanceTo == 0) && (_to != address(0))) {
+            _investorData.investorCount = (_investorData.investorCount).add(1);
+        }
+        // Check whether sender is moving all of their tokens
+        if (_value == _balanceFrom) {
+            _investorData.investorCount = (_investorData.investorCount).sub(1);
+        }
+        //Also adjust investor list
+        if (!_investorData.investorListed[_to] && (_to != address(0))) {
+            _investorData.investors.push(_to);
+            _investorData.investorListed[_to] = true;
+        }
+
+    }
+
+     /**
+    * @notice removes addresses with zero balances from the investors list
+    * @param _investorData Date releated to investor metrics
+    * @param _index Index in investor list
+    * NB - pruning this list will mean you may not be able to iterate over investors on-chain as of a historical checkpoint
+    */
+    function pruneInvestors(InvestorDataStorage storage _investorData, uint256 _index) public {
+        _investorData.investorListed[_investorData.investors[_index]] = false;
+        _investorData.investors[_index] = _investorData.investors[_investorData.investors.length - 1];
+        _investorData.investors.length--;
+    }
+
+}