recommended fixes

contracts/modules/TransferManager/LockUpTransferManager.sol

@@ -31,33 +31,33 @@ contract LockUpTransferManager is ITransferManager {
 
     bytes32[] lockupArray;
 
-    event AddNewLockUpToUser(
-        address indexed userAddress,
-        bytes32 indexed lockupName
+    event AddLockUpToUser(
+        address indexed _userAddress,
+        bytes32 indexed _lockupName
     );
 
     event RemoveLockUpFromUser(
-        address indexed userAddress,
-        bytes32 indexed lockupName
+        address indexed _userAddress,
+        bytes32 indexed _lockupName
     );
 
     event ModifyLockUpType(
-        uint256 lockupAmount,
-        uint256 startTime,
-        uint256 lockUpPeriodSeconds,
-        uint256 releaseFrequencySeconds,
-        bytes32 indexed lockupName
+        uint256 _lockupAmount,
+        uint256 _startTime,
+        uint256 _lockUpPeriodSeconds,
+        uint256 _releaseFrequencySeconds,
+        bytes32 indexed _lockupName
     );
 
     event AddNewLockUpType(
-        bytes32 indexed lockupName,
-        uint256 lockupAmount,
-        uint256 startTime,
-        uint256 lockUpPeriodSeconds,
-        uint256 releaseFrequencySeconds
+        bytes32 indexed _lockupName,
+        uint256 _lockupAmount,
+        uint256 _startTime,
+        uint256 _lockUpPeriodSeconds,
+        uint256 _releaseFrequencySeconds
     );
 
-    event RemoveLockUpType(bytes32 indexed lockupName);
+    event RemoveLockUpType(bytes32 indexed _lockupName);
 
     /**
      * @notice Constructor
@@ -344,37 +344,27 @@ contract LockUpTransferManager is ITransferManager {
         }
     }
 
-    /**
-     * @notice Get the length of the lockups array for a specific user address
-     * @param _userAddress Address of the user whose tokens should be locked up
-     */
-    function getLockUpsLength(address _userAddress) public view returns (uint256) {
-        return userToLockups[_userAddress].length;
-    }
-
     /**
      * @notice Get a specific element in a user's lockups array given the user's address and the element index
-     * @param _userAddress Address of the user whose tokens should be locked up
      * @param _lockupName The name of the lockup
      */
-    function getLockUp(address _userAddress, bytes32 _lockupName) public view returns (
+    function getLockUp(bytes32 _lockupName) external view returns (
         uint256 lockupAmount,
         uint256 startTime,
         uint256 lockUpPeriodSeconds,
         uint256 releaseFrequencySeconds,
         uint256 unlockedAmount
     ) {
-        require(
-            userToLockups[_userAddress][userToLockupIndex[_userAddress][_lockupName]] == _lockupName,
-            "User not assosicated with given lockup"
-        );
-        return (
-            lockups[_lockupName].lockupAmount,
-            lockups[_lockupName].startTime,
-            lockups[_lockupName].lockUpPeriodSeconds,
-            lockups[_lockupName].releaseFrequencySeconds,
-            _getUnlockedAmountForLockup(_lockupName)
-        );
+        if (lockups[_lockupName].lockupAmount != 0) {
+            return (
+                lockups[_lockupName].lockupAmount,
+                lockups[_lockupName].startTime,
+                lockups[_lockupName].lockUpPeriodSeconds,
+                lockups[_lockupName].releaseFrequencySeconds,
+                _getUnlockedAmountForLockup(_lockupName)
+            );
+        }
+        return (uint256(0), uint256(0), uint256(0), uint256(0), uint256(0));
     }
 
    /**
@@ -582,7 +572,7 @@ contract LockUpTransferManager is ITransferManager {
         lockupToUserIndex[_lockupName][_userAddress] = lockupToUsers[_lockupName].length;
         userToLockups[_userAddress].push(_lockupName);
         lockupToUsers[_lockupName].push(_userAddress);
-        emit AddNewLockUpToUser(_userAddress, _lockupName);
+        emit AddLockUpToUser(_userAddress, _lockupName);
     }
 
     function _addNewLockUpType(

test/w_lockup_transfer_manager.js

@@ -446,7 +446,7 @@ contract('LockUpTransferManager', accounts => {
                         from: token_owner
                     }
             );
-            assert.equal((tx.logs[0].args.lockupAmount).toNumber(), web3.utils.toWei('12', 'ether'));
+            assert.equal((tx.logs[0].args._lockupAmount).toNumber(), web3.utils.toWei('12', 'ether'));
         });
 
         it("Should fail to add the creation of the lockup where lockupName is already exists", async() => {
@@ -478,8 +478,8 @@ contract('LockUpTransferManager', accounts => {
                         from: token_owner
                     }
             );
-            assert.equal(tx.logs[1].args.userAddress, account_investor1);
-            assert.equal((tx.logs[0].args.lockupAmount).toNumber(), web3.utils.toWei('0.5', 'ether'));
+            assert.equal(tx.logs[1].args._userAddress, account_investor1);
+            assert.equal((tx.logs[0].args._lockupAmount).toNumber(), web3.utils.toWei('0.5', 'ether'));
         });
 
         it("Should allow the creation of a lockup where the lockup amount is prime no", async() => {
@@ -495,8 +495,8 @@ contract('LockUpTransferManager', accounts => {
                         from: token_owner
                     }
             );
-            assert.equal(tx.logs[1].args.userAddress, account_investor1);
-            assert.equal((tx.logs[0].args.lockupAmount).toNumber(), web3.utils.toWei('64951', 'ether'));
+            assert.equal(tx.logs[1].args._userAddress, account_investor1);
+            assert.equal((tx.logs[0].args._lockupAmount).toNumber(), web3.utils.toWei('64951', 'ether'));
         });
 
         it("Should prevent the transfer of tokens in a lockup", async() => {
@@ -517,7 +517,7 @@ contract('LockUpTransferManager', accounts => {
                 }
             );
             await increaseTime(2);
-            let tx = await I_LockUpTransferManager.getLockUp.call(account_investor2, "b_lockup");
+            let tx = await I_LockUpTransferManager.getLockUp.call("b_lockup");
             console.log("Amount get unlocked:", (tx[4].toNumber()));
             await catchRevert(
                 I_SecurityToken.transfer(account_investor1, web3.utils.toWei('1', 'ether'), { from: account_investor2 })
@@ -527,21 +527,21 @@ contract('LockUpTransferManager', accounts => {
         it("Should prevent the transfer of tokens if the amount is larger than the amount allowed by lockups", async() => {
             // wait 20 seconds
             await increaseTime(duration.seconds(20));
-            let tx = await I_LockUpTransferManager.getLockUp.call(account_investor2, "b_lockup");
+            let tx = await I_LockUpTransferManager.getLockUp.call("b_lockup");
             console.log("Amount get unlocked:", (tx[4].toNumber()));
             await catchRevert(
                 I_SecurityToken.transfer(account_investor1, web3.utils.toWei('4', 'ether'), { from: account_investor2 })
             );
         });
 
         it("Should allow the transfer of tokens in a lockup if a period has passed", async() => {
-            let tx = await I_LockUpTransferManager.getLockUp.call(account_investor2, "b_lockup");
+            let tx = await I_LockUpTransferManager.getLockUp.call("b_lockup");
             console.log("Amount get unlocked:", (tx[4].toNumber()));
             await I_SecurityToken.transfer(account_investor1, web3.utils.toWei('1', 'ether'), { from: account_investor2 });
         });
 
         it("Should again transfer of tokens in a lockup if a period has passed", async() => {
-            let tx = await I_LockUpTransferManager.getLockUp.call(account_investor2, "b_lockup");
+            let tx = await I_LockUpTransferManager.getLockUp.call("b_lockup");
             console.log("Amount get unlocked:", (tx[4].toNumber()));
             await I_SecurityToken.transfer(account_investor1, web3.utils.toWei('1', 'ether'), { from: account_investor2 });
         });
@@ -550,7 +550,7 @@ contract('LockUpTransferManager', accounts => {
 
             // wait 20 more seconds + 1 to get rid of same block time
             await increaseTime(duration.seconds(21));
-            let tx = await I_LockUpTransferManager.getLockUp.call(account_investor2, "b_lockup");
+            let tx = await I_LockUpTransferManager.getLockUp.call( "b_lockup");
             console.log("Amount get unlocked:", (tx[4].toNumber()));
             await I_SecurityToken.transfer(account_investor1, web3.utils.toWei('2', 'ether'), { from: account_investor2 });
         });
@@ -682,8 +682,8 @@ contract('LockUpTransferManager', accounts => {
             );
 
             await increaseTime(1);
-            let tx = await I_LockUpTransferManager.getLockUp.call(account_investor3, "c_lockup");
-            let tx2 = await I_LockUpTransferManager.getLockUp.call(account_investor3, "d_lockup");
+            let tx = await I_LockUpTransferManager.getLockUp.call("c_lockup");
+            let tx2 = await I_LockUpTransferManager.getLockUp.call("d_lockup");
             console.log("Total Amount get unlocked:", (tx[4].toNumber()) + (tx2[4].toNumber()));
             await catchRevert(
                 I_SecurityToken.transfer(account_investor2, web3.utils.toWei('2', 'ether'), { from: account_investor3 })
@@ -859,11 +859,7 @@ contract('LockUpTransferManager', accounts => {
                 I_SecurityToken.transfer(account_investor2, web3.utils.toWei('1', 'ether'), { from: account_investor1 })
             );
 
-            // check and get the lockup
-            let lockUpCount = await I_LockUpTransferManager.getLockUpsLength(account_investor1);
-            assert.equal(lockUpCount, 1)
-
-            let lockUp = await I_LockUpTransferManager.getLockUp(account_investor1, "f_lockup");
+            let lockUp = await I_LockUpTransferManager.getLockUp("f_lockup");
             console.log(lockUp);
             // elements in lockup array are uint lockUpPeriodSeconds, uint releaseFrequencySeconds, uint startTime, uint totalAmount
             assert.equal(
@@ -902,7 +898,7 @@ contract('LockUpTransferManager', accounts => {
 
         it("Modify the lockup during the lockup periods", async() => {
             let balance = await I_SecurityToken.balanceOf(account_investor1)
-            let lockUp = await I_LockUpTransferManager.getLockUp(account_investor1, "f_lockup");
+            let lockUp = await I_LockUpTransferManager.getLockUp("f_lockup");
             console.log(lockUp[4].dividedBy(new BigNumber(1).times(new BigNumber(10).pow(18))).toNumber());
             // edit the lockup
             await I_LockUpTransferManager.modifyLockUpType(
@@ -931,7 +927,7 @@ contract('LockUpTransferManager', accounts => {
 
             // removing the lockup type 
             let tx = await I_LockUpTransferManager.removeLockupType("k_lockup", {from: token_owner});
-            assert.equal(web3.utils.toUtf8(tx.logs[0].args.lockupName), "k_lockup");
+            assert.equal(web3.utils.toUtf8(tx.logs[0].args._lockupName), "k_lockup");
 
             // attaching the lockup to a user
 
@@ -944,10 +940,9 @@ contract('LockUpTransferManager', accounts => {
             );
         })
 
-        it("Should succesfully get the lockup - fail because no lockup exist for the user of this name", async() => {
-            await catchRevert(
-                I_LockUpTransferManager.getLockUp(account_investor1, 9)
-            );
+        it("Should succesfully get the non existed lockup value, it will give everything 0", async() => {
+            let data = await I_LockUpTransferManager.getLockUp(9);
+            assert.equal(data[0], 0);
         })
 
         it("Should get configuration function signature", async() => {