@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/contracts/invite/InvitesV2.sol

@@ -0,0 +1,345 @@
+// 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 "../Interfaces.sol";
+import "../utils/NameService.sol";
+import "../utils/DAOUpgradeableContract.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 DAOUpgradeableContract {
+	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;
+
+	mapping(uint256 => Level) public levels;
+
+	address public owner;
+	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 isActive() {
+		require(active, "not active");
+		_;
+	}
+
+	function initialize(
+		INameService _ns,
+		uint256 _level0Bounty,
+		address _owner
+	) public initializer {
+		__init_invites(_ns, _level0Bounty, _owner);
+	}
+
+	function __init_invites(
+		INameService _ns,
+		uint256 _level0Bounty,
+		address _owner
+	) internal virtual {
+		setDAO(_ns);
+		owner = _owner;
+		active = true;
+		Level storage lvl = levels[0];
+		lvl.bounty = _level0Bounty;
+		goodDollar = cERC20(nameService.getAddress("GOODDOLLAR"));
+		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 ||
+				address(uint160(uint256(_myCode))) == msg.sender,
+			"invite code already in use"
+		);
+		require(_myCode != _inviterCode, "self invite");
+		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)) {
+			require(inviter != msg.sender, "self invite");
+			user.invitedBy = inviter;
+			users[inviter].invitees.push(msg.sender);
+			users[inviter].pending.push(msg.sender);
+			stats.totalInvited += 1;
+		}
+		if (canCollectBountyFor(msg.sender)) {
+			_bountyFor(msg.sender, true);
+		}
+		emit InviteeJoined(inviter, msg.sender);
+	}
+
+	function _whitelistedOnChainOrDefault(address _invitee)
+		internal
+		view
+		returns (uint256 chainId)
+	{
+		(bool success, bytes memory result) = address(getIdentity()).staticcall(
+			abi.encodeWithSignature("getWhitelistedOnChainId(address)", _invitee)
+		);
+		if (success == false) {
+			return _chainId();
+		}
+
+		return abi.decode(result, (uint256));
+	}
+
+	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].bountyPaid &&
+			getIdentity().isWhitelisted(_invitee) &&
+			getIdentity().isWhitelisted(invitedBy) &&
+			_whitelistedOnChainOrDefault(_invitee) == _chainId() &&
+			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 - users[invitedBy].levelStarted) / 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 / 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() < 185000) break; // leave enough gas for the token transfer around 150k if we are using supertoken
+			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);
+		payable(msg.sender).transfer(address(this).balance);
+		active = false;
+	}
+
+	/// @notice helper function to get current chain id
+	/// @return chainId id
+	function _chainId() internal view returns (uint256 chainId) {
+		assembly {
+			chainId := chainid()
+		}
+	}
+
+	/**
+	 * @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
+	 * 2 uses uups upgradeable - not compatible upgrade for v1
+	 * 2.1 prevent multichain claims
+	 */
+	function version() public pure returns (string memory) {
+		return "2.1";
+	}
+}

package/contracts/mocks/AaveMock.sol

