@gooddollar/goodprotocol 1.0.30 → 1.0.31-beta.0

package/artifacts/contracts/utils/ProtocolUpgradeFuseRecover.sol/ProtocolUpgradeFuseRecover.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/1978ac65522bd5d330515fa5e80306f2.json"
+  "buildInfo": "../../../build-info/82edabb017e079b951c9a9557f562e2a.json"
 }

package/artifacts/contracts/utils/ProtocolUpgradeRecover.sol/ProtocolUpgradeRecover.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/1978ac65522bd5d330515fa5e80306f2.json"
+  "buildInfo": "../../../build-info/82edabb017e079b951c9a9557f562e2a.json"
 }

package/artifacts/contracts/utils/ProxyFactory1967.sol/ERC1967Proxy.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/1978ac65522bd5d330515fa5e80306f2.json"
+  "buildInfo": "../../../build-info/82edabb017e079b951c9a9557f562e2a.json"
 }

package/artifacts/contracts/utils/ProxyFactory1967.sol/ProxyFactory1967.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/1978ac65522bd5d330515fa5e80306f2.json"
+  "buildInfo": "../../../build-info/82edabb017e079b951c9a9557f562e2a.json"
 }

package/artifacts/contracts/utils/ReputationTestHelper.sol/ReputationTestHelper.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/1978ac65522bd5d330515fa5e80306f2.json"
+  "buildInfo": "../../../build-info/82edabb017e079b951c9a9557f562e2a.json"
 }

package/contracts/staking/FuseStakingV3.sol

@@ -98,12 +98,27 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 	/**
 	 * @dev initialize
 	 */
