@gooddollar/goodprotocol 2.0.25-beta.0 → 2.0.25-beta.10

package/contracts/reserve/GoodReserveCDai.sol

@@ -59,6 +59,9 @@ contract GoodReserveCDai is
 
 	bool public gdxDisabled;
 	bool public discountDisabled;
+
+	uint256 private _reentrantStatus;
+
 	// Emits when new GD tokens minted
 	event UBIMinted(
 		//epoch of UBI
@@ -186,19 +189,21 @@ contract GoodReserveCDai is
 		uint256 _tokenAmount,
 		uint256 _minReturn,
 		address _targetAddress
-	) external returns (uint256) {
+	) external nonReentrant returns (uint256) {
 		ERC20 buyWith = ERC20(cDaiAddress);
 		uint256 gdReturn = getMarketMaker().buy(buyWith, _tokenAmount);
 		_targetAddress = _targetAddress == address(0x0)
 			? msg.sender
 			: _targetAddress;
 		address exchangeHelper = nameService.getAddress("EXCHANGE_HELPER");
-		if (msg.sender != exchangeHelper)
-			require(
-				buyWith.transferFrom(msg.sender, address(this), _tokenAmount) == true,
-				"transferFrom failed, make sure you approved input token transfer"
-			);
+
+		require(
+			buyWith.transferFrom(msg.sender, address(this), _tokenAmount) == true,
+			"transferFrom failed, make sure you approved input token transfer"
+		);
+
 		require(gdReturn >= _minReturn, "GD return must be above the minReturn");
+
 		_mintGoodDollars(_targetAddress, gdReturn, true);
 		//mint GDX
 		_mintGDX(_targetAddress, gdReturn);
@@ -224,7 +229,7 @@ contract GoodReserveCDai is
 		address _token,
 		address _to,
 		uint256 _amount
-	) external {
+	) external nonReentrant {
 		getMarketMaker().mintFromReserveRatio(ERC20(_token), _amount);
 		_mintGoodDollars(_to, _amount, false);
 		//mint GDX
@@ -247,16 +252,24 @@ contract GoodReserveCDai is
 		uint256 _minReturn,
 		address _target,
 		address _seller
-	) external returns (uint256, uint256) {
+	) external nonReentrant returns (uint256, uint256) {
 		require(paused() == false, "paused");
 		GoodMarketMaker mm = getMarketMaker();
 		if (msg.sender != nameService.getAddress("EXCHANGE_HELPER")) {
-			IGoodDollar(nameService.getAddress("GOODDOLLAR")).burnFrom(
-				msg.sender,
-				_gdAmount
-			);
 			_seller = msg.sender;
 		}
+
+		/**
+		 * transferfrom and then burn instead of burnfrom to make sure funds after fee are valid
+		 * ie specifically for addresses that hold stolen funds who has 100% fee applied
+		 */
+		IGoodDollar(nameService.getAddress("GOODDOLLAR")).transferFrom(
+			msg.sender,
+			address(this),
+			_gdAmount
+		);
+		IGoodDollar(nameService.getAddress("GOODDOLLAR")).burn(_gdAmount);
+
 		_target = _target == address(0x0) ? msg.sender : _target;
 		//discount on exit contribution based on gdx
 
@@ -358,18 +371,21 @@ contract GoodReserveCDai is
 	 * @dev only FundManager or other with mint G$ permission can call this to trigger minting.
 	 * Reserve sends UBI + interest to FundManager.
 	 * @param _daiToConvert DAI amount to convert cDAI
-	 * @param _startingCDAIBalance Initial cDAI balance before staking collect process start
 	 * @param _interestToken The token that was transfered to the reserve
 	 * @return gdUBI,interestInCdai how much GD UBI was minted and how much cDAI collected from staking contracts
 	 */
 	function mintUBI(
 		uint256 _daiToConvert,
-		uint256 _startingCDAIBalance,
+		uint256 /*_startingCDAIBalance*/, // dont trust it, use reserveSupply from marketmaker instead
 		ERC20 _interestToken
-	) external returns (uint256, uint256) {
+	) external nonReentrant returns (uint256, uint256) {
 		cERC20(cDaiAddress).mint(_daiToConvert);
+
+		(uint256 reserveSupply, , , ) = getMarketMaker().reserveTokens(cDaiAddress);
+
 		uint256 interestInCdai = _interestToken.balanceOf(address(this)) -
-			_startingCDAIBalance;
+			reserveSupply;
+
 		uint256 gdInterestToMint = getMarketMaker().mintInterest(
 			_interestToken,
 			interestInCdai
@@ -519,4 +535,16 @@ contract GoodReserveCDai is
 	function when() public pure override returns (CallPhase) {
 		return CallPhase.Pre;
 	}
+
+	modifier nonReentrant() {
+		// On the first call to nonReentrant, _status will be _NOT_ENTERED
+		require(_reentrantStatus != 1, "ReentrancyGuard: reentrant call");
+
+		// Any calls to nonReentrant after this point will fail
+		_reentrantStatus = 1;
+		_;
+		// By storing the original value once again, a refund is triggered (see
+		// https://eips.ethereum.org/EIPS/eip-2200)
+		_reentrantStatus = 0;
+	}
 }

package/contracts/staking/FuseStakingV3.sol

@@ -103,7 +103,7 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		validators.push(address(0xcb876A393F05a6677a8a029f1C6D7603B416C0A6));
 		stakeBackRatio = 33333; //%33
 		communityPoolRatio = 33333; //%33
-		maxSlippageRatio = 3000; //3%
+		maxSlippageRatio = 600; //0.6%
 		keeperFeeRatio = 30; //0.03%
 		RATIO_BASE = 100000; //100%
 		uniswap = Uniswap(
@@ -146,10 +146,12 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 
 	function updateSettings(
 		uint256 _stakeBackRatio,
-		uint256 _communityPoolRatio
+		uint256 _communityPoolRatio,
+		uint256 _maxSlippageRatio
 	) external onlyGuardian {
 		communityPoolRatio = _communityPoolRatio;
 		stakeBackRatio = _stakeBackRatio;
+		maxSlippageRatio = _maxSlippageRatio;
 	}
 
 	function stake() public payable returns (bool) {

package/contracts/staking/GoodFundManager.sol

@@ -32,6 +32,13 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 	//address of the active staking contracts
 	address[] public activeContracts;
 
+	// Rewards per block for particular Staking contract
+	mapping(address => Reward) public rewardsForStakingContract;
+
+	uint256 private _reentrantStatus;
+
+	/** ADD NEW VARIABLES AFTER THIS LINE **/
+
 	event GasCostSet(uint256 newGasCost);
 	event CollectInterestTimeThresholdSet(
 		uint256 newCollectInterestTimeThreshold
@@ -62,8 +69,7 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 		uint256 maxGasAmountSoFar; //  Max gas amount that can spend to collect this interest according to interest amount
 		bool maxGasLargerOrEqualRequired; // Bool that indicates if max gas amount larger or equal to actual gas needed
 	}
-	// Rewards per block for particular Staking contract
-	mapping(address => Reward) public rewardsForStakingContract;
+
 	// Emits when `transferInterest` transfers
 	// funds to the staking contract and to
 	// the bridge
@@ -221,7 +227,7 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 	function collectInterest(
 		address[] calldata _stakingContracts,
 		bool _forceAndWaiverRewards
-	) external {
+	) external nonReentrant {
 		uint256 initialGas = gasleft();
 		uint256 gdUBI;
 		uint256 interestInCdai;
@@ -242,6 +248,10 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 				// elements are sorted by balances from lowest to highest
 
 				if (_stakingContracts[i - 1] != address(0x0)) {
+					require(
+						isActiveContract(_stakingContracts[i - 1]),
+						"collectInterest: not a dao contract"
+					);
 					IGoodStaking(_stakingContracts[i - 1]).collectUBIInterest(
 						reserveAddress
 					);
@@ -277,7 +287,11 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 			if (
 				block.timestamp >= lastCollectedInterest + collectInterestTimeThreshold
 			) {
-				require(interestInCdai >= gasPriceIncDAI, "UBI < gas costs"); // This require is necessary to keeper can not abuse this function
+				require(
+					interestInCdai >= gasPriceIncDAI ||
+						gdUBI >= interestMultiplier * gdRewardToMint,
+					"UBI < gas costs"
+				); // This require is necessary to keeper can not abuse this function
 			} else {
 				require(
 					interestInCdai >= interestMultiplier * gasPriceIncDAI ||
@@ -299,6 +313,20 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 		lastCollectedInterestBlock = block.number;
 	}
 
+	/**
+	 * @dev verifies that contract was added to the approved staking contracts in the past, and is not blacklisted
+	 * @param _contract address of the contract
+	 * @return isActive true if contract is active
+	 **/
+	function isActiveContract(
+		address _contract
+	) public view returns (bool isActive) {
+		return
+			!rewardsForStakingContract[_contract].isBlackListed &&
+			(rewardsForStakingContract[_contract].blockStart > 0 ||
+				rewardsForStakingContract[_contract].blockEnd > 0);
+	}
+
 	/**
 	 * @dev  Function that get interest informations of staking contracts in the sorted array by highest interest to lowest interest amount
 	 * @return array of interestInfo struct
@@ -467,4 +495,16 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 	function getActiveContractsCount() public view returns (uint256) {
 		return activeContracts.length;
 	}
+
+	modifier nonReentrant() {
+		// On the first call to nonReentrant, _status will be _NOT_ENTERED
+		require(_reentrantStatus != 1, "ReentrancyGuard: reentrant call");
+
+		// Any calls to nonReentrant after this point will fail
+		_reentrantStatus = 1;
+		_;
+		// By storing the original value once again, a refund is triggered (see
+		// https://eips.ethereum.org/EIPS/eip-2200)
+		_reentrantStatus = 0;
+	}
 }

package/contracts/utils/BulkWhitelist.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+import "../Interfaces.sol";
+import "../utils/NameService.sol";
+import "./AdminWallet.sol";
+
+/* @title Admin wallet contract allowing whitelisting and topping up of
+ * addresses
+ */
+contract BulkWhitelist {
+	AdminWallet adminWallet;
+
+	constructor(AdminWallet _adminWallet) {
+		adminWallet = _adminWallet;
+	}
+
+	modifier onlyAdmin() {
+		require(adminWallet.isAdmin(msg.sender), "not admin");
+		_;
+	}
+
+	receive() external payable {}
+
+	function whitelist(
+		address[] memory _user,
+		string[] memory _did,
+		uint256[] memory orgChain,
+		uint256[] memory dateAuthenticated
+	) external onlyAdmin {
+		for (uint i = 0; i < _user.length; i++) {
+			adminWallet.whitelist(
+				_user[i],
+				_did[i],
+				orgChain[i],
+				dateAuthenticated[i]
+			);
+		}
+		uint256 toTop = address(this).balance;
+		payable(address(msg.sender)).transfer(toTop);
+	}
+
+	function removeWhitelisted(address[] memory _user) external onlyAdmin {
+		for (uint i = 0; i < _user.length; i++) {
+			adminWallet.removeWhitelist(_user[i]);
+		}
+
+		uint256 toTop = address(this).balance;
+		payable(address(msg.sender)).transfer(toTop);
+	}
+}

package/contracts/utils/BuyGDClone.sol

@@ -6,128 +6,6 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@mean-finance/uniswap-v3-oracle/solidity/interfaces/IStaticOracle.sol";
 import "../Interfaces.sol";
 
-// @uniswap/v3-core
-interface ISwapRouter {
-	struct ExactInputSingleParams {
-		address tokenIn;
-		address tokenOut;
-		uint24 fee;
-		address recipient;
-		uint256 amountIn;
-		uint256 amountOutMinimum;
-		uint160 sqrtPriceLimitX96;
-	}
-
-	/// @notice Swaps `amountIn` of one token for as much as possible of another token
-	/// @dev Setting `amountIn` to 0 will cause the contract to look up its own balance,
-	/// and swap the entire amount, enabling contracts to send tokens before calling this function.
-	/// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
-	/// @return amountOut The amount of the received token
-	function exactInputSingle(
-		ExactInputSingleParams calldata params
-	) external payable returns (uint256 amountOut);
-
-	struct ExactInputParams {
-		bytes path;
-		address recipient;
-		uint256 amountIn;
-		uint256 amountOutMinimum;
-	}
-
-	/// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
-	/// @dev Setting `amountIn` to 0 will cause the contract to look up its own balance,
-	/// and swap the entire amount, enabling contracts to send tokens before calling this function.
-	/// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
-	/// @return amountOut The amount of the received token
-	function exactInput(
-		ExactInputParams calldata params
-	) external payable returns (uint256 amountOut);
-
-	struct ExactOutputSingleParams {
-		address tokenIn;
-		address tokenOut;
-		uint24 fee;
-		address recipient;
-		uint256 amountOut;
-		uint256 amountInMaximum;
-		uint160 sqrtPriceLimitX96;
-	}
-
-	/// @notice Swaps as little as possible of one token for `amountOut` of another token
-	/// that may remain in the router after the swap.
-	/// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
-	/// @return amountIn The amount of the input token
-	function exactOutputSingle(
-		ExactOutputSingleParams calldata params
-	) external payable returns (uint256 amountIn);
-
-	struct ExactOutputParams {
-		bytes path;
-		address recipient;
-		uint256 amountOut;
-		uint256 amountInMaximum;
-	}
-
-	/// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
-	/// that may remain in the router after the swap.
-	/// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
-	/// @return amountIn The amount of the input token
-	function exactOutput(
-		ExactOutputParams calldata params
-	) external payable returns (uint256 amountIn);
-}
-
-interface IQuoterV2 {
-	/// @notice Returns the amount out received for a given exact input swap without executing the swap
-	/// @param path The path of the swap, i.e. each token pair and the pool fee
-	/// @param amountIn The amount of the first token to swap
-	/// @return amountOut The amount of the last token that would be received
-	/// @return sqrtPriceX96AfterList List of the sqrt price after the swap for each pool in the path
-	/// @return initializedTicksCrossedList List of the initialized ticks that the swap crossed for each pool in the path
-	/// @return gasEstimate The estimate of the gas that the swap consumes
-	function quoteExactInput(
-		bytes memory path,
-		uint256 amountIn
-	)
-		external
-		returns (
-			uint256 amountOut,
-			uint160[] memory sqrtPriceX96AfterList,
-			uint32[] memory initializedTicksCrossedList,
-			uint256 gasEstimate
-		);
-
-	struct QuoteExactInputSingleParams {
-		address tokenIn;
-		address tokenOut;
-		uint256 amountIn;
-		uint24 fee;
-		uint160 sqrtPriceLimitX96;
-	}
-
-	/// @notice Returns the amount out received for a given exact input but for a swap of a single pool
-	/// @param params The params for the quote, encoded as `QuoteExactInputSingleParams`
-	/// tokenIn The token being swapped in
-	/// tokenOut The token being swapped out
-	/// fee The fee of the token pool to consider for the pair
-	/// amountIn The desired input amount
-	/// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
-	/// @return amountOut The amount of `tokenOut` that would be received
-	/// @return sqrtPriceX96After The sqrt price of the pool after the swap
-	/// @return initializedTicksCrossed The number of initialized ticks that the swap crossed
-	/// @return gasEstimate The estimate of the gas that the swap consumes
-	function quoteExactInputSingle(
-		QuoteExactInputSingleParams memory params
-	)
-		external
-		returns (
-			uint256 amountOut,
-			uint160 sqrtPriceX96After,
-			uint32 initializedTicksCrossed,
-			uint256 gasEstimate
-		);
-}
-
 /*
  * @title BuyGDClone
  * @notice This contract allows users to swap Celo or cUSD for GoodDollar (GD) tokens.

package/contracts/utils/FuseOldBridgeKill.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8;
+
+import "../Interfaces.sol";
+
+interface IUpgradeabilityOwnerStorage {
+	function upgradeabilityOwner() external view returns (address);
+}
+
+contract Upgradeable {
+	// Avoid using onlyUpgradeabilityOwner name to prevent issues with implementation from proxy contract
+	modifier onlyIfUpgradeabilityOwner() {
+		require(
+			msg.sender ==
+				IUpgradeabilityOwnerStorage(address(this)).upgradeabilityOwner()
+		);
+		/* solcov ignore next */
+		_;
+	}
+}
+
+/**
+ * @title EternalStorage
+ * @dev This contract holds all the necessary state variables to carry out the storage of any contract.
+ */
+contract EternalStorage {
+	mapping(bytes32 => uint256) internal uintStorage;
+	mapping(bytes32 => string) internal stringStorage;
+	mapping(bytes32 => address) internal addressStorage;
+	mapping(bytes32 => bytes) internal bytesStorage;
+	mapping(bytes32 => bool) internal boolStorage;
+	mapping(bytes32 => int256) internal intStorage;
+}
+
+/**
+ * @title Ownable
+ * @dev This contract has an owner address providing basic authorization control
+ */
+contract Ownable is EternalStorage {
+	bytes4 internal constant UPGRADEABILITY_OWNER = 0x6fde8202; // upgradeabilityOwner()
+
+	/**
+	 * @dev Event to show ownership has been transferred
+	 * @param previousOwner representing the address of the previous owner
+	 * @param newOwner representing the address of the new owner
+	 */
+	event OwnershipTransferred(address previousOwner, address newOwner);
+
+	/**
+	 * @dev Throws if called by any account other than the owner.
+	 */
+	modifier onlyOwner() {
+		require(msg.sender == owner());
+		/* solcov ignore next */
+		_;
+	}
+
+	/**
+	 * @dev Throws if called by any account other than contract itself or owner.
+	 */
+	modifier onlyRelevantSender() {
+		// proxy owner if used through proxy, address(0) otherwise
+		(bool ok, bytes memory addr) = address(this).call(
+			abi.encodeWithSelector(UPGRADEABILITY_OWNER)
+		);
+		address upgowner = abi.decode(addr, (address));
+		require(
+			(ok && upgowner != address(0)) || // covers usage without calling through storage proxy
+				msg.sender ==
+				IUpgradeabilityOwnerStorage(address(this)).upgradeabilityOwner() || // covers usage through regular proxy calls
+				msg.sender == address(this) // covers calls through upgradeAndCall proxy method
+		);
+		/* solcov ignore next */
+		_;
+	}
+
+	bytes32 internal constant OWNER =
+		0x02016836a56b71f0d02689e69e326f4f4c1b9057164ef592671cf0d37c8040c0; // keccak256(abi.encodePacked("owner"))
+
+	/**
+	 * @dev Tells the address of the owner
+	 * @return the address of the owner
+	 */
+	function owner() public view returns (address) {
+		return addressStorage[OWNER];
+	}
+
+	/**
+	 * @dev Allows the current owner to transfer control of the contract to a newOwner.
+	 * @param newOwner the address to transfer ownership to.
+	 */
+	function transferOwnership(address newOwner) external onlyOwner {
+		require(newOwner != address(0));
+		setOwner(newOwner);
+	}
+
+	/**
+	 * @dev Sets a new owner address
+	 */
+	function setOwner(address newOwner) internal {
+		emit OwnershipTransferred(owner(), newOwner);
+		addressStorage[OWNER] = newOwner;
+	}
+}
+
+contract Initializable is EternalStorage {
+	bytes32 internal constant INITIALIZED =
+		0x0a6f646cd611241d8073675e00d1a1ff700fbf1b53fcf473de56d1e6e4b714ba; // keccak256(abi.encodePacked("isInitialized"))
+
+	function setInitialize() internal {
+		boolStorage[INITIALIZED] = true;
+	}
+
+	function isInitialized() public view returns (bool) {
+		return boolStorage[INITIALIZED];
+	}
+}
+
+contract FuseOldBridgeKill is Initializable, Upgradeable {
+	function end() external {
+		IGoodDollar(0x495d133B938596C9984d462F007B676bDc57eCEC).renounceMinter();
+	}
+}

package/contracts/utils/LastauthReduction.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "../utils/NameService.sol";
+import "../Interfaces.sol";
+import "../reserve/GoodReserveCDai.sol";
+import "../identity/IdentityV2.sol";
+import "hardhat/console.sol";
+
+contract LastauthReduction {
+	NameService ns;
+
+	uint public reduceByDays = 90;
+	uint public startingPeriodDays = 180 + 90 * 5;
+	uint public finalPeriod = 180;
+	address public manager;
+
+	constructor(NameService _ns) {
+		ns = _ns;
+		manager = msg.sender;
+	}
+
+	function reduce() external {
+		require(msg.sender == manager, "not manager");
+
+		address avatar = ns.dao().avatar();
+
+		IdentityV2 id = IdentityV2(ns.getAddress("IDENTITY"));
+
+		Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
+		uint curPeriod = id.authenticationPeriod();
+
+		IIdentity oldId = id.oldIdentity();
+
+		if (curPeriod <= finalPeriod) {
+			// prevent executing again
+			require(ctrl.unregisterSelf(avatar), "unregistering failed");
+			return;
+		}
+
+		bool ok;
+		if (curPeriod > startingPeriodDays) {
+			(ok, ) = ctrl.genericCall(
+				address(id),
+				abi.encodeCall(
+					IdentityV2.setAuthenticationPeriod,
+					(startingPeriodDays)
+				),
+				address(avatar),
+				0
+			);
+			require(ok, "setAuthenticationPeriod failed");
+
+			if (address(oldId) != address(0)) {
+				(ok, ) = ctrl.genericCall(
+					address(oldId),
+					abi.encodeCall(
+						IdentityV2.setAuthenticationPeriod,
+						(startingPeriodDays)
+					),
+					address(avatar),
+					0
+				);
+				require(ok, "setAuthenticationPeriod failed");
+			}
+		} else {
+			(ok, ) = ctrl.genericCall(
+				address(id),
+				abi.encodeCall(
+					IdentityV2.setAuthenticationPeriod,
+					(curPeriod - reduceByDays)
+				),
+				address(avatar),
+				0
+			);
+			require(ok, "setAuthenticationPeriod failed");
+
+			if (address(oldId) != address(0)) {
+				(ok, ) = ctrl.genericCall(
+					address(oldId),
+					abi.encodeCall(
+						IdentityV2.setAuthenticationPeriod,
+						(curPeriod - reduceByDays)
+					),
+					address(avatar),
+					0
+				);
+				require(ok, "setAuthenticationPeriod failed");
+			}
+		}
+	}
+}