@@ -9,7 +9,7 @@ import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
 contract AaveMock is ERC20PresetMinterPauserUpgradeable {
 	using SafeMathUpgradeable for uint256;
 
-	constructor() {
+	constructor() initializer {
 		__ERC20PresetMinterPauser_init("AAVE", "Aave");
 	}
 

package/contracts/mocks/DAIMock.sol

@@ -5,7 +5,7 @@ pragma solidity >=0.8.0;
 import "@openzeppelin/contracts-upgradeable/token/ERC20/presets/ERC20PresetMinterPauserUpgradeable.sol";
 
 contract DAIMock is ERC20PresetMinterPauserUpgradeable {
-	constructor() {
+	constructor() initializer {
 		__ERC20PresetMinterPauser_init("DAI", "DAI");
 	}
 

package/contracts/mocks/DecimalsMock.sol

@@ -9,7 +9,7 @@ import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
 contract DecimalsMock is ERC20PresetMinterPauserUpgradeable {
 	uint8 tokenDecimals;
 
-	constructor(uint8 decimals) {
+	constructor(uint8 decimals) initializer {
 		__ERC20PresetMinterPauser_init("Eight Decimals Token", "EDT");
 		tokenDecimals = decimals;
 	}

package/contracts/mocks/FeesFormularMock.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8;
+
+import "../token/FeesFormula.sol";
+
+contract FeesFormulaMock is IFeesFormula {
+    uint256 public immutable feePerMillion;
+
+    constructor(uint256 feePerMillion_) {
+        require(feePerMillion_ <= 1e6, "fee higher than 100%");
+        feePerMillion = feePerMillion_;
+    }
+
+    function getTxFees(
+        uint256 value,
+        address sender,
+        address recipient
+    ) external view returns (uint256 fee, bool senderPays) {
+        return (value * feePerMillion / 1E6, true);
+    }
+}

package/contracts/mocks/GoodDollarStakingMock.sol

@@ -2,6 +2,7 @@
 pragma solidity >=0.8.0;
 
 import "../governance/GoodDollarStaking.sol";
+import "hardhat/console.sol";
 
 contract GoodDollarStakingMock is GoodDollarStaking {
 	constructor(
@@ -21,4 +22,19 @@ contract GoodDollarStakingMock is GoodDollarStaking {
 	function upgrade() external override {
 		_setMonthlyRewards(address(this), 2 ether * 1e6); //2M monthly GOOD
 	}
+
+	function upgradeFrom(address staker, uint256 amount)
+		external
+		returns (uint256 shares)
+	{
+		console.log(
+			"from: %s balance: %s",
+			address(msg.sender),
+			token.balanceOf(msg.sender)
+		);
+		require(
+			msg.sender == nameService.getAddress("GDAO_STAKING"),
+			"not GDAO_STAKING"
+		);
+	}
 }

package/contracts/mocks/GoodFundManagerTest.sol

@@ -4,7 +4,7 @@ pragma solidity >=0.8.0;
 import "../staking/GoodFundManager.sol";
 
 contract GoodFundManagerTest is GoodFundManager {
-	constructor(INameService _ns) GoodFundManager() {
+	constructor(INameService _ns) initializer GoodFundManager() {
 		initialize(_ns);
 	}
 

package/contracts/mocks/IdentityMock.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8;
+
+import "../Interfaces.sol";
+
+contract IdentityMock is IIdentity {
+
+    address public immutable owner;
+    address public immutable daoContract;
+
+    constructor(address daoContract_) {
+        owner = msg.sender;
+        daoContract = daoContract_;
+    }
+
+    function isWhitelisted(address user) external view returns (bool) {
+        return true;
+    }
+
+    function addWhitelistedWithDID(address account, string memory did) external {}
+
+    function removeWhitelisted(address account) external {}
+
+    function addBlacklisted(address account) external {}
+
+    function removeBlacklisted(address account) external {}
+
+    function isBlacklisted(address user) external view returns (bool) {
+        return true;
+    }
+
+    function addIdentityAdmin(address account) external returns (bool) {
+        return true;
+    }
+
+    function setAvatar(address _avatar) external {}
+
+    function isIdentityAdmin(address account) external view returns (bool) {
+        return true;
+    }
+
+    // provided by the immutable "owner"
+    //function owner() external view returns (address);
+
+    function removeContract(address account) external {}
+
+    function isDAOContract(address account) external view returns (bool) {
+        return false;
+    }
+
+    function addrToDID(address account) external view returns (string memory) {
+        return "not implemented";
+    }
+
+    function didHashToAddress(bytes32 hash) external view returns (address) {
+        return address(0); // not implemented
+    }
+}

package/contracts/mocks/LendingPoolMock.sol

@@ -9,7 +9,7 @@ pragma solidity >=0.8.0;
 contract LendingPoolMock is ERC20PresetMinterPauserUpgradeable {
 	address public underlyingAsset;
 
-	constructor(address _asset) {
+	constructor(address _asset) initializer {
 		underlyingAsset = _asset;
 		__ERC20PresetMinterPauser_init("aUSDC", "aUSDC");
 	}

package/contracts/mocks/PayableMock.sol

@@ -0,0 +1,3 @@
+contract PayableMock {
+	function rec() public payable {}
+}

package/contracts/mocks/SixteenDecimalsTokenMock.sol

@@ -9,16 +9,11 @@ import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
 contract SixteenDecimalsTokenMock is ERC20PresetMinterPauserUpgradeable {
 	using SafeMathUpgradeable for uint256;
 
-
-
-	constructor() {
+	constructor() initializer {
 		__ERC20PresetMinterPauser_init("SixteenDecimalsToken", "SDT");
 	}
 
-	
-
 	function decimals() public pure override returns (uint8) {
 		return 16;
 	}
-	
 }

package/contracts/mocks/TwentyDecimalsTokenMock.sol

@@ -9,16 +9,11 @@ import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
 contract TwentyDecimalsTokenMock is ERC20PresetMinterPauserUpgradeable {
 	using SafeMathUpgradeable for uint256;
 
-
-
-	constructor() {
+	constructor() initializer {
 		__ERC20PresetMinterPauser_init("TwentyDecimalsToken", "TDT");
 	}
 
-	
-
 	function decimals() public pure override returns (uint8) {
 		return 20;
 	}
-	
 }

package/contracts/mocks/UpgradableMocks.sol

@@ -34,8 +34,9 @@ contract UpgradableMock3 is DAOUpgradeableContract {
 	function decimals() public pure returns (uint256) {
 		return 3;
 	}
+
 	function initialize(INameService _ns) public initializer {
-    setDAO(_ns);
+		setDAO(_ns);
 	}
 }
 
@@ -43,7 +44,8 @@ contract UpgradableMock4 is DAOUpgradeableContract {
 	function decimals() public pure returns (uint256) {
 		return 4;
 	}
+
 	function initialize(INameService _ns) public initializer {
-    setDAO(_ns);
+		setDAO(_ns);
 	}
-}
+}

package/contracts/mocks/UsdcMock.sol

@@ -9,16 +9,11 @@ import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
 contract USDCMock is ERC20PresetMinterPauserUpgradeable {
 	using SafeMathUpgradeable for uint256;
 
-
-
-	constructor() {
+	constructor() initializer {
 		__ERC20PresetMinterPauser_init("USDC", "USDC");
 	}
 
-	
-
 	function decimals() public pure override returns (uint8) {
 		return 6;
 	}
-	
 }

package/contracts/mocks/cBATMock.sol

@@ -14,7 +14,7 @@ contract cBATMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 
 	uint256 exchangeRate = uint256(100e28).div(99);
 
-	constructor(ERC20PresetMinterPauserUpgradeable _bat) {
+	constructor(ERC20PresetMinterPauserUpgradeable _bat) initializer {
 		__ERC20PresetMinterPauser_init("Compound BAT", "cBAT");
 		bat = _bat;
 	}
@@ -22,19 +22,15 @@ contract cBATMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	function mint(uint256 batAmount) public returns (uint256) {
 		bat.transferFrom(msg.sender, address(this), batAmount);
 		//mul by 1e10 to match to precision of 1e28 of the exchange rate
-		_mint(
-			msg.sender,
-			rdiv(batAmount * 1e10, exchangeRateStored()).div(1e19)
-		); //div to reduce precision from RAY 1e27 to 1e8 precision of cDAI
+		_mint(msg.sender, rdiv(batAmount * 1e10, exchangeRateStored()).div(1e19)); //div to reduce precision from RAY 1e27 to 1e8 precision of cDAI
 		return 0;
 	}
 
 	function redeem(uint256 cBatAmount) public returns (uint256) {
-		uint256 daiAmount =
-			rmul(
-				cBatAmount * 1e10, //bring cdai 8 decimals to rdai precision
-				exchangeRateStored().div(10)
-			);
+		uint256 daiAmount = rmul(
+			cBatAmount * 1e10, //bring cdai 8 decimals to rdai precision
+			exchangeRateStored().div(10)
+		);
 		//div to reduce precision from 1e28 of exchange rate to 1e27 that DSMath works on
 		// uint256 daiAmount = cdaiAmount.mul(100).div(99);
 		_burn(msg.sender, cBatAmount);
@@ -43,8 +39,7 @@ contract cBATMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	}
 
 	function redeemUnderlying(uint256 batAmount) public returns (uint256) {
-		uint256 cdaiAmount =
-			rdiv(batAmount * 1e10, exchangeRateStored()).div(1e19);
+		uint256 cdaiAmount = rdiv(batAmount * 1e10, exchangeRateStored()).div(1e19);
 		_burn(msg.sender, cdaiAmount);
 		bat.transfer(msg.sender, batAmount);
 		return 0;

package/contracts/mocks/cDAILowWorthMock.sol

@@ -12,7 +12,7 @@ contract cDAILowWorthMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	using SafeMathUpgradeable for uint256;
 	uint256 exchangeRate = uint256(100e28).div(99);
 
-	constructor(ERC20PresetMinterPauserUpgradeable _dai) {
+	constructor(ERC20PresetMinterPauserUpgradeable _dai) initializer {
 		__ERC20PresetMinterPauser_init("Compound DAI", "cDAI");
 		dai = _dai;
 	}
@@ -20,19 +20,15 @@ contract cDAILowWorthMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	function mint(uint256 daiAmount) public returns (uint256) {
 		dai.transferFrom(msg.sender, address(this), daiAmount);
 		//mul by 1e10 to match to precision of 1e28 of the exchange rate
-		_mint(
-			msg.sender,
-			rdiv(daiAmount * 1e10, exchangeRateStored()).div(1e19)
-		); //div to reduce precision from RAY 1e27 to 1e8 precision of cDAI
+		_mint(msg.sender, rdiv(daiAmount * 1e10, exchangeRateStored()).div(1e19)); //div to reduce precision from RAY 1e27 to 1e8 precision of cDAI
 		return 0;
 	}
 
 	function redeem(uint256 cdaiAmount) public returns (uint256) {
-		uint256 daiAmount =
-			rmul(
-				cdaiAmount * 1e10, //bring cdai 8 decimals to rdai precision
-				exchangeRateStored().div(10)
-			);
+		uint256 daiAmount = rmul(
+			cdaiAmount * 1e10, //bring cdai 8 decimals to rdai precision
+			exchangeRateStored().div(10)
+		);
 		//div to reduce precision from 1e28 of exchange rate to 1e27 that DSMath works on
 		// uint256 daiAmount = cdaiAmount.mul(100).div(99);
 		_burn(msg.sender, cdaiAmount);
@@ -41,8 +37,8 @@ contract cDAILowWorthMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	}
 
 	function redeemUnderlying(uint256 daiAmount) public returns (uint256) {
-		uint256 cdaiAmount =
-			rdiv(daiAmount * 1e10, exchangeRateStored().mul(2)).div(1e19);
+		uint256 cdaiAmount = rdiv(daiAmount * 1e10, exchangeRateStored().mul(2))
+			.div(1e19);
 		_burn(msg.sender, cdaiAmount);
 		dai.transfer(msg.sender, daiAmount.div(2));
 		return 0;

package/contracts/mocks/cDAIMock.sol

@@ -15,7 +15,7 @@ contract cDAIMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	uint256 exchangeRate = 200000000000000000000000000; // initial exchange rate 0.02 from original cToken
 	uint256 mantissa = 28;
 
-	constructor(ERC20PresetMinterPauserUpgradeable _dai) {
+	constructor(ERC20PresetMinterPauserUpgradeable _dai) initializer {
 		__ERC20PresetMinterPauser_init("Compound DAI", "cDAI");
 		dai = _dai;
 	}