@gooddollar/goodprotocol 2.0.31 → 2.0.32

package/contracts/mocks/CeloDistributionHelperTest.sol

@@ -0,0 +1,25 @@
+pragma solidity >=0.8;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/utils/math/Math.sol";
+
+import "../reserve/CeloDistributionHelper.sol";
+
+contract CeloDistributionHelperTest is CeloDistributionHelper {
+	function onDistribution(uint256 _amount) external override {
+		revert();
+	}
+}
+
+contract CeloDistributionHelperTestHelper is CeloDistributionHelper {
+	function setOracle(IStaticOracle oracle) external {
+		STATIC_ORACLE = oracle;
+	}
+
+	function setBridges(address _mpbBridge) external {
+		mpbBridge = IMessagePassingBridge(_mpbBridge);
+	}
+}

package/contracts/reserve/CeloDistributionHelper.sol

@@ -0,0 +1,286 @@
+// 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 "../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 CeloDistributionHelper is
+	DAOUpgradeableContract,
+	AccessControlEnumerableUpgradeable
+{
+	error FEE_LIMIT(uint256 fee);
+	error INVALID_CHAINID();
+
+	bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
+
+	address public constant CELO = 0x471EcE3750Da237f93B8E339c536989b8978a438;
+
+	address public constant CUSD = 0x765DE816845861e75A25fCA122bb6898B8B1282a;
+
+	ISwapRouter public constant ROUTER =
+		ISwapRouter(0x5615CDAb10dc425a742d643d949a7F474C01abc4);
+
+	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 public mpbBridge;
+	FeeSettings public feeSettings;
+	IStaticOracle public STATIC_ORACLE;
+
+	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);
+
+	receive() external payable {}
+
+	function initialize(
+		INameService _ns,
+		IStaticOracle _oracle
+	) 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);
+		mpbBridge = IMessagePassingBridge(
+			nameService.getAddress("MPBBRIDGE_CONTRACT")
+		);
+		STATIC_ORACLE = _oracle;
+		uint24[] memory fees = new uint24[](1);
+		fees[0] = 10000;
+		STATIC_ORACLE.prepareSpecificFeeTiersWithTimePeriod(
+			CUSD,
+			address(nativeToken()),
+			fees,
+			60
+		);
+		fees[0] = 100;
+		STATIC_ORACLE.prepareSpecificFeeTiersWithTimePeriod(CUSD, CELO, 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);
+		}
+
+		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(mpbBridge), _amount);
+			(uint256 lzFee, ) = ILayerZeroFeeEstimator(address(mpbBridge))
+				.estimateSendFee(
+					mpbBridge.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);
+
+			mpbBridge.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),
+				CELO,
+				CUSD,
+				fees,
+				60 //last 1 minute
+			);
+
+		fees[0] = 10000;
+		(gdToSell, ) = STATIC_ORACLE.quoteSpecificFeeTiersWithTimePeriod(
+			uint128(nativeValueInUSD),
+			CUSD,
+			address(nativeToken()),
+			fees,
+			60 //last 1 minute
+		);
+
+		minReceived = nativeToBuy;
+		if (gdToSell > maxAmountToSell) {
+			gdToSell = maxAmountToSell;
+
+			fees[0] = 10000;
+			// gdToSell = (nativeValueInUSD * 1e18) / gdPriceInUSD; // mul by 1e18 so result is in 18 decimals
+			(uint256 minReceivedCUSD, ) = STATIC_ORACLE
+				.quoteSpecificFeeTiersWithTimePeriod(
+					uint128(gdToSell),
+					address(nativeToken()),
+					CUSD,
+					fees,
+					60 //last 1 minute
+				);
+
+			fees[0] = 100;
+			(minReceived, ) = STATIC_ORACLE.quoteSpecificFeeTiersWithTimePeriod(
+				uint128(minReceivedCUSD),
+				CUSD,
+				CELO,
+				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(10000),
+				CUSD,
+				uint24(100),
+				CELO
+			),
+			recipient: address(this),
+			amountIn: amountToSell,
+			amountOutMinimum: amountOutMinimum
+		});
+		try ROUTER.exactInput(params) returns (uint256 amountOut) {
+			return amountOut;
+		} catch Error(string memory reason) {
+			emit BuyNativeFailed(reason);
+			return 0;
+		}
+	}
+}

package/contracts/reserve/GoodMarketMaker.sol

