@gooddollar/goodprotocol 2.0.25-beta.9 → 2.0.26-beta.0

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/AdminWallet.sol

@@ -34,7 +34,8 @@ contract AdminWallet is
 	uint64 public maxDailyNewWallets;
 	uint64 public day;
 
-	ERC20 public gd;
+	ERC20 private gd_removed;
+
 	mapping(address => uint256) public lastGdBalance; // only top non whitelisted if active G$ users
 
 	event AdminsAdded(address payable[] indexed admins);
@@ -66,7 +67,6 @@ contract AdminWallet is
 			addAdmins(_admins);
 		}
 		if (msg.sender != _owner) revokeRole(DEFAULT_ADMIN_ROLE, msg.sender);
-		gd = ERC20(nameService.getAddress("GOODDOLLAR"));
 	}
 
 	modifier onlyOwner() {
@@ -74,10 +74,6 @@ contract AdminWallet is
 		_;
 	}
 
-	function upgrade() public onlyOwner {
-		gd = ERC20(nameService.getAddress("GOODDOLLAR"));
-	}
-
 	function getIdentity() public view returns (IIdentityV2) {
 		return IIdentityV2(nameService.getAddress("IDENTITY"));
 	}
@@ -236,6 +232,8 @@ contract AdminWallet is
 	 * @param _user The address to transfer to
 	 */
 	function topWallet(address payable _user) public onlyAdmin reimburseGas {
+		ERC20 gd = ERC20(nameService.getAddress("GOODDOLLAR"));
+
 		uint256 gdBalance = gd.balanceOf(_user);
 		require(
 			getIdentity().isWhitelisted(_user) || gdBalance != lastGdBalance[_user],

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/ReserveRestore.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "../utils/NameService.sol";
+import "../Interfaces.sol";
+import "../reserve/GoodReserveCDai.sol";
+import "hardhat/console.sol";
+
+contract ReserveRestore {
+	NameService ns;
+	uint256 public constant LOCKED_HACKED_FUNDS = 971921364208;
+	bool public executed;
+	address owner;
+
+	constructor(NameService _ns) {
+		ns = _ns;
+		owner = msg.sender;
+	}
+
+	function end() external {
+		require(msg.sender == owner, "not owner");
+		Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
+		address avatar = ns.dao().avatar();
+
+		// prevent executing again}
+		require(ctrl.unregisterSelf(avatar), "unregistering failed");
+	}
+
+	function donate(address daiFrom, uint256 amount) external {
+		require(msg.sender == owner, "not owner");
+		address avatar = ns.dao().avatar();
+
+		GoodReserveCDai reserve = GoodReserveCDai(ns.getAddress("RESERVE"));
+		ERC20(ns.getAddress("DAI")).transferFrom(daiFrom, address(this), amount);
+		uint256 daiBalance = ERC20(ns.getAddress("DAI")).balanceOf(address(this));
+		cERC20 cdai = cERC20(ns.getAddress("CDAI"));
+		ERC20 dai = ERC20(ns.getAddress("DAI"));
+
+		dai.approve(address(cdai), daiBalance);
+		//Mint cDAIs
+		uint256 cDaiResult = cdai.mint(daiBalance);
+		require(cDaiResult == 0, "Minting cDai failed");
+		uint256 cdaiBalance = cdai.balanceOf(address(this));
+		cdai.transfer(address(reserve), cdaiBalance);
+		cdaiBalance = cdai.balanceOf(address(reserve));
+
+		uint256 gdSupply = ERC20(ns.getAddress("GOODDOLLAR")).totalSupply() -
+			LOCKED_HACKED_FUNDS;
+		console.log("supply: %s", gdSupply);
+		// get 0.0001 dai price in cdai
+		uint256 currentPrice = reserve.currentPrice();
+		console.log("currentPrice: %s", currentPrice);
+
+		console.log("cdaiBalance: %s", cdaiBalance);
+
+		// given price calculate the reserve ratio
+		uint32 reserveRatio = uint32(
+			(cdaiBalance * 1e2 * 1e6) / (currentPrice * gdSupply)
+		); // mul by 1e2 to cover gd precision, cdaibalance precision=initialprice, mul by 1e6 to receive result in the precision of reserveRatio(1e6)
+		console.log("reserveRatio: %s", reserveRatio);
+		Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
+		//     function initializeToken(
+		// 	ERC20 _token,
+		// 	uint256 _gdSupply,
+		// 	uint256 _tokenSupply,
+		// 	uint32 _reserveRatio,
+		// 	uint256 _lastExpansion
+		// )
+		(bool ok, ) = ctrl.genericCall(
+			address(reserve.getMarketMaker()),
+			abi.encodeCall(
+				GoodMarketMaker.initializeToken,
+				(cdai, gdSupply, cdaiBalance, reserveRatio, block.timestamp)
+			),
+			address(avatar),
+			0
+		);
+		require(ok, "initializeToken failed");
+	}
+
+	function upgrade(address daiFrom, uint256 amount) external {
+		require(msg.sender == owner, "not owner");
+		require(executed == false, "already upgraded");
+		executed = true;
+		address avatar = ns.dao().avatar();
+
+		GoodReserveCDai reserve = GoodReserveCDai(ns.getAddress("RESERVE"));
+		ERC20(ns.getAddress("DAI")).transferFrom(daiFrom, address(this), amount);
+		uint256 daiBalance = ERC20(ns.getAddress("DAI")).balanceOf(address(this));
+		require(daiBalance >= 50000e18, "not enough reserve");
+		cERC20 cdai = cERC20(ns.getAddress("CDAI"));
+		ERC20 dai = ERC20(ns.getAddress("DAI"));
+
+		dai.approve(address(cdai), daiBalance);
+		//Mint cDAIs
+		uint256 cDaiResult = cdai.mint(daiBalance);
+		require(cDaiResult == 0, "Minting cDai failed");
+		uint256 cdaiBalance = cdai.balanceOf(address(this));
+		cdai.transfer(address(reserve), cdaiBalance);
+		cdaiBalance = cdai.balanceOf(address(reserve));
+
+		uint256 gdSupply = ERC20(ns.getAddress("GOODDOLLAR")).totalSupply() -
+			LOCKED_HACKED_FUNDS;
+		console.log("supply: %s", gdSupply);
+		// get 0.0001 dai price in cdai
+		uint256 initialPriceCdai = (0.0001 * 1e8 * 1e28) /
+			cdai.exchangeRateStored(); //excghange rate is at 1e28 precision rate/1e28=1 cdai price in dai mul by 1e8 to get in cdai precision
+		console.log("initialPriceCdai: %s", initialPriceCdai);
+
+		console.log("cdaiBalance: %s", cdaiBalance);
+
+		// given price calculate the reserve ratio
+		uint32 reserveRatio = uint32(
+			(cdaiBalance * 1e2 * 1e6) / (initialPriceCdai * gdSupply)
+		); // mul by 1e2 to cover gd precision, cdaibalance precision=initialprice, mul by 1e6 to receive result in the precision of reserveRatio(1e6)
+		console.log("reserveRatio: %s", reserveRatio);
+		Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
+		//     function initializeToken(
+		// 	ERC20 _token,
+		// 	uint256 _gdSupply,
+		// 	uint256 _tokenSupply,
+		// 	uint32 _reserveRatio,
+		// 	uint256 _lastExpansion
+		// )
+		(bool ok, ) = ctrl.genericCall(
+			address(reserve.getMarketMaker()),
+			abi.encodeCall(
+				GoodMarketMaker.initializeToken,
+				(cdai, gdSupply, cdaiBalance, reserveRatio, block.timestamp)
+			),
+			address(avatar),
+			0
+		);
+		require(ok, "initializeToken failed");
+		// ContributionCalc(
+		// 		ns.getAddress("CONTRIBUTION_CALCULATION")
+		// 	).setContributionRatio(0.1*1e18,1e18);
+
+		// exit contribution to 10%
+		(ok, ) = ctrl.genericCall(
+			address(ns.getAddress("CONTRIBUTION_CALCULATION")),
+			abi.encodeCall(ContributionCalc.setContributionRatio, (0.1 * 1e18, 1e18)),
+			address(avatar),
+			0
+		);
+		require(ok, "setContributionRatio failed");
+
+		(ok, ) = ctrl.genericCall(
+			address(reserve),
+			abi.encodeCall(GoodReserveCDai.setGDXDisabled, (true, true)),
+			address(avatar),
+			0
+		);
+
+		require(ok, "setContributionRatio failed");
+	}
+}