@gooddollar/goodprotocol 1.0.15-beta.4 → 1.0.15

package/artifacts/contracts/utils/ReputationTestHelper.sol/ReputationTestHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/d34a491d385a4e70eb0f87d68e82e3ae.json"
+  "buildInfo": "../../../build-info/5f028ffd276aa3fab1dedf39da624f14.json"
 }

package/contracts/governance/MultiBaseGovernanceShareField.sol

@@ -22,10 +22,10 @@ abstract contract MultiBaseGovernanceShareField is DSMath {
 	mapping(address => uint256) public rewardsPerBlock;
 
 	struct UserInfo {
-		uint256 amount; // How many tokens the user has staked.
-		uint256 rewardDebt; // Rewards that accounted already so should be substracted while calculating rewards of staker
-		uint256 rewardEarn; // Reward earn and not minted
-		uint256 rewardMinted; // rewards sent to the user
+		uint128 amount; // How many tokens the user has staked.
+		uint128 rewardDebt; // Rewards that accounted already so should be substracted while calculating rewards of staker
+		uint128 rewardEarn; // Reward earn and not minted
+		uint128 rewardMinted; // rewards sent to the user
 	}
 
 	mapping(address => mapping(address => UserInfo)) public contractToUsers;
@@ -115,15 +115,15 @@ abstract contract MultiBaseGovernanceShareField is DSMath {
 			uint256 pending = (userInfo.amount * accAmountPerShare[_contract]) /
 				1e27 -
 				userInfo.rewardDebt; // Divide 1e27(because userinfo.amount in 18 decimals and accAmountPerShare is in 27decimals) since rewardDebt in 18 decimals so we can calculate how much reward earned in that cycle
-			userInfo.rewardEarn = userInfo.rewardEarn + pending; // Add user's earned rewards to user's account so it can be minted later
+			userInfo.rewardEarn = userInfo.rewardEarn + uint128(pending); // Add user's earned rewards to user's account so it can be minted later
 			totalRewardsAccumulated[_contract] =
 				totalRewardsAccumulated[_contract] +
 				pending;
 		}
-		userInfo.amount = _updatedAmount;
-		userInfo.rewardDebt =
-			(_updatedAmount * accAmountPerShare[_contract]) /
-			1e27; // Divide to 1e27 to keep rewardDebt in 18 decimals since accAmountPerShare is in 27 decimals and amount is 18 decimals
+		userInfo.amount = uint128(_updatedAmount);
+		userInfo.rewardDebt = uint128(
+			(_updatedAmount * accAmountPerShare[_contract]) / 1e27
+		); // Divide to 1e27 to keep rewardDebt in 18 decimals since accAmountPerShare is in 27 decimals and amount is 18 decimals
 	}
 
 	/**
@@ -216,10 +216,9 @@ abstract contract MultiBaseGovernanceShareField is DSMath {
 	) internal returns (uint256) {
 		_update(_contract, _blockStart, _blockEnd);
 		_audit(_contract, _user, contractToUsers[_contract][_user].amount);
-		UserInfo storage userInfo = contractToUsers[_contract][_user];
-		uint256 amount = userInfo.rewardEarn;
-		userInfo.rewardEarn = 0;
-		userInfo.rewardMinted += amount;
+		uint128 amount = contractToUsers[_contract][_user].rewardEarn;
+		contractToUsers[_contract][_user].rewardMinted += amount;
+		contractToUsers[_contract][_user].rewardEarn = 0;
 		rewardsMintedSoFar[_contract] = rewardsMintedSoFar[_contract] + amount;
 		return amount;
 	}

package/contracts/governance/StakersDistribution.sol

@@ -7,7 +7,7 @@ import "../Interfaces.sol";
 import "../governance/GReputation.sol";
 import "../governance/MultiBaseGovernanceShareField.sol";
 import "../staking/GoodFundManager.sol";
-import "../staking/SimpleStaking.sol";
+import "../staking/SimpleStakingV2.sol";
 
 /**
  * Staking contracts will update this contract with staker token stake amount
@@ -34,7 +34,6 @@ contract StakersDistribution is
 	function initialize(INameService _ns) public initializer {
 		monthlyReputationDistribution = 2000000 ether; //2M as specified in specs
 		setDAO(_ns);
-		_updateMonth();
 	}
 
 	/**
@@ -58,12 +57,8 @@ contract StakersDistribution is
 	/**
 	 * @dev internal function to switch to new month. records for new month the current monthlyReputationDistribution
 	 */
