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

package/contracts/ubi/UBIScheme.sol

@@ -8,6 +8,8 @@ import "../utils/NameService.sol";
 import "../Interfaces.sol";
 import "../governance/ClaimersDistribution.sol";
 
+// import "hardhat/console.sol";
+
 /* @title Dynamic amount-per-day UBI scheme allowing claim once a day
  */
 contract UBIScheme is DAOUpgradeableContract {
@@ -71,7 +73,8 @@ contract UBIScheme is DAOUpgradeableContract {
 	//dont use first claim, and give ubi as usual
 	bool public useFirstClaimPool;
 
-	uint256 public defaultDailyUbi;
+	//minimum amount of users to divide the pool for, renamed from defaultDailyUbi
+	uint256 public minActiveUsers;
 
 	// A pool of GD to give to activated users,
 	// since they will enter the UBI pool
@@ -99,14 +102,14 @@ contract UBIScheme is DAOUpgradeableContract {
 	// Total claims per user stat
 	mapping(address => uint256) public totalClaimsPerUser;
 
+	bool public paused;
+
 	// Emits when a withdraw has been succeded
 	event WithdrawFromDao(uint256 prevBalance, uint256 newBalance);
 
 	// Emits when a user is activated
 	event ActivatedUser(address indexed account);
 
-	bool public paused;
-
 	// Emits when a fish has been succeded
 	event InactiveUserFished(
 		address indexed caller,
@@ -154,11 +157,11 @@ contract UBIScheme is DAOUpgradeableContract {
 		firstClaimPool = _firstClaimPool;
 		shouldWithdrawFromDAO = false;
 		cycleLength = 90; //90 days
-		iterationGasLimit = 150000;
+		iterationGasLimit = 185000; //token transfer cost under superfluid
 		periodStart = (block.timestamp / (1 days)) * 1 days + 12 hours; //set start time to GMT noon
 		startOfCycle = periodStart;
-		useFirstClaimPool = true;
-		defaultDailyUbi = 5000;
+		useFirstClaimPool = address(_firstClaimPool) != address(0);
+		minActiveUsers = 1000;
 	}
 
 	function setUseFirstClaimPool(bool _use) public {
@@ -268,8 +271,10 @@ contract UBIScheme is DAOUpgradeableContract {
 				currentDayInCycle() >= currentCycleLength || shouldStartEarlyCycle
 			) //start of cycle or first time
 			{
-				if (shouldWithdrawFromDAO) _withdrawFromDao();
-				currentBalance = token.balanceOf(address(this));
+				if (shouldWithdrawFromDAO) {
+					_withdrawFromDao();
+					currentBalance = token.balanceOf(address(this));
+				}
 				dailyCyclePool = currentBalance / cycleLength;
 				currentCycleLength = cycleLength;
 				startOfCycle = (block.timestamp / (1 hours)) * 1 hours; //start at a round hour
@@ -285,17 +290,20 @@ contract UBIScheme is DAOUpgradeableContract {
 			Funds storage funds = dailyUBIHistory[currentDay];
 			funds.hasWithdrawn = shouldWithdrawFromDAO;
 			funds.openAmount = currentBalance;
-			if (activeUsersCount > 0) {
-				dailyUbi = dailyCyclePool / activeUsersCount;
-			} else if (useFirstClaimPool == false) {
-				dailyUbi = defaultDailyUbi;
-			}
+			dailyUbi = dailyCyclePool / max(activeUsersCount, minActiveUsers);
+			//update minActiveUsers as claimers grow
+			minActiveUsers = max(activeUsersCount / 2, minActiveUsers);
+
 			emit UBICalculated(currentDay, dailyUbi, block.number);
 		}
 
 		return dailyUbi;
 	}
 
+	function max(uint256 a, uint256 b) private pure returns (uint256) {
+		return a >= b ? a : b;
+	}
+
 	/**
 	 *@dev Sets the currentDay variable to amount of days
 	 * since start of contract.
@@ -356,12 +364,14 @@ contract UBIScheme is DAOUpgradeableContract {
 	 * and emits an event in case of claimed.
 	 * In case that `isFirstTime` is true, it awards the user.
 	 * @param _account the account which recieves the funds
+	 * @param _target the recipient of funds
 	 * @param _amount the amount to transfer
 	 * @param _isClaimed true for claimed
 	 * @param _isFirstTime true for new user or fished user
 	 */
 	function _transferTokens(
 		address _account,
+		address _target,
 		uint256 _amount,
 		bool _isClaimed,
 		bool _isFirstTime
@@ -377,7 +387,7 @@ contract UBIScheme is DAOUpgradeableContract {
 
 		// awards a new user or a fished user
 		if (_isFirstTime) {
-			uint256 awardAmount = firstClaimPool.awardUser(_account);
+			uint256 awardAmount = firstClaimPool.awardUser(_target);
 			claimDay[currentDay].claimAmount += awardAmount;
 			emit UBIClaimed(_account, awardAmount);
 		} else {
@@ -386,7 +396,7 @@ contract UBIScheme is DAOUpgradeableContract {
 				emit UBIClaimed(_account, _amount);
 			}
 			IGoodDollar token = nativeToken();
-			require(token.transfer(_account, _amount), "claim transfer failed");
+			require(token.transfer(_target, _amount), "claim transfer failed");
 		}
 	}
 
@@ -403,11 +413,9 @@ contract UBIScheme is DAOUpgradeableContract {
 		{
 			_dailyCyclePool = currentBalance / cycleLength;
 		}
-		if (activeUsersCount > 0) {
-			_dailyUbi = _dailyCyclePool / activeUsersCount;
-		} else if (useFirstClaimPool == false) {
-			_dailyUbi = defaultDailyUbi;
-		}
+
+		_dailyUbi = _dailyCyclePool / max(activeUsersCount, minActiveUsers);
+
 		return _dailyUbi;
 	}
 
@@ -447,9 +455,10 @@ contract UBIScheme is DAOUpgradeableContract {
 	 * calculats the amount the account can claims, and transfers the amount to the account.
 	 * Emits the address of account and amount claimed.
 	 * @param _account The claimer account
+	 * @param _target recipient of funds
 	 * @return A bool indicating if UBI was claimed
 	 */
-	function _claim(address _account) internal returns (bool) {
+	function _claim(address _account, address _target) internal returns (bool) {
 		// calculats the formula up today ie on day 0 there are no active users, on day 1 any user
 		// (new or active) will trigger the calculation with the active users count of the day before
 		// and so on. the new or inactive users that will become active today, will not take into account
@@ -462,16 +471,16 @@ contract UBIScheme is DAOUpgradeableContract {
 			!fishedUsersAddresses[_account] &&
 			!hasClaimed(_account)
 		) {
-			_transferTokens(_account, newDistribution, true, false);
+			_transferTokens(_account, _target, newDistribution, true, false);
 			return true;
 		} else if (!isNotNewUser(_account) || fishedUsersAddresses[_account]) {
 			// a unregistered or fished user
 			activeUsersCount += 1;
 			fishedUsersAddresses[_account] = false;
 			if (useFirstClaimPool) {
-				_transferTokens(_account, 0, false, true);
+				_transferTokens(_account, _target, 0, false, true);
 			} else {
-				_transferTokens(_account, newDistribution, true, false);
+				_transferTokens(_account, _target, newDistribution, true, false);
 			}
 			emit ActivatedUser(_account);
 			return true;
@@ -486,18 +495,39 @@ contract UBIScheme is DAOUpgradeableContract {
 	 * @return A bool indicating if UBI was claimed
 	 */
 	function claim() public requireStarted returns (bool) {
-		require(
-			IIdentity(nameService.getAddress("IDENTITY")).isWhitelisted(msg.sender),
-			"UBIScheme: not whitelisted"
-		);
-		bool didClaim = _claim(msg.sender);
+		address whitelistedRoot = IIdentityV2(nameService.getAddress("IDENTITY"))
+			.getWhitelistedRoot(msg.sender);
+		require(whitelistedRoot != address(0), "UBIScheme: not whitelisted");
+		bool didClaim = _claim(whitelistedRoot, msg.sender);
 		address claimerDistribution = nameService.getAddress("GDAO_CLAIMERS");
 		if (didClaim && claimerDistribution != address(0)) {
-			ClaimersDistribution(claimerDistribution).updateClaim(msg.sender);
+			ClaimersDistribution(claimerDistribution).updateClaim(whitelistedRoot);
 		}
 		return didClaim;
 	}
 
+	function _canFish(address _account) internal view returns (bool) {
+		return
+			isNotNewUser(_account) &&
+			!isActiveUser(_account) &&
+			!fishedUsersAddresses[_account];
+	}
+
+	function _fish(address _account, bool _withTransfer) internal returns (bool) {
+		fishedUsersAddresses[_account] = true; // marking the account as fished so it won't refish
+
+		// making sure that the calculation will be with the correct number of active users in case
+		// that the fisher is the first to make the calculation today
+		uint256 newDistribution = distributionFormula();
+		if (activeUsersCount > 0) {
+			activeUsersCount -= 1;
+		}
+		if (_withTransfer)
+			_transferTokens(msg.sender, msg.sender, newDistribution, false, false);
+		emit InactiveUserFished(msg.sender, _account, newDistribution);
+		return true;
+	}
+
 	/**
 	 * @dev In order to update users from active to inactive, we give out incentive to people
 	 * to update the status of inactive users, this action is called "Fishing". Anyone can
@@ -511,22 +541,9 @@ contract UBIScheme is DAOUpgradeableContract {
 	function fish(address _account) public requireStarted returns (bool) {
 		// checking if the account exists. that's been done because that
 		// will prevent trying to fish non-existence accounts in the system
-		require(
-			isNotNewUser(_account) && !isActiveUser(_account),
-			"is not an inactive user"
-		);
-		require(!fishedUsersAddresses[_account], "already fished");
-		fishedUsersAddresses[_account] = true; // marking the account as fished so it won't refish
+		require(_canFish(_account), "can't fish");
 
-		// making sure that the calculation will be with the correct number of active users in case
-		// that the fisher is the first to make the calculation today
-		uint256 newDistribution = distributionFormula();
-		if (activeUsersCount > 0) {
-			activeUsersCount -= 1;
-		}
-		_transferTokens(msg.sender, newDistribution, false, false);
-		emit InactiveUserFished(msg.sender, _account, newDistribution);
-		return true;
+		return _fish(_account, true);
 	}
 
 	/**
@@ -540,21 +557,23 @@ contract UBIScheme is DAOUpgradeableContract {
 		requireStarted
 		returns (uint256)
 	{
-		for (uint256 i = 0; i < _accounts.length; ++i) {
+		uint256 i;
+		uint256 bounty;
+
+		for (; i < _accounts.length; ++i) {
 			if (gasleft() < iterationGasLimit) {
-				emit TotalFished(i);
-				return i;
+				break;
 			}
-			if (
-				isNotNewUser(_accounts[i]) &&
-				!isActiveUser(_accounts[i]) &&
-				!fishedUsersAddresses[_accounts[i]]
-			) {
-				require(fish(_accounts[i]), "fish has failed");
+			if (_canFish(_accounts[i])) {
+				require(_fish(_accounts[i], false), "fish has failed");
+				bounty += dailyUbi;
 			}
 		}
-		emit TotalFished(_accounts.length);
-		return _accounts.length;
+		if (bounty > 0) {
+			_transferTokens(msg.sender, msg.sender, bounty, false, false);
+		}
+		emit TotalFished(i);
+		return i;
 	}
 
 	/**
@@ -572,18 +591,19 @@ contract UBIScheme is DAOUpgradeableContract {
 		paused = _pause;
 	}
 
-	function upgrade() public {
-		_onlyAvatar();
-		paused = true;
-		activeUsersCount = 50000; //estimated
-		dailyUbi = 0; //required so distributionformula will trigger
-		cycleLength = 30;
-		currentCycleLength = 0; //this will trigger a new cycle calculation in distribution formula
-		startOfCycle = block.timestamp - 91 days; //this will trigger a new calculation in distributionFormula
-		periodStart = 1646136000;
-		distributionFormula();
-		emit CycleLengthSet(cycleLength);
-	}
+	// function upgrade() public {
+	// 	_onlyAvatar();
+	// 	paused = true;
+	// 	activeUsersCount = 50000; //estimated
+	// 	dailyUbi = 0; //required so distributionformula will trigger
+	// 	cycleLength = 30;
+	// 	currentCycleLength = 0; //this will trigger a new cycle calculation in distribution formula
+	// 	startOfCycle = block.timestamp - 91 days; //this will trigger a new calculation in distributionFormula
+	// 	periodStart = 1646136000;
+	// 	maxDailyUBI = 50000;
+	// 	distributionFormula();
+	// 	emit CycleLengthSet(cycleLength);
+	// }
 
 	function setActiveUserCount(uint256 _activeUserCount) public {
 		_onlyAvatar();

package/contracts/utils/AdminWallet.sol

@@ -4,10 +4,10 @@ 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/OwnableUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 
 import "../Interfaces.sol";
+import "../utils/NameService.sol";
 
 /* @title Admin wallet contract allowing whitelisting and topping up of
  * addresses
@@ -15,7 +15,6 @@ import "../Interfaces.sol";
 contract AdminWallet is
 	Initializable,
 	UUPSUpgradeable,
-	OwnableUpgradeable,
 	AccessControlUpgradeable
 {
 	bytes32 public constant WALLET_ADMIN_ROLE = keccak256("WALLET_ADMIN_ROLE");
@@ -28,10 +27,13 @@ contract AdminWallet is
 	uint256 public toppingTimes;
 	uint256 public gasPrice;
 
-	IIdentity public identity;
+	NameService public nameService;
 
 	mapping(uint256 => mapping(address => uint256)) toppings;
 
+	uint64 public maxDailyNewWallets;
+	uint64 public day;
+
 	event AdminsAdded(address payable[] indexed admins);
 	event AdminsRemoved(address[] indexed admins);
 	event WalletTopped(address indexed user, uint256 amount);
@@ -47,17 +49,29 @@ contract AdminWallet is
 	 */
 	function initialize(
 		address payable[] memory _admins,
+		NameService _ns,
 		address _owner,
-		IIdentity _identity
+		uint256 _gasPrice
 	) public initializer {
 		__AccessControl_init_unchained();
-		__Ownable_init_unchained();
 		_setupRole(DEFAULT_ADMIN_ROLE, _owner);
-		_setDefaults(600000, 9e6, 3, 1e10);
-		identity = _identity;
+		_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+
+		_setDefaults(600000, 9e6, 3, _gasPrice);
+		nameService = _ns;
 		if (_admins.length > 0) {
 			addAdmins(_admins);
 		}
+		if (msg.sender != _owner) revokeRole(DEFAULT_ADMIN_ROLE, msg.sender);
+	}
+
+	modifier onlyOwner() {
+		require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not owner");
+		_;
+	}
+
+	function getIdentity() public view returns (IIdentityV2) {
+		return IIdentityV2(nameService.getAddress("IDENTITY"));
 	}
 
 	function setDefaults(
@@ -171,28 +185,45 @@ contract AdminWallet is
 		onlyAdmin
 		reimburseGas
 	{
-		identity.addWhitelistedWithDID(_user, _did);
+		getIdentity().addWhitelistedWithDID(_user, _did);
+	}
+
+	/* @dev Function to add given address to whitelist of identity contract
+	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
+	 */
+	function whitelist(
+		address _user,
+		string memory _did,
+		uint256 orgChain,
+		uint256 dateAuthenticated
+	) public onlyAdmin reimburseGas {
+		getIdentity().addWhitelistedWithDIDAndChain(
+			_user,
+			_did,
+			orgChain,
+			dateAuthenticated
+		);
 	}
 
 	/* @dev Function to remove given address from whitelist of identity contract
 	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
 	 */
 	function removeWhitelist(address _user) public onlyAdmin reimburseGas {
-		identity.removeWhitelisted(_user);
+		getIdentity().removeWhitelisted(_user);
 	}
 
 	/* @dev Function to add given address to blacklist of identity contract
 	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
 	 */
 	function blacklist(address _user) public onlyAdmin reimburseGas {
-		identity.addBlacklisted(_user);
+		getIdentity().addBlacklisted(_user);
 	}
 
 	/* @dev Function to remove given address from blacklist of identity contract
 	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
 	 */
 	function removeBlacklist(address _user) public onlyAdmin reimburseGas {
-		identity.removeBlacklisted(_user);
+		getIdentity().removeBlacklisted(_user);
 	}
 
 	/* @dev Function to top given address with amount of G$ given in constructor

package/contracts/utils/BuyAndBridgeHelper.sol

@@ -0,0 +1,108 @@
+pragma solidity >=0.8.0;
+import "../reserve/ExchangeHelper.sol";
+
+contract BuyAndBridgeHelper {
+	struct BuyParams {
+		address[] buyPath;
+		uint256 tokenAmount;
+		uint256 minReturn;
+		uint256 minDAIAmount;
+		address targetAddress;
+	}
+
+	uint256 public constant CELO = 42220;
+	uint256 public constant FUSE = 122;
+
+	ExchangeHelper public exHelper;
+
+	address public gd;
+	address public gdx;
+	address public fuseBridge;
+	IMultichainRouter public multiChainBridge;
+	address public anyGoodDollar; //G$ multichain wrapper on ethereum
+
+	constructor(ExchangeHelper _exh) {
+		exHelper = _exh;
+		updateAddresses();
+	}
+
+	function updateAddresses() public {
+		fuseBridge = exHelper.nameService().getAddress("BRIDGE_CONTRACT");
+		multiChainBridge = IMultichainRouter(
+			exHelper.nameService().getAddress("MULTICHAIN_ROUTER")
+		);
+		anyGoodDollar = exHelper.nameService().getAddress(
+			"MULTICHAIN_ANYGOODDOLLAR"
+		);
+		gd = exHelper.nameService().getAddress("GOODDOLLAR");
+		gdx = exHelper.nameService().getAddress("RESERVE");
+	}
+
+	function buyAndBridge(BuyParams memory _params, uint256 _toChain)
+		public
+		payable
+		returns (uint256)
+	{
+		require(_toChain == FUSE || _toChain == CELO, "invalid chainId");
+		uint256 valueToSend;
+		if (_params.buyPath[0] != address(0)) {
+			ERC20(_params.buyPath[0]).approve(address(exHelper), type(uint256).max);
+			ERC20(_params.buyPath[0]).transferFrom(
+				msg.sender,
+				address(this),
+				_params.tokenAmount
+			);
+		} else {
+			valueToSend = _params.tokenAmount;
+		}
+
+		address recipient = _params.targetAddress == address(0)
+			? msg.sender
+			: _params.targetAddress;
+
+		//we send bought G$s here
+		uint256 bought = exHelper.buy{ value: valueToSend }(
+			_params.buyPath,
+			_params.tokenAmount,
+			_params.minReturn,
+			_params.minDAIAmount,
+			address(this)
+		);
+
+		require(bought > 0, "buy failed");
+
+		address gdx = exHelper.nameService().getAddress("RESERVE");
+		//make sure we send GDX we received to buyer
+		if (ERC20(gdx).balanceOf(address(this)) >= bought) {
+			require(ERC20(gdx).transfer(msg.sender, bought), "gdx");
+		}
+		bridge(_toChain, recipient, bought);
+	}
+
+	/**
+	 * @notice internal function that takes care of sending the G$s according to the transfer type
+	 * @param _recipient data about the recipient
+	 * @param _amount how much to send
+	 */
+	function bridge(
+		uint256 _toChain,
+		address _recipient,
+		uint256 _amount
+	) internal {
+		if (_toChain == FUSE) {
+			IGoodDollar(gd).transferAndCall(
+				fuseBridge,
+				_amount,
+				abi.encodePacked(_recipient)
+			);
+		} else if (_toChain == CELO) {
+			IGoodDollar(gd).approve(address(multiChainBridge), _amount);
+			multiChainBridge.anySwapOutUnderlying(
+				anyGoodDollar,
+				_recipient,
+				_amount,
+				_toChain
+			);
+		}
+	}
+}

package/contracts/utils/GoodDollarMintBurnWrapper.sol

@@ -17,7 +17,7 @@ import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeab
 import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts/utils/math/Math.sol";
-import "hardhat/console.sol";
+// import "hardhat/console.sol";
 
 import "./DAOUpgradeableContract.sol";
 
@@ -625,4 +625,22 @@ contract GoodDollarMintBurnWrapper is
 			minterSupply[minter].lastDayReset = currentDay;
 		}
 	}
+
+	function upgradeSuperGoodDollar() external onlyRole(DEFAULT_ADMIN_ROLE) {
+		address _newns = 0x0F5dB7a64A6a64052693676CA898EC7F7A94FF4e;
+		_revokeRole(DEFAULT_ADMIN_ROLE, avatar); //old avatar
+		setDAO(INameService(_newns)); //changes avatar + nativeToken
+		token = address(nativeToken());
+		_setupRole(DEFAULT_ADMIN_ROLE, avatar); //new avatar
+		updateFrequency = 3 days;
+		_setMinterCaps(
+			0xf27Ee99622C3C9b264583dACB2cCE056e194494f,
+			0,
+			0,
+			0,
+			0,
+			300 * 1e6 * 1e18, //300M
+			5000 //50%
+		);
+	}
 }