@gooddollar/goodprotocol 1.0.9 → 1.0.13-beta.0

package/contracts/staking/compound/GoodCompoundStakingV2.sol

@@ -0,0 +1,315 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+import "../SimpleStakingV2.sol";
+import "../../Interfaces.sol";
+import "../UniswapV2SwapHelper.sol";
+
+/**
+ * @title Staking contract that donates earned interest to the DAO
+ * allowing stakers to deposit Token
+ * or withdraw their stake in Token
+ * the contracts buy cToken and can transfer the daily interest to the  DAO
+ */
+contract GoodCompoundStakingV2 is SimpleStakingV2 {
+	using UniswapV2SwapHelper for IHasRouter;
+
+	// Address of the TOKEN/USD oracle from chainlink
+	address tokenUsdOracle;
+	//Address of the COMP/USD oracle from chianlink
+	address compUsdOracle;
+
+	// Gas cost to collect interest from this staking contract
+	uint32 collectInterestGasCost;
+	// Gas cost to collect COMP rewards
+	uint32 compCollectGasCost;
+
+	address[] tokenToDaiSwapPath;
+
+	ERC20 comp;
+
+	Uniswap uniswapContract;
+
+	function getSettings()
+		external
+		view
+		returns (uint32 _collectInterestGasCost, uint32 _compCollectGasCost)
+	{
+		return (collectInterestGasCost, compCollectGasCost);
+	}
+
+	/**
+	 * @param _token Token to swap DEFI token
+	 * @param _iToken DEFI token address
+	 * @param _ns Address of the NameService
+	 * @param _tokenName Name of the staking token which will be provided to staker for their staking share
+	 * @param _tokenSymbol Symbol of the staking token which will be provided to staker for their staking share
+	 * @param _maxRewardThreshold Determines blocks to pass for 1x Multiplier
+	 * @param _tokenUsdOracle address of the TOKEN/USD oracle
+	 * @param _compUsdOracle address of the COMP/USD oracle
+	 * @param _tokenToDaiSwapPath the uniswap path to swap token to DAI, should be empty if token is DAI
+	 */
+	function init(
+		address _token,
+		address _iToken,
+		INameService _ns,
+		string memory _tokenName,
+		string memory _tokenSymbol,
+		uint64 _maxRewardThreshold,
+		address _tokenUsdOracle,
+		address _compUsdOracle,
+		address[] memory _tokenToDaiSwapPath
+	) public {
+		initialize(
+			_token,
+			_iToken,
+			_ns,
+			_tokenName,
+			_tokenSymbol,
+			_maxRewardThreshold
+		);
+
+		address dai = nameService.getAddress("DAI");
+		require(
+			_token == dai ||
+				(_tokenToDaiSwapPath[0] == _token &&
+					_tokenToDaiSwapPath[_tokenToDaiSwapPath.length - 1] == dai),
+			"path"
+		);
+
+		//above  initialize going  to revert on second call, so this is safe
+		compUsdOracle = _compUsdOracle;
+		tokenUsdOracle = _tokenUsdOracle;
+		tokenToDaiSwapPath = _tokenToDaiSwapPath;
+		comp = ERC20(nameService.getAddress("COMP"));
+		uniswapContract = Uniswap(nameService.getAddress("UNISWAP_ROUTER"));
+		collectInterestGasCost = 250000;
+		compCollectGasCost = 150000;
+		comp.approve(address(uniswapContract), type(uint256).max);
+		token.approve(address(uniswapContract), type(uint256).max);
+		token.approve(address(iToken), type(uint256).max); // approve the transfers to defi protocol as much as possible in order to save gas
+	}
+
+	/**
+	 * @dev stake some Token
+	 * @param _amount of Token to stake
+	 */
+	function mintInterestToken(uint256 _amount) internal override {
+		require(cERC20(address(iToken)).mint(_amount) == 0, "minting");
+	}
+
+	/**
+	 * @dev redeem Token from compound
+	 * @param _amount of token to redeem in Token
+	 */
+	function redeem(uint256 _amount) internal override {
+		require(cERC20(address(iToken)).redeemUnderlying(_amount) == 0, "redeem");
+	}
+
+	/**
+	 * @dev Function to redeem cToken + reward COMP for DAI, so reserve knows how to handle it. (reserve can handle dai or cdai)
+	 * @dev _amount of token in iToken
+	 * @dev _recipient recipient of the DAI
+	 * @return actualTokenGains amount of token redeemed for dai,
+			actualRewardTokenGains amount of reward token redeemed for dai,
+			daiAmount total dai received
+	 */
+	function redeemUnderlyingToDAI(uint256 _amount, address _recipient)
+		internal
+		override
+		returns (
+			uint256 actualTokenGains,
+			uint256 actualRewardTokenGains,
+			uint256 daiAmount
+		)
+	{
+		uint256 compBalance = comp.balanceOf(address(this));
+
+		uint256 redeemedDAI;
+
+		if (compBalance > 0) {
+			address[] memory compToDaiSwapPath = new address[](3);
+			compToDaiSwapPath[0] = address(comp);
+			compToDaiSwapPath[1] = uniswapContract.WETH();
+			compToDaiSwapPath[2] = nameService.getAddress("DAI");
+			actualRewardTokenGains = IHasRouter(this).maxSafeTokenAmount(
+				address(comp),
+				uniswapContract.WETH(),
+				compBalance,
+				maxLiquidityPercentageSwap
+			);
+
+			redeemedDAI = IHasRouter(this).swap(
+				compToDaiSwapPath,
+				actualRewardTokenGains,
+				0,
+				_recipient
+			);
+		}
+		//in case of cdai there's no need to swap to DAI, we send cdai to reserve directly
+		actualTokenGains = iTokenWorthInToken(_amount);
+		if (address(iToken) == nameService.getAddress("CDAI")) {
+			require(iToken.transfer(_recipient, _amount), "collect");
+			return (
+				actualTokenGains,
+				actualRewardTokenGains,
+				actualTokenGains + redeemedDAI
+			); // If iToken is cDAI then just return cDAI
+		}
+
+		//out of requested interests to withdraw how much is it safe to swap
+		uint256 safeAmount = IHasRouter(this).maxSafeTokenAmount(
+			address(token),
+			tokenToDaiSwapPath[1],
+			actualTokenGains,
+			maxLiquidityPercentageSwap
+		);
+
+		if (actualTokenGains > safeAmount) {
+			actualTokenGains = safeAmount;
+			//recalculate how much iToken to redeem
+			_amount = tokenWorthIniToken(actualTokenGains);
+		}
+
+		require(cERC20(address(iToken)).redeem(_amount) == 0, "iredeem");
+
+		actualTokenGains = token.balanceOf(address(this));
+
+		if (actualTokenGains > 0) {
+			redeemedDAI += IHasRouter(this).swap(
+				tokenToDaiSwapPath,
+				actualTokenGains,
+				0,
+				_recipient
+			);
+		}
+
+		return (actualTokenGains, actualRewardTokenGains, redeemedDAI);
+	}
+
+	/**
+	 * @dev returns decimals of token.
+	 */
+	function tokenDecimal() internal view override returns (uint256) {
+		return uint256(ERC20(address(token)).decimals());
+	}
+
+	/**
+	 * @dev returns decimals of interest token.
+	 */
+	function iTokenDecimal() internal view override returns (uint256) {
+		return uint256(ERC20(address(iToken)).decimals());
+	}
+
+	/**
+	 * @dev Function that calculates current interest gains of this staking contract
+	 * @param _returnTokenBalanceInUSD determine return token balance of staking contract in USD
+	 * @param _returnTokenGainsInUSD determine return token gains of staking contract in USD
+	 * @return  iTokenGains gains in itoken, tokenGains gains in token, tokenBalance total locked Tokens, balanceInUsd locked tokens worth in USD, tokenGainsInUSD token Gains in USD
+	 */
+	function currentGains(
+		bool _returnTokenBalanceInUSD,
+		bool _returnTokenGainsInUSD
+	)
+		public
+		view
+		override
+		returns (
+			uint256 iTokenGains,
+			uint256 tokenGains,
+			uint256 tokenBalance,
+			uint256 balanceInUSD,
+			uint256 tokenGainsInUSD
+		)
+	{
+		tokenBalance = iTokenWorthInToken(iToken.balanceOf(address(this)));
+		balanceInUSD = _returnTokenBalanceInUSD
+			? getTokenValueInUSD(tokenUsdOracle, tokenBalance, token.decimals())
+			: 0;
+		uint256 compValueInUSD = _returnTokenGainsInUSD
+			? getTokenValueInUSD(
+				compUsdOracle,
+				comp.balanceOf(address(this)),
+				18 // COMP is in 18 decimal
+			)
+			: 0;
+		if (tokenBalance <= totalProductivity) {
+			return (0, 0, tokenBalance, balanceInUSD, compValueInUSD);
+		}
+
+		tokenGains = tokenBalance - totalProductivity;
+		tokenGainsInUSD = _returnTokenGainsInUSD
+			? getTokenValueInUSD(tokenUsdOracle, tokenGains, token.decimals()) +
+				compValueInUSD
+			: 0;
+
+		iTokenGains = tokenWorthIniToken(tokenGains);
+	}
+
+	/**
+	 * @dev Function to get interest transfer cost for this particular staking contract
+	 */
+	function getGasCostForInterestTransfer()
+		external
+		view
+		override
+		returns (uint32)
+	{
+		uint256 compBalance = comp.balanceOf(address(this));
+		if (compBalance > 0) return collectInterestGasCost + 200000; // need to make more check for this value
+
+		return collectInterestGasCost;
+	}
+
+	/**
+	 * @dev Calculates worth of given amount of iToken in Token
+	 * @param _amount Amount of token to calculate worth in Token
+	 * @return Worth of given amount of token in Token
+	 */
+	function iTokenWorthInToken(uint256 _amount)
+		internal
+		view
+		override
+		returns (uint256)
+	{
+		uint256 er = cERC20(address(iToken)).exchangeRateStored();
+		(uint256 decimalDifference, bool caseType) = tokenDecimalPrecision();
+		uint256 mantissa = 18 + tokenDecimal() - iTokenDecimal();
+		uint256 tokenWorth = caseType == true
+			? (_amount * (10**decimalDifference) * er) / 10**mantissa
+			: ((_amount / (10**decimalDifference)) * er) / 10**mantissa; // calculation based on https://compound.finance/docs#protocol-math
+		return tokenWorth;
+	}
+
+	/**
+	 * @dev Calculates worth of given amount of token in iToken
+	 * @param _amount Amount of iToken to calculate worth in token
+	 * @return tokenWorth Worth of given amount of token in iToken
+	 */
+	function tokenWorthIniToken(uint256 _amount)
+		public
+		view
+		returns (uint256 tokenWorth)
+	{
+		uint256 er = cERC20(address(iToken)).exchangeRateStored();
+		(uint256 decimalDifference, bool caseType) = tokenDecimalPrecision();
+		uint256 mantissa = 18 + tokenDecimal() - iTokenDecimal();
+		tokenWorth = caseType == true
+			? ((_amount / (10**decimalDifference)) * 10**mantissa) / er
+			: ((_amount * (10**decimalDifference)) * 10**mantissa) / er; // calculation based on https://compound.finance/docs#protocol-math
+	}
+
+	/**
+	 * @dev Set Gas cost to interest collection for this contract
+	 * @param _collectInterestGasCost Gas cost to collect interest
+	 * @param _rewardTokenCollectCost gas cost to collect reward tokens
+	 */
+	function setcollectInterestGasCostParams(
+		uint32 _collectInterestGasCost,
+		uint32 _rewardTokenCollectCost
+	) external {
+		_onlyAvatar();
+		collectInterestGasCost = _collectInterestGasCost;
+		compCollectGasCost = _rewardTokenCollectCost;
+	}
+}