-	function _updateMonth() internal {
-		uint256 month = block.timestamp / 30 days;
-		if (
-			nameService.getAddress("FUND_MANAGER") != address(0) &&
-			month != currentMonth
-		) {
+	function _updateRewards() internal {
+		if (nameService.getAddress("FUND_MANAGER") != address(0)) {
 			//read active staking contracts set pro rate monthly share
 			GoodFundManager gfm = GoodFundManager(
 				nameService.getAddress("FUND_MANAGER")
@@ -83,9 +78,8 @@ contract StakersDistribution is
 				(, uint64 blockStart, uint64 blockEnd, ) = gfm
 					.rewardsForStakingContract(activeStakingList[i]);
 				if (blockStart <= block.number && blockEnd > block.number) {
-					(, , , uint256 lockedValueInUSD, ) = SimpleStaking(
-						activeStakingList[i]
-					).currentGains(true, false);
+					uint256 lockedValueInUSD = SimpleStakingV2(activeStakingList[i])
+						.lockedUSDValue();
 					contractLockedValue[i] = lockedValueInUSD;
 					totalLockedValue += contractLockedValue[i];
 				}
@@ -101,9 +95,6 @@ contract StakersDistribution is
 					_setMonthlyRewards(activeStakingList[i], contractShare);
 				}
 			}
-
-			//update new month
-			currentMonth = month;
 		}
 	}
 
@@ -137,7 +128,7 @@ contract StakersDistribution is
 
 		_claimReputation(_staker, contracts);
 
-		_updateMonth(); //previous calls will use previous month reputation
+		_updateRewards();
 	}
 
 	/**
@@ -168,7 +159,7 @@ contract StakersDistribution is
 		address[] memory contracts = new address[](1);
 		contracts[0] = stakingContract;
 		_claimReputation(_staker, contracts);
-		_updateMonth(); //previous calls will use previous month reputation
+		_updateRewards();
 	}
 
 	/**
@@ -181,13 +172,11 @@ contract StakersDistribution is
 		address[] calldata _stakingContracts
 	) external {
 		_claimReputation(_staker, _stakingContracts);
-		_updateMonth(); //previous calls will use previous month reputation
 	}
 
-	function _claimReputation(
-		address _staker,
-		address[] memory _stakingContracts
-	) internal {
+	function _claimReputation(address _staker, address[] memory _stakingContracts)
+		internal
+	{
 		uint256 totalRep;
 		GoodFundManager gfm = GoodFundManager(
 			nameService.getAddress("FUND_MANAGER")
@@ -206,10 +195,7 @@ contract StakersDistribution is
 				);
 		}
 		if (totalRep > 0) {
-			GReputation(nameService.getAddress("REPUTATION")).mint(
-				_staker,
-				totalRep
-			);
+			GReputation(nameService.getAddress("REPUTATION")).mint(_staker, totalRep);
 			emit ReputationEarned(_staker, _stakingContracts, totalRep);
 		}
 	}

package/contracts/reserve/ExchangeHelper.sol

@@ -99,8 +99,8 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		uint256 _minReturn,
 		uint256 _minDAIAmount,
 		address _targetAddress
-	) public nonReentrant payable returns (uint256) {
-		require(_buyPath.length > 0 , "Provide valid path");
+	) public payable nonReentrant returns (uint256) {
+		require(_buyPath.length > 0, "Provide valid path");
 		GoodReserveCDai reserve = GoodReserveCDai(
 			nameService.getAddress("RESERVE")
 		);
@@ -114,7 +114,10 @@ contract ExchangeHelper is DAOUpgradeableContract {
 				"you need to pay with ETH"
 			);
 		} else {
-			require(msg.value == 0 , 'When input token is different than ETH message value should be zero');
+			require(
+				msg.value == 0,
+				"When input token is different than ETH message value should be zero"
+			);
 			require(
 				ERC20(_buyPath[0]).transferFrom(
 					msg.sender,
@@ -133,7 +136,10 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		} else if (_buyPath[0] == daiAddress) {
 			result = _cdaiMintAndBuy(_tokenAmount, _minReturn, receiver);
 		} else {
-			require(_buyPath[_buyPath.length - 1] == daiAddress , "Target token in the path must be DAI");
+			require(
+				_buyPath[_buyPath.length - 1] == daiAddress,
+				"Target token in the path must be DAI"
+			);
 			uint256[] memory swap = _uniswapSwap(
 				_buyPath,
 				_tokenAmount,
@@ -175,7 +181,7 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		uint256 _minTokenReturn,
 		address _targetAddress
 	) public nonReentrant returns (uint256) {
-		require(_sellPath.length > 0 , "Provide valid path");
+		require(_sellPath.length > 0, "Provide valid path");
 		address receiver = _targetAddress == address(0x0)
 			? msg.sender
 			: _targetAddress;
@@ -193,11 +199,16 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		(result, contributionAmount) = reserve.sell(
 			_gdAmount,
 			_minReturn,
-			(_sellPath.length == 1 && _sellPath[0] == cDaiAddress) ? receiver : address(this), // if the tokens that will received is cDai then return it directly to receiver
+			(_sellPath.length == 1 && _sellPath[0] == cDaiAddress)
+				? receiver
+				: address(this), // if the tokens that will received is cDai then return it directly to receiver
 			msg.sender
 		);
-		if (_sellPath.length == 1 && (_sellPath[0] == daiAddress || _sellPath[0] == cDaiAddress)) {
-			if(_sellPath[0] == daiAddress ){
+		if (
+			_sellPath.length == 1 &&
+			(_sellPath[0] == daiAddress || _sellPath[0] == cDaiAddress)
+		) {
+			if (_sellPath[0] == daiAddress) {
 				result = _redeemDAI(result);
 
 				require(
@@ -205,9 +216,12 @@ contract ExchangeHelper is DAOUpgradeableContract {
 					"Transfer failed"
 				);
 			}
-		} else if(_sellPath[0] != cDaiAddress){
+		} else if (_sellPath[0] != cDaiAddress) {
 			result = _redeemDAI(result);
-			require(_sellPath[0] == daiAddress, "Input token for uniswap must be DAI");
+			require(
+				_sellPath[0] == daiAddress,
+				"Input token for uniswap must be DAI"
+			);
 			uint256[] memory swap = _uniswapSwap(
 				_sellPath,
 				result,
@@ -218,12 +232,12 @@ contract ExchangeHelper is DAOUpgradeableContract {
 
 			result = swap[swap.length - 1];
 			require(result > 0, "token selling failed");
-		}else{
+		} else {
 			revert();
 		}
 
 		emit TokenSold(
-			receiver,
+			msg.sender,
 			_sellPath[_sellPath.length - 1],
 			_gdAmount,
 			contributionAmount,
@@ -295,9 +309,7 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		uint256 _minTokenReturn,
 		address _receiver
 	) internal returns (uint256[] memory) {
-		Uniswap uniswapContract = Uniswap(
-			nameService.getAddress("UNISWAP_ROUTER")
-		);
+		Uniswap uniswapContract = Uniswap(nameService.getAddress("UNISWAP_ROUTER"));
 		address wETH = uniswapContract.WETH();
 		uint256[] memory swap;
 		bool isBuy = _inputPath[_inputPath.length - 1] == daiAddress; // if outputToken is dai then transaction is buy with any ERC20 token
@@ -322,10 +334,7 @@ contract ExchangeHelper is DAOUpgradeableContract {
 			return swap;
 		} else {
 			if (isBuy)
-				ERC20(_inputPath[0]).approve(
-					address(uniswapContract),
-					_tokenAmount
-				);
+				ERC20(_inputPath[0]).approve(address(uniswapContract), _tokenAmount);
 			swap = uniswapContract.swapExactTokensForTokens(
 				_tokenAmount,
 				isBuy ? _minDAIAmount : _minTokenReturn,

package/contracts/reserve/GoodReserveCDai.sol

@@ -192,14 +192,14 @@ contract GoodReserveCDai is
 		_mintGoodDollars(_targetAddress, gdReturn, true);
 		//mint GDX
 		_mintGDX(_targetAddress, gdReturn);
-		if (msg.sender != exchangeHelper)
-			emit TokenPurchased(
-				msg.sender,
-				cDaiAddress,
-				_tokenAmount,
-				gdReturn,
-				_targetAddress
-			);
+
+		emit TokenPurchased(
+			msg.sender != exchangeHelper ? msg.sender : tx.origin,
+			cDaiAddress,
+			_tokenAmount,
+			gdReturn,
+			_targetAddress
+		);
 		return gdReturn;
 	}
 
@@ -250,8 +250,7 @@ contract GoodReserveCDai is
 		uint256 discount = gdx <= _gdAmount ? gdx : _gdAmount;
 
 		//burn gdx used for discount
-		if (discount > 0)
-			_burn(_seller, discount);
+		if (discount > 0) _burn(_seller, discount);
 
 		uint256 contributionAmount = 0;
 		uint256 gdAmountTemp = _gdAmount; // to prevent stack too deep errors
@@ -276,15 +275,16 @@ contract GoodReserveCDai is
 			"Token return must be above the minReturn"
 		);
 		cERC20(cDaiAddress).transfer(_target, tokenReturn);
-		if (_seller == msg.sender)
-			emit TokenSold(
-				msg.sender,
-				cDaiAddress,
-				_gdAmount,
-				contributionAmount,
-				tokenReturn,
-				_target
-			);
+
+		emit TokenSold(
+			_seller,
+			cDaiAddress,
+			_gdAmount,
+			contributionAmount,
+			tokenReturn,
+			_target
+		);
+
 		return (tokenReturn, contributionAmount);
 	}
 

package/contracts/staking/SimpleStakingV2.sol

@@ -37,6 +37,8 @@ abstract contract SimpleStakingV2 is
 	//max percentage of token/dai pool liquidity to swap to DAI when collecting interest out of 100000
 	uint24 public maxLiquidityPercentageSwap = 300; //0.3%
 
+	uint256 public lockedUSDValue;
+
 	/**
 	 * @dev Emitted when `staker` stake `value` tokens of `token`
 	 */
