removed bugs and fixed lint

contracts/mainnet/connectors/compound-import/events.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.7.6;
 pragma experimental ABIEncoderV2;
 

contracts/mainnet/connectors/compound-import/helpers.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.7.6;
 
 import { DSMath } from "../../common/math.sol";
@@ -6,26 +7,28 @@ import { TokenInterface, AccountInterface } from "../../common/interfaces.sol";
 import { ComptrollerInterface, CompoundMappingInterface, CETHInterface, CTokenInterface } from "./interface.sol";
 
 abstract contract Helpers is DSMath, Basic {
-
 	/**
 	 * @dev Compound CEth
 	 */
-    CETHInterface internal constant cEth = CETHInterface(0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5);
+	CETHInterface internal constant cEth =
+		CETHInterface(0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5);
 
 	/**
 	 * @dev Compound Comptroller
 	 */
-    ComptrollerInterface internal constant troller = ComptrollerInterface(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
+	ComptrollerInterface internal constant troller =
+		ComptrollerInterface(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
 
 	/**
 	 * @dev Compound Mapping
 	 */
-    CompoundMappingInterface internal constant compMapping = CompoundMappingInterface(0xe7a85d0adDB972A4f0A4e57B698B37f171519e88);
+	CompoundMappingInterface internal constant compMapping =
+		CompoundMappingInterface(0xe7a85d0adDB972A4f0A4e57B698B37f171519e88);
 
 	struct ImportData {
 		address[] cTokens; // is the list of all tokens the user has interacted with (supply/borrow) -> used to enter markets
-        uint[] borrowAmts;
+		uint256[] borrowAmts;
-        uint[] supplyAmts;
+		uint256[] supplyAmts;
 		address[] borrowTokens;
 		address[] supplyTokens;
 		CTokenInterface[] borrowCtokens;
@@ -50,7 +53,6 @@ abstract contract Helpers is DSMath, Basic {
 }
 
 contract CompoundHelper is Helpers {
-
 	/**
 	 * @notice fetch the borrow details of the user
 	 * @dev approve the cToken to spend (borrowed amount of) tokens to allow for repaying later
@@ -64,23 +66,31 @@ contract CompoundHelper is Helpers {
 	) internal returns (ImportData memory) {
 		if (_importInputData.borrowIds.length > 0) {
 			// initialize arrays for borrow data
-            data.borrowTokens = new address[](_importInputData.borrowIds.length);
+			uint256 _length = _importInputData.borrowIds.length;
-            data.borrowCtokens = new CTokenInterface[](_importInputData.borrowIds.length);
+			data.borrowTokens = new address[](_length);
-            data.borrowCtokensAddr = new address[](_importInputData.borrowIds.length);
+			data.borrowCtokens = new CTokenInterface[](_length);
-            data.borrowAmts = new uint[](_importInputData.borrowIds.length);
+			data.borrowCtokensAddr = new address[](_length);
+			data.borrowAmts = new uint256[](_length);
 
 			// populate the arrays with borrow tokens, cToken addresses and instances, and borrow amounts
-            for (uint i = 0; i < _importInputData.borrowIds.length; i++) {
+			for (uint256 i; i < _length; i++) {
-                (address _token, address _cToken) = compMapping.getMapping(_importInputData.borrowIds[i]);
+				(address _token, address _cToken) = compMapping.getMapping(
+					_importInputData.borrowIds[i]
+				);
 
-                require(_token != address(0) && _cToken != address(0), "ctoken mapping not found");
+				require(
+					_token != address(0) && _cToken != address(0),
+					"ctoken mapping not found"
+				);
 
 				data.cTokens[i] = _cToken;
 
 				data.borrowTokens[i] = _token;
 				data.borrowCtokens[i] = CTokenInterface(_cToken);
 				data.borrowCtokensAddr[i] = _cToken;
-                data.borrowAmts[i] = data.borrowCtokens[i].borrowBalanceCurrent(_importInputData.userAccount);
+				data.borrowAmts[i] = data.borrowCtokens[i].borrowBalanceCurrent(
+					_importInputData.userAccount
+				);
 
 				// give the resp. cToken address approval to spend tokens
 				if (_token != ethAddr && data.borrowAmts[i] > 0) {
@@ -104,24 +114,32 @@ contract CompoundHelper is Helpers {
 		ImportData memory data
 	) internal view returns (ImportData memory) {
 		// initialize arrays for supply data
-        data.supplyTokens = new address[](_importInputData.supplyIds.length);
+		uint256 _length = _importInputData.supplyIds.length;
-        data.supplyCtokens = new CTokenInterface[](_importInputData.supplyIds.length);
+		data.supplyTokens = new address[](_length);
-        data.supplyCtokensAddr = new address[](_importInputData.supplyIds.length);
+		data.supplyCtokens = new CTokenInterface[](_length);
-        data.supplyAmts = new uint[](_importInputData.supplyIds.length);
+		data.supplyCtokensAddr = new address[](_length);
+		data.supplyAmts = new uint256[](_length);
 
 		// populate arrays with supply data (supply tokens address, cToken addresses, cToken instances and supply amounts)
-        for (uint i = 0; i < _importInputData.supplyIds.length; i++) {
+		for (uint256 i; i < _length; i++) {
-            (address _token, address _cToken) = compMapping.getMapping(_importInputData.supplyIds[i]);
+			(address _token, address _cToken) = compMapping.getMapping(
+				_importInputData.supplyIds[i]
+			);
 
-            require(_token != address(0) && _cToken != address(0), "ctoken mapping not found");
+			require(
+				_token != address(0) && _cToken != address(0),
+				"ctoken mapping not found"
+			);
 
-            uint _supplyIndex = add(i, _importInputData.borrowIds.length);
+			uint256 _supplyIndex = add(i, _importInputData.borrowIds.length);
 			data.cTokens[_supplyIndex] = _cToken;
 
 			data.supplyTokens[i] = _token;
 			data.supplyCtokens[i] = CTokenInterface(_cToken);
 			data.supplyCtokensAddr[i] = (_cToken);
-            data.supplyAmts[i] = data.supplyCtokens[i].balanceOf(_importInputData.userAccount);
+			data.supplyAmts[i] = data.supplyCtokens[i].balanceOf(
+				_importInputData.userAccount
+			);
 		}
 		return data;
 	}
@@ -136,19 +154,22 @@ contract CompoundHelper is Helpers {
 	function _repayUserDebt(
 		address _userAccount,
 		CTokenInterface[] memory _cTokenContracts,
-        uint[] memory _borrowAmts
+		uint256[] memory _borrowAmts
 	) internal {
-        for(uint i = 0; i < _cTokenContracts.length; i++){
+		for (uint256 i; i < _cTokenContracts.length; i++) {
 			if (_borrowAmts[i] > 0) {
-                if(address(_cTokenContracts[i]) == address(cEth)){
+				if (address(_cTokenContracts[i]) == address(cEth))
-                    cEth.repayBorrowBehalf{value: _borrowAmts[i]}(_userAccount);
+					cEth.repayBorrowBehalf{ value: _borrowAmts[i] }(
-                }
+						_userAccount
-                else{
+					);
-                    require(_cTokenContracts[i].repayBorrowBehalf(
+				else
+					require(
+						_cTokenContracts[i].repayBorrowBehalf(
 							_userAccount,
 							_borrowAmts[i]
-                    ) == 0, "repayOnBehalf-failed");
+						) == 0,
-                }
+						"repayOnBehalf-failed"
+					);
 			}
 		}
 	}
@@ -163,17 +184,18 @@ contract CompoundHelper is Helpers {
 	function _transferTokensToDsa(
 		address _userAccount,
 		CTokenInterface[] memory _cTokenContracts,
-        uint[] memory _amts
+		uint256[] memory _amts
 	) internal {
-        for(uint i = 0; i < _cTokenContracts.length; i++) {
+		for (uint256 i; i < _cTokenContracts.length; i++)
-            if(_amts[i] > 0) {
+			if (_amts[i] > 0)
-                require(_cTokenContracts[i].transferFrom(
+				require(
+					_cTokenContracts[i].transferFrom(
 						_userAccount,
 						address(this),
 						_amts[i]
-                ), "ctoken-transfer-failed-allowance?");
+					),
-            }
+					"ctoken-transfer-failed-allowance?"
-        }
+				);
 	}
 
 	/**
@@ -188,14 +210,13 @@ contract CompoundHelper is Helpers {
 		uint256[] memory _amts,
 		uint256[] memory _flashLoanFees
 	) internal {
-        for (uint i = 0; i < _cTokenContracts.length; i++) {
+		for (uint256 i; i < _cTokenContracts.length; i++)
-            if (_amts[i] > 0) {
+			if (_amts[i] > 0)
-                require(_cTokenContracts[i].borrow(
+				require(
-                    add(
+					_cTokenContracts[i].borrow(
-                        _amts[i], 
+						add(_amts[i], _flashLoanFees[i])
-                        _flashLoanFees[i]
+					) == 0,
-                    )) == 0, "borrow-failed-collateral?");
+					"borrow-failed-collateral?"
-            }
+				);
-        }        
 	}
 }

contracts/mainnet/connectors/compound-import/interface.sol

@@ -1,46 +1,100 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.7.6;
 
 interface TokenInterface {
-    function balanceOf(address) external view returns (uint);
+	function balanceOf(address) external view returns (uint256);
-    function allowance(address, address) external view returns (uint);
+
-    function approve(address, uint) external;
+	function allowance(address, address) external view returns (uint256);
-    function transfer(address, uint) external returns (bool);
+
-    function transferFrom(address, address, uint) external returns (bool);
+	function approve(address, uint256) external;
+
+	function transfer(address, uint256) external returns (bool);
+
+	function transferFrom(
+		address,
+		address,
+		uint256
+	) external returns (bool);
 }
 
 interface CTokenInterface {
-    function mint(uint mintAmount) external returns (uint);
+	function mint(uint256 mintAmount) external returns (uint256);
-    function redeem(uint redeemTokens) external returns (uint);
-    function borrow(uint borrowAmount) external returns (uint);
-    function repayBorrow(uint repayAmount) external returns (uint);
-    function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint); // For ERC20
-    function liquidateBorrow(address borrower, uint repayAmount, address cTokenCollateral) external returns (uint);
 
-    function borrowBalanceCurrent(address account) external returns (uint);
+	function redeem(uint256 redeemTokens) external returns (uint256);
-    function redeemUnderlying(uint redeemAmount) external returns (uint);
+
-    function exchangeRateCurrent() external returns (uint);
+	function borrow(uint256 borrowAmount) external returns (uint256);
+
+	function repayBorrow(uint256 repayAmount) external returns (uint256);
+
+	function repayBorrowBehalf(address borrower, uint256 repayAmount)
+		external
+		returns (uint256); // For ERC20
+
+	function liquidateBorrow(
+		address borrower,
+		uint256 repayAmount,
+		address cTokenCollateral
+	) external returns (uint256);
+
+	function borrowBalanceCurrent(address account) external returns (uint256);
+
+	function redeemUnderlying(uint256 redeemAmount) external returns (uint256);
+
+	function exchangeRateCurrent() external returns (uint256);
 
 	function balanceOf(address owner) external view returns (uint256 balance);
-    function transferFrom(address, address, uint) external returns (bool);
-    function allowance(address, address) external view returns (uint);
 
+	function transferFrom(
+		address,
+		address,
+		uint256
+	) external returns (bool);
+
+	function allowance(address, address) external view returns (uint256);
 }
 
 interface CETHInterface {
 	function mint() external payable;
+
 	function repayBorrow() external payable;
+
 	function repayBorrowBehalf(address borrower) external payable;
-    function liquidateBorrow(address borrower, address cTokenCollateral) external payable;
+
+	function liquidateBorrow(address borrower, address cTokenCollateral)
+		external
+		payable;
 }
 
 interface ComptrollerInterface {
-    function enterMarkets(address[] calldata cTokens) external returns (uint[] memory);
+	function enterMarkets(address[] calldata cTokens)
-    function exitMarket(address cTokenAddress) external returns (uint);
+		external
-    function getAssetsIn(address account) external view returns (address[] memory);
+		returns (uint256[] memory);
-    function getAccountLiquidity(address account) external view returns (uint, uint, uint);
+
+	function exitMarket(address cTokenAddress) external returns (uint256);
+
+	function getAssetsIn(address account)
+		external
+		view
+		returns (address[] memory);
+
+	function getAccountLiquidity(address account)
+		external
+		view
+		returns (
+			uint256,
+			uint256,
+			uint256
+		);
 }
 
 interface CompoundMappingInterface {
-    function cTokenMapping(string calldata tokenId) external view returns (address);
+	function cTokenMapping(string calldata tokenId)
-    function getMapping(string calldata tokenId) external view returns (address, address);
+		external
+		view
+		returns (address);
+
+	function getMapping(string calldata tokenId)
+		external
+		view
+		returns (address, address);
 }

contracts/mainnet/connectors/compound-import/main.sol

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.7.6;
 pragma experimental ABIEncoderV2;
 
@@ -11,7 +12,6 @@ import { Events } from "./events.sol";
 // 4. Then borrow debt of same tokens but include flash loan fee in it.
 
 contract CompoundImportResolver is CompoundHelper {
-
 	/**
 	 * @notice this function performs the import of user's Compound positions into its DSA
 	 * @dev called internally by the importCompound and migrateCompound functions
@@ -22,29 +22,49 @@ contract CompoundImportResolver is CompoundHelper {
 		ImportInputData memory _importInputData,
 		uint256[] memory _flashLoanFees
 	) internal returns (string memory _eventName, bytes memory _eventParam) {
-        require(AccountInterface(address(this)).isAuth(_importInputData.userAccount), "user-account-not-auth");
+		require(
+			AccountInterface(address(this)).isAuth(
+				_importInputData.userAccount
+			),
+			"user-account-not-auth"
+		);
 
 		require(_importInputData.supplyIds.length > 0, "0-length-not-allowed");
 
 		ImportData memory data;
 
-        uint _length = add(_importInputData.supplyIds.length, _importInputData.borrowIds.length);
+		uint256 _length = add(
+			_importInputData.supplyIds.length,
+			_importInputData.borrowIds.length
+		);
 		data.cTokens = new address[](_length);
 
 		// get info about all borrowings and lendings by the user on Compound
 		data = getBorrowAmounts(_importInputData, data);
 		data = getSupplyAmounts(_importInputData, data);
 
-        _enterMarkets(_importInputData.cTokens);
+		_enterMarkets(data.cTokens);
 
 		// pay back user's debt using flash loan funds
-        _repayUserDebt(_importInputData.userAccount, data.borrowCtokens, data.borrowAmts);
+		_repayUserDebt(
+			_importInputData.userAccount,
+			data.borrowCtokens,
+			data.borrowAmts
+		);
 
 		// transfer user's tokens to DSA
-        _transferTokensToDsa(_importInputData.userAccount, data.supplyCtokens, data.supplyAmts);
+		_transferTokensToDsa(
+			_importInputData.userAccount,
+			data.supplyCtokens,
+			data.supplyAmts
+		);
 
 		// borrow the earlier position from Compound with flash loan fee added
-        _borrowDebtPosition(data.borrowCtokens, data.borrowAmts, _flashLoanFees);
+		_borrowDebtPosition(
+			data.borrowCtokens,
+			data.borrowAmts,
+			_flashLoanFees
+		);
 
 		_eventName = "LogCompoundImport(address,address[],string[],string[],uint256[],uint256[])";
 		_eventParam = abi.encode(
@@ -70,7 +90,11 @@ contract CompoundImportResolver is CompoundHelper {
 		string[] memory _supplyIds,
 		string[] memory _borrowIds,
 		uint256[] memory _flashLoanFees
-    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+	)
+		external
+		payable
+		returns (string memory _eventName, bytes memory _eventParam)
+	{
 		ImportInputData memory inputData = ImportInputData({
 			userAccount: _userAccount,
 			supplyIds: _supplyIds,
@@ -79,7 +103,6 @@ contract CompoundImportResolver is CompoundHelper {
 
 		(_eventName, _eventParam) = _importCompound(inputData, _flashLoanFees);
 	}
-
 }
 
 contract ConnectV2CompoundImport is CompoundImportResolver {