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

package/contracts/reserve/GenericDistributionHelper.sol

@@ -0,0 +1,319 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8;
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@mean-finance/uniswap-v3-oracle/solidity/interfaces/IStaticOracle.sol";
+import "@gooddollar/bridge-contracts/contracts/messagePassingBridge/IMessagePassingBridge.sol";
+import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
+
+import "../utils/DAOUpgradeableContract.sol";
+
+// import "hardhat/console.sol";
+
+/***
+ * @dev DistributionHelper receives funds and distributes them to recipients
+ * recipients can be on other blockchains and get their funds via fuse/multichain bridge
+ * accounts with ADMIN_ROLE can update the recipients, defaults to Avatar
+ */
+contract GenericDistributionHelper is
+	DAOUpgradeableContract,
+	AccessControlEnumerableUpgradeable
+{
+	error FEE_LIMIT(uint256 fee);
+	error INVALID_CHAINID();
+
+	bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
+
+	enum TransferType {
+		LayerZeroBridge,
+		Transfer,
+		TransferAndCall
+	}
+
+	struct DistributionRecipient {
+		uint32 bps; //share out of each distribution
+		uint32 chainId; //for multichain bridge
+		address addr; //recipient address
+		TransferType transferType;
+	}
+
+	struct FeeSettings {
+		uint128 maxFee;
+		uint128 minBalanceForFees;
+		uint8 percentageToSellForFee;
+		uint8 maxSlippage;
+	}
+
+	DistributionRecipient[] public distributionRecipients;
+
+	IMessagePassingBridge private _unused_mpbBridge;
+	FeeSettings public feeSettings;
+	IStaticOracle public STATIC_ORACLE;
+	ISwapRouter public ROUTER;
+
+	address public gasToken;
+
+	address public reserveToken;
+
+	event Distribution(
+		uint256 distributed,
+		uint256 startingBalance,
+		uint256 incomingAmount,
+		DistributionRecipient[] distributionRecipients,
+		uint256 gdSoldForGas,
+		uint256 nativeBoughtForGas
+	);
+	event RecipientUpdated(DistributionRecipient recipient, uint256 index);
+	event RecipientAdded(DistributionRecipient recipient, uint256 index);
+	event BuyNativeFailed(
+		string reason,
+		uint256 amountToSell,
+		uint256 amountOutMinimum
+	);
+
+	receive() external payable {}
+
+	function initialize(
+		INameService _ns,
+		IStaticOracle _oracle,
+		address _gasToken, //weth
+		address _reserveToken,
+		ISwapRouter _router,
+		FeeSettings memory _feeData
+	) external initializer {
+		__AccessControlEnumerable_init();
+		setDAO(_ns);
+		_setupRole(DEFAULT_ADMIN_ROLE, avatar); //this needs to happen after setDAO for avatar to be non empty
+		_setupRole(GUARDIAN_ROLE, avatar);
+		STATIC_ORACLE = _oracle;
+		ROUTER = _router;
+		feeSettings = _feeData;
+		gasToken = _gasToken;
+		_setReserveToken(_reserveToken);
+	}
+
+	function getBridge() public view returns (IMessagePassingBridge) {
+		return IMessagePassingBridge(nameService.getAddress("MPBBRIDGE_CONTRACT"));
+	}
+
+	function setReserveToken(
+		address _reserveToken
+	) public onlyRole(GUARDIAN_ROLE) {
+		_setReserveToken(_reserveToken);
+	}
+
+	function _setReserveToken(address _reserveToken) internal {
+		uint24[] memory fees = new uint24[](1);
+		fees[0] = 100;
+		reserveToken = _reserveToken;
+		STATIC_ORACLE.prepareSpecificFeeTiersWithTimePeriod(
+			reserveToken,
+			address(nativeToken()),
+			fees,
+			60
+		);
+		STATIC_ORACLE.prepareSpecificFeeTiersWithTimePeriod(
+			reserveToken,
+			gasToken,
+			fees,
+			60
+		);
+	}
+
+	function setFeeSettings(
+		FeeSettings memory _feeData
+	) external onlyRole(GUARDIAN_ROLE) {
+		feeSettings = _feeData;
+	}
+
+	/**
+	 * @notice this is usually called by reserve, but can be called by anyone anytime to trigger distribution
+	 * @param _amount how much was sent, informational only
+	 */
+	function onDistribution(uint256 _amount) external virtual {
+		//we consider the actual balance and not _amount
+		uint256 toDistribute = nativeToken().balanceOf(address(this));
+		if (toDistribute == 0) return;
+
+		uint256 boughtNative;
+		uint256 gdToSellForFee;
+		uint256 minReceived;
+		if (address(this).balance < feeSettings.minBalanceForFees) {
+			gdToSellForFee =
+				(toDistribute * feeSettings.percentageToSellForFee) /
+				100;
+			(gdToSellForFee, minReceived) = calcGDToSell(gdToSellForFee);
+			toDistribute -= gdToSellForFee;
+			boughtNative = buyNativeWithGD(gdToSellForFee, minReceived);
+
+			//try to unwrap to native
+			try IWETH(gasToken).withdraw(boughtNative) {
+				// success
+			} catch Error(string memory reason) {
+				emit BuyNativeFailed(reason, boughtNative, 0);
+			} catch {
+				emit BuyNativeFailed("WETH withdraw failed", boughtNative, 0);
+			}
+		}
+
+		uint256 totalDistributed;
+		for (uint256 i = 0; i < distributionRecipients.length; i++) {
+			DistributionRecipient storage r = distributionRecipients[i];
+			if (r.bps > 0) {
+				uint256 toTransfer = (toDistribute * r.bps) / 10000;
+				totalDistributed += toTransfer;
+				if (toTransfer > 0) distribute(r, toTransfer);
+			}
+		}
+
+		emit Distribution(
+			totalDistributed,
+			toDistribute,
+			_amount,
+			distributionRecipients,
+			gdToSellForFee,
+			boughtNative
+		);
+	}
+
+	/**
+	 * @notice add or update a recipient details, if address exists it will update, otherwise add
+	 * to "remove" set recipient bps to 0. only ADMIN_ROLE can call this.
+	 */
+	function addOrUpdateRecipient(
+		DistributionRecipient memory _recipient
+	) external onlyRole(DEFAULT_ADMIN_ROLE) {
+		if (
+			_recipient.transferType != TransferType.LayerZeroBridge &&
+			_recipient.chainId != block.chainid
+		) {
+			revert INVALID_CHAINID();
+		}
+
+		for (uint256 i = 0; i < distributionRecipients.length; i++) {
+			if (distributionRecipients[i].addr == _recipient.addr) {
+				distributionRecipients[i] = _recipient;
+				emit RecipientUpdated(_recipient, i);
+				return;
+			}
+		}
+		//if reached here then add new one
+		emit RecipientAdded(_recipient, distributionRecipients.length);
+		distributionRecipients.push(_recipient);
+	}
+
+	/**
+	 * @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 distribute(
+		DistributionRecipient storage _recipient,
+		uint256 _amount
+	) internal {
+		if (_recipient.transferType == TransferType.LayerZeroBridge) {
+			nativeToken().approve(address(getBridge()), _amount);
+			(uint256 lzFee, ) = ILayerZeroFeeEstimator(address(getBridge()))
+				.estimateSendFee(
+					getBridge().toLzChainId(_recipient.chainId),
+					address(this),
+					_recipient.addr,
+					_amount,
+					false,
+					abi.encodePacked(uint16(1), uint256(400000)) // 400k gas to execute bridge at target chain
+				);
+			if (lzFee > feeSettings.maxFee || lzFee > address(this).balance)
+				revert FEE_LIMIT(lzFee);
+
+			getBridge().bridgeToWithLz{ value: lzFee }(
+				_recipient.addr,
+				_recipient.chainId,
+				_amount,
+				""
+			);
+		} else if (_recipient.transferType == TransferType.TransferAndCall) {
+			nativeToken().transferAndCall(_recipient.addr, _amount, "");
+		} else if (_recipient.transferType == TransferType.Transfer) {
+			nativeToken().transfer(_recipient.addr, _amount);
+		}
+	}
+
+	function calcGDToSell(
+		uint256 maxAmountToSell
+	) public view returns (uint256 gdToSell, uint256 minReceived) {
+		uint24[] memory fees = new uint24[](1);
+		fees[0] = 100;
+		uint256 nativeToBuy = feeSettings.minBalanceForFees *
+			3 -
+			address(this).balance;
+		(uint256 nativeValueInUSD, ) = STATIC_ORACLE
+			.quoteSpecificFeeTiersWithTimePeriod(
+				uint128(nativeToBuy),
+				gasToken,
+				reserveToken,
+				fees,
+				60 //last 1 minute
+			);
+
+		(gdToSell, ) = STATIC_ORACLE.quoteSpecificFeeTiersWithTimePeriod(
+			uint128(nativeValueInUSD),
+			reserveToken,
+			address(nativeToken()),
+			fees,
+			60 //last 1 minute
+		);
+
+		minReceived = nativeToBuy;
+		if (gdToSell > maxAmountToSell) {
+			gdToSell = maxAmountToSell;
+
+			fees[0] = 100;
+			// gdToSell = (nativeValueInUSD * 1e18) / gdPriceInUSD; // mul by 1e18 so result is in 18 decimals
+			(uint256 minReceivedCUSD, ) = STATIC_ORACLE
+				.quoteSpecificFeeTiersWithTimePeriod(
+					uint128(gdToSell),
+					address(nativeToken()),
+					reserveToken,
+					fees,
+					60 //last 1 minute
+				);
+
+			(minReceived, ) = STATIC_ORACLE.quoteSpecificFeeTiersWithTimePeriod(
+				uint128(minReceivedCUSD),
+				reserveToken,
+				gasToken,
+				fees,
+				60 //last 1 minute
+			);
+		}
+	}
+
+	function buyNativeWithGD(
+		uint256 amountToSell,
+		uint256 minReceived
+	) internal returns (uint256 nativeBought) {
+		ERC20(nativeToken()).approve(address(ROUTER), amountToSell);
+		uint256 amountOutMinimum = (minReceived * (100 - feeSettings.maxSlippage)) /
+			100; // 5% slippage
+		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
+			path: abi.encodePacked(
+				nativeToken(),
+				uint24(100),
+				reserveToken,
+				uint24(100),
+				gasToken
+			),
+			recipient: address(this),
+			amountIn: amountToSell,
+			amountOutMinimum: amountOutMinimum
+		});
+		try ROUTER.exactInput(params) returns (uint256 amountOut) {
+			return amountOut;
+		} catch Error(string memory reason) {
+			emit BuyNativeFailed(reason, amountToSell, amountOutMinimum);
+			return 0;
+		}
+	}
+}

package/contracts/ubi/UBISchemeV2.sol

@@ -130,13 +130,16 @@ contract UBISchemeV2 is DAOUpgradeableContract {
 	 * @dev Constructor
 	 * @param _ns the DAO
 	 */
-	function initialize(INameService _ns) public initializer {
+	function initialize(
+		INameService _ns,
+		uint256 _minActiveUsers
+	) public initializer {
 		setDAO(_ns);
 		shouldWithdrawFromDAO = false;
 		cycleLength = 30; //30 days
 		periodStart = (block.timestamp / (1 days)) * 1 days - 12 hours; //set start time to GMT noon
 		startOfCycle = periodStart;
-		minActiveUsers = 1000;
+		minActiveUsers = _minActiveUsers;
 		reserveFactor = 10500;
 	}
 
@@ -266,7 +269,7 @@ contract UBISchemeV2 is DAOUpgradeableContract {
 				dailyCyclePool /
 				max((prevDayClaimers * reserveFactor) / 10000, minActiveUsers);
 			//update minActiveUsers as claimers grow
-			minActiveUsers = max(prevDayClaimers / 2, minActiveUsers);
+			minActiveUsers = (prevDayClaimers + minActiveUsers * 29) / 30; //smooth it a bit
 
 			emit UBICalculated(currentDay, dailyUbi, block.number);
 		}
@@ -344,7 +347,8 @@ contract UBISchemeV2 is DAOUpgradeableContract {
 		bool shouldStartEarlyCycle = currentDayInCycle() + 1 >=
 			currentCycleLength ||
 			nextDailyPool > (dailyCyclePool * 105) / 100 ||
-			currentBalance < (dailyCyclePool * (cycleLength - currentDayInCycle()));
+			currentBalance <
+			(dailyCyclePool * (cycleLength - currentDayInCycle() - 1));
 
 		uint256 _dailyCyclePool = dailyCyclePool;
 		uint256 _dailyUbi;

package/contracts/utils/ProxyFactory1967.sol

@@ -46,10 +46,10 @@ contract ProxyFactory1967 {
 		contractCodeHash = keccak256(type(ERC1967Proxy).creationCode);
 	}
 
-	function deployMinimal(address _logic, bytes memory _data)
-		public
-		returns (address proxy)
-	{
+	function deployMinimal(
+		address _logic,
+		bytes memory _data
+	) public returns (address proxy) {
 		// Adapted from https://github.com/optionality/clone-factory/blob/32782f82dfc5a00d103a7e61a17a5dedbd1e8e9d/contracts/CloneFactory.sol
 		bytes20 targetBytes = bytes20(_logic);
 		assembly {
@@ -82,20 +82,19 @@ contract ProxyFactory1967 {
 		return _deployProxy(_salt, _logic, _data, msg.sender);
 	}
 
-	function deployCode(uint256 _salt, bytes calldata _bytecode)
-		external
-		returns (address)
-	{
+	function deployCode(
+		uint256 _salt,
+		bytes calldata _bytecode
+	) external returns (address) {
 		address addr = _deployCode(_salt, msg.sender, _bytecode);
 		emit ContractCreated(addr);
 		return addr;
 	}
 
-	function getDeploymentAddress(uint256 _salt, address _sender)
-		public
-		view
-		returns (address)
-	{
+	function getDeploymentAddress(
+		uint256 _salt,
+		address _sender
+	) public view returns (address) {
 		return getDeploymentAddress(_salt, _sender, contractCodeHash);
 	}
 
@@ -146,11 +145,10 @@ contract ProxyFactory1967 {
 		return addr;
 	}
 
-	function _getSalt(uint256 _salt, address _sender)
-		internal
-		pure
-		returns (bytes32)
-	{
+	function _getSalt(
+		uint256 _salt,
+		address _sender
+	) internal pure returns (bytes32) {
 		return keccak256(abi.encodePacked(_salt, _sender));
 	}
 }