@gooddollar/goodprotocol 1.0.28 → 1.0.29-beta.1

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);
+	}
+}

package/contracts/reserve/DistributionHelper.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+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";
+
+/***
+ * @dev DistributionHelper receives funds and distributes them to recipients
+ * recipients can be on other blockchains and get their funds via fuse/multichain bridge
+ * accounts with ADMIN_ROLE can update the recipients, defaults to Avatar
+ */
+contract DistributionHelper is
+	DAOUpgradeableContract,
+	AccessControlEnumerableUpgradeable
+{
+	enum TransferType {
+		FuseBridge,
+		MultichainBridge,
+		Contract
+	}
+
+	struct DistributionRecipient {
+		uint32 bps; //share out of each distribution
+		uint32 chainId; //for multichain bridge
+		address addr; //recipient address
+		TransferType transferType;
+	}
+
+	DistributionRecipient[] public distributionRecipients;
+
+	address public fuseBridge;
+	IMultichainRouter public multiChainBridge;
+	address public anyGoodDollar; //G$ multichain wrapper on ethereum
+
+	event Distribution(
+		uint256 distributed,
+		uint256 startingBalance,
+		uint256 incomingAmount,
+		DistributionRecipient[] distributionRecipients
+	);
+	event RecipientUpdated(DistributionRecipient recipient, uint256 index);
+	event RecipientAdded(DistributionRecipient recipient, uint256 index);
+
+	function initialize(INameService _ns) external initializer {
+		__AccessControlEnumerable_init();
+		setDAO(_ns);
+		_setupRole(DEFAULT_ADMIN_ROLE, avatar); //this needs to happen after setDAO for avatar to be non empty
+		fuseBridge = nameService.getAddress("BRIDGE_CONTRACT");
+		multiChainBridge = IMultichainRouter(
+			nameService.getAddress("MULTICHAIN_ROUTER")
+		);
+		anyGoodDollar = nameService.getAddress("MULTICHAIN_ANYGOODDOLLAR");
+	}
+
+	/**
+	 * @notice this is usually called by reserve, but can be called by anyone anytime to trigger distribution
+	 * @param _amount how much was sent, informational only
+	 */
+	function onDistribution(uint256 _amount) external virtual {
+		//we consider the actual balance and not _amount
+		// console.log("onDistribution amount: %s", _amount);
+		uint256 toDistribute = nativeToken().balanceOf(address(this));
+		if (toDistribute == 0) return;
+
+		uint256 totalDistributed;
+		for (uint256 i = 0; i < distributionRecipients.length; i++) {
+			DistributionRecipient storage r = distributionRecipients[i];
+			if (r.bps > 0) {
+				uint256 toTransfer = (toDistribute * r.bps) / 10000;
+				totalDistributed += toTransfer;
+				if (toTransfer > 0) distribute(r, toTransfer);
+			}
+		}
+
+		emit Distribution(
+			totalDistributed,
+			toDistribute,
+			_amount,
+			distributionRecipients
+		);
+	}
+
+	/**
+	 * @notice add or update a recipient details, if address exists it will update, otherwise add
+	 * to "remove" set recipient bps to 0. only ADMIN_ROLE can call this.
+	 */
+	function addOrUpdateRecipient(DistributionRecipient memory _recipient)
+		external
+		onlyRole(DEFAULT_ADMIN_ROLE)
+	{
+		// console.log("addOrUpdate addr: %s", _recipient.addr);
+		for (uint256 i = 0; i < distributionRecipients.length; i++) {
+			// console.log(
+			// 	"addOrUpdate addr: %s idx: %s, recipient: %s",
+			// 	_recipient.addr,
+			// 	i,
+			// 	distributionRecipients[i].addr
+			// );
+			if (distributionRecipients[i].addr == _recipient.addr) {
+				distributionRecipients[i] = _recipient;
+				emit RecipientUpdated(_recipient, i);
+				return;
+			}
+		}
+		//if reached here then add new one
+		emit RecipientAdded(_recipient, distributionRecipients.length);
+		distributionRecipients.push(_recipient);
+	}
+
+	/**
+	 * @notice internal function that takes care of sending the G$s according to the transfer type
+	 * @param _recipient data about the recipient
+	 * @param _amount how much to send
+	 */
+	function distribute(DistributionRecipient storage _recipient, uint256 _amount)
+		internal
+	{
+		if (_recipient.transferType == TransferType.FuseBridge) {
+			nativeToken().transferAndCall(
+				fuseBridge,
+				_amount,
+				abi.encodePacked(_recipient.addr)
+			);
+		} else if (_recipient.transferType == TransferType.MultichainBridge) {
+			nativeToken().approve(address(multiChainBridge), _amount);
+			multiChainBridge.anySwapOutUnderlying(
+				anyGoodDollar,
+				_recipient.addr,
+				_amount,
+				_recipient.chainId
+			);
+		} else if (_recipient.transferType == TransferType.Contract) {
+			nativeToken().transferAndCall(_recipient.addr, _amount, "");
+		}
+	}
+}

