@gooddollar/goodprotocol 1.0.30-beta.2 → 1.0.30-beta.3

package/contracts/fuseFaucet/Faucet.sol

@@ -0,0 +1,258 @@
+//SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "../Interfaces.sol";
+import "../utils/NameService.sol";
+
+/**
+ * @title FuseFaucet contract that can top up users wallets
+ */
+contract Faucet is Initializable, UUPSUpgradeable, AccessControlUpgradeable {
+	bytes32 public constant RELAYER_ROLE = keccak256("relayer");
+
+	event WalletTopped(
+		address indexed account, //address topped
+		uint256 amount,
+		address whitelistedRoot, //if account is connected to a whitelisted account, this will be it
+		address indexed relayerOrWhitelisted //the sender of the tx
+	);
+
+	uint256 public perDayRoughLimit;
+	uint256 public toppingAmount;
+	uint256 public gasRefund;
+	uint256 public startTime;
+	uint256 public currentDay;
+
+	NameService public nameService;
+
+	mapping(uint256 => mapping(address => uint256)) public toppings;
+	mapping(address => bool) public notFirstTime;
+
+	struct Wallet {
+		uint128 lastDayTopped;
+		uint32 dailyToppingCount;
+		uint128[7] lastWeekToppings;
+	}
+
+	mapping(address => Wallet) public wallets;
+	uint32 public maxDailyToppings;
+	uint64 public gasPrice;
+	uint32 public maxPerWeekMultiplier;
+	uint32 public maxSwapAmount;
+	address public goodDollar_unused; //kept because of upgrades
+	uint64 public maxDailyNewWallets;
+	uint64 public dailyNewWalletsCount;
+
+	function initialize(
+		NameService _ns,
+		uint64 _gasPrice,
+		address relayer,
+		address owner
+	) public initializer {
+		__AccessControl_init_unchained();
+		_setupRole(DEFAULT_ADMIN_ROLE, owner);
+		if (relayer != address(0)) _setupRole(RELAYER_ROLE, relayer);
+		gasPrice = _gasPrice;
+		setToppingAmount(600000 * gasPrice); //0.6M gwei
+		maxDailyToppings = 3;
+		startTime = block.timestamp;
+		nameService = _ns;
+		maxPerWeekMultiplier = 2;
+		maxSwapAmount = 1000;
+		maxDailyNewWallets = 5000;
+	}
+
+	function _authorizeUpgrade(address newImplementation)
+		internal
+		override
+		onlyRole(DEFAULT_ADMIN_ROLE)
+	{}
+
+	function getIdentity() public view returns (IIdentityV2) {
+		return IIdentityV2(nameService.getAddress("IDENTITY"));
+	}
+
+	function upgrade() public {
+		if (maxDailyNewWallets == 0) maxDailyNewWallets = 5000;
+	}
+
+	modifier reimburseGas() {
+		uint256 _gasRefund = gasleft();
+		_;
+		_gasRefund = _gasRefund - gasleft() + 42000;
+		payable(msg.sender).transfer(_gasRefund * gasPrice); //gas price assumed 1e9 = 1gwei
+	}
+
+	receive() external payable {}
+
+	/*
+	 * only whitelisted account or relayer can top non whitelisted accounts
+	 * if target account is whitelisted anyone can top it
+	 */
+	modifier onlyAuthorized(address toTop) {
+		require(
+			getIdentity().getWhitelistedRoot(toTop) != address(0) ||
+				getIdentity().getWhitelistedRoot(msg.sender) != address(0) ||
+				hasRole(RELAYER_ROLE, msg.sender),
+			"not authorized"
+		);
+		_;
+	}
+
+	modifier toppingLimit(address _user) {
+		//switch wallet to the account we do the accounting for
+		address whitelistedRoot = getIdentity().getWhitelistedRoot(_user);
+		_user = whitelistedRoot == address(0) ? _user : payable(whitelistedRoot);
+
+		uint256 prevDay = currentDay;
+
+		setDay();
+		if (currentDay != prevDay) dailyNewWalletsCount = 0;
+
+		require(
+			wallets[_user].lastDayTopped != uint128(currentDay) ||
+				wallets[_user].dailyToppingCount < maxDailyToppings,
+			"max daily toppings"
+		);
+
+		require(
+			(notFirstTime[_user] == false &&
+				dailyNewWalletsCount < maxDailyNewWallets) ||
+				whitelistedRoot != address(0),
+			"User not whitelisted or not first time"
+		);
+
+		//reset inactive days
+		uint256 dayOfWeek = currentDay % 7;
+		uint256 dayDiff = (currentDay - wallets[_user].lastDayTopped);
+		dayDiff = dayDiff > 7 ? 7 : dayDiff;
+		dayDiff = dayDiff > dayOfWeek ? dayOfWeek + 1 : dayDiff;
+		for (uint256 day = dayOfWeek + 1 - dayDiff; day <= dayOfWeek; day++) {
+			wallets[_user].lastWeekToppings[day] = 0;
+		}
+
+		uint128 weekTotal = 0;
+		for (uint256 i = 0; i <= dayOfWeek; i++) {
+			weekTotal += wallets[_user].lastWeekToppings[uint256(i)];
+		}
+
+		require(
+			weekTotal < perDayRoughLimit * maxPerWeekMultiplier,
+			"User wallet has been topped too many times this week"
+		);
+		_;
+	}
+
+	/* @dev Internal function that sets current day
+	 */
+	function setDay() internal {
+		currentDay = (block.timestamp - startTime) / 1 days;
+	}
+
+	function canTop(address _user) external view returns (bool) {
+		if (toppingAmount < address(_user).balance) return false;
+
+		address whitelistedRoot = getIdentity().getWhitelistedRoot(_user);
+		_user = whitelistedRoot == address(0) ? _user : whitelistedRoot;
+
+		uint256 _currentDay = (block.timestamp - startTime) / 1 days;
+		bool can = (wallets[_user].lastDayTopped != uint128(_currentDay) ||
+			wallets[_user].dailyToppingCount < 3) &&
+			((notFirstTime[_user] == false &&
+				dailyNewWalletsCount < maxDailyNewWallets) ||
+				whitelistedRoot != address(0));
+
+		uint128[7] memory lastWeekToppings = wallets[_user].lastWeekToppings;
+		//reset inactive days
+		uint256 dayOfWeek = _currentDay % 7;
+		uint256 dayDiff = (_currentDay - wallets[_user].lastDayTopped);
+		dayDiff = dayDiff > 7 ? 7 : dayDiff;
+		dayDiff = dayDiff > dayOfWeek ? dayOfWeek + 1 : dayDiff;
+
+		for (uint256 day = dayOfWeek + 1 - dayDiff; day <= dayOfWeek; day++) {
+			lastWeekToppings[day] = 0;
+		}
+
+		uint128 weekTotal = 0;
+		for (uint256 i = 0; i <= dayOfWeek; i++) {
+			weekTotal += lastWeekToppings[uint256(i)];
+		}
+		can = can && weekTotal < perDayRoughLimit * maxPerWeekMultiplier;
+		return can;
+	}
+
+	/* @dev Function to top given address with amount of G$ given in constructor
+	 * can only be done by admin the amount of times specified in constructor per day
+	 * @param _user The address to transfer to
+	 */
+	function topWallet(address payable _user)
+		public
+		reimburseGas
+		toppingLimit(_user)
+		onlyAuthorized(_user)
+	{
+		_topWallet(_user);
+	}
+
+	function _topWallet(address payable _wallet) internal {
+		address payable target = _wallet;
+
+		//switch wallet to the account we do the accounting for
+		address whitelistedRoot = getIdentity().getWhitelistedRoot(_wallet);
+		_wallet = whitelistedRoot == address(0)
+			? _wallet
+			: payable(whitelistedRoot);
+
+		require(toppingAmount > address(_wallet).balance);
+		uint256 toTop = toppingAmount - address(_wallet).balance;
+
+		uint256 dayOfWeek = currentDay % 7;
+
+		if (wallets[_wallet].lastDayTopped == uint128(currentDay))
+			wallets[_wallet].dailyToppingCount += 1;
+		else wallets[_wallet].dailyToppingCount = 1;
+		wallets[_wallet].lastDayTopped = uint128(currentDay);
+		wallets[_wallet].lastWeekToppings[dayOfWeek] += uint128(toTop);
+
+		if (notFirstTime[_wallet] == false && whitelistedRoot == address(0)) {
+			dailyNewWalletsCount++;
+		}
+		notFirstTime[_wallet] = true;
+
+		target.transfer(toTop);
+		emit WalletTopped(target, toTop, whitelistedRoot, msg.sender);
+	}
+
+	function onTokenTransfer(
+		address payable _from,
+		uint256 amount,
+		bytes calldata data
+	) external returns (bool) {
+		require(amount <= maxSwapAmount, "slippage");
+		address uniswapLike = abi.decode(data, (address));
+		Uniswap uniswap = Uniswap(uniswapLike);
+		address[] memory path = new address[](2);
+		path[0] = address(msg.sender);
+		path[1] = uniswap.WETH();
+
+		cERC20(msg.sender).approve(address(uniswapLike), type(uint256).max);
+		uniswap.swapExactTokensForETH(amount, 0, path, _from, block.timestamp);
+		return true;
+	}
+
+	function setToppingAmount(uint256 _amount)
+		public
+		onlyRole(DEFAULT_ADMIN_ROLE)
+	{
+		toppingAmount = _amount;
+		perDayRoughLimit = 2 * toppingAmount;
+	}
+
+	function setGasPrice(uint64 _price) external onlyRole(DEFAULT_ADMIN_ROLE) {
+		gasPrice = _price;
+	}
+}

