@gooddollar/goodprotocol 2.0.25-beta.0 → 2.0.25-beta.10

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/invite/InvitesV2.sol

@@ -57,6 +57,8 @@ contract InvitesV2 is DAOUpgradeableContract {
 
 	bool public levelExpirationEnabled;
 
+	bytes32 private campaignCode;
+
 	event InviteeJoined(address indexed inviter, address indexed invitee);
 	event InviterBounty(
 		address indexed inviter,
@@ -125,8 +127,9 @@ contract InvitesV2 is DAOUpgradeableContract {
 		address inviter = codeToUser[_inviterCode];
 		//allow user to set inviter if doesnt have one
 		require(
-			user.inviteCode == 0x0 ||
-				(user.invitedBy == address(0) && inviter != address(0)),
+			!user.bountyPaid &&
+				(user.inviteCode == 0x0 ||
+					(user.invitedBy == address(0) && inviter != address(0))),
 			"user already joined"
 		);
 		if (user.inviteCode == 0x0) {
@@ -138,10 +141,15 @@ contract InvitesV2 is DAOUpgradeableContract {
 		if (inviter != address(0)) {
 			require(inviter != msg.sender, "self invite");
 			user.invitedBy = inviter;
-			users[inviter].invitees.push(msg.sender);
-			users[inviter].pending.push(msg.sender);
 			stats.totalInvited += 1;
-			user.bountyAtJoin = levels[users[inviter].level].bounty;
+			/** support special campaign code without inviter */
+			if (inviter == address(this)) {
+				user.bountyAtJoin = levels[0].bounty;
+			} else {
+				users[inviter].invitees.push(msg.sender);
+				users[inviter].pending.push(msg.sender);
+				user.bountyAtJoin = levels[users[inviter].level].bounty;
+			}
 		}
 
 		if (canCollectBountyFor(msg.sender)) {
@@ -165,19 +173,15 @@ contract InvitesV2 is DAOUpgradeableContract {
 
 	function canCollectBountyFor(address _invitee) public view returns (bool) {
 		address invitedBy = users[_invitee].invitedBy;
-		uint256 daysToComplete = levels[users[invitedBy].level].daysToComplete;
-		bool isLevelExpired = levelExpirationEnabled == true &&
-			daysToComplete > 0 &&
-			daysToComplete <
-			(users[_invitee].joinedAt - users[invitedBy].levelStarted) / 1 days;
 
 		return
-			invitedBy != address(0) &&
+			users[_invitee].bountyAtJoin > 0 &&
 			!users[_invitee].bountyPaid &&
 			getIdentity().isWhitelisted(_invitee) &&
-			getIdentity().isWhitelisted(invitedBy) &&
-			_whitelistedOnChainOrDefault(_invitee) == _chainId() &&
-			isLevelExpired == false;
+			(invitedBy == address(0) ||
+				invitedBy == address(this) ||
+				getIdentity().isWhitelisted(invitedBy)) &&
+			_whitelistedOnChainOrDefault(_invitee) == _chainId();
 	}
 
 	function getInvitees(
@@ -237,44 +241,51 @@ contract InvitesV2 is DAOUpgradeableContract {
 		bool isSingleBounty
 	) internal returns (uint256 bounty) {
 		address invitedBy = users[_invitee].invitedBy;
-		uint256 joinedAt = users[_invitee].joinedAt;
-		Level memory level = levels[users[invitedBy].level];
 		uint256 bountyToPay = users[_invitee].bountyAtJoin;
+		bool earnedLevel = false;
 
-		//hardcoded for users invited before the bountyAtJoin change
-		if (bountyToPay == 0) {
-			uint precision = 10 ** goodDollar.decimals();
-			bountyToPay = joinedAt > 1687878272 ? 1000 * precision : 500 * precision;
-		}
+		if (invitedBy != address(this) && invitedBy != address(0)) {
+			uint256 joinedAt = users[_invitee].joinedAt;
+			Level memory level = levels[users[invitedBy].level];
+
+			//hardcoded for users invited before the bountyAtJoin change
+			if (bountyToPay == 0) {
+				uint precision = 10 ** goodDollar.decimals();
+				bountyToPay = joinedAt > 1687878272
+					? 1000 * precision
+					: 500 * precision;
+			}
+
+			// if inviter level is now higher than when invitee joined or the base level has changed
+			// we give level bounty if it is higher otherwise the original bounty at the time the user registered
+
+			bountyToPay = level.bounty > bountyToPay ? level.bounty : bountyToPay;
 
-		// if inviter level is now higher than when invitee joined or the base level has changed
-		// we give level bounty if it is higher otherwise the original bounty at the time the user registered
+			bool isLevelExpired = level.daysToComplete > 0 &&
+				joinedAt > users[invitedBy].levelStarted && //prevent overflow in subtraction
+				level.daysToComplete <
+				(joinedAt - users[invitedBy].levelStarted) / 1 days; //how long after level started did invitee join
 
-		bountyToPay = level.bounty > bountyToPay ? level.bounty : bountyToPay;
+			users[invitedBy].totalApprovedInvites += 1;
+			users[invitedBy].totalEarned += bountyToPay;
 
-		bool isLevelExpired = level.daysToComplete > 0 &&
-			joinedAt > users[invitedBy].levelStarted && //prevent overflow in subtraction
-			level.daysToComplete <
-			(joinedAt - users[invitedBy].levelStarted) / 1 days; //how long after level started did invitee join
+			if (
+				level.toNext > 0 &&
+				users[invitedBy].totalApprovedInvites >= level.toNext &&
+				isLevelExpired == false
+			) {
+				users[invitedBy].level += 1;
+				users[invitedBy].levelStarted = block.timestamp;
+				earnedLevel = true;
+			}
+
+			if (isSingleBounty) goodDollar.transfer(invitedBy, bountyToPay);
+		}
 
 		users[_invitee].bountyPaid = true;
-		users[invitedBy].totalApprovedInvites += 1;
-		users[invitedBy].totalEarned += bountyToPay;
 		stats.totalApprovedInvites += 1;
 		stats.totalBountiesPaid += bountyToPay;
 
-		bool earnedLevel = false;
-		if (
-			level.toNext > 0 &&
-			users[invitedBy].totalApprovedInvites >= level.toNext &&
-			isLevelExpired == false
-		) {
-			users[invitedBy].level += 1;
-			users[invitedBy].levelStarted = block.timestamp;
-			earnedLevel = true;
-		}
-
-		if (isSingleBounty) goodDollar.transfer(invitedBy, bountyToPay);
 		goodDollar.transfer(_invitee, bountyToPay / 2); //pay invitee half the bounty
 		emit InviterBounty(
 			invitedBy,
@@ -322,6 +333,11 @@ contract InvitesV2 is DAOUpgradeableContract {
 		active = _active;
 	}
 
+	function setCampaignCode(bytes32 _code) public ownerOrAvatar {
+		campaignCode = _code;
+		codeToUser[campaignCode] = address(this);
+	}
+
 	function end() public ownerOrAvatar isActive {
 		uint256 gdBalance = goodDollar.balanceOf(address(this));
 		goodDollar.transfer(msg.sender, gdBalance);
@@ -346,8 +362,9 @@ contract InvitesV2 is DAOUpgradeableContract {
 	 * 2 uses uups upgradeable - not compatible upgrade for v1
 	 * 2.1 prevent multichain claims
 	 * 2.2 record bounty at join time
+	 * 2.3 support campaignCode
 	 */
 	function version() public pure returns (string memory) {
-		return "2.2";
+		return "2.3";
 	}
 }

package/contracts/invite/OneTimeReward.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+import "../Interfaces.sol";
+import "../utils/NameService.sol";
+import "../utils/DAOUpgradeableContract.sol";
+
+contract OneTimeReward is Ownable, DAOContract {
+	bool public isActive;
+	uint public rewardAmount;
+	mapping(address => bool) public claimed;
+
+	event RewardClaimed(address indexed user, uint amount);
+
+	constructor(uint256 _rewardAmount, INameService _nameService) {
+		rewardAmount = _rewardAmount;
+		isActive = true;
+		setDAO(_nameService);
+	}
+
+	function getIdentity() public view returns (IIdentityV2) {
+		return IIdentityV2(nameService.getAddress("IDENTITY"));
+	}
+
+	function updateSettings(
+		bool _isActive,
+		uint _rewardAmount
+	) external onlyOwner {
+		isActive = _isActive;
+		rewardAmount = _rewardAmount;
+	}
+
+	function checkActiveAndBalance() public view returns (bool) {
+		if (!isActive) {
+			return false;
+		}
+
+		if (nativeToken().balanceOf(address(this)) < rewardAmount) {
+			return false;
+		}
+
+		return true;
+	}
+
+	function checkCanClaimReward(address _user) public view returns (bool) {
+		address whitelistedRoot = getIdentity().getWhitelistedRoot(_user);
+		return canClaimReward(whitelistedRoot);
+	}
+
+	function canClaimReward(
+		address whitelistedRoot
+	) internal view returns (bool) {
+		if (checkActiveAndBalance() == false) {
+			return false;
+		}
+
+		if (whitelistedRoot == address(0)) {
+			return false;
+		}
+
+		if (claimed[whitelistedRoot]) {
+			return false;
+		}
+
+		return true;
+	}
+
+	function claimReward(address _user) public {
+		address whitelistedRoot = getIdentity().getWhitelistedRoot(_user);
+		require(canClaimReward(whitelistedRoot), "User cannot claim reward");
+		claimed[whitelistedRoot] = true;
+
+		nativeToken().transfer(_user, rewardAmount);
+
+		emit RewardClaimed(_user, rewardAmount);
+	}
+
+	function withdrawAll(address _token) external onlyOwner {
+		uint balance = IERC20(_token).balanceOf(address(this));
+		require(balance > 0, "No tokens to withdraw");
+
+		IERC20(_token).transfer(msg.sender, balance);
+	}
+}

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;
 	}
 
 	/**