@@ -300,8 +300,18 @@ contract GoodMarketMaker is DAOUpgradeableContract, DSMath {
 
 		// The return value after the deduction
 		uint256 tokenReturn = sellReturn(_token, amountAfterContribution);
-		rtoken.gdSupply -= _gdAmount;
+
+		rtoken.gdSupply -= amountAfterContribution;
 		rtoken.reserveSupply -= tokenReturn;
+		//burn contributed tokens on curve
+		if (_contributionGdAmount > 0) {
+			uint256 nom = rtoken.gdSupply * rtoken.reserveRatio;
+			uint256 denom = rtoken.gdSupply - _contributionGdAmount;
+			uint256 newRatio = nom / denom;
+			rtoken.reserveRatio = uint32(newRatio);
+			rtoken.gdSupply -= _contributionGdAmount;
+		}
+
 		emit BalancesUpdated(
 			msg.sender,
 			address(_token),

package/contracts/staking/GoodFundManager.sol

@@ -398,13 +398,16 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 			staking.blockStart,
 			staking.blockEnd
 		);
-		if (amount > 0 && staking.isBlackListed == false) {
+		if (
+			amount > 0 &&
+			staking.isBlackListed == false &&
+			GoodReserveCDai(nameService.getAddress("RESERVE")).paused() == false
+		) {
 			GoodReserveCDai(nameService.getAddress("RESERVE")).mintRewardFromRR(
 				_token,
 				_user,
 				amount
 			);
-
 			emit StakingRewardMinted(msg.sender, _user, amount);
 		}
 	}

package/contracts/utils/ProtoclUpgradeV4Mento.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "../utils/NameService.sol";
+import "../Interfaces.sol";
+import "../MentoInterfaces.sol";
+
+// import "hardhat/console.sol";
+
+interface MentoExchange {
+	function reserve() external view returns (address);
+}
+
+contract ProtocolUpgradeV4Mento {
+	address avatar;
+
+	constructor(address _avatar) {
+		avatar = _avatar;
+	}
+
+	function upgrade(
+		Controller _controller,
+		IBancorExchangeProvider.PoolExchange memory _exchange,
+		address _mentoExchange,
+		address _mentoController,
+		address _distHelper,
+		uint256 totalGlobalSupply
+	) external {
+		require(msg.sender == address(avatar), "only avatar can call this");
+
+		// uint32 expansionFrequency = 1 days;
+		// uint64 expansionRate = 288617289021952; //10% a year = ((1e18 - expansionRate)/1e18)^365=0.9
+		uint256 cUSDBalance = ERC20(_exchange.reserveAsset).balanceOf(
+			MentoExchange(_mentoExchange).reserve()
+		);
+		require(cUSDBalance >= 200000e18, "not enough reserve");
+
+		uint256 gdSupply = ERC20(_exchange.tokenAddress).totalSupply();
+		uint256 price = 0.0001 ether; // we initialize with price of 0.0001
+		// given price calculate the reserve ratio
+		uint32 reserveRatio = uint32(
+			(cUSDBalance * 1e18 * 1e8) / (price * totalGlobalSupply)
+		); //cUSDBalance/(price * gdSupply/1e18) * 1e8
+		uint32 exitContribution = 0.1 * 1e8;
+
+		_exchange.reserveBalance = cUSDBalance;
+		_exchange.tokenSupply = totalGlobalSupply;
+		_exchange.reserveRatio = reserveRatio;
+		_exchange.exitContribution = exitContribution;
+
+		(bool ok, bytes memory result) = _controller.genericCall(
+			address(_mentoExchange),
+			abi.encodeCall(IBancorExchangeProvider.createExchange, _exchange),
+			address(avatar),
+			0
+		);
+
+		// console.log("createExchange %s", ok);
+		require(ok, "createExchange failed");
+		bytes32 exchangeId = abi.decode(result, (bytes32));
+		// console.logBytes32(exchangeId);
+		(ok, ) = _controller.genericCall(
+			address(_mentoController),
+			abi.encodeCall(
+				IGoodDollarExpansionController.setExpansionConfig,
+				(exchangeId, 288617289021952, 1 days) //10% a year = ((1e18 - expansionRate)/1e18)^365=0.9 frequency 1 day
+			),
+			address(avatar),
+			0
+		);
+		require(ok, "setExpansionConfig failed");
+
+		(ok, ) = _controller.genericCall(
+			address(_mentoController),
+			abi.encodeCall(
+				IGoodDollarExpansionController.setDistributionHelper,
+				_distHelper
+			),
+			address(avatar),
+			0
+		);
+		require(ok, "setDistribuitionHelper failed");
+
+		// mint exit liquidity to bridge
+		uint256 toMint = totalGlobalSupply - gdSupply;
+		require(
+			_controller.mintTokens(
+				toMint,
+				0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5,
+				address(avatar)
+			),
+			"bridge minting failed"
+		);
+
+		// prevent executing again
+		require(_controller.unregisterSelf(avatar), "unregistering failed");
+		avatar = address(0);
+	}
+}