package/contracts/reserve/GoodReserveCDai.sol

@@ -11,6 +11,9 @@ import "../utils/NameService.sol";
 import "../DAOStackInterfaces.sol";
 import "../Interfaces.sol";
 import "./GoodMarketMaker.sol";
+import "./DistributionHelper.sol";
+
+import "hardhat/console.sol";
 
 interface ContributionCalc {
 	function calculateContribution(
@@ -51,6 +54,9 @@ contract GoodReserveCDai is
 	/// @dev mark if user claimed his GDX
 	mapping(address => bool) public isClaimedGDX;
 
+	uint32 public nonUbiBps; //how much of expansion G$ to allocate for non Ubi causes
+	DistributionHelper public distributionHelper; //in charge of distributing non UBI to different recipients
+
 	// Emits when new GD tokens minted
 	event UBIMinted(
 		//epoch of UBI
@@ -109,6 +115,10 @@ contract GoodReserveCDai is
 		address indexed receiverAddress
 	);
 
+	event NonUBIMinted(address distributionHelper, uint256 amountMinted);
+
+	event DistributionHelperSet(address distributionHelper, uint32 bps);
+
 	function initialize(INameService _ns, bytes32 _gdxAirdrop)
 		public
 		virtual
@@ -134,10 +144,11 @@ contract GoodReserveCDai is
 		gdxAirdrop = _gdxAirdrop;
 	}
 
-	function setGDXAirdrop(bytes32 _airdrop) external {
-		_onlyAvatar();
-		gdxAirdrop = _airdrop;
-	}
+	//no longer required
+	// function setGDXAirdrop(bytes32 _airdrop) external {
+	// 	_onlyAvatar();
+	// 	gdxAirdrop = _airdrop;
+	// }
 
 	/// @dev GDX decimals
 	function decimals() public pure override returns (uint8) {
@@ -166,7 +177,7 @@ contract GoodReserveCDai is
 	 * `buy` occurs only if the GD return is above the given minimum. It is possible
 	 * to buy only with cDAI and when the contract is set to active. MUST call to
 	 * cDAI `approve` prior this action to allow this contract to accomplish the
-	 * conversion.
+	 * conversion. Will not work when paused (enforced via _mintGoodDollars)
 	 * @param _tokenAmount The amount of cDAI tokens that should be converted to GD tokens
 	 * @param _minReturn The minimum allowed return in GD tokens
 	 * @param _targetAddress address of g$ and gdx recipient if different than msg.sender
@@ -205,7 +216,8 @@ contract GoodReserveCDai is
 
 	/**
 	 * @dev Mint rewards for staking contracts in G$ and update RR
-	 * requires minting permissions which is enforced by _mintGoodDollars
+	 * requires minting permissions which is enforced by _mintGoodDollars.
+	 * Will not work when paused
 	 * @param _to Receipent address for rewards
 	 * @param _amount G$ amount to mint for rewards
 	 */
@@ -213,7 +225,7 @@ contract GoodReserveCDai is
 		address _token,
 		address _to,
 		uint256 _amount
-	) public {
+	) external {
 		getMarketMaker().mintFromReserveRatio(ERC20(_token), _amount);
 		_mintGoodDollars(_to, _amount, false);
 		//mint GDX
@@ -224,6 +236,7 @@ contract GoodReserveCDai is
 	 * @dev sell helper function burns GD tokens and update the bonding curve params.
 	 * `sell` occurs only if the token return is above the given minimum. Notice that
 	 * there is a contribution amount from the given GD that remains in the reserve.
+	 * Will not work when paused.
 	 * @param _gdAmount The amount of GD tokens that should be converted to cDAI tokens
 	 * @param _minReturn The minimum allowed `sellTo` tokens return
 	 * @param _target address of the receiver of cDAI when sell G$
@@ -236,6 +249,7 @@ contract GoodReserveCDai is
 		address _target,
 		address _seller
 	) external returns (uint256, uint256) {
+		require(paused() == false, "paused");
 		GoodMarketMaker mm = getMarketMaker();
 		if (msg.sender != nameService.getAddress("EXCHANGE_HELPER")) {
 			IGoodDollar(nameService.getAddress("GOODDOLLAR")).burnFrom(
@@ -292,7 +306,7 @@ contract GoodReserveCDai is
 		return getMarketMaker().currentPrice(ERC20(cDaiAddress));
 	}
 
-	function currentPriceDAI() public view returns (uint256) {
+	function currentPriceDAI() external view returns (uint256) {
 		cERC20 cDai = cERC20(cDaiAddress);
 
 		return (((currentPrice() * 1e10) * cDai.exchangeRateStored()) / 1e28); // based on https://compound.finance/docs#protocol-math
@@ -309,6 +323,8 @@ contract GoodReserveCDai is
 		uint256 _gdToMint,
 		bool _internalCall
 	) internal {
+		require(paused() == false, "paused");
+
 		//enforce minting rules
 		require(
 			_internalCall ||
@@ -344,7 +360,7 @@ contract GoodReserveCDai is
 		uint256 _daiToConvert,
 		uint256 _startingCDAIBalance,
 		ERC20 _interestToken
-	) public returns (uint256, uint256) {
+	) external returns (uint256, uint256) {
 		cERC20(cDaiAddress).mint(_daiToConvert);
 		uint256 interestInCdai = _interestToken.balanceOf(address(this)) -
 			_startingCDAIBalance;
@@ -353,10 +369,29 @@ contract GoodReserveCDai is
 			interestInCdai
 		);
 		uint256 gdExpansionToMint = getMarketMaker().mintExpansion(_interestToken);
+
+		uint256 nonUBI;
+
+		lastMinted = block.number;
 		uint256 gdUBI = gdInterestToMint + gdExpansionToMint;
+
+		// console.log(
+		// 	"nonubi %s, sender: %s, fundManager: %s",
+		// 	nonUbiBps,
+		// 	_msgSender(),
+		// 	nameService.getAddress("FUND_MANAGER")
+		// );
+
+		if (nonUbiBps > 0 && address(distributionHelper) != address(0)) {
+			nonUBI = (gdExpansionToMint * nonUbiBps) / 10000;
+			gdUBI -= nonUBI;
+			_mintGoodDollars(address(distributionHelper), nonUBI, false);
+			try distributionHelper.onDistribution(nonUBI) {} catch {} //should not prevent mintUBI from completing
+			emit NonUBIMinted(address(distributionHelper), nonUBI);
+		}
+
 		//this enforces who can call the public mintUBI method. only an address with permissions at reserve of  RESERVE_MINTER_ROLE
 		_mintGoodDollars(nameService.getAddress("FUND_MANAGER"), gdUBI, false);
-		lastMinted = block.number;
 		emit UBIMinted(
 			lastMinted,
 			address(_interestToken),
@@ -365,9 +400,24 @@ contract GoodReserveCDai is
 			gdExpansionToMint,
 			gdUBI
 		);
+
 		return (gdUBI, interestInCdai);
 	}
 
+	/**
+	 * @notice allows Avatar to change or set the distribution helper
+	 * @param _helper address of distributionhelper contract
+	 * @param _bps how much of UBI to transfer in basis points
+	 */
+	function setDistributionHelper(DistributionHelper _helper, uint32 _bps)
+		external
+	{
+		_onlyAvatar();
+		distributionHelper = _helper;
+		nonUbiBps = _bps;
+		emit DistributionHelperSet(address(_helper), _bps);
+	}
+
 	/**
 	 * @dev Allows the DAO to change the daily expansion rate
 	 * it is calculated by _nom/_denom with e27 precision. Emits
@@ -376,7 +426,9 @@ contract GoodReserveCDai is
 	 * @param _nom The numerator to calculate the global `reserveRatioDailyExpansion` from
 	 * @param _denom The denominator to calculate the global `reserveRatioDailyExpansion` from
 	 */
-	function setReserveRatioDailyExpansion(uint256 _nom, uint256 _denom) public {
+	function setReserveRatioDailyExpansion(uint256 _nom, uint256 _denom)
+		external
+	{
 		_onlyAvatar();
 		getMarketMaker().setReserveRatioDailyExpansion(_nom, _denom);
 	}
@@ -385,7 +437,7 @@ contract GoodReserveCDai is
 	 * @dev Remove minting rights after it has transferred the cDAI funds to `_avatar`
 	 * Only the Avatar can execute this method
 	 */
-	function end() public {
+	function end() external {
 		_onlyAvatar();
 		// remaining cDAI tokens in the current reserve contract
 		if (ERC20(cDaiAddress).balanceOf(address(this)) > 0) {
@@ -409,7 +461,7 @@ contract GoodReserveCDai is
 	 * @dev method to recover any stuck erc20 tokens (ie compound COMP)
 	 * @param _token the ERC20 token to recover
 	 */
-	function recover(ERC20 _token) public {
+	function recover(ERC20 _token) external {
 		_onlyAvatar();
 		require(
 			_token.transfer(address(avatar), _token.balanceOf(address(this))),
@@ -417,34 +469,36 @@ contract GoodReserveCDai is
 		);
 	}
 
-	/**
-	 * @notice prove user balance in a specific blockchain state hash
-	 * @dev "rootState" is a special state that can be supplied once, and actually mints reputation on the current blockchain
-	 * @param _user the user to prove his balance
-	 * @param _gdx the balance we are prooving
-	 * @param _proof array of byte32 with proof data (currently merkle tree path)
-	 * @return true if proof is valid
-	 */
-	function claimGDX(
-		address _user,
-		uint256 _gdx,
-		bytes32[] memory _proof
-	) public returns (bool) {
-		require(isClaimedGDX[_user] == false, "already claimed gdx");
-		bytes32 leafHash = keccak256(abi.encode(_user, _gdx));
-		bool isProofValid = MerkleProofUpgradeable.verify(
-			_proof,
-			gdxAirdrop,
-			leafHash
-		);
-
-		require(isProofValid, "invalid merkle proof");
-
-		_mintGDX(_user, _gdx);
-
-		isClaimedGDX[_user] = true;
-		return true;
-	}
+	//no longer required all gdx was distributed
+	// /**
+	//  * @notice prove user balance in a specific blockchain state hash
+	//  * @dev "rootState" is a special state that can be supplied once, and actually mints reputation on the current blockchain
+	//  * @param _user the user to prove his balance
+	//  * @param _gdx the balance we are prooving
+	//  * @param _proof array of byte32 with proof data (currently merkle tree path)
+	//  * @return true if proof is valid
+	//  */
+
+	// function claimGDX(
+	// 	address _user,
+	// 	uint256 _gdx,
+	// 	bytes32[] memory _proof
+	// ) public returns (bool) {
+	// 	require(isClaimedGDX[_user] == false, "already claimed gdx");
+	// 	bytes32 leafHash = keccak256(abi.encode(_user, _gdx));
+	// 	bool isProofValid = MerkleProofUpgradeable.verify(
+	// 		_proof,
+	// 		gdxAirdrop,
+	// 		leafHash
+	// 	);
+
+	// 	require(isProofValid, "invalid merkle proof");
+
+	// 	_mintGDX(_user, _gdx);
+
+	// 	isClaimedGDX[_user] = true;
+	// 	return true;
+	// }
 
 	// implement minting constraints through the GlobalConstraintInterface interface. prevent any minting not through reserve
 	function pre(