@@ -216,6 +218,9 @@ abstract contract SimpleStakingV2 is
 			_donationPer
 		);
 
+		(, , , uint256 lockedValueInUSD, ) = currentGains(true, false);
+		lockedUSDValue = lockedValueInUSD;
+
 		//notify GDAO distrbution for stakers
 		StakersDistribution sd = StakersDistribution(
 			nameService.getAddress("GDAO_STAKERS")
@@ -259,6 +264,9 @@ abstract contract SimpleStakingV2 is
 			nameService.getAddress("FUND_MANAGER")
 		);
 
+		(, , , uint256 lockedValueInUSD, ) = currentGains(true, false);
+		lockedUSDValue = lockedValueInUSD;
+
 		//this will revert in case user doesnt have enough productivity to withdraw _amount, as productivity=staking tokens amount
 		_burn(msg.sender, _amount); // burn their staking tokens
 
@@ -350,7 +358,11 @@ abstract contract SimpleStakingV2 is
 		}
 	}
 
-	function _convertValueTo18Decimals(uint256 _amount) internal view returns(uint256 amountInEighteenDecimals) {
+	function _convertValueTo18Decimals(uint256 _amount)
+		internal
+		view
+		returns (uint256 amountInEighteenDecimals)
+	{
 		amountInEighteenDecimals = token.decimals() == 18
 			? _amount
 			: _amount * 10**(18 - token.decimals());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "1.0.15-beta.4",
+  "version": "1.0.15",
   "description": "GoodDollar Protocol",
   "scripts": {
     "build": "scripts/build.sh deploy",

package/releases/deployment.json

@@ -458,6 +458,10 @@
         "GoodMarketMaker": "0xDAC6A0c973Ba7cF3526dE456aFfA43AB421f659F",
         "GoodReserveCDai": "0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0",
         "ExchangeHelper": "0x98FA532Dd5C3a6b66fbf370813803192DE4e0abd",
+        "CompoundStakingFactory": "0x78cc5ab2f0990b5fe58f95baebf8f37879534aeb",
+        "AaveStakingFactory": "0xf4411c22766947DB2da39Ad534A040b770B51153",
+        "StakersDistribution": "0x5766cf4b2fdb09d986eb1783d276013c224e28c8",
+        "GoodFundManager": "0x0c6c80d2061afa35e160f3799411d83bdeea0a5a",
         "ProtocolUpgradeRecover": "0x6f1b4dFDd7156FC5752541Ef35EDF57B48E74475",
         "network": "production-mainnet",
         "networkId": 1,
@@ -488,8 +492,16 @@
                 6944
             ]
         ],
-        "StakersDistribution": "0x12D15EfC3c9661AD68209CD197D416BFd9B145f5",
-        "GoodFundManager": "0x3F55BD3B432EDC73Bbb704Fa5a29CC08dc1aDBEB",
+        "StakingContractsV3": [
+            [
+                "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754",
+                13888
+            ],
+            [
+                "0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f",
+                6944
+            ]
+        ],
         "GReputation": "0x3A9299BE789ac3730e4E4c49d6d2Ad1b8BC34DFf",
         "CompoundVotingMachine": "0xc2Ff55b896e3c42f9e1c2f7467C51b93F1C23dFD"
     },

