@gooddollar/goodprotocol 1.0.29-beta.0 → 1.0.29-beta.2

package/contracts/invite/InvitesV2.sol

@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
+import "../Interfaces.sol";
+import "../utils/NameService.sol";
+
+// import "hardhat/console.sol";
+
+/**
+ * @title InvitesV1 contract that handles invites with pre allocated bounty pool
+ * 1.1 adds invitee bonus
+ * 2 uses uups upgradeable - not compatible upgrade for v1
+ */
+contract InvitesV2 is Initializable, UUPSUpgradeable {
+	using SafeMathUpgradeable for uint256;
+
+	struct Stats {
+		uint256 totalApprovedInvites;
+		uint256 totalBountiesPaid;
+		uint256 totalInvited;
+		uint256[5] __reserevedSpace;
+	}
+
+	struct User {
+		address invitedBy;
+		bytes32 inviteCode;
+		bool bountyPaid;
+		address[] invitees;
+		address[] pending;
+		uint256 level;
+		uint256 levelStarted;
+		uint256 totalApprovedInvites;
+		uint256 totalEarned;
+		uint256 joinedAt;
+		uint256[5] __reserevedSpace;
+	}
+
+	struct Level {
+		uint256 toNext;
+		uint256 bounty; //in G$ cents ie 2 decimals
+		uint256 daysToComplete;
+		uint256[5] __reserevedSpace;
+	}
+
+	mapping(bytes32 => address) public codeToUser;
+	mapping(address => User) public users;
+	address payable public avatar;
+
+	mapping(uint256 => Level) public levels;
+
+	address public owner;
+	NameService public nameService;
+	cERC20 public goodDollar;
+	bool public active;
+	Stats public stats;
+
+	bool public levelExpirationEnabled;
+
+	event InviteeJoined(address indexed inviter, address indexed invitee);
+	event InviterBounty(
+		address indexed inviter,
+		address indexed invitee,
+		uint256 bountyPaid,
+		uint256 inviterLevel,
+		bool earnedLevel
+	);
+
+	modifier ownerOrAvatar() {
+		require(
+			msg.sender == owner || msg.sender == avatar,
+			"Only owner or avatar can perform this action"
+		);
+		_;
+	}
+
+	modifier onlyAvatar() {
+		require(msg.sender == avatar, "Only DAO avatar can perform this action");
+		_;
+	}
+
+	modifier isActive() {
+		require(active);
+		_;
+	}
+
+	function initialize(
+		address payable _avatar,
+		address _ns,
+		address _gd,
+		uint256 _level0Bounty,
+		address _owner
+	) public initializer {
+		owner = _owner;
+		nameService = NameService(_ns);
+		active = true;
+		Level storage lvl = levels[0];
+		lvl.bounty = _level0Bounty;
+		goodDollar = cERC20(_gd);
+		avatar = _avatar;
+		levelExpirationEnabled = false;
+	}
+
+	function _authorizeUpgrade(address newImplementation)
+		internal
+		override
+		ownerOrAvatar
+	{}
+
+	function getIdentity() public view returns (IIdentityV2) {
+		return IIdentityV2(nameService.getAddress("IDENTITY"));
+	}
+
+	function setLevelExpirationEnabled(bool _isEnabled) public ownerOrAvatar {
+		levelExpirationEnabled = _isEnabled;
+	}
+
+	function join(bytes32 _myCode, bytes32 _inviterCode) public isActive {
+		require(
+			codeToUser[_myCode] == address(0) || codeToUser[_myCode] == msg.sender,
+			"invite code already in use"
+		);
+		User storage user = users[msg.sender]; // this is not expensive as user is new
+		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 already joined"
+		);
+		if (user.inviteCode == 0x0) {
+			user.inviteCode = _myCode;
+			user.levelStarted = block.timestamp;
+			user.joinedAt = block.timestamp;
+			codeToUser[_myCode] = msg.sender;
+		}
+		if (inviter != address(0)) {
+			user.invitedBy = inviter;
+			users[inviter].invitees.push(msg.sender);
+			users[inviter].pending.push(msg.sender);
+			stats.totalInvited += 1;
+		}
+		emit InviteeJoined(inviter, msg.sender);
+	}
+
+	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.sub(users[invitedBy].levelStarted).div(1 days);
+
+		return
+			invitedBy != address(0) &&
+			!users[_invitee].bountyPaid &&
+			getIdentity().isWhitelisted(_invitee) &&
+			getIdentity().isWhitelisted(invitedBy) &&
+			isLevelExpired == false;
+	}
+
+	function getInvitees(address _inviter)
+		public
+		view
+		returns (address[] memory)
+	{
+		return users[_inviter].invitees;
+	}
+
+	function getPendingInvitees(address _inviter)
+		public
+		view
+		returns (address[] memory)
+	{
+		address[] memory pending = users[_inviter].pending;
+		uint256 cur = 0;
+		uint256 total = 0;
+		for (uint256 i; i < pending.length; i++) {
+			if (!users[pending[i]].bountyPaid) {
+				total++;
+			}
+		}
+
+		address[] memory result = new address[](total);
+
+		for (uint256 i; i < pending.length; i++) {
+			if (!users[pending[i]].bountyPaid) {
+				result[cur] = pending[i];
+				cur++;
+			}
+		}
+
+		return result;
+	}
+
+	function getPendingBounties(address _inviter) public view returns (uint256) {
+		address[] memory pending = users[_inviter].pending;
+		uint256 total = 0;
+		for (uint256 i; i < pending.length; i++) {
+			if (canCollectBountyFor(pending[i])) {
+				total++;
+			}
+		}
+		return total;
+	}
+
+	/**
+	 * @dev  pay bounty for the inviter of _invitee
+	 * invitee need to be whitelisted
+	 */
+	function bountyFor(address _invitee)
+		public
+		isActive
+		returns (uint256 bounty)
+	{
+		require(canCollectBountyFor(_invitee), "user not elligble for bounty yet");
+		return _bountyFor(_invitee, true);
+	}
+
+	function _bountyFor(address _invitee, bool isSingleBounty)
+		internal
+		returns (uint256 bounty)
+	{
+		address invitedBy = users[_invitee].invitedBy;
+		uint256 joinedAt = users[_invitee].joinedAt;
+		Level memory level = levels[users[invitedBy].level];
+
+		bool isLevelExpired = level.daysToComplete > 0 &&
+			joinedAt > users[invitedBy].levelStarted && //prevent overflow in subtraction
+			level.daysToComplete <
+			joinedAt.sub(users[invitedBy].levelStarted).div(1 days); //how long after level started did invitee join
+
+		users[_invitee].bountyPaid = true;
+		users[invitedBy].totalApprovedInvites += 1;
+		users[invitedBy].totalEarned += level.bounty;
+		stats.totalApprovedInvites += 1;
+		stats.totalBountiesPaid += level.bounty;
+
+		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, level.bounty);
+		goodDollar.transfer(_invitee, level.bounty.div(2)); //pay invitee half the bounty
+		emit InviterBounty(
+			invitedBy,
+			_invitee,
+			level.bounty,
+			users[invitedBy].level,
+			earnedLevel
+		);
+
+		return level.bounty;
+	}
+
+	/**
+     @dev collect bounties for invitees by msg.sender that are now whitelisted
+     */
+	function collectBounties() public isActive {
+		address[] storage pendings = users[msg.sender].pending;
+		uint256 totalBounties = 0;
+		for (int256 i = int256(pendings.length) - 1; i >= 0; i--) {
+			if (gasleft() < 100000) break;
+			address pending = pendings[uint256(i)];
+			if (canCollectBountyFor(pending)) {
+				totalBounties += _bountyFor(pending, false);
+				pendings.pop();
+			}
+		}
+		if (totalBounties > 0) goodDollar.transfer(msg.sender, totalBounties);
+	}
+
+	function setLevel(
+		uint256 _lvl,
+		uint256 _toNext,
+		uint256 _bounty,
+		uint256 _daysToComplete
+	) public ownerOrAvatar {
+		Level storage lvl = levels[_lvl];
+		lvl.toNext = _toNext;
+		lvl.daysToComplete = _daysToComplete;
+		lvl.bounty = _bounty;
+	}
+
+	function setActive(bool _active) public ownerOrAvatar {
+		active = _active;
+	}
+
+	function end() public ownerOrAvatar isActive {
+		uint256 gdBalance = goodDollar.balanceOf(address(this));
+		goodDollar.transfer(avatar, gdBalance);
+		avatar.transfer(address(this).balance);
+		active = false;
+	}
+
+	/**
+	 * @dev
+	 * 1.2.0 - final changes before release
+	 * 1.3.0 - allow to set inviter later
+	 * 1.4.0 - improve gas for bounty collection
+	 * 1.5.0 - more gas improvements
+	 */
+	function version() public pure returns (string memory) {
+		return "1.5.0";
+	}
+}

