@gooddollar/goodprotocol 2.0.32-beta.0 → 2.0.33-beta.0

package/contracts/fuseFaucet/SuperfluidFacuet.sol

@@ -17,8 +17,6 @@ contract SuperfluidFaucet is
 	using SafeMathUpgradeable for uint256;
 
 	bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
-	uint public constant GAS_TOPPING_AMOUNT = 350000;
-	uint public constant FIRST_GAS_TOPPING_AMOUNT = 15e5;
 
 	uint256 public _deprecated;
 	uint256 public maxValuePerPeriod;
@@ -31,6 +29,9 @@ contract SuperfluidFaucet is
 
 	mapping(address => RecipientInfo) public recipientInfo;
 
+	uint public gasToppingAmount;
+	uint public firstGasToppingAmount;
+
 	event WalletTopped(address recipient, uint256 amount);
 	event SettingsUpdated(uint256 maxValuePerPeriod, uint256 toppingPeriod);
 
@@ -51,7 +52,9 @@ contract SuperfluidFaucet is
 		_setupRole(ADMIN_ROLE, msg.sender);
 		_grantRole(ADMIN_ROLE, _admin);
 		maxValuePerPeriod = _maxValuePerPeriod;
-		toppingPeriod = _toppingPeriod;
+		toppingPeriod = _toppingPeriod * 1 days;
+		gasToppingAmount = 500000;
+		firstGasToppingAmount = 20e5;
 	}
 
 	function updateSettings(
@@ -59,7 +62,7 @@ contract SuperfluidFaucet is
 		uint256 _toppingPeriod
 	) external onlyRole(ADMIN_ROLE) {
 		maxValuePerPeriod = _maxValuePerPeriod;
-		toppingPeriod = _toppingPeriod;
+		toppingPeriod = _toppingPeriod * 1 days;
 		emit SettingsUpdated(_maxValuePerPeriod, _toppingPeriod);
 	}
 
@@ -78,6 +81,11 @@ contract SuperfluidFaucet is
 
 		uint256 currentPeriod = block.timestamp / toppingPeriod;
 
+		// fix bug where period was divid by 30 and not by 30days, (for non effected users lsatWithdrawlPeriod will be < 57947235 for sure)
+		if (info.lastWithdrawalPeriod > 0 && info.lastWithdrawalPeriod > 57947235) {
+			if (currentPeriod > (info.lastWithdrawalPeriod * 30) / toppingPeriod)
+				return true;
+		}
 		if (currentPeriod > info.lastWithdrawalPeriod) {
 			return true; // New period, reset counters
 		}
@@ -97,15 +105,22 @@ contract SuperfluidFaucet is
 		return canTop(recipient, blockFee);
 	}
 