-	function initialize() public initializer {
+	function initialize(address _uniswap, address _gd) public initializer {
 		__Ownable_init_unchained();
-		consensus = IConsensus(
-			address(0x3014ca10b91cb3D0AD85fEf7A3Cb95BCAc9c0f79)
-		);
+		consensus = IConsensus(address(0x3014ca10b91cb3D0AD85fEf7A3Cb95BCAc9c0f79));
 		validators.push(address(0xcb876A393F05a6677a8a029f1C6D7603B416C0A6));
+		stakeBackRatio = 33333; //%33
+		communityPoolRatio = 33333; //%33
+		maxSlippageRatio = 3000; //3%
+		keeperFeeRatio = 30; //0.03%
+		RATIO_BASE = 100000; //100%
+		uniswap = Uniswap(
+			_uniswap == address(0)
+				? 0xE3F85aAd0c8DD7337427B9dF5d0fB741d65EEEB5
+				: _uniswap
+		);
+
+		GD = IGoodDollar(_gd);
+		uniswapFactory = UniswapFactory(uniswap.factory());
+		uniswapPair = UniswapPair(uniswapFactory.getPair(uniswap.WETH(), _gd));
+		pegSwap = PegSwap(0xdfE016328E7BcD6FA06614fE3AF3877E931F7e0a);
+		USDC = address(0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5);
+		fUSD = address(0x249BE57637D8B013Ad64785404b24aeBaE9B098B);
 	}
 
 	modifier notPaused() {
@@ -116,79 +131,13 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		_;
 	}
 
-	function upgrade0() external {
-		if (RATIO_BASE == 0) {
-			stakeBackRatio = 33333; //%33
-			communityPoolRatio = 33333; //%33
-			maxSlippageRatio = 3000; //3%
-			keeperFeeRatio = 30; //0.03%
-			RATIO_BASE = 100000; //100%
-		}
-	}
-
-	function upgrade1(
-		address _gd,
-		address _ubischeme,
-		address _uniswap
-	) external {
-		if (address(uniswapPair) == address(0)) {
-			uniswap = Uniswap(
-				_uniswap == address(0)
-					? 0xFB76e9E7d88E308aB530330eD90e84a952570319
-					: _uniswap
-			);
-			GD = IGoodDollar(_gd);
-			ubischeme = UBIScheme(_ubischeme);
-
-			uniswapFactory = UniswapFactory(uniswap.factory());
-			uniswapPair = UniswapPair(
-				uniswapFactory.getPair(uniswap.WETH(), _gd)
-			);
-		}
-	}
-
-	function upgrade2() external {
-		if (USDC == address(0)) {
-			USDC = address(0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5);
-			fUSD = address(0x249BE57637D8B013Ad64785404b24aeBaE9B098B);
-		}
-	}
-
-	function upgrade3() external {
-		if (guardian == address(0)) {
-			paused = true;
-			guardian = address(0x5128E3C1f8846724cc1007Af9b4189713922E4BB);
-		}
-	}
-
-	function upgrade4() external {
-		if (address(pegSwap) == address(0)) {
-			pegSwap = PegSwap(0xdfE016328E7BcD6FA06614fE3AF3877E931F7e0a);
-			paused = false;
-		}
-	}
-
-	function upgrade5() external {
+	function approve() external {
 		cERC20(fUSD).approve(address(pegSwap), type(uint256).max);
 		cERC20(USDC).approve(address(uniswap), type(uint256).max);
 	}
 
-	function upgrade6() external {
-		//switch to voltage
-		uniswap = Uniswap(0xE3F85aAd0c8DD7337427B9dF5d0fB741d65EEEB5);
-		uniswapFactory = UniswapFactory(uniswap.factory());
-		uniswapPair = UniswapPair(
-			uniswapFactory.getPair(uniswap.WETH(), address(GD))
-		);
-	}
-
-	function setContracts(address _gd, address _ubischeme) public onlyOwner {
-		if (_gd != address(0)) {
-			GD = IGoodDollar(_gd);
-		}
-		if (_ubischeme != address(0)) {
-			ubischeme = UBIScheme(_ubischeme);
-		}
+	function setUBIScheme(address _ubischeme) public onlyOwner {
+		ubischeme = UBIScheme(_ubischeme);
 	}
 
 	function stake() public payable returns (bool) {
@@ -230,17 +179,15 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 
 	function withdrawAll() public onlyGuardian {
 		for (uint256 i = 0; i < validators.length; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 			if (cur == 0) continue;
 			undelegateWithCatch(validators[i], cur);
 		}
 		uint256 effectiveBalance = balance(); //use only undelegated funds
 		pendingFuseEarnings = 0;
 		if (effectiveBalance > 0) {
-			msg.sender.call{ value: effectiveBalance }("");
+			(bool ok, ) = msg.sender.call{ value: effectiveBalance }("");
+			require(ok, "transfer failed");
 		}
 	}
 
@@ -254,10 +201,7 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		);
 		uint256 perValidator = _value.div(validators.length);
 		for (uint256 i = 0; i < validators.length; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 			if (cur == 0) continue;
 			if (cur <= perValidator) {
 				undelegateWithCatch(validators[i], cur);
@@ -296,10 +240,7 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		uint256 perValidator = (totalDelegated() + _value) / validators.length;
 		uint256 left = _value;
 		for (uint256 i = 0; i < validators.length && left > 0; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 
 			if (cur < perValidator) {
 				uint256 toDelegate = perValidator.sub(cur);
@@ -319,20 +260,14 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 	function totalDelegated() public view returns (uint256) {
 		uint256 total = 0;
 		for (uint256 i = 0; i < validators.length; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 			total += cur;
 		}
 		return total;
 	}
 
 	function removeValidator(address _validator) public onlyOwner {
-		uint256 delegated = consensus.delegatedAmount(
-			address(this),
-			_validator
-		);
+		uint256 delegated = consensus.delegatedAmount(address(this), _validator);
 		if (delegated > 0) {
 			uint256 prevBalance = balance();
 			undelegateWithCatch(_validator, delegated);
@@ -356,18 +291,13 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 
 	function collectUBIInterest() public notPaused {
 		uint256 curDay = ubischeme.currentDay();
-		require(
-			curDay != lastDayCollected,
-			"can collect only once in a ubi cycle"
-		);
+		require(curDay != lastDayCollected, "can collect only once in a ubi cycle");
 
 		uint256 earnings = balance() - pendingFuseEarnings;
 		require(pendingFuseEarnings + earnings > 0, "no earnings to collect");
 
 		lastDayCollected = curDay;
-		uint256 fuseUBI = earnings.mul(RATIO_BASE - stakeBackRatio).div(
-			RATIO_BASE
-		);
+		uint256 fuseUBI = earnings.mul(RATIO_BASE - stakeBackRatio).div(RATIO_BASE);
 		uint256 stakeBack = earnings - fuseUBI;
 
 		uint256[] memory fuseswapResult = _buyGD(fuseUBI + pendingFuseEarnings); //buy GD with X% of earnings
@@ -378,9 +308,9 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		uint256 keeperFee = gdBought.mul(keeperFeeRatio).div(RATIO_BASE);
 		if (keeperFee > 0) GD.transfer(msg.sender, keeperFee);
 		gdBought -= keeperFee;
-		uint256 communityPoolContribution = gdBought
-			.mul(communityPoolRatio)
-			.div(RATIO_BASE); //subtract fee // * ommunityPoolRatio // = G$ after fee * communityPoolRatio%
+		uint256 communityPoolContribution = gdBought.mul(communityPoolRatio).div(
+			RATIO_BASE
+		); //subtract fee // * ommunityPoolRatio // = G$ after fee * communityPoolRatio%
 
 		uint256 ubiAfterFeeAndPool = gdBought.sub(communityPoolContribution);
 
@@ -407,13 +337,10 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 	function _buyGD(uint256 _value) internal returns (uint256[] memory) {
 		//buy from uniwasp
 		require(_value > 0, "buy value should be > 0");
-		(uint256 maxFuse, uint256 fuseGDOut) = calcMaxFuseWithPriceImpact(
+		(uint256 maxFuse, uint256 fuseGDOut) = calcMaxFuseWithPriceImpact(_value);
+		(uint256 maxFuseUSDC, uint256 usdcGDOut) = calcMaxFuseUSDCWithPriceImpact(
 			_value
 		);
-		(
-			uint256 maxFuseUSDC,
-			uint256 usdcGDOut
-		) = calcMaxFuseUSDCWithPriceImpact(_value);
 		address[] memory path;
 		if (maxFuse >= maxFuseUSDC) {
 			path = new address[](2);
@@ -471,9 +398,12 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		address[] memory path = new address[](2);
 		path[1] = fUSD;
 		path[0] = uniswap.WETH();
-		uint256[] memory result = uniswap.swapExactETHForTokens{
-			value: maxFuse
-		}((tokenOut * 95) / 100, path, address(this), block.timestamp);
+		uint256[] memory result = uniswap.swapExactETHForTokens{ value: maxFuse }(
+			(tokenOut * 95) / 100,
+			path,
+			address(this),
+			block.timestamp
+		);
 
 		pegSwap.swap(result[1], fUSD, USDC);
 		usedFuse = result[0];

package/contracts/staking/GoodFundManager.sol

@@ -194,10 +194,10 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 			}
 		}
 
-		if (exist && (_isBlackListed || _rewardsPerBlock == 0)) {
+		if (exist && _isBlackListed) {
 			activeContracts[i] = activeContracts[activeContracts.length - 1];
 			activeContracts.pop();
-		} else if (!exist && !(_isBlackListed || _rewardsPerBlock == 0)) {
+		} else if (!exist && !_isBlackListed) {
 			activeContracts.push(_stakingAddress);
 		}
 		emit StakingRewardSet(

package/hardhat.config.ts

@@ -83,7 +83,10 @@ const hhconfig: HardhatUserConfig = {
       accounts: {
         accountsBalance: "10000000000000000000000000"
       },
-      initialDate: "2021-12-01" //required for DAO tests like guardian
+      initialDate: "2021-12-01", //required for DAO tests like guardian
+      forking: process.env.FORK_CHAIN_ID && {
+        url: "https://eth-mainnet.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY
+      }
     },
     test: {
       allowUnlimitedContractSize: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "1.0.30",
+  "version": "1.0.31-beta.0",
   "description": "GoodDollar Protocol",
   "scripts": {
     "build": "scripts/build.sh deploy",

package/scripts/multichain-deploy/v3-fix.ts

@@ -0,0 +1,120 @@
+/***
+ * This script will deploy a fixed goodfundmanager that doenst disable staking contracts if rewards=0
+ * It will also then re submit the staking contracts
+ */
+
+import { network, ethers } from "hardhat";
+
+import {
+  executeViaGuardian,
+  executeViaSafe
+} from "../multichain-deploy/helpers";
+
+import releaser from "../releaser";
+import dao from "../../releases/deployment.json";
+const { name: networkName } = network;
+
+export const deployMainnet = async () => {
+  let [root, ...signers] = await ethers.getSigners();
+
+  let executionMethod = networkName === "localhost" ? "guardians" : "safe";
+
+  const networkKey =
+    networkName === "localhost" ? "production-mainnet" : networkName;
+  let release: { [key: string]: any } = dao[networkKey];
+
+  let safeOwner = new ethers.Wallet(
+    process.env.SAFEOWNER_PRIVATE_KEY || ethers.constants.HashZero,
+    ethers.provider
+  );
+
+  //test with guardians safe on hardhat mainnet fork
+  if (network.name === "localhost") {
+    root = await ethers.getImpersonatedSigner(
+      "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+    );
+    await signers[0].sendTransaction({
+      to: root.address,
+      value: ethers.constants.WeiPerEther
+    });
+  }
+
+  console.log("got signers:", {
+    networkName,
+    networkKey,
+    root: root.address,
+    safeOwner: safeOwner.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  console.log("deploying goodfundmanager implementation");
+  const gfmImpl = await (
+    await ethers.getContractFactory("GoodFundManager")
+  ).deploy();
+
+  const proposalContracts = [
+    release.GoodFundManager, //Fundmanager -> upgrade to new version
+    release.GoodFundManager, //Fundmanager -> set staking rewards compound to 0
+    release.GoodFundManager //Fundmanager -> set staking rewards aave to 0
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "upgradeTo(address)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [gfmImpl.address]), //upgradeTo(address)
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ), //setstakingrewards to 0
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ) //setstakingrewards to 0
+  ];
+
+  if (executionMethod === "safe") {
+    return executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      networkName === "localhost"
+        ? "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+        : release.GuardiansSafe,
+      safeOwner
+    );
+  } else {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await deployMainnet().catch(console.log);
+};
+if (process.argv[1].includes("v3-fix")) main();

package/test/staking/FuseStaking.test.ts

@@ -71,10 +71,8 @@ describe("FuseStakingV3", () => {
       await ethers.getContractFactory("FuseStakingV3")
     ).deploy()) as FuseStakingV3;
 
-    await staking.initialize();
-    await staking.upgrade0();
-    await staking.upgrade1(NULL_ADDRESS, ubiMock.address, uniswap.address);
-    await staking.upgrade2();
+    await staking.initialize(uniswap.address, NULL_ADDRESS);
+    await staking.setUBIScheme(ubiMock.address);
   });
 
   it("should have owner", async () => {

package/test/staking/StakingRewards.test.ts

@@ -641,12 +641,13 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
 
     await advanceBlocks(4);
 
-    const userMintedAndPending = await goodCompoundStaking.getUserMintedAndPending(staker.address);
+    const userMintedAndPending =
+      await goodCompoundStaking.getUserMintedAndPending(staker.address);
     const userMintedReward = userMintedAndPending[0].toString();
     const userPendingReward = userMintedAndPending[1].toString();
     expect(userMintedReward).to.equal("5000");
     expect(userPendingReward).to.equal("2000");
-  
+
     await goodCompoundStaking
       .connect(staker)
       .withdrawStake(stakingAmount, false);
@@ -1430,7 +1431,7 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     expect(data.isBlackListed).to.equal(true);
   });
 
-  it("it should remove staking contract from active staking contracts when it's reward set to zero", async () => {
+  it("it should not remove staking contract from active staking contracts when it's reward set to zero", async () => {
     const simpleStaking1 = await goodCompoundStakingTestFactory.deploy(
       bat.address,
       cBat.address,
@@ -1449,9 +1450,6 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
     const activeContractsCount =
       await goodFundManager.getActiveContractsCount();
-    const lastActiveContractBeforeAdd = await goodFundManager.activeContracts(
-      activeContractsCount.sub(1)
-    );
 
     const simpleStaking = await goodCompoundStakingTestFactory.deploy(
       bat.address,
@@ -1471,9 +1469,9 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     await genericCall(goodFundManager.address, encodedData, avatar, 0);
     const activeContractsCountAfterAdded =
       await goodFundManager.getActiveContractsCount();
-    const lastActiveContractAfterAdd = await goodFundManager.activeContracts(
-      activeContractsCountAfterAdded.sub(1)
-    );
+
+    expect(activeContractsCountAfterAdded).equal(activeContractsCount.add(1));
+
     encodedData = goodFundManager.interface.encodeFunctionData(
       "setStakingReward",
       ["0", simpleStaking.address, 10, 1000, false] // set 10 gd per block
@@ -1485,16 +1483,15 @@ describe("StakingRewards - staking with cDAI mocks and get Rewards in GoodDollar
     const lastActiveContractAfterRemove = await goodFundManager.activeContracts(
       activeContractsCountAfterRemoved.sub(1)
     );
-    expect(lastActiveContractBeforeAdd).to.be.equal(
-      lastActiveContractAfterRemove
-    );
-    expect(lastActiveContractAfterAdd).to.be.equal(simpleStaking.address);
-    expect(activeContractsCountAfterAdded).to.be.gt(activeContractsCount);
-    expect(activeContractsCountAfterAdded).to.be.gt(
+
+    expect(lastActiveContractAfterRemove).to.be.equal(simpleStaking.address);
+    expect(activeContractsCountAfterAdded).to.be.eq(
       activeContractsCountAfterRemoved
     );
-    expect(activeContractsCount).to.be.equal(activeContractsCountAfterRemoved);
+
+    expect(activeContractsCount).to.be.lt(activeContractsCountAfterRemoved);
   });
+
   it("it should distribute rewards correctly when there is multiple stakers", async () => {
     const simpleStaking1 = await goodCompoundStakingTestFactory.deploy(
       bat.address,