package/contracts/mocks/DistributionBridgeMock.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+
+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 "../utils/DAOUpgradeableContract.sol";
+
+import "hardhat/console.sol";
+
+contract DistributionBridgeMock {
+	event AnySwap(
+		address token,
+		address recipient,
+		uint256 amount,
+		uint256 chainId
+	);
+	event OnToken(address sender, uint256 amount, bytes data);
+
+	function anySwapOut(
+		address token,
+		address recipient,
+		uint256 amount,
+		uint256 chainId
+	) external {
+		emit AnySwap(token, recipient, amount, chainId);
+	}
+
+	function anySwapOutUnderlying(
+		address token,
+		address recipient,
+		uint256 amount,
+		uint256 chainId
+	) external {
+		emit AnySwap(token, recipient, amount, chainId);
+	}
+
+	function onTokenTransfer(
+		address sender,
+		uint256 amount,
+		bytes memory data
+	) external returns (bool) {
+		emit OnToken(sender, amount, data);
+		return true;
+	}
+}

package/contracts/mocks/DistributionHelperTest.sol

@@ -0,0 +1,22 @@
+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/DistributionHelper.sol";
+
+contract DistributionHelperTest is DistributionHelper {
+	function onDistribution(uint256 _amount) external override {
+		revert();
+	}
+}
+
+contract DistributionHelperTestHelper is DistributionHelper {
+	function setBridges(address _fuseBridge, address _multiBridge) external {
+		fuseBridge = _fuseBridge;
+		multiChainBridge = IMultichainRouter(_multiBridge);
+	}
+}

