Reinvent lockup

contracts/modules/Experimental/TransferManager/LockupVolumeRestrictionTMFactory.sol → contracts/modules/TransferManager/LockUpTransferManagerFactory.sol

@@ -1,12 +1,12 @@
 pragma solidity ^0.4.24;
 
-import "./../../ModuleFactory.sol";
-import "./LockupVolumeRestrictionTM.sol";
+import "../ModuleFactory.sol";
+import "./LockUpTransferManager.sol";
 
 /**
- * @title Factory for deploying ManualApprovalTransferManager module
+ * @title Factory for deploying LockUpTransferManager module
  */
-contract LockupVolumeRestrictionTMFactory is ModuleFactory {
+contract LockUpTransferManagerFactory is ModuleFactory {
 
     /**
      * @notice Constructor
@@ -19,8 +19,8 @@ contract LockupVolumeRestrictionTMFactory is ModuleFactory {
       ModuleFactory(_polyAddress, _setupCost, _usageCost, _subscriptionCost)
     {
         version = "1.0.0";
-        name = "LockupVolumeRestrictionTM";
-        title = "Lockup Volume Restriction Transfer Manager";
+        name = "LockUpTransferManager";
+        title = "LockUp Transfer Manager";
         description = "Manage transfers using lock ups over time";
         compatibleSTVersionRange["lowerBound"] = VersionUtils.pack(uint8(0), uint8(0), uint8(0));
         compatibleSTVersionRange["upperBound"] = VersionUtils.pack(uint8(0), uint8(0), uint8(0));
@@ -33,10 +33,10 @@ contract LockupVolumeRestrictionTMFactory is ModuleFactory {
     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");
-        LockupVolumeRestrictionTM lockupVolumeRestrictionTransferManager = new LockupVolumeRestrictionTM(msg.sender, address(polyToken));
+        LockUpTransferManager lockUpTransferManager = new LockUpTransferManager(msg.sender, address(polyToken));
         /*solium-disable-next-line security/no-block-members*/
-        emit GenerateModuleFromFactory(address(lockupVolumeRestrictionTransferManager), getName(), address(this), msg.sender, now);
-        return address(lockupVolumeRestrictionTransferManager);
+        emit GenerateModuleFromFactory(address(lockUpTransferManager), getName(), address(this), msg.sender, now);
+        return address(lockUpTransferManager);
     }
 
     /**
@@ -61,7 +61,7 @@ contract LockupVolumeRestrictionTMFactory is ModuleFactory {
      */
     function getTags() external view returns(bytes32[]) {
         bytes32[] memory availableTags = new bytes32[](2);
-        availableTags[0] = "Volume";
+        availableTags[0] = "LockUp";
         availableTags[1] = "Transfer Restriction";
         return availableTags;
     }

migrations/2_deploy_contracts.js

@@ -9,6 +9,7 @@ const EtherDividendCheckpointLogic = artifacts.require('./EtherDividendCheckpoin
 const ERC20DividendCheckpointLogic = artifacts.require('./ERC20DividendCheckpoint.sol')
 const EtherDividendCheckpointFactory = artifacts.require('./EtherDividendCheckpointFactory.sol')
 const ERC20DividendCheckpointFactory = artifacts.require('./ERC20DividendCheckpointFactory.sol')
+const LockUpTransferManagerFactory = artifacts.require('./LockUpTransferManagerFactory.sol')
 const ModuleRegistry = artifacts.require('./ModuleRegistry.sol');
 const ModuleRegistryProxy = artifacts.require('./ModuleRegistryProxy.sol');
 const ManualApprovalTransferManagerFactory = artifacts.require('./ManualApprovalTransferManagerFactory.sol')
@@ -164,6 +165,10 @@ module.exports = function (deployer, network, accounts) {
     // B) Deploy the GeneralTransferManagerFactory Contract (Factory used to generate the GeneralTransferManager contract and this
     // manager attach with the securityToken contract at the time of deployment)
     return deployer.deploy(GeneralTransferManagerFactory, PolyToken, 0, 0, 0, GeneralTransferManagerLogic.address, {from: PolymathAccount});
+  }).then(() => {
+    // C) Deploy the LockUpTransferManagerFactory Contract (Factory used to generate the LockUpTransferManager contract and
+    // this manager attach with the securityToken contract at the time of deployment)
+    return deployer.deploy(LockUpTransferManagerFactory, PolyToken, 0, 0, 0, {from: PolymathAccount});
   }).then(() => {
     // C) Deploy the GeneralPermissionManagerFactory Contract (Factory used to generate the GeneralPermissionManager contract and
     // this manager attach with the securityToken contract at the time of deployment)
@@ -211,6 +216,10 @@ module.exports = function (deployer, network, accounts) {
   }).then(() => {
     // Update all addresses into the registry contract by calling the function updateFromregistry
     return moduleRegistry.updateFromRegistry({from: PolymathAccount});
+  }).then(() => {
+    // D) Register the LockUpTransferManagerFactory in the ModuleRegistry to make the factory available at the protocol level.
+    // So any securityToken can use that factory to generate the LockUpTransferManager contract.
+    return moduleRegistry.registerModule(LockUpTransferManagerFactory.address, {from: PolymathAccount});
   }).then(() => {
     // D) Register the PercentageTransferManagerFactory in the ModuleRegistry to make the factory available at the protocol level.
     // So any securityToken can use that factory to generate the PercentageTransferManager contract.
@@ -249,6 +258,11 @@ module.exports = function (deployer, network, accounts) {
     // contract, Factory should comes under the verified list of factories or those factories deployed by the securityToken issuers only.
     // Here it gets verified because it is deployed by the third party account (Polymath Account) not with the issuer accounts.
     return moduleRegistry.verifyModule(CountTransferManagerFactory.address, true, {from: PolymathAccount});
+  }).then(() => {
+    // F) Once the LockUpTransferManagerFactory registered with the ModuleRegistry contract then for making them accessble to the securityToken
+    // contract, Factory should comes under the verified list of factories or those factories deployed by the securityToken issuers only.
+    // Here it gets verified because it is deployed by the third party account (Polymath Account) not with the issuer accounts.
+    return moduleRegistry.verifyModule(LockUpTransferManagerFactory.address, true, {from: PolymathAccount});
   }).then(() => {
     // G) Once the PercentageTransferManagerFactory registered with the ModuleRegistry contract then for making them accessble to the securityToken
     // contract, Factory should comes under the verified list of factories or those factories deployed by the securityToken issuers only.
@@ -333,6 +347,7 @@ module.exports = function (deployer, network, accounts) {
     ERC20DividendCheckpointLogic:         ${ERC20DividendCheckpointLogic.address}
     EtherDividendCheckpointFactory:       ${EtherDividendCheckpointFactory.address}
     ERC20DividendCheckpointFactory:       ${ERC20DividendCheckpointFactory.address}
+    LockUpTransferManagerFactory:         ${LockUpTransferManagerFactory.address}
     ---------------------------------------------------------------------------------
     `);
     console.log('\n');

test/helpers/createInstances.js

@@ -25,7 +25,7 @@ const GeneralTransferManager = artifacts.require("./GeneralTransferManager.sol")
 const GeneralTransferManagerFactory = artifacts.require("./GeneralTransferManagerFactory.sol");
 const GeneralPermissionManagerFactory = artifacts.require("./GeneralPermissionManagerFactory.sol");
 const CountTransferManagerFactory = artifacts.require("./CountTransferManagerFactory.sol");
-const VolumeRestrictionTransferManagerFactory = artifacts.require("./LockupVolumeRestrictionTMFactory");
+const LockUpTransferManagerFactory = artifacts.require("./LockUpTransferManagerFactory");
 const PreSaleSTOFactory = artifacts.require("./PreSaleSTOFactory.sol");
 const PolyToken = artifacts.require("./PolyToken.sol");
 const PolyTokenFaucet = artifacts.require("./PolyTokenFaucet.sol");
@@ -262,11 +262,11 @@ export async function deployPercentageTMAndVerified(accountPolymath, MRProxyInst
 }
 
 export async function deployLockupVolumeRTMAndVerified(accountPolymath, MRProxyInstance, polyToken, setupCost) {
-    I_VolumeRestrictionTransferManagerFactory = await VolumeRestrictionTransferManagerFactory.new(polyToken, setupCost, 0, 0, { from: accountPolymath });
+    I_VolumeRestrictionTransferManagerFactory = await LockUpTransferManagerFactory.new(polyToken, setupCost, 0, 0, { from: accountPolymath });
     assert.notEqual(
         I_VolumeRestrictionTransferManagerFactory.address.valueOf(),
         "0x0000000000000000000000000000000000000000",
-        "VolumeRestrictionTransferManagerFactory contract was not deployed"
+        "LockUpTransferManagerFactory contract was not deployed"
     );
 
     await registerAndVerifyByMR(I_VolumeRestrictionTransferManagerFactory.address, accountPolymath, MRProxyInstance);