package/package.json

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

package/releases/deployment.json

@@ -321,62 +321,66 @@
     },
     "test": {
         "ProxyFactory": "0x36dE29DB57062A583436Ae071e141404dFE2311C",
-        "NameService": "0xAd8C024cE4E90D0bf00eD29f441581F6FDE54C34",
-        "GReputation": "0x80073051B408D4011221634c7fe464d16Eef4eb5",
-        "CompoundVotingMachine": "0xFA18ab3DD023DAFB2cEB6cb0507557b26362180E",
-        "ClaimersDistribution": "0x065A4F59bEE2Eaca8a73Ca4eD84CA0aB288b5BdD",
-        "GovernanceStaking": "0xcFa693a6B5d8399b771582afF07B5a8f55D75d40",
-        "UBIScheme": "0x4dd4301DB4461EbD0ac859fFFCc90531EBaC5D75",
-        "ProtocolUpgradeFuse": "0xAf49e224e71AF966D5367E6c8DED0CF7FcD110d0",
+        "NameService": "0x105678e10c32a29543902067fEd1BB2e5E0B3CEe",
+        "GReputation": "0xFf73F4DEeFFe4f7E53E20d757b99d82D465c93b9",
+        "CompoundVotingMachine": "0x1dfBd51e464E45A9Dfe33B79222D6B3f0bedC1f0",
+        "ClaimersDistribution": "0xB3375A6f09CFFF8591577d03133eeaF39cA76a84",
+        "GovernanceStaking": "0xFD6F7A6a5c21A3f503EBaE7a473639974379c351",
+        "UBIScheme": "0x137dbc6fd877D802c567B74741D9B2526685718A",
+        "ProtocolUpgradeFuse": "0x0ed64d01D0B4B655E410EF1441dD677B695639E7",
         "network": "test",
         "networkId": 4447,
-        "HomeBridge": "0xc90C13734D20e27904dF248FB850f50C81CE3642",
-        "OneTimePayments": "0x4D5D3FaE9b08a4FA2aEB9Bc0d86E3dB3b3126438",
-        "AdminWallet": "0x65E001B67f1aD28FF337C4F6e1cA52F31F5Eb9Fd",
-        "Identity": "0x473A31861aB89d5D7a78E7efc57ad31d84ED5343",
-        "GoodDollar": "0x040F0292f908c83BdEcCAE7600344503F2a20691",
-        "Controller": "0x75B282FdEaEce36C6E9363F30010058c284D9199",
-        "Avatar": "0xB3cbA81d4ce278661E26E2107936A014efc31343",
-        "FirstClaimPool": "0xd3aF095DE5D1419ADabE47a48d6110e37236A97F",
-        "BancorFormula": "0x0d6e43d4d7944408d9a5A10BC57B4348d61cD764",
-        "DAI": "0xB3a1e45D60f9394bC4327f5Dc46dB56D8a3c3688",
-        "cDAI": "0x1f720E7952650ED8Ca142feBD52aCBe8b7A21741",
-        "COMP": "0xD83C9f1B0DaFb1992eF92ac62D6509e54AD4eD48"
+        "HomeBridge": "0xDC11f7E700A4c898AE5CAddB1082cFfa76512aDD",
+        "OneTimePayments": "0x86A2EE8FAf9A840F7a2c64CA3d51209F9A02081D",
+        "AdminWallet": "0x34B40BA116d5Dec75548a9e9A8f15411461E8c70",
+        "Identity": "0x36b58F5C1969B7b6591D752ea6F5486D069010AB",
+        "GoodDollar": "0x5971B98C0066517Bae7D44021f42e50B77cfe1F9",
+        "Controller": "0xF380bC8b4e595dECa3A55A4C98A6C4fA1c96f537",
+        "Avatar": "0x724dbC61127E39A610Be416b455deb800d51A3B2",
+        "FirstClaimPool": "0x720472c8ce72c2A2D711333e064ABD3E6BbEAdd3",
+        "BancorFormula": "0xD8a5a9b31c3C0232E196d518E89Fd8bF83AcAd43",
+        "DAI": "0x4C4a2f8c81640e47606d3fd77B353E87Ba015584",
+        "cDAI": "0x2E2Ed0Cfd3AD2f1d34481277b3204d807Ca2F8c2",
+        "COMP": "0x21dF544947ba3E8b3c32561399E88B52Dc8b2823"
     },
     "test-mainnet": {
         "ProxyFactory": "0xce17442a9e26bcFDFAb2e9028e3A655d046f1654",
-        "NameService": "0x55125Ed5fa29594A8DbD7D0fB186888537B9c140",
-        "GReputation": "0x7235eC3c7b450eE36De0141b205d89D08C5de5fE",
-        "CompoundVotingMachine": "0xE8A10EA2E8764EB25684A2974913dDAbFefA4494",
-        "GoodMarketMaker": "0xF4eD16cBD64f07230C5bc9667357cE1D161DF894",
-        "GoodReserveCDai": "0x1bEA43626e0b6Afe157FBD1398093359261bB53e",
-        "ExchangeHelper": "0x6fad49b578CbF1d8F21b6dF17ccBB5d409Fb6BC8",
-        "GoodFundManager": "0x7963849A738719BE64c669c8Ce5613A6331C8caC",
-        "StakersDistribution": "0x5c73Ed454acB4467C0a35264D7a455C607FcE1bA",
-        "ProtocolUpgrade": "0x9c15162c1f7f01C64c0e068f2E48D39Cd7b18f86",
-        "UniswapV2SwapHelper": "0x39683C5c01B4a875FA7d4f5766D2Df521Fc0b4AD",
-        "CompoundStakingFactory": "0x712e1b726F6149C768fff8572CeA0Bdba23a561B",
-        "AaveStakingFactory": "0x36c7b0946e701EA6cE8e101B4C959FF15D0DeE15",
+        "NameService": "0xE88Cd74511b17f10363b557c2E9632CAab353b39",
+        "GReputation": "0x3B7bF1232414Bc52E3C233D0aF8524f259463034",
+        "CompoundVotingMachine": "0xA6F88E890518adAB4517f95c74b0aF4370b7e0be",
+        "GoodMarketMaker": "0xa3b0167657e47ABa3b541C1b21448B449f2CE3bc",
+        "GoodReserveCDai": "0xFE67C7f6d6A9eDA3adE28d8d1bdf1B764491E823",
+        "ExchangeHelper": "0x9bDB9d2aD7Aaf2763e49aa518A3b3CC4798210c6",
+        "GoodFundManager": "0xfE16B3e38B6eEb8f4eA0C820cB4547ec03edFE0e",
+        "StakersDistribution": "0xab06522CFF9ec6302a32b9db057293E80e1BC43a",
+        "ProtocolUpgrade": "0x5D42EBdBBa61412295D7b0302d6F50aC449Ddb4F",
+        "UniswapV2SwapHelper": "0xddE78e6202518FF4936b5302cC2891ec180E8bFf",
+        "CompoundStakingFactory": "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5",
+        "AaveStakingFactory": "0xaB7B4c595d3cE8C85e16DA86630f2fc223B05057",
         "network": "test-mainnet",
         "networkId": 4447,
-        "ForeignBridge": "0x9F95c870a4104603630CBEDBbbd56c6465Cc8A58",
-        "Contribution": "0x770ace66dd84B035F71FfC977448032EE688604d",
+        "ForeignBridge": "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9",
+        "Contribution": "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0",
         "StakingContracts": [
             [
-                "0xb440419193c65B52e68a819BBe11Bd770Bf93B33",
+                "0x8f19E89ed457Ca4a3cb0dF96653d1952F465ca4A",
                 13888
+            ],
+            [
+                "0x810D8eB0BC99Faebc340EcA183e0110Cf0635A89",
+                "6944"
             ]
         ],
-        "DonationsStaking": "0x4e21A8F1d5C27C3A99b2781E1aB215f6a75A0122",
-        "Identity": "0x66a2BECe75FCE45ddFe2C06216CE9350a4c46498",
-        "GoodDollar": "0x53DE0F59992D932020ad00CF4ABEe89051F8961d",
-        "Controller": "0x86851c91c15A49Ba4a9Cc9859f2d84C47b7aD91d",
-        "Avatar": "0xB8FC6cFAb3E190e648aac2d7aB69d466f3674bDB",
-        "FirstClaimPool": "0x59E0b0C67a8f14BE8C5855C95CdD2ba95a7f2BbB",
-        "BancorFormula": "0x1aaaD333A7d363a8576779B71BF589580cC9D82E",
-        "DAI": "0x63766F0efAa46a86E9055bB46e41ff7bc64CBEA2",
-        "cDAI": "0x24ef01de6baE76eE73Da210940A296F739d87952",
-        "COMP": "0x3C3297C2Be0F0C51b604dC0A798cF610d7406De2"
+        "DonationsStaking": "0x0B92eE05ABeeeEdef0a0e861468A4317d6E2AC93",
+        "Identity": "0x0165878A594ca255338adfa4d48449f69242Eb8F",
+        "GoodDollar": "0x9bd03768a7DCc129555dE410FF8E85528A4F88b5",
+        "Controller": "0x23dB4a08f2272df049a4932a4Cc3A6Dc1002B33E",
+        "Avatar": "0x61c36a8d610163660E21a8b7359e1Cac0C9133e1",
+        "FirstClaimPool": "0xE6E340D132b5f46d1e472DebcD681B2aBc16e57E",
+        "BancorFormula": "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
+        "DAI": "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+        "cDAI": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
+        "COMP": "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"
     },
     "production": {
         "ProxyFactory": "0x4659176E962763e7C8A4eF965ecfD0fdf9f52057",
@@ -415,8 +419,8 @@
         "StakersDistribution": "0x12D15EfC3c9661AD68209CD197D416BFd9B145f5",
         "ProtocolUpgrade": "0xfc918F32D89b7592Fbda5a0FbC7Eaa0c9a0d5d4a",
         "UniswapV2SwapHelper": "0x62305662fA7c4BC442803b940d9192DbDC92D710",
-        "CompoundStakingFactory": "0x2C89e77d53C31ED6b331a19207799B3C11Db07eA",
-        "AaveStakingFactory": "0xa9Ec98203296ED5BC3985490058575e49c40300a",
+        "CompoundStakingFactory": "0x5f6f25143cd580e2e285210d7cfcb26e59cf9566",
+        "AaveStakingFactory": "0xa99ba154223052b8c5fd92b3f5df9eb08b72d5fc",
         "network": "production-mainnet",
         "networkId": 1,
         "ForeignBridge": "0xD5D11eE582c8931F336fbcd135e98CEE4DB8CCB0",
@@ -424,10 +428,16 @@
         "StakingContracts": [
             [
                 "0xD33bA17C8A644C585089145e86E282fada6F3bfd",
+                310
+            ]
+        ],
+        "StakingContractsV2": [
+            [
+                "0x02416eb83cff1f19163f21010149c3867f3261e1",
                 13888
             ],
             [
-                "0x589ceb6cA1112f7aCCA19930b47871c5A259B0fC",
+                "0xf4c34bed7dd779485692bb1857acf9c561b45010",
                 6944
             ]
         ],

package/scripts/upgradeToV2/upgradeToV2.ts

@@ -819,7 +819,9 @@ export const main = async (
         ]
       });
       const tx = await (
-        await compfactory.cloneAndInit(
+        await compfactory[
+          "cloneAndInit(address,address,uint64,address,address,address[])"
+        ](
           token.address,
           release.NameService,
           protocolSettings.staking.fullRewardsThreshold, //blocks before switching for 0.5x rewards to 1x multiplier
@@ -841,7 +843,7 @@ export const main = async (
     //   Promise.resolve(["0x9999c40c8b88c740076b15d2e708db6a7a071b53", 13888])
     // ];
     let deployed;
-    if (!isRopsten && !isDevelop) {
+    if (!isRopsten || isTest) {
       const aaveps = aaveTokens.map(async token => {
         let rewardsPerBlock = (protocolSettings.staking.rewardsPerBlock / 2) //aave gets half of the rewards
           .toFixed(0);
@@ -851,7 +853,9 @@ export const main = async (
           rewardsPerBlock
         });
         const tx = await (
-          await aavefactory.cloneAndInit(
+          await aavefactory[
+            "cloneAndInit(address,address,address,uint64,address,address,address,address[])"
+          ](
             token.address,
             get(protocolSettings, "aave.lendingPool", dao.AaveLendingPool),
             release.NameService,

package/test/governance/StakersDistribution.test.ts

@@ -149,7 +149,7 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     const router = uniswap.router;
     await setDAOAddress("UNISWAP_ROUTER", router.address);
 
-    let simpleStakingFactory = await getStakingFactory("GoodCompoundStaking");
+    let simpleStakingFactory = await getStakingFactory("GoodCompoundStakingV2");
 
     simpleUsdcStaking = await simpleStakingFactory
       .deploy()
@@ -774,4 +774,33 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     expect(usdcStakingProductivity[1]).to.be.equal(daiStakingProductivity[1]);
     expect(usdcStakingRewardsPerBlock).to.be.equal(daiStakingRewardsPerBlock);
   });
+
+  it("should be able to transfer staking token when using stakersdistribution", async () => {
+    const stakingAmountDai = ethers.utils.parseEther("10000");
+    const stakingAmountUsdc = ethers.utils.parseUnits("10000", 6);
+    await dai["mint(address,uint256)"](staker.address, stakingAmountDai);
+    await dai.connect(staker).approve(simpleStaking.address, stakingAmountDai);
+    await usdc["mint(address,uint256)"](staker.address, stakingAmountUsdc);
+    await usdc
+      .connect(staker)
+      .approve(simpleUsdcStaking.address, stakingAmountUsdc);
+    await simpleStaking.connect(staker).stake(stakingAmountDai, 0, false);
+    await increaseTime(86700 * 30); // Increase one month
+    await simpleUsdcStaking.connect(staker).stake(stakingAmountUsdc, 0, false);
+    await advanceBlocks(10);
+
+    await simpleUsdcStaking
+      .connect(staker)
+      .transfer(signers[1].address, stakingAmountUsdc);
+
+    expect(await simpleUsdcStaking.balanceOf(signers[1].address)).to.eq(
+      stakingAmountUsdc
+    );
+    expect(await simpleUsdcStaking.balanceOf(staker.address)).to.eq(0);
+    // await expect(
+    //   simpleStaking
+    //     .connect(staker)
+    //     .transfer(signers[1].address, ethers.utils.parseEther("10000"))
+    // ).to.not.reverted;
+  });
 });

package/test/helpers.ts

@@ -23,6 +23,7 @@ export const getStakingFactory = async (
     | "GoodAaveStaking"
     | "GoodCompoundStakingTest"
     | "GoodAaveStakingV2"
+    | "GoodCompoundStakingV2"
 ) => {
   let swapHelper = await ethers
     .getContractFactory("UniswapV2SwapHelper")

package/test/staking/CompoundStakingFactory.test.ts

@@ -4,7 +4,7 @@ import { expect } from "chai";
 import {
   CERC20,
   GoodCompoundStaking,
-  CompoundStakingFactory,
+  CompoundStakingFactory
 } from "../../types";
 import { createDAO, deployUniswap } from "../helpers";
 import { Contract } from "ethers";
@@ -46,33 +46,35 @@ describe("CompoundStakingFactory", () => {
     await dao.setDAOAddress("UNISWAP_ROUTER", router.address);
     let swapHelper = await ethers
       .getContractFactory("UniswapV2SwapHelper")
-      .then((_) => _.deploy());
+      .then(_ => _.deploy());
 
     stakingFactory = (await ethers
       .getContractFactory("CompoundStakingFactory", {
-        libraries: { UniswapV2SwapHelper: swapHelper.address },
+        libraries: { UniswapV2SwapHelper: swapHelper.address }
       })
-      .then((_) => _.deploy())) as CompoundStakingFactory;
+      .then(_ => _.deploy())) as CompoundStakingFactory;
   });
 
-  it("should create proxy clone", async () => {
-    const res = await (
-      await stakingFactory.clone(cdai, ethers.constants.HashZero)
-    ).wait();
-    const log = res.events.find((_) => _.event === "Deployed");
-    const detAddress = await stakingFactory.predictAddress(
-      cdai,
-      ethers.constants.HashZero
-    );
-    expect(log).to.not.empty;
-    expect(log.args.proxy).to.equal(detAddress);
-    expect(log.args.cToken).to.equal(cdai);
-  });
+  // it("should create proxy clone", async () => {
+  //   const res = await (
+  //     await stakingFactory.clone(cdai, ethers.constants.HashZero)
+  //   ).wait();
+  //   const log = res.events.find(_ => _.event === "Deployed");
+  //   const detAddress = await stakingFactory.predictAddress(
+  //     cdai,
+  //     ethers.constants.HashZero
+  //   );
+  //   expect(log).to.not.empty;
+  //   expect(log.args.proxy).to.equal(detAddress);
+  //   expect(log.args.cToken).to.equal(cdai);
+  // });
 
   it("should create and initialize clone", async () => {
     console.log(await dao.nameService.getAddress("UNISWAP_ROUTER"));
     const res = await (
-      await stakingFactory.cloneAndInit(
+      await stakingFactory[
+        "cloneAndInit(address,address,uint64,address,address,address[])"
+      ](
         cdai,
         dao.nameService.address,
         5760,
@@ -81,8 +83,9 @@ describe("CompoundStakingFactory", () => {
         []
       )
     ).wait();
-    const log = res.events.find((_) => _.event === "Deployed");
+    const log = res.events.find(_ => _.event === "Deployed");
     const detAddress = await stakingFactory.predictAddress(
+      await stakingFactory.impl(),
       cdai,
       ethers.utils.solidityKeccak256(
         ["address", "uint64", "address", "address[]"],
@@ -95,12 +98,12 @@ describe("CompoundStakingFactory", () => {
 
     //check initialization
     const staking: GoodCompoundStaking = (await ethers.getContractAt(
-      "GoodCompoundStaking",
+      "GoodCompoundStakingV2",
       detAddress
     )) as GoodCompoundStaking;
     expect(await staking.iToken()).to.equal(cdai);
     expect(await staking.token()).to.equal(dai);
-    expect(await staking.name()).to.equal("GoodCompoundStaking Compound DAI");
+    expect(await staking.name()).to.equal("GoodCompoundStakingV2 Compound DAI");
     expect(await staking.symbol()).to.equal("gcDAI");
   });
 });

package/test/staking/DifferentStakingTokens.test.ts

@@ -90,7 +90,9 @@ describe("Different decimals staking token", () => {
     goodDollar = await ethers.getContractAt("IGoodDollar", gd);
 
     tokenUsdOracleFactory = await ethers.getContractFactory("BatUSDMockOracle");
-    goodCompoundStakingFactory = await getStakingFactory("GoodCompoundStaking");
+    goodCompoundStakingFactory = await getStakingFactory(
+      "GoodCompoundStakingV2"
+    );
 
     tokenFactory = await ethers.getContractFactory("DecimalsMock");
     cTokenFactory = await ethers.getContractFactory("cDecimalsMock");

package/test/staking/DonationsStaking.test.ts

@@ -57,7 +57,9 @@ describe("DonationsStaking - DonationStaking contract that receives funds in ETH
     const goodFundManagerFactory = await ethers.getContractFactory(
       "GoodFundManager"
     );
-    goodCompoundStakingFactory = await getStakingFactory("GoodCompoundStaking");
+    goodCompoundStakingFactory = await getStakingFactory(
+      "GoodCompoundStakingV2"
+    );
 
     const daiFactory = await ethers.getContractFactory("DAIMock");
     let {