updated test case and update contarcts

jointerinc · Aug 24, 2020 · 218bc09 · 218bc09
1 parent e48e73c
commit 218bc09
Show file tree

Hide file tree

Showing 10 changed files with 468 additions and 467 deletions.
diff --git a/contracts/Auction/Auction.sol b/contracts/Auction/Auction.sol
@@ -94,6 +94,7 @@ contract AuctionUtils is RegisteryAuction {
         fundWalletRatio = 90;
         groupBonusRatio = 2;
         mainTokenRatio = 100;
+        averageDay = 10;
     }
 
     function setGroupBonusRatio(uint256 _groupBonusRatio)
@@ -151,6 +152,24 @@ contract AuctionUtils is RegisteryAuction {
         maxContributionAllowed = _maxContributionAllowed;
         return true;
     }
+
+    function setStackingPercent(uint256 _stacking)
+        external
+        onlyAuthorized()
+        returns (bool)
+    {
+        stacking = _stacking;
+        return true;
+    }
+
+    function setAverageDays(uint256 _averageDay)
+        external
+        onlyAuthorized()
+        returns (bool)
+    {
+        averageDay = _averageDay;
+        return true;
+    }
 }
 
 contract AuctionFormula is SafeMath, TokenTransfer {
@@ -359,15 +378,15 @@ contract AuctionFundCollector is IndividualBonus {
         require(
             _tokenAmount >=
                 safeAdd(
-                    walletDayWiseContribution[auctionDay][_from],
+                    mainTokenCheckDayWise[auctionDay][_from],
                     _contributedAmount
                 ),
             "ERR_USER_DONT_HAVE_EQUAL_BALANCE"
         );
 
         uint256 lockToken = safeDiv(
             safeAdd(
-                walletDayWiseContribution[auctionDay][_from],
+                mainTokenCheckDayWise[auctionDay][_from],
                 _contributedAmount
             ),
             _mainTokenPrice
@@ -433,7 +452,12 @@ contract AuctionFundCollector is IndividualBonus {
         }
 
         todayContribution = safeAdd(todayContribution, _contributedAmount);
-
+
+        mainTokenCheckDayWise[auctionDay][_caller] = safeAdd(
+            walletDayWiseContribution[auctionDay][_caller],
+            _contributedAmount
+        );
+
         walletDayWiseContribution[auctionDay][_recipient] = safeAdd(
             walletDayWiseContribution[auctionDay][_recipient],
             _contributedAmount
@@ -664,7 +688,7 @@ contract Auction is Upgradeable, AuctionFundCollector, AuctionInitializeInterfac
             );
         }
 
-        uint256 _avgDays = 10;
+        uint256 _avgDays = averageDay;
         uint256 _avgInvestment = 0;
 
         if (auctionDay < 11 && auctionDay > 1) {

diff --git a/contracts/Auction/AuctionStorage.sol b/contracts/Auction/AuctionStorage.sol
@@ -51,6 +51,8 @@ contract AuctionStorage {
     // today token supply
     uint256 public todaySupply;
 
+    uint256 public averageDay;
+
     // address how much invested by them in auciton till date
     mapping(address => uint256) public userTotalFund;
 
@@ -79,6 +81,10 @@ contract AuctionStorage {
     mapping(uint256 => mapping(address => uint256))
         public walletDayWiseContribution;
 
+    // daywise contribution
+    mapping(uint256 => mapping(address => uint256))
+        public mainTokenCheckDayWise;
+
     // return index of user for bonus
     mapping(uint256 => uint256) public indexReturn;
 

diff --git a/contracts/Liquadity/AuctionLiquadity.sol b/contracts/Liquadity/AuctionLiquadity.sol
@@ -270,6 +270,14 @@ contract LiquadityUtils is RegisteryLiquadity {
     {
         reductionStartDay = _reductionStartDay;
     }
+
+    function setRelayPercent(uint256 _relayPercent)
+        public
+        onlyOwner()
+        returns (bool)
+    {
+        relayPercent = _relayPercent;
+    }
 }
 
 contract LiquadityFormula is LiquadityUtils {
@@ -349,6 +357,7 @@ contract Liquadity is
         tagAlongRatio = 100;
         reductionStartDay = 21;
         maxIteration = 35;
+        relayPercent = 10;
         appreciationLimitWithDecimal = safeMul(120, DECIMAL_NOMINATOR);
         baseTokenVolatiltyRatio = 5 * PRICE_NOMINATOR;
         baseToken = IERC20Token(_baseToken);
@@ -471,7 +480,7 @@ contract Liquadity is
     {
         if (address(this).balance < previousMainReserveContribution) {
             while (previousMainReserveContribution >= address(this).balance) {
-                _liquadate(safeMul(10, PRICE_NOMINATOR));
+                _liquadate(safeMul(relayPercent, PRICE_NOMINATOR));
                 _convertBaseTokenToEth();
                 if (address(this).balance >=previousMainReserveContribution){
                     break;
@@ -634,21 +643,17 @@ contract Liquadity is
             );
             return _convertWithToken(_reverseBalance, mainTokenTobaseToken);
         } else {
-            uint256 converterBalance = mainToken.balanceOf(converter);
-
-            uint256 relayPercent = 10;
-
-            if (converterBalance > _reverseBalance)
-
-                relayPercent = safeDiv(
+            uint256 converterBalance = mainToken.balanceOf(converter); 
+            uint _tempRelayPercent  = relayPercent;            
+            if (converterBalance > _reverseBalance)      
+                _tempRelayPercent = safeDiv(
                     safeMul(
                         safeSub(converterBalance, _reverseBalance),
                         safeMul(100, PRICE_NOMINATOR)
                     ),
                     _reverseBalance
-                );
-
-            _liquadate(safeMul(relayPercent, PRICE_NOMINATOR));
+                );         
+            _liquadate(safeMul(_tempRelayPercent, PRICE_NOMINATOR));
             return _priceRecoveryWithConvertMainToken(_percent);
         }
     }
@@ -688,17 +693,17 @@ contract Liquadity is
             }else{
                 // redemption amount always less then what converter have
                 uint256 converterBalance = baseToken.balanceOf(converter);
-                uint256 relayPercent = 10;
+                uint256 _tempRelayPercent = relayPercent;
                 if (converterBalance > _amount) {
-                    relayPercent = safeDiv(
+                    _tempRelayPercent = safeDiv(
                         safeMul(safeSub(converterBalance, _amount), 100),
                         _amount
                     );
-                    if (relayPercent > 99) relayPercent = 99;
+                    if (_tempRelayPercent > 99) _tempRelayPercent = 99;
                 }
 
-                _liquadate(safeMul(relayPercent, PRICE_NOMINATOR));
-                _amount = safeSub(_amount, safeDiv(_amount, relayPercent));
+                _liquadate(safeMul(_tempRelayPercent, PRICE_NOMINATOR));
+                _amount = safeSub(_amount, safeDiv(_amount, _tempRelayPercent));
                 return _convertWithToken(_amount, baseTokenToMainToken);
             }
         }

diff --git a/contracts/Liquadity/LiquadityStorage.sol b/contracts/Liquadity/LiquadityStorage.sol
@@ -85,6 +85,8 @@ contract LiquadityStorage {
 
     // check if today token price reach certain level
     bool public isAppreciationLimitReached;  
+
+    uint256 public relayPercent; 
 
      // mapping for where user last reddeem 
     mapping(address => uint256) public lastReedeemDay;

diff --git a/contracts/WhiteList/WhiteList.sol b/contracts/WhiteList/WhiteList.sol
@@ -253,14 +253,7 @@ contract WhiteList is
         return _addMoreWallets(msg.sender,_which);
     }
 
-    function addMoreWallets(address _mainWallet,address _subWallet)
-        public
-        onlySystem()
-        notZeroAddress(_subWallet)
-        returns (bool)
-    {
-        return _addMoreWallets(_mainWallet,_subWallet);
-    }
+
 
     function addWalletBehalfExchange(address _mainWallet,address _subWallet)
         public