package/contracts/fuseFaucet/FuseFaucet.sol

@@ -6,8 +6,7 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "../Interfaces.sol";
 
 /**
- * @title DonationStaking contract that receives funds in ETH/DAI
- * and stake them in the SimpleStaking contract
+ * @title FuseFaucet contract that can top up users wallets
  */
 contract FuseFaucet is Initializable {
 	event WalletTopped(address indexed user, uint256 amount);

package/contracts/governance/GReputation.sol

@@ -11,6 +11,8 @@ import "../Interfaces.sol";
  * to return the current reputation token.
  * The DAO avatar will be the owner of this reputation token and not the Controller.
  * Minting by the DAO will be done using controller.genericCall and not via controller.mintReputation
+ *
+ * V2 fixes merkle tree bug
  */
 contract GReputation is Reputation {
 	bytes32 public constant ROOT_STATE = keccak256("rootState");
@@ -99,25 +101,36 @@ contract GReputation is Reputation {
 
 	function _canMint() internal view override {
 		require(
-			_msgSender() == nameService.getAddress("GDAO_CLAIMERS") ||
-				_msgSender() == nameService.getAddress("GDAO_STAKING") ||
-				_msgSender() == nameService.getAddress("GDAO_STAKERS") ||
-				hasRole(MINTER_ROLE, _msgSender()),
+			hasRole(MINTER_ROLE, _msgSender()) ||
+				(address(nameService) != address(0) &&
+					(_msgSender() == nameService.getAddress("GDAO_CLAIMERS") ||
+						_msgSender() == nameService.getAddress("GDAO_STAKING") ||
+						_msgSender() == nameService.getAddress("GDAO_STAKERS"))),
 			"GReputation: need minter role or be GDAO contract"
 		);
 	}
 
-	/// @notice internal function that overrides Reputation.sol with consideration to delegation
-	/// @param _user the address to mint for
-	/// @param _amount the amount of rep to mint
-	/// @return the actual amount minted
 	function _mint(address _user, uint256 _amount)
 		internal
 		override
 		returns (uint256)
 	{
+		return _mint(_user, _amount, false);
+	}
+
+	/// @notice internal function that overrides Reputation.sol with consideration to delegation
+	/// @param _user the address to mint for
+	/// @param _amount the amount of rep to mint
+	/// @return the actual amount minted
+	function _mint(
+		address _user,
+		uint256 _amount,
+		bool ignoreRepTarget
+	) internal returns (uint256) {
 		address repTarget = reputationRecipients[_user];
-		repTarget = repTarget != address(0) ? repTarget : _user;
+		repTarget = ignoreRepTarget == false && repTarget != address(0)
+			? repTarget
+			: _user;
 
 		super._mint(repTarget, _amount);
 
@@ -368,24 +381,75 @@ contract GReputation is Reputation {
 	}
 
 	/**
-	 * @notice prove user balance in a specific blockchain state hash
+	 * @notice prove user balance in a specific blockchain state hash, uses new sorted pairs trees and double hash for preimage attack mitigation
 	 * @dev "rootState" is a special state that can be supplied once, and actually mints reputation on the current blockchain
 	 * we use non sorted merkle tree, as sorting while preparing merkle tree is heavy
 	 * @param _id the string id of the blockchain we supply proof for
 	 * @param _user the user to prove his balance
 	 * @param _balance the balance we are prooving
 	 * @param _proof array of byte32 with proof data (currently merkle tree path)
- 	 * @param _nodeIndex index of node in the tree (for unsorted merkle tree proof)
-
 	 * @return true if proof is valid
 	 */
 	function proveBalanceOfAtBlockchain(
+		string memory _id,
+		address _user,
+		uint256 _balance,
+		bytes32[] memory _proof
+	) public returns (bool) {
+		return
+			_proveBalanceOfAtBlockchain(
+				_id,
+				_user,
+				_balance,
+				_proof,
+				new bool[](0),
+				0,
+				false
+			);
+	}
+
+	/**
+	 * DEPRECATED: future state hashes will be with sorted pairs and with double hash leaf values
+	 * @notice prove user balance in a specific blockchain state hash
+	 * @dev "rootState" is a special state that can be supplied once, and actually mints reputation on the current blockchain
+	 * we use non sorted merkle tree, as sorting while preparing merkle tree is heavy
+	 * @param _id the string id of the blockchain we supply proof for
+	 * @param _user the user to prove his balance
+	 * @param _balance the balance we are prooving
+	 * @param _proof array of byte32 with proof data (currently merkle tree path)
+	 * @param _isRightNode array of bool with indication if should be hashed on right or left
+	 * @param _nodeIndex index of node in the tree (for unsorted merkle tree proof)
+	 * @return true if proof is valid
+	 */
+	function proveBalanceOfAtBlockchainLegacy(
 		string memory _id,
 		address _user,
 		uint256 _balance,
 		bytes32[] memory _proof,
+		bool[] memory _isRightNode,
 		uint256 _nodeIndex
 	) public returns (bool) {
+		return
+			_proveBalanceOfAtBlockchain(
+				_id,
+				_user,
+				_balance,
+				_proof,
+				_isRightNode,
+				_nodeIndex,
+				true
+			);
+	}
+
+	function _proveBalanceOfAtBlockchain(
+		string memory _id,
+		address _user,
+		uint256 _balance,
+		bytes32[] memory _proof,
+		bool[] memory _isRightNode,
+		uint256 _nodeIndex,
+		bool legacy
+	) internal returns (bool) {
 		bytes32 idHash = keccak256(bytes(_id));
 		require(
 			blockchainStates[idHash].length > 0,
@@ -402,11 +466,17 @@ contract GReputation is Reputation {
 		);
 
 		bytes32 leafHash = keccak256(abi.encode(_user, _balance));
+		//v2 double hash fix to prevent preimage attack
+		if (legacy == false) {
+			leafHash = keccak256(abi.encode(leafHash));
+		}
 		bool isProofValid = checkProofOrdered(
 			_proof,
+			_isRightNode,
 			stateHash,
 			leafHash,
-			_nodeIndex
+			_nodeIndex,
+			legacy == false
 		);
 
 		require(isProofValid, "invalid merkle proof");
@@ -414,7 +484,10 @@ contract GReputation is Reputation {
 		//if initiial state then set real balance
 		if (idHash == ROOT_STATE) {
 			uint256 curTotalSupply = totalSupplyLocalAt(block.number);
-			_mint(_user, _balance);
+			// on proof for ROOT_HASH we force to ignore the repTarget, so it is the same wallet address receiving the reputation (prevent double voting power on snapshot)
+			// also it should behave the same as blockchain sync proof which also doesnt use repTarget, but updates the same address as in the proof
+			_mint(_user, _balance, true);
+
 			updateValueAtNow(totalSupplyHistory, curTotalSupply); // we undo the totalsupply, as we alredy set the totalsupply of the airdrop
 		}
 
@@ -544,9 +617,11 @@ contract GReputation is Reputation {
 	 */
 	function checkProofOrdered(
 		bytes32[] memory _proof,
+		bool[] memory _isRightNode,
 		bytes32 _root,
 		bytes32 _hash,
-		uint256 _index
+		uint256 _index,
+		bool sorted
 	) public pure returns (bool) {
 		// use the index to determine the node ordering
 		// index ranges 1 to n
@@ -558,6 +633,16 @@ contract GReputation is Reputation {
 		for (uint256 j = 0; j < _proof.length; j++) {
 			proofElement = _proof[j];
 
+			// for new sorted format
+			if (sorted) {
+				computedHash = proofElement < computedHash
+					? keccak256(abi.encodePacked(proofElement, computedHash))
+					: keccak256(abi.encodePacked(computedHash, proofElement));
+				continue;
+			}
+
+			// start of legacy format for the first GOOD airdrop
+
 			// calculate remaining elements in proof
 			remaining = _proof.length - j;
 
@@ -568,7 +653,10 @@ contract GReputation is Reputation {
 				_index = _index / 2 + 1;
 			}
 
-			if (_index % 2 == 0) {
+			if (
+				(_isRightNode.length > 0 && _isRightNode[j] == false) ||
+				(_isRightNode.length == 0 && _index % 2 == 0)
+			) {
 				computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
 				_index = _index / 2;
 			} else {