@gooddollar/goodprotocol 1.0.8 → 1.0.11

package/contracts/staking/aave/GoodAaveStakingV2.sol

@@ -0,0 +1,263 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+import "../SimpleStakingV2.sol";
+import "../../Interfaces.sol";
+import "../../utils/DataTypes.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 GoodAaveStakingV2 is SimpleStakingV2 {
+	using UniswapV2SwapHelper for IHasRouter;
+
+	// Address of the TOKEN/USD oracle from chainlink
+	address public tokenUsdOracle;
+
+	//LendingPool of aave
+	ILendingPool public lendingPool;
+
+	//Address of the AaveIncentivesController
+	IAaveIncentivesController public incentiveController;
+
+	//address of the AAVE/USD oracle
+	address public aaveUSDOracle;
+	// Gas cost to collect interest from this staking contract
+	uint32 public collectInterestGasCost;
+	// Gas cost to claim stkAave rewards
+	uint32 public stkAaveClaimGasCost;
+
+	address[] public tokenToDaiSwapPath;
+
+	/**
+	 * @param _token Token to swap DEFI token
+	 * @param _lendingPool LendingPool 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 _tokenSymbol Determines blocks to pass for 1x Multiplier
+	 * @param _tokenUsdOracle address of the TOKEN/USD oracle
+	 * @param _incentiveController Aave incentive controller which provides AAVE rewards
+	 * @param _aaveUSDOracle address of the AAVE/USD oracle
+	 */
+	function init(
+		address _token,
+		address _lendingPool,
+		INameService _ns,
+		string memory _tokenName,
+		string memory _tokenSymbol,
+		uint64 _maxRewardThreshold,
+		address _tokenUsdOracle,
+		IAaveIncentivesController _incentiveController,
+		address _aaveUSDOracle,
+		address[] memory _tokenToDaiSwapPath
+	) public {
+		lendingPool = ILendingPool(_lendingPool);
+		DataTypes.ReserveData memory reserve = lendingPool.getReserveData(_token);
+		initialize(
+			_token,
+			reserve.aTokenAddress,
+			_ns,
+			_tokenName,
+			_tokenSymbol,
+			_maxRewardThreshold
+		);
+		require(
+			_tokenToDaiSwapPath[0] == _token &&
+				_tokenToDaiSwapPath[_tokenToDaiSwapPath.length - 1] ==
+				nameService.getAddress("DAI"),
+			"invalid _tokenToDaiSwapPath"
+		);
+		tokenToDaiSwapPath = _tokenToDaiSwapPath;
+
+		//above  initialize going  to revert on second call, so this is safe
+		tokenUsdOracle = _tokenUsdOracle;
+		incentiveController = _incentiveController;
+		aaveUSDOracle = _aaveUSDOracle;
+		collectInterestGasCost = 250000;
+		stkAaveClaimGasCost = 50000;
+		_approveTokens();
+	}
+
+	/**
+	 * @dev stake some Token
+	 * @param _amount of Token to stake
+	 */
+	function mintInterestToken(uint256 _amount) internal override {
+		lendingPool.deposit(address(token), _amount, address(this), 0);
+	}
+
+	/**
+	 * @dev redeem Token from aave
+	 * @param _amount of token to redeem in Token
+	 */
+	function redeem(uint256 _amount) internal override {
+		uint256 withdrawnAmount = lendingPool.withdraw(
+			address(token),
+			_amount,
+			address(this)
+		);
+		require(withdrawnAmount > 0, "Withdrawn amount should be bigger than zero");
+	}
+
+	/**
+	 * @dev Function to redeem aToken for DAI, so reserve knows how to handle it. (reserve can handle dai or cdai)
+	 * also transfers stkaave to reserve
+	 * @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 earned,
+			daiAmount total dai received
+	 */
+	function redeemUnderlyingToDAI(uint256 _amount, address _recipient)
+		internal
+		override
+		returns (
+			uint256 actualTokenGains,
+			uint256 actualRewardTokenGains,
+			uint256 daiAmount
+		)
+	{
+		//out of requested interests to withdraw how much is it safe to swap
+		actualTokenGains = IHasRouter(this).maxSafeTokenAmount(
+			address(token),
+			tokenToDaiSwapPath[1],
+			_amount,
+			maxLiquidityPercentageSwap
+		);
+
+		lendingPool.withdraw(address(token), actualTokenGains, address(this));
+		actualTokenGains = token.balanceOf(address(this));
+
+		address[] memory tokenAddress = new address[](1);
+		tokenAddress[0] = address(iToken);
+
+		actualRewardTokenGains = incentiveController.claimRewards(
+			tokenAddress,
+			type(uint256).max,
+			avatar
+		);
+
+		if (actualTokenGains > 0) {
+			daiAmount = IHasRouter(this).swap(
+				tokenToDaiSwapPath,
+				actualTokenGains,
+				0,
+				_recipient
+			);
+		}
+	}
+
+	/**
+	 * @dev returns decimals of token.
+	 */
+	function tokenDecimal() internal view override returns (uint256) {
+		ERC20 token = ERC20(address(token));
+		return uint256(token.decimals());
+	}
+
+	/**
+	 * @dev returns decimals of interest token.
+	 */
+	function iTokenDecimal() internal view override returns (uint256) {
+		ERC20 aToken = ERC20(address(iToken));
+		return uint256(aToken.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 current balance , balanceInUSD, tokenGainsInUSD
+	 */
+	function currentGains(
+		bool _returnTokenBalanceInUSD,
+		bool _returnTokenGainsInUSD
+	)
+		public
+		view
+		override
+		returns (
+			uint256 iTokenGains,
+			uint256 tokenGains,
+			uint256 tokenBalance,
+			uint256 balanceInUSD,
+			uint256 tokenGainsInUSD
+		)
+	{
+		ERC20 aToken = ERC20(address(iToken));
+		tokenBalance = aToken.balanceOf(address(this));
+		balanceInUSD = _returnTokenBalanceInUSD
+			? getTokenValueInUSD(tokenUsdOracle, tokenBalance, token.decimals())
+			: 0;
+		address[] memory tokenAddress = new address[](1);
+		tokenAddress[0] = address(token);
+		if (tokenBalance <= totalProductivity) {
+			return (0, 0, tokenBalance, balanceInUSD, 0);
+		}
+		iTokenGains = tokenGains = tokenBalance - totalProductivity;
+
+		tokenGainsInUSD = _returnTokenGainsInUSD
+			? getTokenValueInUSD(tokenUsdOracle, tokenGains, token.decimals())
+			: 0;
+	}
+
+	/**
+	 * @dev Function to get interest transfer cost for this particular staking contract
+	 */
+	function getGasCostForInterestTransfer()
+		external
+		view
+		override
+		returns (uint32)
+	{
+		address[] memory tokenAddress = new address[](1);
+		tokenAddress[0] = address(iToken);
+		uint256 stkAaaveBalance = incentiveController.getRewardsBalance(
+			tokenAddress,
+			address(this)
+		);
+		if (stkAaaveBalance > 0)
+			return collectInterestGasCost + stkAaveClaimGasCost;
+
+		return collectInterestGasCost;
+	}
+
+	/**
+	 * @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;
+		stkAaveClaimGasCost = _rewardTokenCollectCost;
+	}
+
+	/**
+	 * @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)
+	{
+		return _amount; // since aToken is peg to Token 1:1 return exact amount
+	}
+
+	function _approveTokens() internal {
+		address uniswapRouter = nameService.getAddress("UNISWAP_ROUTER");
+		token.approve(uniswapRouter, type(uint256).max);
+		token.approve(address(lendingPool), type(uint256).max); // approve the transfers to defi protocol as much as possible in order to save gas
+	}
+}

package/contracts/staking/compound/CompoundStakingFactory.sol

@@ -2,7 +2,7 @@
 
 pragma solidity >=0.8.0;
 import "@openzeppelin/contracts-upgradeable/proxy/ClonesUpgradeable.sol";
-import "./GoodCompoundStaking.sol";
+import "./GoodCompoundStakingV2.sol";
 import "../../Interfaces.sol";
 
 /**
@@ -14,23 +14,44 @@ import "../../Interfaces.sol";
 contract CompoundStakingFactory {
 	using ClonesUpgradeable for address;
 
-	address impl = address(new GoodCompoundStaking());
+	address public impl = address(new GoodCompoundStakingV2());
 
-	event Deployed(address proxy, address cToken);
+	event Deployed(address proxy, address cToken, address impl);
 
-	function clone(cERC20 cToken, bytes32 paramsHash)
-		public
-		returns (GoodCompoundStaking)
-	{
-		address deployed = address(impl).cloneDeterministic(
+	function clone(
+		address _impl,
+		cERC20 cToken,
+		bytes32 paramsHash
+	) internal returns (GoodCompoundStakingV2) {
+		address deployed = address(_impl).cloneDeterministic(
 			keccak256(abi.encodePacked(address(cToken), paramsHash))
 		);
-		emit Deployed(deployed, address(cToken));
-		return GoodCompoundStaking(deployed);
+		emit Deployed(deployed, address(cToken), _impl);
+		return GoodCompoundStakingV2(deployed);
+	}
+
+	function cloneAndInit(
+		cERC20 _cToken,
+		INameService _ns,
+		uint64 _maxRewardThreshold,
+		address _tokenUsdOracle,
+		address _compUsdOracle,
+		address[] memory _tokenToDaiSwapPath
+	) public {
+		cloneAndInit(
+			impl,
+			_cToken,
+			_ns,
+			_maxRewardThreshold,
+			_tokenUsdOracle,
+			_compUsdOracle,
+			_tokenToDaiSwapPath
+		);
 	}
 
 	/**
 	@dev Function to clone Staking contract and initialize new one with new ctoken
+	@param _impl address of contract to clone
 	@param cToken Staking cToken to use in staking contract
 	@param _ns NameService that holds whole necessary addresses
 	@param _maxRewardThreshold Block numbers that need to pass in order to user would get their rewards with 1x multiplier instead of 0.5x
@@ -38,6 +59,7 @@ contract CompoundStakingFactory {
 	@param _compUsdOracle address of the AAVE/USD oracle
 	 */
 	function cloneAndInit(
+		address _impl,
 		cERC20 cToken,
 		INameService _ns,
 		uint64 _maxRewardThreshold,
@@ -45,7 +67,8 @@ contract CompoundStakingFactory {
 		address _compUsdOracle,
 		address[] memory _tokenToDaiSwapPath
 	) public {
-		GoodCompoundStaking deployed = clone(
+		GoodCompoundStakingV2 deployed = clone(
+			_impl,
 			cToken,
 			keccak256(
 				abi.encodePacked(
@@ -60,7 +83,7 @@ contract CompoundStakingFactory {
 			cToken.underlying(),
 			address(cToken),
 			_ns,
-			string(abi.encodePacked("GoodCompoundStaking ", cToken.name())),
+			string(abi.encodePacked("GoodCompoundStakingV2 ", cToken.name())),
 			string(abi.encodePacked("g", cToken.symbol())),
 			_maxRewardThreshold,
 			_tokenUsdOracle,
@@ -69,13 +92,13 @@ contract CompoundStakingFactory {
 		);
 	}
 
-	function predictAddress(cERC20 cToken, bytes32 paramsHash)
-		public
-		view
-		returns (address)
-	{
+	function predictAddress(
+		address _impl,
+		cERC20 cToken,
+		bytes32 paramsHash
+	) public view returns (address) {
 		return
-			address(impl).predictDeterministicAddress(
+			address(_impl).predictDeterministicAddress(
 				keccak256(abi.encodePacked(address(cToken), paramsHash))
 			);
 	}

package/contracts/staking/compound/GoodCompoundStaking.sol

@@ -315,7 +315,7 @@ contract GoodCompoundStaking is SimpleStaking {
 		compCollectGasCost = _rewardTokenCollectCost;
 	}
 
-	function _approveTokens() internal override {
+	function _approveTokens() internal {
 		address uniswapRouter = address(uniswapContract);
 		comp.approve(uniswapRouter, type(uint256).max);
 		token.approve(uniswapRouter, type(uint256).max);

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.8",
+  "version": "1.0.11",
   "description": "GoodDollar Protocol",
   "scripts": {
     "build": "scripts/build.sh deploy",