package/test/governance/StakersDistribution.test.ts

@@ -383,23 +383,21 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(40);
     await increaseTime(86700 * 30); // Increase one month
-    const stakerGDAOBalanceBeforeStake = await grep.balanceOfLocal(
-      staker.address
-    );
+    const stakerGDAOBalanceBeforeStake = await grep.balanceOf(staker.address);
     await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
-    const stakerGDAOBalanceAfterStake = await grep.balanceOfLocal(
-      staker.address
-    );
+    const stakerGDAOBalanceAfterStake = await grep.balanceOf(staker.address);
     await simpleStaking.connect(staker).withdrawRewards();
 
     const rewardsPerBlockAfterStake = await stakersDistribution.rewardsPerBlock(
       simpleStaking.address
     );
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(staker.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
     await advanceBlocks(10);
     await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);
-    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(staker.address);
-    expect(rewardsPerBlockAfterStake).to.be.equal(rewardsPerBlockBeforeStake); // Should not update rewards per block since simplestaking blockend passed
+    const GDAOBalanceAfterWithdraw = await grep.balanceOf(staker.address);
+    expect(rewardsPerBlockAfterStake).to.not.be.equal(
+      rewardsPerBlockBeforeStake
+    ); // Should update rewards per block every stake/withdraw
     expect(GDAOBalanceBeforeWithdraw).to.be.equal(GDAOBalanceAfterWithdraw); // Should not earn any GDAO since simplestaking blockend passed
     expect(stakerGDAOBalanceAfterStake.gt(stakerGDAOBalanceBeforeStake)).to.be
       .true;
