@gooddollar/goodprotocol 1.0.28 → 1.0.29-beta.1

package/contracts/staking/utils/Math64X64.sol

@@ -0,0 +1,268 @@
+// SPDX-License-Identifier: BSD-4-Clause
+/*
+ * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
+ * Author: Mikhail Vladimirov <mikhail.vladimirov@gmail.com>
+ */
+pragma solidity ^0.8.0;
+
+/**
+ * Smart contract library of mathematical functions operating with signed
+ * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
+ * basically a simple fraction whose numerator is signed 128-bit integer and
+ * denominator is 2^64.  As long as denominator is always the same, there is no
+ * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
+ * represented by int128 type holding only the numerator.
+ */
+library Math64x64 {
+	/*
+	 * Minimum value signed 64.64-bit fixed point number may have.
+	 */
+	int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
+
+	/*
+	 * Maximum value signed 64.64-bit fixed point number may have.
+	 */
+	int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
+
+	/**
+	 * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
+	 * number.  Revert on overflow.
+	 *
+	 * @param x unsigned 256-bit integer number
+	 * @return signed 64.64-bit fixed point number
+	 */
+	function fromUInt(uint256 x) internal pure returns (int128) {
+		unchecked {
+			require(x <= 0x7FFFFFFFFFFFFFFF);
+			return int128(int256(x << 64));
+		}
+	}
+
+	/**
+	 * Convert signed 64.64 fixed point number into unsigned 64-bit integer
+	 * number rounding down.  Revert on underflow.
+	 *
+	 * @param x signed 64.64-bit fixed point number
+	 * @return unsigned 64-bit integer number
+	 */
+	function toUInt(int128 x) internal pure returns (uint64) {
+		unchecked {
+			require(x >= 0);
+			return uint64(uint128(x >> 64));
+		}
+	}
+
+	/**
+	 * Calculate x * y rounding down, where x is signed 64.64 fixed point number
+	 * and y is unsigned 256-bit integer number.  Revert on overflow.
+	 *
+	 * @param x signed 64.64 fixed point number
+	 * @param y unsigned 256-bit integer number
+	 * @return unsigned 256-bit integer number
+	 */
+	function mulu(int128 x, uint256 y) internal pure returns (uint256) {
+		unchecked {
+			if (y == 0) return 0;
+
+			require(x >= 0);
+
+			uint256 lo = (uint256(int256(x)) *
+				(y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
+			uint256 hi = uint256(int256(x)) * (y >> 128);
+
+			require(hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+			hi <<= 64;
+
+			require(
+				hi <=
+					0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -
+						lo
+			);
+			return hi + lo;
+		}
+	}
+
+	/**
+	 * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
+	 * integer numbers.  Revert on overflow or when y is zero.
+	 *
+	 * @param x unsigned 256-bit integer number
+	 * @param y unsigned 256-bit integer number
+	 * @return signed 64.64-bit fixed point number
+	 */
+	function divu(uint256 x, uint256 y) internal pure returns (int128) {
+		unchecked {
+			require(y != 0);
+			uint128 result = divuu(x, y);
+			require(result <= uint128(MAX_64x64));
+			return int128(result);
+		}
+	}
+
+	/**
+	 * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
+	 * and y is unsigned 256-bit integer number.  Revert on overflow.
+	 *
+	 * @param x signed 64.64-bit fixed point number
+	 * @param y uint256 value
+	 * @return signed 64.64-bit fixed point number
+	 */
+	function pow(int128 x, uint256 y) internal pure returns (int128) {
+		unchecked {
+			bool negative = x < 0 && y & 1 == 1;
+
+			uint256 absX = uint128(x < 0 ? -x : x);
+			uint256 absResult;
+			absResult = 0x100000000000000000000000000000000;
+
+			if (absX <= 0x10000000000000000) {
+				absX <<= 63;
+				while (y != 0) {
+					if (y & 0x1 != 0) {
+						absResult = (absResult * absX) >> 127;
+					}
+					absX = (absX * absX) >> 127;
+
+					if (y & 0x2 != 0) {
+						absResult = (absResult * absX) >> 127;
+					}
+					absX = (absX * absX) >> 127;
+
+					if (y & 0x4 != 0) {
+						absResult = (absResult * absX) >> 127;
+					}
+					absX = (absX * absX) >> 127;
+
+					if (y & 0x8 != 0) {
+						absResult = (absResult * absX) >> 127;
+					}
+					absX = (absX * absX) >> 127;
+
+					y >>= 4;
+				}
+
+				absResult >>= 64;
+			} else {
+				uint256 absXShift = 63;
+				if (absX < 0x1000000000000000000000000) {
+					absX <<= 32;
+					absXShift -= 32;
+				}
+				if (absX < 0x10000000000000000000000000000) {
+					absX <<= 16;
+					absXShift -= 16;
+				}
+				if (absX < 0x1000000000000000000000000000000) {
+					absX <<= 8;
+					absXShift -= 8;
+				}
+				if (absX < 0x10000000000000000000000000000000) {
+					absX <<= 4;
+					absXShift -= 4;
+				}
+				if (absX < 0x40000000000000000000000000000000) {
+					absX <<= 2;
+					absXShift -= 2;
+				}
+				if (absX < 0x80000000000000000000000000000000) {
+					absX <<= 1;
+					absXShift -= 1;
+				}
+
+				uint256 resultShift = 0;
+				while (y != 0) {
+					require(absXShift < 64);
+
+					if (y & 0x1 != 0) {
+						absResult = (absResult * absX) >> 127;
+						resultShift += absXShift;
+						if (absResult > 0x100000000000000000000000000000000) {
+							absResult >>= 1;
+							resultShift += 1;
+						}
+					}
+					absX = (absX * absX) >> 127;
+					absXShift <<= 1;
+					if (absX >= 0x100000000000000000000000000000000) {
+						absX >>= 1;
+						absXShift += 1;
+					}
+
+					y >>= 1;
+				}
+
+				require(resultShift < 64);
+				absResult >>= 64 - resultShift;
+			}
+			int256 result = negative ? -int256(absResult) : int256(absResult);
+			require(result >= MIN_64x64 && result <= MAX_64x64);
+			return int128(result);
+		}
+	}
+
+	/**
+	 * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
+	 * integer numbers.  Revert on overflow or when y is zero.
+	 *
+	 * @param x unsigned 256-bit integer number
+	 * @param y unsigned 256-bit integer number
+	 * @return unsigned 64.64-bit fixed point number
+	 */
+	function divuu(uint256 x, uint256 y) private pure returns (uint128) {
+		unchecked {
+			require(y != 0);
+
+			uint256 result;
+
+			if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
+				result = (x << 64) / y;
+			else {
+				uint256 msb = 192;
+				uint256 xc = x >> 192;
+				if (xc >= 0x100000000) {
+					xc >>= 32;
+					msb += 32;
+				}
+				if (xc >= 0x10000) {
+					xc >>= 16;
+					msb += 16;
+				}
+				if (xc >= 0x100) {
+					xc >>= 8;
+					msb += 8;
+				}
+				if (xc >= 0x10) {
+					xc >>= 4;
+					msb += 4;
+				}
+				if (xc >= 0x4) {
+					xc >>= 2;
+					msb += 2;
+				}
+				if (xc >= 0x2) msb += 1; // No need to shift xc anymore
+
+				result = (x << (255 - msb)) / (((y - 1) >> (msb - 191)) + 1);
+				require(result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+				uint256 hi = result * (y >> 128);
+				uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+				uint256 xh = x >> 192;
+				uint256 xl = x << 64;
+
+				if (xl < lo) xh -= 1;
+				xl -= lo; // We rely on overflow behavior here
+				lo = hi << 128;
+				if (xl < lo) xh -= 1;
+				xl -= lo; // We rely on overflow behavior here
+
+				assert(xh == hi >> 128);
+
+				result += xl / y;
+			}
+
+			require(result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+			return uint128(result);
+		}
+	}
+}

package/contracts/staking/utils/StakingRewardsFixedAPY.sol

@@ -0,0 +1,336 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "./Math64X64.sol";
+import "hardhat/console.sol";
+
+/***
+ * @dev helper contract for calculating fixed per block compounding interest rate rewards.
+ */
+abstract contract StakingRewardsFixedAPY {
+	using Math64x64 for int128;
+
+	// precision constant for math
+	uint128 public constant PRECISION = 1e18;
+	uint128 public constant SHARE_PRECISION = 1e18;
+	uint128 public constant SHARE_DECIMALS = 1e4;
+
+	// the users stake information
+	struct StakerInfo {
+		uint128 lastSharePrice; // the share price that can be used to calculate earned rewards
+		uint128 rewardsPaid; // rewards that accounted already so should be substracted
+	}
+
+	struct Stats {
+		// last block this staking contract was updated and rewards were calculated
+		uint128 lastUpdateBlock;
+		// total supply of active stakes
+		uint128 totalStaked;
+		uint128 totalRewardsPaid;
+		uint256 savings; //total earning compounding interest;
+	}
+
+	Stats public stats;
+
+	// the user info sheet
+	mapping(address => StakerInfo) public stakersInfo;
+
+	// interest rate per one block in 1e18 precision.
+	//for example APY=5% then per block = nroot(1+0.05,numberOfBlocksPerYear)
+	//nroot(1.05,6000000) = 1.000000008131694
+	//in 1e18 = 1000000008131694000
+	int128 public interestRatePerBlockX64;
+
+	/**
+	 * @notice internal helper to convert unsigned interest rate per block in 1e18 precision to x64 format
+	 */
+	function _setAPY(uint128 _interestRatePerBlock) internal updateReward {
+		interestRatePerBlockX64 = Math64x64.divu(_interestRatePerBlock, 1e18); //convert to signed int x64
+	}
+
+	/**
+	 * @notice modifier to compound the APY on every state update
+	 */
+	modifier updateReward() {
+		_updateReward();
+		_;
+	}
+
+	/**
+	 * @dev the amount of shares of the savings _account holds
+	 * @param _account the address
+	 */
+	function sharesOf(address _account)
+		public
+		view
+		virtual
+		returns (uint256 shares);
+
+	/**
+	 * @dev the total outstanding shares
+	 */
+	function sharesSupply() public view virtual returns (uint256);
+
+	/**
+	 * @notice calculates the compounded savings based on passed blocks
+	 * @return compoundedSavings the new savings
+	 */
+	function _compound() internal view returns (uint256 compoundedSavings) {
+		if (stats.savings == 0 || block.number == stats.lastUpdateBlock) {
+			return stats.savings;
+		}
+
+		//earned in timespan = (interestRatePerBlock^blocksPassed * savings - savings)/PRECISION
+		//earned perToken = earnedInTimeSpan*PRECISION/totalStaked
+		//PRECISION cancels out
+		int128 compound = interestRatePerBlockX64.pow(
+			block.number - stats.lastUpdateBlock
+		);
+		compoundedSavings = compound.mulu(stats.savings);
+	}
+
+	/**
+	 * @notice calculates the current share price (savings/totalShares)
+	 * @return price the current share price in SHARE_PRECISION
+	 */
+	function sharePrice() public view returns (uint256 price) {
+		uint256 compoundedSavings = _compound();
+
+		// console.log(
+		// 	"compoundedSavings %s, shares: %s, sharePrice: %s",
+		// 	compoundedSavings,
+		// 	stats.totalShares,
+		// 	(compoundedSavings * SHARE_PRECISION) / (stats.totalShares * PRECISION)
+		// );
+
+		return
+			sharesSupply() == 0
+				? 0
+				: (compoundedSavings * SHARE_PRECISION) / (sharesSupply() * PRECISION);
+	}
+
+	/**
+	 * @notice calculate how much user can withdraw
+	 * @return balance account compounded savings balance
+	 */
+	function getSavings(address _account)
+		external
+		view
+		returns (uint256 balance)
+	{
+		balance = (sharePrice() * sharesOf(_account)) / SHARE_PRECISION;
+	}
+
+	function ceil(uint256 amount, uint256 precision)
+		internal
+		pure
+		returns (uint256)
+	{
+		return ((amount + precision - 1) / precision);
+	}
+
+	/**
+	 * @dev helper to get _amount worth of shares
+	 */
+	function amountToShares(uint256 _amount)
+		public
+		view
+		returns (uint256 shares)
+	{
+		return
+			ceil(
+				(_amount * SHARE_PRECISION * SHARE_DECIMALS) / sharePrice(),
+				SHARE_DECIMALS
+			); //ceil ensures shares value >= amount
+	}
+
+	/**
+	 * @dev helper to get _account lastSharePrice, which is used to calculate accumulated rewards since lastSharePrice was updated
+	 */
+	function lastSharePrice(address _account)
+		public
+		view
+		returns (uint256 price)
+	{
+		return uint256(stakersInfo[_account].lastSharePrice);
+	}
+
+	/**
+	 * @dev get the principle of _account (ie estimated original deposit)
+	 */
+	function principle(address _account)
+		external
+		view
+		returns (uint256 deposited)
+	{
+		return (lastSharePrice(_account) * sharesOf(_account)) / SHARE_PRECISION;
+	}
+
+	/**
+	 * @notice The function allows anyone to calculate the exact amount of reward
+	 * earned.
+	 * @param _account A staker address
+	 * @return earnedRewards total rewards earned
+	 */
+	function earned(address _account)
+		public
+		view
+		returns (uint256 earnedRewards)
+	{
+		uint256 shares = sharesOf(_account);
+		uint256 curPrice = sharePrice();
+		uint256 lastPrice = lastSharePrice(_account);
+		lastPrice = lastPrice > curPrice ? curPrice : lastPrice; //it could be that share price is lower immediatly after staking
+
+		earnedRewards =
+			((curPrice * shares) - (lastPrice * shares)) /
+			SHARE_PRECISION;
+	}
+
+	/**
+	 * @notice calculate the interest earned and not yet paid for stats.totalStaked
+	 * @return debt the rewards(interest) not yet paid
+	 */
+	function getRewardsDebt() external view returns (uint256 debt) {
+		debt = _compound() - stats.totalStaked * PRECISION; //totalStaked is in G$ precision (ie 2 decimals)
+	}
+
+	/**
+	 * @notice compounds the global savings
+	 */
+	function _updateReward() internal virtual {
+		stats.savings = _compound();
+		stats.lastUpdateBlock = uint128(block.number);
+	}
+
+	/**
+	 * @notice perform state update when withdrawing
+	 * @param _from account address withdrawing
+	 * @param _shares amount to withdraw, if amount is max uint then it will withdraw available balance
+	 * @return depositComponent how much was withdrawn from user original stake. >0 only when _amount > interest (rewards) earned
+	 * @return rewardComponent how much was withdrawn from user earned rewards
+	 */
+	function _withdraw(address _from, uint256 _shares)
+		internal
+		virtual
+		updateReward
+		returns (uint256 depositComponent, uint256 rewardComponent)
+	{
+		uint256 sharesBalance = sharesOf(_from);
+
+		require(_shares > 0 && _shares <= sharesBalance, "no balance");
+
+		uint256 amount = (sharePrice() * _shares) / SHARE_PRECISION;
+
+		uint256 pendingRewards = earned(_from);
+
+		rewardComponent = pendingRewards >= amount ? amount : pendingRewards;
+
+		depositComponent = amount > rewardComponent ? amount - rewardComponent : 0;
+
+		//because of rounding down of rewardComponent after some operations this can cause the deposit component to be larger
+		//than it actually was
+		if (stats.totalStaked < depositComponent) {
+			uint256 diff = depositComponent - stats.totalStaked;
+			rewardComponent += diff;
+			depositComponent = stats.totalStaked;
+		}
+
+		require(amount > 0, "min shares withdraw value: 1 gd");
+
+		// console.log("withdraw: reducing principle by %s", _amount);
+
+		stats.savings -= amount * PRECISION;
+		stats.totalStaked -= uint128(depositComponent);
+		stats.totalRewardsPaid += uint128(rewardComponent);
+		stakersInfo[_from].rewardsPaid += uint128(rewardComponent);
+
+		uint256 newShareSupply = sharesSupply() - _shares;
+		uint256 newSharePrice = newShareSupply == 0
+			? 0
+			: (stats.savings * SHARE_PRECISION) / (newShareSupply * PRECISION);
+
+		if (
+			depositComponent > 0 ||
+			rewardComponent == pendingRewards ||
+			newShareSupply == 0
+		) //we have withdrawn all rewards so we reset lastSharePrice
+		{
+			// console.log("withdraw: reset shareprice to: %s", newSharePrice);
+			stakersInfo[_from].lastSharePrice = uint128(newSharePrice);
+		} else {
+			//we set the lastSharePrice to not include remaining rewards value
+			stakersInfo[_from].lastSharePrice = uint128(
+				newSharePrice -
+					((pendingRewards - rewardComponent) * SHARE_PRECISION) /
+					(sharesBalance - _shares)
+			);
+		}
+	}
+
+	/**
+	 * @notice perform state update when staking
+	 * @param _from account address staking
+	 * @param _amount amount to stake
+	 */
+	function _stake(address _from, uint256 _amount)
+		internal
+		virtual
+		updateReward
+		returns (uint256 shares)
+	{
+		require(_amount > 0, "Cannot stake 0");
+		shares = sharesSupply() > 0
+			? ((_amount * SHARE_PRECISION) / sharePrice()) //amount/sharePrice = new shares = amount/(savings/totalShares)
+			: (_amount * SHARE_DECIMALS); //principal/number of shares is shares price, so initially each share price will represent G%cent/SHARE_DECIMALS
+		require(shares > 0, "min stake 1 share price");
+
+		stakersInfo[_from].lastSharePrice = uint128(
+			sharesOf(_from) == 0
+				? (_amount * SHARE_PRECISION) / shares
+				: ((sharesOf(_from) * stakersInfo[_from].lastSharePrice) +
+					(shares * sharePrice())) / (sharesOf(_from) + shares)
+		);
+		stats.totalStaked += uint128(_amount);
+		stats.savings += _amount * PRECISION;
+	}
+
+	/**
+	 * @notice keep track of debt to user in case reward minting failed
+	 * @dev notice that this should not be called when _rewardsPaid are 0
+	 * @return shares added to cover rewards
+	 */
+	function _undoReward(address _to, uint256 _rewardsPaid)
+		internal
+		virtual
+		returns (uint256 shares)
+	{
+		//skip on invalid input
+		if (_rewardsPaid == 0) {
+			return 0;
+		}
+
+		//calculate this before udpating global savings
+		shares = sharesSupply() > 0
+			? ((_rewardsPaid * SHARE_PRECISION) / sharePrice())
+			: (_rewardsPaid * SHARE_DECIMALS); //staker previously withdrew all, so shares issued like on first stake
+
+		stats.totalRewardsPaid -= uint128(_rewardsPaid);
+		stats.savings += _rewardsPaid * PRECISION; //rewards are part of the compounding interest
+
+		stakersInfo[_to].rewardsPaid -= uint128(_rewardsPaid);
+
+		//remove rewards from the lastSharePrice
+		//we set the lastSharePrice to not include unwithdrawn rewards
+		//if lastSharePrice is 0 then nothing to do. it means all funds are rewards ie profit
+		if (stakersInfo[_to].lastSharePrice > 0) {
+			uint256 rewardsSharesPart = (_rewardsPaid * SHARE_PRECISION) /
+				(sharesOf(_to) + shares);
+
+			stakersInfo[_to].lastSharePrice = rewardsSharesPart >=
+				stakersInfo[_to].lastSharePrice
+				? 0
+				: uint128(stakersInfo[_to].lastSharePrice - rewardsSharesPart);
+		}
+	}
+}

package/contracts/utils/BulkProof.sol

@@ -32,14 +32,14 @@ contract BulkProof {
 		bytes32[] proof;
 	}
 
-	function bulkProof(Proof[] calldata proofs) external {
-		for (uint256 i = 0; i < proofs.length; i++) {
-			Proof memory proof = proofs[i];
-			GoodReserveCDai(0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0).claimGDX(
-				proof.account,
-				proof.balance,
-				proof.proof
-			);
-		}
-	}
+	// function bulkProof(Proof[] calldata proofs) external {
+	// 	for (uint256 i = 0; i < proofs.length; i++) {
+	// 		Proof memory proof = proofs[i];
+	// 		GoodReserveCDai(0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0).claimGDX(
+	// 			proof.account,
+	// 			proof.balance,
+	// 			proof.proof
+	// 		);
+	// 	}
+	// }
 }