@gooddollar/goodprotocol 2.0.25-beta.9 → 2.0.26-beta.0

package/contracts/fuseFaucet/SuperfluidFacuet.sol

@@ -0,0 +1,129 @@
+// 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 "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
+
+/**
+ * to be deployed on base to support superfluid airdrop to G$ users
+ */
+contract SuperfluidFaucet is
+	Initializable,
+	UUPSUpgradeable,
+	AccessControlUpgradeable
+{
+	using SafeMathUpgradeable for uint256;
+
+	bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+
+	uint256 public toppingAmount;
+	uint256 public maxAmountPerPeriod;
+	uint256 public toppingPeriod;
+
+	struct RecipientInfo {
+		uint256 lastWithdrawalPeriod;
+		uint256 totalWithdrawnThisPeriod;
+	}
+
+	mapping(address => RecipientInfo) public recipientInfo;
+
+	event WalletTopped(address recipient, uint256 amount);
+	event SettingsUpdated(
+		uint256 toppingAmount,
+		uint256 maxAmountPerPeriod,
+		uint256 toppingPeriod
+	);
+
+	/// @custom:oz-upgrades-unsafe-allow constructor
+	constructor() {
+		_disableInitializers();
+	}
+
+	function initialize(
+		uint256 _toppingAmount,
+		uint256 _maxAmountPerPeriod,
+		uint256 _toppingPeriod,
+		address _admin
+	) public initializer {
+		__AccessControl_init();
+		__UUPSUpgradeable_init();
+
+		_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+		_setupRole(ADMIN_ROLE, msg.sender);
+		_grantRole(ADMIN_ROLE, _admin);
+		toppingAmount = _toppingAmount;
+		maxAmountPerPeriod = _maxAmountPerPeriod;
+		toppingPeriod = _toppingPeriod;
+	}
+
+	function updateSettings(
+		uint256 _toppingAmount,
+		uint256 _maxAmountPerPeriod,
+		uint256 _toppingPeriod
+	) external onlyRole(ADMIN_ROLE) {
+		toppingAmount = _toppingAmount;
+		maxAmountPerPeriod = _maxAmountPerPeriod;
+		toppingPeriod = _toppingPeriod;
+		emit SettingsUpdated(_toppingAmount, _maxAmountPerPeriod, _toppingPeriod);
+	}
+
+	function canTop(address recipient) public view returns (bool) {
+		if (recipient == address(0)) return false;
+		if (recipient.balance >= toppingAmount / 2) return false;
+
+		uint256 amountToSend = toppingAmount.sub(recipient.balance);
+		if (address(this).balance < amountToSend) return false;
+
+		uint256 currentPeriod = block.timestamp / toppingPeriod;
+		RecipientInfo storage info = recipientInfo[recipient];
+
+		if (currentPeriod > info.lastWithdrawalPeriod) {
+			return true; // New period, reset counters
+		}
+
+		if (info.totalWithdrawnThisPeriod.add(amountToSend) > maxAmountPerPeriod)
+			return false;
+
+		return true;
+	}
+
+	function topWallet(address payable recipient) external onlyRole(ADMIN_ROLE) {
+		require(canTop(recipient), "Recipient cannot be topped up");
+
+		uint256 currentPeriod = block.timestamp / toppingPeriod;
+		RecipientInfo storage info = recipientInfo[recipient];
+
+		if (currentPeriod > info.lastWithdrawalPeriod) {
+			info.totalWithdrawnThisPeriod = 0;
+			info.lastWithdrawalPeriod = currentPeriod;
+		}
+
+		uint256 amountToSend = toppingAmount.sub(recipient.balance);
+		require(
+			address(this).balance >= amountToSend,
+			"Insufficient contract balance for topping up"
+		);
+
+		info.totalWithdrawnThisPeriod = info.totalWithdrawnThisPeriod.add(
+			amountToSend
+		);
+
+		(bool success, ) = recipient.call{ value: amountToSend }("");
+		require(success, "Failed to send Ether");
+
+		emit WalletTopped(recipient, amountToSend);
+	}
+
+	receive() external payable {}
+
+	function withdraw() external onlyRole(DEFAULT_ADMIN_ROLE) {
+		uint256 balance = address(this).balance;
+		payable(msg.sender).transfer(balance);
+	}
+
+	function _authorizeUpgrade(
+		address newImplementation
+	) internal override onlyRole(DEFAULT_ADMIN_ROLE) {}
+}