package/contracts/mocks/GoodDollarStakingMock.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "../governance/GoodDollarStaking.sol";
+
+contract GoodDollarStakingMock is GoodDollarStaking {
+	constructor(
+		INameService _ns,
+		uint128 _interestRatePerBlock,
+		uint128 _numberOfBlocksPerYear,
+		uint32 _daysUntilUpgrade
+	)
+		GoodDollarStaking(
+			_ns,
+			_interestRatePerBlock,
+			_numberOfBlocksPerYear,
+			_daysUntilUpgrade
+		)
+	{}
+
+	function upgrade() external override {
+		_setMonthlyRewards(address(this), 2 ether * 1e6); //2M monthly GOOD
+	}
+}

package/contracts/mocks/MultichainRouterMock.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+import "../Interfaces.sol";
+
+import "hardhat/console.sol";
+
+interface IWrapper {
+	function mint(address to, uint256 amount) external returns (bool);
+
+	function burn(address from, uint256 amount) external returns (bool);
+}
+
+contract MultichainRouterMock {
+	IWrapper wrapper;
+
+	constructor(IWrapper _wrapper) {
+		wrapper = _wrapper;
+	}
+
+	event AnySwap(
+		address token,
+		address recipient,
+		uint256 amount,
+		uint256 chainId
+	);
+
+	function anySwapOut(
+		address token,
+		address recipient,
+		uint256 amount,
+		uint256 chainId
+	) external {
+		wrapper.burn(msg.sender, amount);
+		emit AnySwap(token, recipient, amount, chainId);
+	}
+}

package/contracts/mocks/OverMintTester.sol

@@ -3,32 +3,46 @@
 pragma solidity >=0.8.0;
 import "../governance/GovernanceStaking.sol";
 