+	function updateGasToppingAmounts(
+		uint _gasToppingAmount,
+		uint _firstGasToppingAmount
+	) external onlyRole(ADMIN_ROLE) {
+		gasToppingAmount = _gasToppingAmount;
+		firstGasToppingAmount = _firstGasToppingAmount;
+	}
+
 	function getToppingValue(
 		bool firstTime,
 		uint baseFee
-	) public pure returns (uint) {
+	) public view returns (uint) {
 		//top wallet with current base fee + 10% for priority fee and l1 fees
 		return
-			((firstTime ? FIRST_GAS_TOPPING_AMOUNT : GAS_TOPPING_AMOUNT) *
-				baseFee *
-				110) / 100;
+			((firstTime ? firstGasToppingAmount : gasToppingAmount) * baseFee * 110) /
+			100;
 	}
 
 	function topWallet(address payable recipient) external onlyRole(ADMIN_ROLE) {
@@ -115,6 +130,12 @@ contract SuperfluidFaucet is
 		uint amount = getToppingValue(firstTime, block.basefee);
 		uint256 currentPeriod = block.timestamp / toppingPeriod;
 
+		// fix bug where period was divid by 30 and not by 30days, (for non effected users lsatWithdrawlPeriod will be < 57947235 for sure)
+		if (info.lastWithdrawalPeriod > 0 && info.lastWithdrawalPeriod > 57947235) {
+			info.lastWithdrawalPeriod =
+				(info.lastWithdrawalPeriod * 30) /
+				toppingPeriod;
+		}
 		if (currentPeriod > info.lastWithdrawalPeriod) {
 			info.totalWithdrawnThisPeriod = 0;
 			info.lastWithdrawalPeriod = currentPeriod;

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

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "../MentoInterfaces.sol";
+import "@openzeppelin/contracts/access/AccessControl.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+
+contract BuyFromReserveHelper is AccessControl, ReentrancyGuard {
+	using SafeERC20 for IERC20;
+
+	bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+	bytes32 public constant EXECUTOR_ROLE = keccak256("EXECUTOR_ROLE");
+
+	address public safe;
+	address public exchangeProvider;
+	bytes32 public exchangeId;
+	IERC20 public tokenIn;
+	IERC20 public tokenOut;
+	IBroker public broker;
+
+	event SafeUpdated(address indexed newSafe);
+	event SettingsUpdated(
+		address indexed exchangeProvider,
+		bytes32 indexed exchangeId
+	);
+	event GDBought(address indexed buyer, uint256 amountIn, uint256 amountOut);
+
+	constructor(
+		address _safe,
+		address _tokenIn,
+		address _tokenOut,
+		address _broker,
+		address _exchangeProvider,
+		bytes32 _exchangeId
+	) {
+		require(_safe != address(0), "Safe address cannot be zero");
+		require(_tokenIn != address(0), "TokenIn address cannot be zero");
+		require(_tokenOut != address(0), "TokenOut address cannot be zero");
+		require(_broker != address(0), "Broker address cannot be zero");
+		require(_exchangeProvider != address(0), "ExchangeProvider cannot be zero");
+		require(_exchangeId != bytes32(0), "ExchangeId cannot be zero");
+
+		safe = _safe;
+		tokenIn = IERC20(_tokenIn);
+		tokenOut = IERC20(_tokenOut);
+		broker = IBroker(_broker);
+		exchangeProvider = _exchangeProvider;
+		exchangeId = _exchangeId;
+
+		_setupRole(DEFAULT_ADMIN_ROLE, _safe);
+		_setupRole(EXECUTOR_ROLE, msg.sender);
+	}
+
+	function updateSafe(address _newSafe) external {
+		require(msg.sender == safe, "Only safe can update");
+		require(_newSafe != address(0), "New safe address cannot be zero");
+
+		// Update admin role
+		_revokeRole(DEFAULT_ADMIN_ROLE, safe);
+		_setupRole(DEFAULT_ADMIN_ROLE, _newSafe);
+
+		safe = _newSafe;
+		emit SafeUpdated(_newSafe);
+	}
+
+	function updateSettings(
+		address _exchangeProvider,
+		bytes32 _exchangeId,
+		address _tokenIn,
+		address _tokenOut,
+		address _broker
+	) external onlyRole(DEFAULT_ADMIN_ROLE) {
+		require(_exchangeProvider != address(0), "ExchangeProvider cannot be zero");
+		require(_exchangeId != bytes32(0), "ExchangeId cannot be zero");
+		require(_tokenIn != address(0), "TokenIn address cannot be zero");
+		require(_tokenOut != address(0), "TokenOut address cannot be zero");
+		require(_broker != address(0), "Broker address cannot be zero");
+
+		exchangeProvider = _exchangeProvider;
+		exchangeId = _exchangeId;
+		tokenIn = IERC20(_tokenIn);
+		tokenOut = IERC20(_tokenOut);
+		broker = IBroker(_broker);
+
+		emit SettingsUpdated(_exchangeProvider, _exchangeId);
+	}
+
+	function buyGdFromBroker(
+		uint256 amountInNominal,
+		uint256 minReturnNominal
+	) external onlyRole(EXECUTOR_ROLE) nonReentrant {
+		require(amountInNominal > 0, "Amount must be greater than zero");
+		require(minReturnNominal > 0, "Minimum return must be greater than zero");
+
+		uint256 amountIn = amountInNominal * 1e18;
+		uint256 minReturn = minReturnNominal * 1e18;
+
+		// assume minimum price for 0.00005 for G$ for safety check
+		require((amountIn * 1e18) / 5e13 >= minReturn, "minReturn seems too low");
+
+		// Transfer tokenIn from the safe to this contract
+		tokenIn.safeTransferFrom(safe, address(this), amountIn);
+
+		// Reset any existing approval
+		tokenIn.safeApprove(address(broker), 0);
+		// Approve the broker to spend tokenIn
+		tokenIn.safeApprove(address(broker), amountIn);
+
+		// Call the broker to buy tokenOut (G$)
+		uint256 amountOut = broker.swapIn(
+			exchangeProvider,
+			exchangeId,
+			address(tokenIn),
+			address(tokenOut),
+			amountIn,
+			minReturn
+		);
+
+		// Verify minimum return
+		require(amountOut >= minReturn, "Insufficient return amount");
+
+		// Transfer bought tokens to safe
+		tokenOut.safeTransfer(safe, amountOut);
+
+		emit GDBought(msg.sender, amountIn, amountOut);
+	}
+}

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);
+	}
+}