package/contracts/governance/CompoundVotingMachine.sol

@@ -33,11 +33,9 @@ contract CompoundVotingMachine is ContextUpgradeable, DAOUpgradeableContract {
 	/// @notice The number of votes required in order for a voter to become a proposer
 	uint256 public proposalPercentage;
 
-	function proposalThreshold(uint256 blockNumber)
-		public
-		view
-		returns (uint256)
-	{
+	function proposalThreshold(
+		uint256 blockNumber
+	) public view returns (uint256) {
 		return (rep.totalSupplyAt(blockNumber) * proposalPercentage) / 1000000; //0.25%
 	}
 
@@ -102,6 +100,8 @@ contract CompoundVotingMachine is ContextUpgradeable, DAOUpgradeableContract {
 		uint256 quoromRequired;
 		// support proposal voting bridge
 		uint256 forBlockchain;
+		// flag to mark proposal was approved as not malicious by guardians
+		bool guardianApproved;
 	}
 
 	/// @notice Ballot receipt record for a voter
@@ -426,6 +426,11 @@ contract CompoundVotingMachine is ContextUpgradeable, DAOUpgradeableContract {
 			"CompoundVotingMachine::execute: proposal for wrong blockchain"
 		);
 
+		require(
+			address(guardian) == address(0) || proposals[proposalId].guardianApproved,
+			"CompoundVotingMachine: proposal not approved"
+		);
+
 		proposals[proposalId].executed = true;
 		address[] memory _targets = proposals[proposalId].targets;
 		uint256[] memory _values = proposals[proposalId].values;
@@ -501,7 +506,9 @@ contract CompoundVotingMachine is ContextUpgradeable, DAOUpgradeableContract {
 	}
 
 	/// @notice get the actions to be done in a proposal
-	function getActions(uint256 proposalId)
+	function getActions(
+		uint256 proposalId
+	)
 		public
 		view
 		returns (
@@ -516,11 +523,10 @@ contract CompoundVotingMachine is ContextUpgradeable, DAOUpgradeableContract {
 	}
 
 	/// @notice get the receipt of a single voter in a proposal
-	function getReceipt(uint256 proposalId, address voter)
-		public
-		view
-		returns (Receipt memory)
-	{
+	function getReceipt(
+		uint256 proposalId,
+		address voter
+	) public view returns (Receipt memory) {
 		return proposals[proposalId].receipts[voter];
 	}
 
@@ -770,6 +776,15 @@ contract CompoundVotingMachine is ContextUpgradeable, DAOUpgradeableContract {
 		emit GuardianSet(guardian);
 	}
 
+	function approveProposal(uint256 _proposalId) public {
+		require(
+			_msgSender() == address(avatar) || _msgSender() == guardian,
+			"CompoundVotingMachine: not avatar or guardian"
+		);
+
+		proposals[_proposalId].guardianApproved = true;
+	}
+
 	/// @notice allow anyone to emit details about proposal that passed. can be used for cross-chain proposals using blockheader proofs
 	function emitSucceeded(uint256 _proposalId) public {
 		require(

package/contracts/governance/StakersDistribution.sol

@@ -52,6 +52,7 @@ contract StakersDistribution is
 	) external {
 		_onlyAvatar();
 		monthlyReputationDistribution = newMonthlyReputationDistribution;
+		_updateRewards();
 	}
 
 	/**
@@ -174,9 +175,10 @@ contract StakersDistribution is
 		_claimReputation(_staker, _stakingContracts);
 	}
 
-	function _claimReputation(address _staker, address[] memory _stakingContracts)
-		internal
-	{
+	function _claimReputation(
+		address _staker,
+		address[] memory _stakingContracts
+	) internal {
 		uint256 totalRep;
 		GoodFundManager gfm = GoodFundManager(
 			nameService.getAddress("FUND_MANAGER")
@@ -206,11 +208,10 @@ contract StakersDistribution is
 	 * @param _user the user to check rewards for
 	 * @return reputation rewards pending for user
 	 */
-	function getUserPendingRewards(address[] memory _contracts, address _user)
-		public
-		view
-		returns (uint256)
-	{
+	function getUserPendingRewards(
+		address[] memory _contracts,
+		address _user
+	) public view returns (uint256) {
 		uint256 pending;
 		for (uint256 i = 0; i < _contracts.length; i++) {
 			(
@@ -239,11 +240,10 @@ contract StakersDistribution is
 	 * @param _user account to get rewards status for
 	 * @return (minted, pending) in GDAO 18 decimals
 	 */
-	function getUserMintedAndPending(address[] memory _contracts, address _user)
-		public
-		view
-		returns (uint256, uint256)
-	{
+	function getUserMintedAndPending(
+		address[] memory _contracts,
+		address _user
+	) public view returns (uint256, uint256) {
 		uint256 pending = getUserPendingRewards(_contracts, _user);
 		uint256 minted;
 		for (uint256 i = 0; i < _contracts.length; i++) {

package/contracts/reserve/DistributionHelper.sol

@@ -44,7 +44,7 @@ contract DistributionHelper is
 		0x467719aD09025FcC6cF6F8311755809d45a5E5f3;
 
 	enum TransferType {
-		FuseBridge,
+		DEPRECATED_FuseBridge,
 		LayerZeroBridge,
 		AxelarBridge,
 		Contract
@@ -182,10 +182,11 @@ contract DistributionHelper is
 		if (toDistribute == 0) return;
 
 		if (address(this).balance < feeSettings.minBalanceForFees) {
-			uint256 gdToSellfForFee = (toDistribute *
+			uint256 gdToSellForFee = (toDistribute *
 				feeSettings.percentageToSellForFee) / 100;
-			toDistribute -= gdToSellfForFee;
-			buyNativeWithGD(gdToSellfForFee);
+			gdToSellForFee = calcGDToSell(gdToSellForFee);
+			toDistribute -= gdToSellForFee;
+			buyNativeWithGD(gdToSellForFee);
 		}
 
 		uint256 totalDistributed;
@@ -234,12 +235,8 @@ contract DistributionHelper is
 		DistributionRecipient storage _recipient,
 		uint256 _amount
 	) internal {
-		if (_recipient.transferType == TransferType.FuseBridge) {
-			nativeToken().transferAndCall(
-				fuseBridge,
-				_amount,
-				abi.encodePacked(_recipient.addr)
-			);
+		if (_recipient.transferType == TransferType.DEPRECATED_FuseBridge) {
+			revert("DEPRECATED");
 		} else if (_recipient.transferType == TransferType.LayerZeroBridge) {
 			nativeToken().approve(address(mpbBridge), _amount);
 			(uint256 lzFee, ) = ILayerZeroFeeEstimator(address(mpbBridge))
@@ -276,6 +273,28 @@ contract DistributionHelper is
 		}
 	}
 
+	function calcGDToSell(
+		uint256 maxAmountToSell
+	) public view returns (uint256 gdToSell) {
+		uint24[] memory fees = new uint24[](1);
+		fees[0] = 500;
+
+		uint256 ethToBuy = feeSettings.minBalanceForFees * 3;
+		(uint256 ethValueInUSDC, ) = STATIC_ORACLE
+			.quoteSpecificFeeTiersWithTimePeriod(
+				uint128(ethToBuy),
+				WETH_TOKEN,
+				USDC_TOKEN,
+				fees,
+				60 //last 1 minute
+			);
+
+		uint256 gdPriceInDai = GoodReserveCDai(nameService.getAddress("RESERVE"))
+			.currentPriceDAI();
+		gdToSell = (ethValueInUSDC * 1e12 * 100) / gdPriceInDai; //* 1e12 to increase usdc to 18 decimals, mul by 100 so result is in 2 G$ 2 decimals
+		gdToSell = gdToSell > maxAmountToSell ? maxAmountToSell : gdToSell;
+	}
+
 	function buyNativeWithGD(uint256 amountToSell) internal {
 		address[] memory path = new address[](2);
 		path[0] = nameService.getAddress("DAI");

package/contracts/reserve/ExchangeHelper.sol

@@ -5,6 +5,8 @@ import "../utils/DAOUpgradeableContract.sol";
 import "../utils/NameService.sol";
 import "./GoodReserveCDai.sol";
 
+// import "hardhat/console.sol";
+
 contract ExchangeHelper is DAOUpgradeableContract {
 	uint256 private _status;
 
@@ -78,6 +80,14 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		cDaiAddress = nameService.getAddress("CDAI");
 		// Approve transfer to cDAI contract
 		ERC20(daiAddress).approve(cDaiAddress, type(uint256).max);
+		address reserve = nameService.getAddress("RESERVE");
+		if (reserve != address(0)) {
+			ERC20(nameService.getAddress("GOODDOLLAR")).approve(
+				reserve,
+				type(uint256).max
+			);
+			ERC20(cDaiAddress).approve(reserve, type(uint256).max);
+		}
 		ERC20(daiAddress).approve(
 			nameService.getAddress("UNISWAP_ROUTER"),
 			type(uint256).max
@@ -121,11 +131,9 @@ contract ExchangeHelper is DAOUpgradeableContract {
 			require(
 				ERC20(_buyPath[0]).transferFrom(
 					msg.sender,
-					address(_buyPath[0]) == cDaiAddress
-						? address(reserve)
-						: address(this),
+					address(this),
 					_tokenAmount
-				) == true,
+				),
 				"transferFrom failed, make sure you approved input token transfer"
 			);
 		}
@@ -191,8 +199,9 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		GoodReserveCDai reserve = GoodReserveCDai(
 			nameService.getAddress("RESERVE")
 		);
-		IGoodDollar(nameService.getAddress("GOODDOLLAR")).burnFrom(
+		ERC20(nameService.getAddress("GOODDOLLAR")).transferFrom(
 			msg.sender,
+			address(this),
 			_gdAmount
 		);
 
@@ -290,7 +299,6 @@ contract ExchangeHelper is DAOUpgradeableContract {
 		require(cDaiResult == 0, "Minting cDai failed");
 
 		uint256 cDaiInput = cDai.balanceOf(address(this)) - currCDaiBalance;
-		cDai.transfer(address(reserve), cDaiInput);
 		return reserve.buy(cDaiInput, _minReturn, _targetAddress);
 	}
 
@@ -333,8 +341,9 @@ contract ExchangeHelper is DAOUpgradeableContract {
 			);
 			return swap;
 		} else {
-			if (isBuy)
+			if (isBuy) {
 				ERC20(_inputPath[0]).approve(address(uniswapContract), _tokenAmount);
+			}
 			swap = uniswapContract.swapExactTokensForTokens(
 				_tokenAmount,
 				isBuy ? _minDAIAmount : _minTokenReturn,

package/contracts/reserve/GoodMarketMaker.sol

@@ -8,6 +8,8 @@ import "../DAOStackInterfaces.sol";
 import "../Interfaces.sol";
 import "../utils/DAOUpgradeableContract.sol";
 
+// import "hardhat/console.sol";
+
 /**
 @title Dynamic reserve ratio market maker
 */
@@ -187,11 +189,10 @@ contract GoodMarketMaker is DAOUpgradeableContract, DSMath {
 	 * @param _tokenAmount The amount of reserve token buying with
 	 * @return Number of GD that should be given in exchange as calculated by the bonding curve
 	 */
-	function buyReturn(ERC20 _token, uint256 _tokenAmount)
-		public
-		view
-		returns (uint256)
-	{
+	function buyReturn(
+		ERC20 _token,
+		uint256 _tokenAmount
+	) public view returns (uint256) {
 		ReserveToken memory rtoken = reserveTokens[address(_token)];
 		return
 			getBancor().calculatePurchaseReturn(
@@ -208,11 +209,10 @@ contract GoodMarketMaker is DAOUpgradeableContract, DSMath {
 	 * @param _gdAmount The amount of GD that are sold
 	 * @return Number of tokens that should be given in exchange as calculated by the bonding curve
 	 */
-	function sellReturn(ERC20 _token, uint256 _gdAmount)
-		public
-		view
-		returns (uint256)
-	{
+	function sellReturn(
+		ERC20 _token,
+		uint256 _gdAmount
+	) public view returns (uint256) {
 		ReserveToken memory rtoken = reserveTokens[address(_token)];
 		return
 			getBancor().calculateSaleReturn(
@@ -264,7 +264,8 @@ contract GoodMarketMaker is DAOUpgradeableContract, DSMath {
 		rtoken.gdSupply += _gdAmount;
 		rtoken.reserveRatio = uint32(
 			((rtoken.reserveSupply * 1e27) /
-				(rtoken.gdSupply * priceBeforeGdSupplyChange)) / 10**reserveDecimalsDiff
+				(rtoken.gdSupply * priceBeforeGdSupplyChange)) /
+				10 ** reserveDecimalsDiff
 		); // Divide it decimal diff to bring it proper decimal
 	}
 
@@ -317,55 +318,46 @@ contract GoodMarketMaker is DAOUpgradeableContract, DSMath {
 	 * @param _token The desired reserve token to have
 	 * @return price of GD
 	 */
-	function currentPrice(ERC20 _token) public view returns (uint256) {
+	function currentPrice(ERC20 _token) public view returns (uint256 price) {
 		ReserveToken memory rtoken = reserveTokens[address(_token)];
-		return
-			getBancor().calculateSaleReturn(
-				rtoken.gdSupply,
-				rtoken.reserveSupply,
-				rtoken.reserveRatio,
-				(10**decimals)
-			);
+		price =
+			(rtoken.reserveSupply * 1e8) /
+			(rtoken.gdSupply * rtoken.reserveRatio); // gd precision 1e2 + reserveRatio precision 1e6 = multiply by 1e8 not to lose precision
 	}
 
-	//TODO: need real calculation and tests
 	/**
 	 * @dev Calculates how much G$ to mint based on added token supply (from interest)
 	 * and on current reserve ratio, in order to keep G$ price the same at the bonding curve
-	 * formula to calculate the gd to mint: gd to mint =
-	 * addreservebalance * (gdsupply / (reservebalance * reserveratio))
+	 * formula to calculate the gd to mint: amountToMint = reserveInterest * tokenSupply / reserveBalance
 	 * @param _token the reserve token
 	 * @param _addTokenSupply amount of token added to supply
-	 * @return how much to mint in order to keep price in bonding curve the same
+	 * @return toMint how much to mint in order to keep price in bonding curve the same
 	 */
-	function calculateMintInterest(ERC20 _token, uint256 _addTokenSupply)
-		public
-		view
-		returns (uint256)
-	{
-		uint256 decimalsDiff = uint256(27) - decimals;
-		//resulting amount is in RAY precision
-		//we divide by decimalsdiff to get precision in GD (2 decimals)
-		return
-			((_addTokenSupply * 1e27) / currentPrice(_token)) / (10**decimalsDiff);
+	function calculateMintInterest(
+		ERC20 _token,
+		uint256 _addTokenSupply
+	) public view returns (uint256 toMint) {
+		ReserveToken memory rtoken = reserveTokens[address(_token)];
+
+		toMint = (_addTokenSupply * rtoken.gdSupply) / rtoken.reserveSupply;
 	}
 
 	/**
 	 * @dev Updates bonding curve based on _addTokenSupply and new minted amount
 	 * @param _token The reserve token
 	 * @param _addTokenSupply Amount of token added to supply
-	 * @return How much to mint in order to keep price in bonding curve the same
+	 * @return toMint How much to mint in order to keep price in bonding curve the same
 	 */
-	function mintInterest(ERC20 _token, uint256 _addTokenSupply)
-		public
-		returns (uint256)
-	{
+	function mintInterest(
+		ERC20 _token,
+		uint256 _addTokenSupply
+	) public returns (uint256 toMint) {
 		_onlyReserveOrAvatar();
 		_onlyActiveToken(_token);
 		if (_addTokenSupply == 0) {
 			return 0;
 		}
-		uint256 toMint = calculateMintInterest(_token, _addTokenSupply);
+		toMint = calculateMintInterest(_token, _addTokenSupply);
 		ReserveToken storage reserveToken = reserveTokens[address(_token)];
 		reserveToken.gdSupply += toMint;
 		reserveToken.reserveSupply += _addTokenSupply;
@@ -376,24 +368,22 @@ contract GoodMarketMaker is DAOUpgradeableContract, DSMath {
 	/**
 	 * @dev Calculate how much G$ to mint based on expansion change (new reserve
 	 * ratio), in order to keep G$ price the same at the bonding curve. the
-	 * formula to calculate the gd to mint: gd to mint =
-	 * (reservebalance / (newreserveratio * currentprice)) - gdsupply
+	 * formula to calculate the gd to mint:
+	 * amountToMint = (tokenSupply * reserveRatio - tokenSupply * newRatio) / newRatio
 	 * @param _token The reserve token
-	 * @return How much to mint in order to keep price in bonding curve the same
+	 * @return toMint How much to mint in order to keep price in bonding curve the same
 	 */
-	function calculateMintExpansion(ERC20 _token) public view returns (uint256) {
+	function calculateMintExpansion(
+		ERC20 _token
+	) public view returns (uint256 toMint) {
 		ReserveToken memory reserveToken = reserveTokens[address(_token)];
 		uint32 newReserveRatio = calculateNewReserveRatio(_token); // new reserve ratio
-		uint256 reserveDecimalsDiff = uint256(27) - _token.decimals(); // //result is in RAY precision
-		uint256 denom = (uint256(newReserveRatio) *
-			1e21 *
-			currentPrice(_token) *
-			(10**reserveDecimalsDiff)) / 1e27; // (newreserveratio * currentprice) in RAY precision
-		uint256 gdDecimalsDiff = uint256(27) - decimals;
-		uint256 toMint = ((reserveToken.reserveSupply *
-			(10**reserveDecimalsDiff) *
-			1e27) / denom) / (10**gdDecimalsDiff); // reservebalance in RAY precision // return to gd precision
-		return toMint - reserveToken.gdSupply;
+		toMint =
+			(reserveToken.gdSupply *
+				reserveToken.reserveRatio -
+				reserveToken.gdSupply *
+				newReserveRatio) /
+			newReserveRatio;
 	}
 
 	/**

package/contracts/reserve/GoodReserveCDai.sol

@@ -59,6 +59,9 @@ contract GoodReserveCDai is
 
 	bool public gdxDisabled;
 	bool public discountDisabled;
+
+	uint256 private _reentrantStatus;
+
 	// Emits when new GD tokens minted
 	event UBIMinted(
 		//epoch of UBI
@@ -186,19 +189,21 @@ contract GoodReserveCDai is
 		uint256 _tokenAmount,
 		uint256 _minReturn,
 		address _targetAddress
-	) external returns (uint256) {
+	) external nonReentrant returns (uint256) {
 		ERC20 buyWith = ERC20(cDaiAddress);
 		uint256 gdReturn = getMarketMaker().buy(buyWith, _tokenAmount);
 		_targetAddress = _targetAddress == address(0x0)
 			? msg.sender
 			: _targetAddress;
 		address exchangeHelper = nameService.getAddress("EXCHANGE_HELPER");
-		if (msg.sender != exchangeHelper)
-			require(
-				buyWith.transferFrom(msg.sender, address(this), _tokenAmount) == true,
-				"transferFrom failed, make sure you approved input token transfer"
-			);
+
+		require(
+			buyWith.transferFrom(msg.sender, address(this), _tokenAmount) == true,
+			"transferFrom failed, make sure you approved input token transfer"
+		);
+
 		require(gdReturn >= _minReturn, "GD return must be above the minReturn");
+
 		_mintGoodDollars(_targetAddress, gdReturn, true);
 		//mint GDX
 		_mintGDX(_targetAddress, gdReturn);
@@ -224,7 +229,7 @@ contract GoodReserveCDai is
 		address _token,
 		address _to,
 		uint256 _amount
-	) external {
+	) external nonReentrant {
 		getMarketMaker().mintFromReserveRatio(ERC20(_token), _amount);
 		_mintGoodDollars(_to, _amount, false);
 		//mint GDX
@@ -247,16 +252,24 @@ contract GoodReserveCDai is
 		uint256 _minReturn,
 		address _target,
 		address _seller
-	) external returns (uint256, uint256) {
+	) external nonReentrant returns (uint256, uint256) {
 		require(paused() == false, "paused");
 		GoodMarketMaker mm = getMarketMaker();
 		if (msg.sender != nameService.getAddress("EXCHANGE_HELPER")) {
-			IGoodDollar(nameService.getAddress("GOODDOLLAR")).burnFrom(
-				msg.sender,
-				_gdAmount
-			);
 			_seller = msg.sender;
 		}
+
+		/**
+		 * transferfrom and then burn instead of burnfrom to make sure funds after fee are valid
+		 * ie specifically for addresses that hold stolen funds who has 100% fee applied
+		 */
+		IGoodDollar(nameService.getAddress("GOODDOLLAR")).transferFrom(
+			msg.sender,
+			address(this),
+			_gdAmount
+		);
+		IGoodDollar(nameService.getAddress("GOODDOLLAR")).burn(_gdAmount);
+
 		_target = _target == address(0x0) ? msg.sender : _target;
 		//discount on exit contribution based on gdx
 
@@ -358,18 +371,21 @@ contract GoodReserveCDai is
 	 * @dev only FundManager or other with mint G$ permission can call this to trigger minting.
 	 * Reserve sends UBI + interest to FundManager.
 	 * @param _daiToConvert DAI amount to convert cDAI
-	 * @param _startingCDAIBalance Initial cDAI balance before staking collect process start
 	 * @param _interestToken The token that was transfered to the reserve
 	 * @return gdUBI,interestInCdai how much GD UBI was minted and how much cDAI collected from staking contracts
 	 */
 	function mintUBI(
 		uint256 _daiToConvert,
-		uint256 _startingCDAIBalance,
+		uint256 /*_startingCDAIBalance*/, // dont trust it, use reserveSupply from marketmaker instead
 		ERC20 _interestToken
-	) external returns (uint256, uint256) {
+	) external nonReentrant returns (uint256, uint256) {
 		cERC20(cDaiAddress).mint(_daiToConvert);
+
+		(uint256 reserveSupply, , , ) = getMarketMaker().reserveTokens(cDaiAddress);
+
 		uint256 interestInCdai = _interestToken.balanceOf(address(this)) -
-			_startingCDAIBalance;
+			reserveSupply;
+
 		uint256 gdInterestToMint = getMarketMaker().mintInterest(
 			_interestToken,
 			interestInCdai
@@ -519,4 +535,16 @@ contract GoodReserveCDai is
 	function when() public pure override returns (CallPhase) {
 		return CallPhase.Pre;
 	}
+
+	modifier nonReentrant() {
+		// On the first call to nonReentrant, _status will be _NOT_ENTERED
+		require(_reentrantStatus != 1, "ReentrancyGuard: reentrant call");
+
+		// Any calls to nonReentrant after this point will fail
+		_reentrantStatus = 1;
+		_;
+		// By storing the original value once again, a refund is triggered (see
+		// https://eips.ethereum.org/EIPS/eip-2200)
+		_reentrantStatus = 0;
+	}
 }