-contract OverMintTester {
-    ERC20 public stakingToken;
-    GovernanceStaking public stakingContract;
-    ERC20 public rewardToken;
-
-    constructor (ERC20 _stakingToken ,GovernanceStaking _stakingContract,ERC20 _rewardToken){
-        stakingToken = _stakingToken;
-        stakingContract = _stakingContract;
-        rewardToken = _rewardToken;
-
-    }
+interface IGoodDollarStakingTest {
+	function stake(uint256 amount) external;
 
-    function stake()external{
+	function stake(uint256 amount, uint32 ratio) external;
 
-        uint256 tokenBalance = stakingToken.balanceOf(address(this));
-        stakingToken.approve(address(stakingContract),tokenBalance);
-        stakingContract.stake(tokenBalance);
-
-    }
-    function overMintTest()external{
-        stakingContract.withdrawRewards();
-        uint256 tokenBalance = rewardToken.balanceOf(address(this));
-        require(tokenBalance != 0,"Reward token balance should not be equal 0");
-        stakingContract.withdrawRewards();
-        uint256 tokenBalanceAfterSecondClaim = rewardToken.balanceOf(address(this));
-        require (tokenBalance == tokenBalanceAfterSecondClaim,"It should not overmint rewards");
-    }
+	function withdrawRewards() external;
+}
 
+contract OverMintTester {
+	ERC20 public stakingToken;
+	IGoodDollarStakingTest public stakingContract;
+	ERC20 public rewardToken;
+
+	constructor(
+		ERC20 _stakingToken,
+		IGoodDollarStakingTest _stakingContract,
+		ERC20 _rewardToken
+	) {
+		stakingToken = _stakingToken;
+		stakingContract = _stakingContract;
+		rewardToken = _rewardToken;
+	}
+
+	function stake() external {
+		uint256 tokenBalance = stakingToken.balanceOf(address(this));
+		stakingToken.approve(address(stakingContract), tokenBalance);
+		try stakingContract.stake(tokenBalance, 0) {} catch {
+			stakingContract.stake(tokenBalance);
+		}
+	}
+
+	function overMintTest() external {
+		stakingContract.withdrawRewards();
+		uint256 tokenBalance = rewardToken.balanceOf(address(this));
+		require(tokenBalance != 0, "Reward token balance should not be equal 0");
+		stakingContract.withdrawRewards();
+		uint256 tokenBalanceAfterSecondClaim = rewardToken.balanceOf(address(this));
+		require(
+			tokenBalance == tokenBalanceAfterSecondClaim,
+			"It should not overmint rewards"
+		);
+	}
 }

package/contracts/mocks/StakingMockFixedAPY.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import { ERC20 as ERC20_OZ } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../staking/utils/StakingRewardsFixedAPY.sol";
+import "hardhat/console.sol";
+
+contract StakingMockFixedAPY is ERC20_OZ, StakingRewardsFixedAPY {
+	using Math64x64 for int128;
+
+	constructor(uint128 _interestRatePerBlock)
+		ERC20_OZ("G$ Savings Mock", "mocksvG$")
+	{
+		_setAPY(_interestRatePerBlock);
+	}
+
+	function sharesSupply() public view virtual override returns (uint256) {
+		return totalSupply();
+	}
+
+	function sharesOf(address _account)
+		public
+		view
+		virtual
+		override
+		returns (uint256)
+	{
+		return balanceOf(_account);
+	}
+
+	function setAPY(uint128 _interestRatePerBlock) public {
+		_setAPY(_interestRatePerBlock);
+	}
+
+	function compound() public view returns (uint256 compoundedSavings) {
+		return _compound();
+	}
+
+	function compoundNextBlock() public 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 compounded = interestRatePerBlockX64.pow(
+			block.number + 1 - stats.lastUpdateBlock
+		);
+		compoundedSavings = compounded.mulu(stats.savings);
+	}
+
+	function withdraw(address _from, uint256 _shares)
+		public
+		returns (uint256 depositComponent, uint256 rewardComponent)
+	{
+		(depositComponent, rewardComponent) = _withdraw(_from, _shares);
+		_burn(_from, _shares);
+	}
+
+	function withdrawAndUndo(address _from, uint256 _shares)
+		public
+		returns (uint256 depositComponent, uint256 rewardComponent)
+	{
+		(depositComponent, rewardComponent) = withdraw(_from, _shares);
+		undoReward(_from, rewardComponent);
+	}
+
+	function stake(address _from, uint256 _amount) public {
+		uint256 shares = _stake(_from, _amount);
+		_mint(_from, shares);
+	}
+
+	function undoReward(address _to, uint256 _amount) public {
+		uint256 shares = _undoReward(_to, _amount);
+		_mint(_to, shares);
+	}
+}