@@ -438,10 +436,10 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     const blockNumberOfStake = (await ethers.provider.getBlockNumber()) + 1;
     await simpleStaking.connect(staker).stake(stakingAmount, 0, false);
     await advanceBlocks(30);
-    const GDAOBalanceBeforeWithdraw = await grep.balanceOfLocal(staker.address);
+    const GDAOBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
     await simpleStaking.connect(staker).withdrawStake(stakingAmount, false);
 
-    const GDAOBalanceAfterWithdraw = await grep.balanceOfLocal(staker.address);
+    const GDAOBalanceAfterWithdraw = await grep.balanceOf(staker.address);
     expect(GDAOBalanceAfterWithdraw).to.be.gt(GDAOBalanceBeforeWithdraw);
 
     expect(GDAOBalanceAfterWithdraw).to.be.equal(
@@ -653,18 +651,23 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
       simpleStaking1.address
     );
     await advanceBlocks(4);
-    const gdaoBalanceBeforeWithdraw = await goodDollar.balanceOf(
-      staker.address
-    );
+    const gdaoBalanceBeforeWithdraw = await grep.balanceOf(staker.address);
+    console.log({ gdaoBalanceBeforeWithdraw, rewardsPerBlock });
     await simpleStaking1.connect(staker).withdrawStake(stakingAmount, false);
     const withdrawBlockNumber = await ethers.provider.getBlockNumber();
-    const gdaoBalanceAfterWithdraw = await goodDollar.balanceOf(staker.address);
+    await stakersDistribution.claimReputation(staker.address, [
+      simpleUsdcStaking.address,
+      simpleStaking.address
+    ]);
+
+    const gdaoBalanceAfterWithdraw = await grep.balanceOf(staker.address);
     const calculatedNewBalance = gdaoBalanceBeforeWithdraw.add(
       rewardsPerBlock.mul(withdrawBlockNumber - stakeBlockNumber)
     );
     expect(gdaoBalanceAfterWithdraw).to.be.gt(gdaoBalanceBeforeWithdraw);
 
-    expect(gdaoBalanceBeforeWithdraw).to.be.equal(calculatedNewBalance);
+    expect(gdaoBalanceAfterWithdraw).to.be.equal(calculatedNewBalance);
+
     encodedData = goodFundManagerFactory.interface.encodeFunctionData(
       "setStakingReward",
       [
@@ -756,17 +759,19 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     const daiStakingRewardsPerBlock = await stakersDistribution.rewardsPerBlock(
       simpleStaking.address
     );
-    const gdaoBalanceBeforeWithdraw = await grep.balanceOfLocal(staker.address);
+
+    expect(usdcStakingRewardsPerBlock).to.equal(daiStakingRewardsPerBlock);
+
     await simpleUsdcStaking
       .connect(staker)
       .withdrawStake(stakingAmountUsdc, false);
     await simpleStaking.connect(staker).withdrawStake(stakingAmountDai, false);
-    const gdaoBalanceAfterWithdraw = await grep.balanceOfLocal(staker.address);
-    expect(gdaoBalanceAfterWithdraw.sub(gdaoBalanceBeforeWithdraw)).to.be.equal(
-      UserPendingGdaos.add(usdcStakingRewardsPerBlock).add(
-        daiStakingRewardsPerBlock.mul(2)
-      )
-    );
+
+    await stakersDistribution.claimReputation(staker.address, [
+      simpleUsdcStaking.address,
+      simpleStaking.address
+    ]);
+
     expect(UserPendingGdaos).to.be.equal(
       usdcStakingPendingGdaos.add(daiStakingPendingGdaos)
     );
@@ -834,7 +839,9 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
       .approve(simpleUsdcStaking.address, stakingAmountUsdc);
     await increaseTime(86700 * 30); // Increase one month
     await simpleUsdcStaking.connect(sender).stake(stakingAmountUsdc, 0, false);
-    await simpleUsdcStaking.connect(sender).transfer(receiver.address, stakingAmountUsdc);
+    await simpleUsdcStaking
+      .connect(sender)
+      .transfer(receiver.address, stakingAmountUsdc);
     await advanceBlocks(10);
     const UserPendingGdaos = await stakersDistribution.getUserPendingRewards(
       [simpleUsdcStaking.address],