@gooddollar/goodprotocol 2.2.0-beta.1 → 2.2.0

package/contracts/invite/InvitesV2.sol

@@ -7,8 +7,9 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "../Interfaces.sol";
 import "../utils/NameService.sol";
 import "../utils/DAOUpgradeableContract.sol";
+import "../ubi/UBISchemeV2.sol";
 
-// import "hardhat/console.sol";
+import "hardhat/console.sol";
 
 /**
  * @title InvitesV1 contract that handles invites with pre allocated bounty pool
@@ -59,6 +60,9 @@ contract InvitesV2 is DAOUpgradeableContract {
 
 	bytes32 private campaignCode;
 
+	uint8 public minimumClaims; // minimum claims required for invitee to be eligible for bounty
+	uint8 public minimumDays; // minimum days since join required for invitee to be eligible for bounty
+
 	event InviteeJoined(address indexed inviter, address indexed invitee);
 	event InviterBounty(
 		address indexed inviter,
@@ -173,8 +177,21 @@ contract InvitesV2 is DAOUpgradeableContract {
 
 	function canCollectBountyFor(address _invitee) public view returns (bool) {
 		address invitedBy = users[_invitee].invitedBy;
+		bool hasMinClaims = true;
+
+		try
+			UBISchemeV2(nameService.getAddress("UBISCHEME")).totalClaimsPerUser(
+				_invitee
+			)
+		returns (uint256 claims) {
+			hasMinClaims = claims >= minimumClaims;
+		} catch {
+			hasMinClaims = true; // if call fails for any reason we dont want to block bounty collection
+		}
 
 		return
+			block.timestamp >= users[_invitee].joinedAt + minimumDays * 1 days && // wait at least 7 day before allowing bounty collection
+			hasMinClaims && // invitee needs to have made at least 3 claim
 			users[_invitee].bountyAtJoin > 0 &&
 			!users[_invitee].bountyPaid &&
 			getIdentity().isWhitelisted(_invitee) &&
@@ -248,14 +265,6 @@ contract InvitesV2 is DAOUpgradeableContract {
 			uint256 joinedAt = users[_invitee].joinedAt;
 			Level memory level = levels[users[invitedBy].level];
 
-			//hardcoded for users invited before the bountyAtJoin change
-			if (bountyToPay == 0) {
-				uint precision = 10 ** goodDollar.decimals();
-				bountyToPay = joinedAt > 1687878272
-					? 1000 * precision
-					: 500 * precision;
-			}
-
 			// if inviter level is now higher than when invitee joined or the base level has changed
 			// we give level bounty if it is higher otherwise the original bounty at the time the user registered
 
@@ -338,6 +347,12 @@ contract InvitesV2 is DAOUpgradeableContract {
 		codeToUser[campaignCode] = address(this);
 	}
 
+	/// @notice set minimum claims and days required for invitee to be eligible for reward
+	function setMinimums(uint8 _minClaims, uint8 _minDays) public ownerOrAvatar {
+		minimumClaims = _minClaims;
+		minimumDays = _minDays;
+	}
+
 	function end() public ownerOrAvatar isActive {
 		uint256 gdBalance = goodDollar.balanceOf(address(this));
 		goodDollar.transfer(msg.sender, gdBalance);
@@ -345,6 +360,10 @@ contract InvitesV2 is DAOUpgradeableContract {
 		active = false;
 	}
 
+	function setOwner(address _owner) public ownerOrAvatar {
+		owner = _owner;
+	}
+
 	/// @notice helper function to get current chain id
 	/// @return chainId id
 	function _chainId() internal view returns (uint256 chainId) {
@@ -363,8 +382,9 @@ contract InvitesV2 is DAOUpgradeableContract {
 	 * 2.1 prevent multichain claims
 	 * 2.2 record bounty at join time
 	 * 2.3 support campaignCode
+	 * 2.4 minimum claims and days requirement for bounty eligibility
 	 */
 	function version() public pure returns (string memory) {
-		return "2.3";
+		return "2.4";
 	}
 }

package/contracts/reserve/GenericDistributionHelper.sol

@@ -298,6 +298,8 @@ contract GenericDistributionHelper is
 		uint256 amountToSell,
 		uint256 minReceived
 	) internal returns (uint256 nativeBought) {
+		if (amountToSell == 0) return 0;
+
 		address[] memory gdPools = STATIC_ORACLE.getAllPoolsForPair(
 			reserveToken,
 			address(nativeToken())
@@ -306,17 +308,35 @@ contract GenericDistributionHelper is
 			reserveToken,
 			gasToken
 		);
+
+		if (gdPools.length == 0 || gasPools.length == 0) {
+			emit BuyNativeFailed("no pools available", amountToSell, minReceived);
+			return 0;
+		}
+
+		// initialize with first pool and track max liquidity
 		uint24 gasFee = IUniswapV3Pool(gasPools[0]).fee();
-		uint24 gdFee = IUniswapV3Pool(gdPools[0]).fee();
-		for (uint i = 1; i < gasPools.length; i++) {
-			uint24 fee = IUniswapV3Pool(gasPools[i]).fee();
-			gasFee = gasFee < fee ? gasFee : fee;
+		uint256 maxGasBalance = ERC20(gasToken).balanceOf(gasPools[0]);
+		for (uint256 i = 1; i < gasPools.length; i++) {
+			uint256 balance = ERC20(gasToken).balanceOf(gasPools[i]);
+			if (balance > maxGasBalance) {
+				maxGasBalance = balance;
+				gasFee = IUniswapV3Pool(gasPools[i]).fee();
+			}
 		}
-		for (uint i = 1; i < gdPools.length; i++) {
-			uint24 fee = IUniswapV3Pool(gdPools[i]).fee();
-			gdFee = gdFee < fee ? gdFee : fee;
+
+		uint24 gdFee = IUniswapV3Pool(gdPools[0]).fee();
+		uint256 maxStableBalance = ERC20(reserveToken).balanceOf(gdPools[0]);
+		for (uint256 i = 1; i < gdPools.length; i++) {
+			uint256 balance = ERC20(reserveToken).balanceOf(gdPools[i]);
+			if (balance > maxStableBalance) {
+				maxStableBalance = balance;
+				gdFee = IUniswapV3Pool(gdPools[i]).fee();
+			}
 		}
+
 		ERC20(nativeToken()).approve(address(ROUTER), amountToSell);
+
 		uint256 amountOutMinimum = (minReceived * (100 - feeSettings.maxSlippage)) /
 			100; // 5% slippage
 		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
@@ -331,11 +351,19 @@ contract GenericDistributionHelper is
 			amountIn: amountToSell,
 			amountOutMinimum: amountOutMinimum
 		});
+
 		try ROUTER.exactInput(params) returns (uint256 amountOut) {
 			return amountOut;
 		} catch Error(string memory reason) {
 			emit BuyNativeFailed(reason, amountToSell, amountOutMinimum);
 			return 0;
+		} catch {
+			emit BuyNativeFailed(
+				"swap reverted without reason",
+				amountToSell,
+				amountOutMinimum
+			);
+			return 0;
 		}
 	}
 }

package/contracts/ubi/UBISchemeV2.sol

@@ -386,7 +386,14 @@ contract UBISchemeV2 is DAOUpgradeableContract {
 		if (
 			currentDay == (block.timestamp - periodStart) / (1 days) && dailyUbi > 0
 		) {
-			return hasClaimed(_member) ? 0 : dailyUbi;
+			return
+				hasClaimed(
+					IIdentityV2(nameService.getAddress("IDENTITY")).getWhitelistedRoot(
+						_member
+					)
+				)
+					? 0
+					: dailyUbi;
 		}
 		return estimateNextDailyUBI();
 	}

package/contracts/utils/UpdateReserveRatio.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "../utils/NameService.sol";
+import "../Interfaces.sol";
+import "../DAOStackInterfaces.sol";
+import "../MentoInterfaces.sol";
+
+import "hardhat/console.sol";
+
+interface MentoExchange {
+	function reserve() external view returns (address);
+}
+
+/**
+ * @notice set the new reserve ratio on Celo for xdc reserve deploy
+ */
+contract UpdateReserveRatio {
+	address owner;
+
+	constructor(address _owner) {
+		owner = _owner;
+	}
+
+	function upgrade(
+		Controller _controller,
+		address _mentoExchange,
+		bytes32 _exchangeId,
+		uint32 _reserveRatio,
+		uint256 _verifyCurrentSupply,
+		uint256 _newTotalSupply
+	) external {
+		require(msg.sender == owner, "only owner can call this");
+		address avatar = _controller.avatar();
+		//verify that the total supply the new reserve ratio was based on still applies
+		require(
+			ERC20(Avatar(avatar).nativeToken()).totalSupply() == _verifyCurrentSupply,
+			"total supply mismatch"
+		);
+
+		if (block.chainid == 42220) {
+			IBancorExchangeProvider.PoolExchange
+				memory _exchange = IBancorExchangeProvider(_mentoExchange)
+					.getPoolExchange(_exchangeId);
+
+			_exchange.reserveRatio = _reserveRatio;
+			_exchange.tokenSupply = _newTotalSupply;
+
+			(bool ok, bytes memory result) = _controller.genericCall(
+				address(_mentoExchange),
+				abi.encodeCall(
+					IBancorExchangeProvider.updateExchange,
+					(_exchangeId, _exchange)
+				),
+				address(avatar),
+				0
+			);
+
+			require(ok, "update failed");
+			console.log("update done");
+			bool updated = abi.decode(result, (bool));
+			require(updated, "not updated");
+		} else {
+			IBancorExchangeProvider.PoolExchange memory _exchange;
+
+			_exchange.reserveRatio = _reserveRatio;
+			_exchange.tokenSupply = _newTotalSupply;
+			_exchange.reserveAsset = 0xfA2958CB79b0491CC627c1557F441eF849Ca8eb1; //usdc on xdc
+			_exchange.tokenAddress = Avatar(avatar).nativeToken();
+			_exchange.reserveBalance = 200000 * 1e6; // 200k USDC on xdc
+			_exchange.exitContribution = 10000000; //10%
+
+			(bool ok, bytes memory result) = _controller.genericCall(
+				address(_mentoExchange),
+				abi.encodeCall(IBancorExchangeProvider.createExchange, (_exchange)),
+				address(avatar),
+				0
+			);
+
+			require(ok, "create failed");
+			console.log("create done");
+			bytes32 created = abi.decode(result, (bytes32));
+			console.logBytes32(created);
+			require(created != bytes32(0), "not created");
+		}
+		owner = address(0); //mark as run;
+		// prevent executing again
+		require(_controller.unregisterSelf(avatar), "unregistering failed");
+	}
+}
+
+contract CreateReserveExchange {
+	address owner;
+
+	constructor(address _owner) {
+		owner = _owner;
+	}
+
+	function upgrade(
+		Controller _controller,
+		address _mentoExchange,
+		IBancorExchangeProvider.PoolExchange memory _exchange
+	) external {
+		require(msg.sender == owner, "only owner can call this");
+		address avatar = _controller.avatar();
+
+		(bool ok, ) = _controller.genericCall(
+			address(_mentoExchange),
+			abi.encodeCall(IBancorExchangeProvider.createExchange, _exchange),
+			address(avatar),
+			0
+		);
+
+		// console.log("createExchange %s", ok);
+		require(ok, "createExchange failed");
+
+		owner = address(0); //mark as run;
+		// prevent executing again
+		require(_controller.unregisterSelf(avatar), "unregistering failed");
+	}
+}

package/hardhat.config.ts

@@ -29,7 +29,7 @@ envEnc.config();
 config();
 
 const mnemonic = process.env.MNEMONIC || "test test test test test test test test test test test junk";
-const deployerPrivateKey = process.env.DEV_KEY || ethers.utils.hexZeroPad("0x11", 32);
+const deployerPrivateKey = process.env.PRIVATE_KEY || ethers.utils.hexZeroPad("0x11", 32);
 const infura_api = process.env.INFURA_API;
 const alchemy_key = process.env.ALCHEMY_KEY;
 const etherscan_key = process.env.ETHERSCAN_KEY;
@@ -41,7 +41,7 @@ const MAINNET_URL = "https://mainnet.infura.io/v3/" + infura_api;
 
 const xdc = {
   accounts: { mnemonic },
-  url: "https://rpc.ankr.com/xdc",
+  url: "https://rpc.xdc.org",
   gas: 3000000,
   gasPrice: 12.5e9,
   chainId: 50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "2.2.0-beta.1",
+  "version": "2.2.0",
   "description": "GoodDollar Protocol",
   "engines": {
     "node": ">=16.x"
@@ -128,8 +128,6 @@
     "press-any-key": "^0.1.1",
     "prompt": "^1.3.0",
     "regenerator-runtime": "^0.13.9",
-    "sharp": "^0.34.5",
-    "sharp-phash": "^2.2.0",
     "solhint": "*",
     "solidity-coverage": "^0.8.4",
     "truffle": "^5.11.5",

package/releases/deploy-settings.json

@@ -311,6 +311,9 @@
   "production-xdc": {
     "gasPrice": 12.5e9,
     "superfluidHost": "0x0000000000000000000000000000000000000000",
+    "reserve": {
+      "gasToken": "0x951857744785e80e2de051c32ee7b25f9c458c42"
+    },
     "ubi": {
       "maxInactiveDays": 14,
       "minActiveUsers": 30000

package/releases/deployment.json

@@ -568,12 +568,12 @@
   "development-mainnet": { "networkId": 1 },
   "test": {
     "ProxyFactory": "0xCd7c00Ac6dc51e8dCc773971Ac9221cC582F3b1b",
-    "NameService": "0x421eF26e50B0a9B22BEbEb034ef62409E4982eAf",
-    "GReputation": "0x89d8aBD52beEE7eE9536083CaF89AE0C5CE00C99",
-    "CompoundVotingMachine": "0x2a4EF648d211487260b656D9CE8d05e9E86354d1",
-    "ClaimersDistribution": "0x36544e42e372d1188792088C271dd8076794B217",
+    "NameService": "0x79a8656f72F7F3F1C658718b5C9Fe808e2D6Ab39",
+    "GReputation": "0xFde4C515250562688C4E84cBe82Cf9af9F5d46Ae",
+    "CompoundVotingMachine": "0xd5e9cE20E33818a30e3626aAB3D1db9f09Ea8181",
+    "ClaimersDistribution": "0xde7FB3BA189eC8Fb278f0B8f1F005526eB489254",
     "GovernanceStaking": "0xf5C3953Ae4639806fcbCC3196f71dd81B0da4348",
-    "UBIScheme": "0x160554Da2f84105E879f415917bdd68DEEC17BB4",
+    "UBIScheme": "0x8f298403715F62f8958Aa1cd1cfDE6cE9B47319e",
     "ProtocolUpgradeFuse": "0xDDa0648FA8c9cD593416EC37089C2a2E6060B45c",
     "network": "test",
     "networkId": 4447,
@@ -592,23 +592,23 @@
   },
   "test-mainnet": {
     "ProxyFactory": "0x70E5370b8981Abc6e14C91F4AcE823954EFC8eA3",
-    "NameService": "0x0708e4f1f9F16b185B87f85aCB934A6F13Ea4060",
-    "GReputation": "0x274d1a996Af9E406fEa1E76321b68581cb7C03AC",
-    "CompoundVotingMachine": "0x9F34160Fa8c1b296b67599c601249AEd26ef518c",
-    "GoodMarketMaker": "0x6B7b15dBfDe6B025428106f026Ea6146b2CF1D38",
-    "GoodReserveCDai": "0x77921dD809a08E8a022eE049fF04A666d6842668",
-    "ExchangeHelper": "0x1dc21E2f463E87CA0fEc04B90C200727fc407E1E",
-    "GoodFundManager": "0x17e235C296BBc62CD88c37696aC99a657Ae503b0",
-    "StakersDistribution": "0x07Eb78E143EFc9cc2b24d22c293b18b7e058f610",
+    "NameService": "0xA1de3421535CF40A6B341F165F1671878C48f1de",
+    "GReputation": "0x81099494e5325Bd6237EB67cA116514137E10Ba6",
+    "CompoundVotingMachine": "0xB7D090220BA506CCe0D2d0de3005893534Dc5f46",
+    "GoodMarketMaker": "0x31a7e4029bDe7eDd07b497B850474b0c65bd6D3f",
+    "GoodReserveCDai": "0x879892FbE36f7499Bea8744a01550190c078A68E",
+    "ExchangeHelper": "0x4fE75c387D27724d0a27b78fE6229E0f1385Db48",
+    "GoodFundManager": "0x1D98610e8702C66479565F73EBF3289Cff607e95",
+    "StakersDistribution": "0xde979777C259a24b623b7783be44F5810FC54B51",
     "ProtocolUpgrade": "0xbe18A1B61ceaF59aEB6A9bC81AB4FB87D56Ba167",
     "UniswapV2SwapHelper": "0x25C0a2F0A077F537Bd11897F04946794c2f6f1Ef",
     "CompoundStakingFactory": "0x01cf58e264d7578D4C67022c58A24CbC4C4a304E",
     "AaveStakingFactory": "0xd038A2EE73b64F30d65802Ad188F27921656f28F",
     "StakingContracts": [
-      ["0xBAb9F0Bfaf3FbC4041e23F50f17A5dd8E52D5866", 13888],
-      ["0xEdB0C48Ab3d332B5FBA86c83162C734F2acCf8F1", "6944"]
+      ["0x31553691c8225B730914Ab2FC6b7EC6dbbBf52cd", 13888],
+      ["0xbfaeAb1e80726804Dcf46653961A538095cCC6AD", "6944"]
     ],
-    "DonationsStaking": "0xbE811FF6E7e40Db414ecFA0d18946Df83C0a1ed8",
+    "DonationsStaking": "0x1935252558E7FE0AF6cDB6897bb5c6dB81620577",
     "network": "test-mainnet",
     "networkId": 4447,
     "ForeignBridge": "0x7B4f352Cd40114f12e82fC675b5BA8C7582FC513",
@@ -673,6 +673,7 @@
     "ProxyFactory": "0x5BE34022c26FA03a8d6926314a42414c7ca2dF51",
     "GuardiansSafe": "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec",
     "CUSD": "0xfA2958CB79b0491CC627c1557F441eF849Ca8eb1",
+    "USDC": "0xfA2958CB79b0491CC627c1557F441eF849Ca8eb1",
     "ReserveToken": "0xfA2958CB79b0491CC627c1557F441eF849Ca8eb1",
     "Identity": "0x27a4a02C9ed591E1a86e2e5D05870292c34622C9",
     "DAOCreator": "0xa2B9993D198904e4bdCE48379FDff65405607F42",
@@ -686,6 +687,17 @@
     "Invites": "0x6bd698566632bf2e81e2278f1656CB24aAF06D2e",
     "UBIScheme": "0x22867567E2D80f2049200E25C6F31CB6Ec2F0faf",
     "MpbBridge": "0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5",
-    "BulkWhitelist": "0xe8861A20452Db53dF685F1d9e6B7017de3DB0E46"
+    "BulkWhitelist": "0xe8861A20452Db53dF685F1d9e6B7017de3DB0E46",
+    "UniswapV3Router": "0x3b9edecc4286ba33ea6e27119c2a4db99829839d",
+    "UniswapV3RouterOfficial": "0xaa52bB8110fE38D0d2d2AF0B85C3A3eE622CA455",
+    "StaticOracle": "0x725244458f011551Dde1104c9728746EEBEA19f9",
+    "WXDC": "0x951857744785e80e2de051c32ee7b25f9c458c42",
+    "MentoProxyAdmin": "0x8471406C3Bff67Cc6538481C8550364bda6Ca691",
+    "MentoExchangeProvider": "0x2fFBB49055d487DdBBb0C052Cd7c2a02A7971e41",
+    "MentoExpansionController": "0x5557E9dEF86ad6564462741a7A3f3679C1223f5d",
+    "MentoReserve": "0x94A3240f484A04F5e3d524f528d02694c109463b",
+    "MentoBroker": "0x88de45906D4F5a57315c133620cfa484cB297541",
+    "DistributionHelper": "0xB8A0d4b97327a0B6dD0705dC290AE26aA38a7d2b",
+    "USDCEXchangeId": "0xf8d028730f58a008390c265fca425bb912e4c7efa370d4cef756a06f5029acd2"
   }
 }

package/test/helpers.ts

@@ -459,7 +459,10 @@ export const deployUBI = async (deployedDAO, withFirstClaim = true) => {
 
   await genericCall(gd, encoded);
 
-  console.log("set firstclaim,ubischeme as scheme and starting...");
+  console.log("set firstclaim,ubischeme as scheme and starting...", {
+    ubischeme: ubiScheme.address,
+    firstClaim: firstClaim.address
+  });
   await setSchemes([firstClaim.address, ubiScheme.address]);
 
   if (withFirstClaim) {

package/test/identity/IdentityV4.test.ts

@@ -1,5 +1,5 @@
 import hre, { ethers, upgrades } from "hardhat";
-import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { loadFixture, time } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
 import { IGoodDollar, IIdentity, IdentityV3, IdentityV4 } from "../../types";
 import { createDAO, increaseTime, advanceBlocks } from "../helpers";
@@ -107,11 +107,14 @@ describe("IdentityV4", () => {
   //   await expect(identity.connect(signers[2]).setAuthenticationPeriod(10)).reverted;
   // });
 
-  // it("should let owner set auth period", async () => {
-  //   const encoded = identity.interface.encodeFunctionData("setAuthenticationPeriod", [10]);
-  //   await genericCall(identity.address, encoded);
-  //   expect(await identity.authenticationPeriod()).eq(10);
-  // });
+  it("should retun the last reverify period as authenticationPeriod", async () => {
+    await expect(identity.setReverifyDaysOptions([1, 7, 111])).not.reverted;
+    expect(await identity.authenticationPeriod()).eq(111);
+  });
+
+  it("should enforce order in reverify days options", async () => {
+    await expect(identity.setReverifyDaysOptions([1, 111, 7])).reverted;
+  });
 
   it("should revert when non admin tries to pause", async () => {
     await expect(identity.connect(signers[2]).pause(true)).reverted;
@@ -411,6 +414,10 @@ describe("IdentityV4", () => {
   });
 
   it("should follow reverify schedule and cycle authCount", async () => {
+    // set timestamp to a fixed point (now) to avoid exclusion of old users
+    // due to initialDate set in hardhat config
+    const block = await ethers.provider.getBlock("latest");
+    await time.setNextBlockTimestamp(Number((Date.now() / 1000).toFixed(0)));
     await expect(identity.setReverifyDaysOptions([1, 7, 180])).not.reverted;
 
     const u = signers[12];
@@ -450,5 +457,8 @@ describe("IdentityV4", () => {
     expect(await identity.isWhitelisted(u.address)).to.be.true;
     // cleanup (remove whitelisted) to avoid affecting other tests
     await identity.removeWhitelisted(u.address);
+
+    // restore time to normal flow
+    time.setNextBlockTimestamp(block.timestamp);
   });
 });

package/test/invite/InvitesV2.test.ts

@@ -1,7 +1,7 @@
 import hre, { ethers, upgrades } from "hardhat";
-import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { loadFixture, time } from "@nomicfoundation/hardhat-network-helpers";
 import { expect } from "chai";
-import { InvitesV2, IGoodDollar, IIdentity, IdentityV2 } from "../../types";
+import { InvitesV2, IGoodDollar, IIdentity, IdentityV2, UBISchemeV2 } from "../../types";
 import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
 import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
 
@@ -15,6 +15,8 @@ describe("InvitesV2", () => {
 
   let avatar, gd: IGoodDollar, Controller, id: IdentityV2, setDAOAddress, setSchemes;
 
+  let ubi: UBISchemeV2;
+
   const initialState = async () => {};
   before(async () => {
     [founder, inviter1, inviter2, invitee1, invitee2, invitee3, invitee4, invitee5, invitee6, invitee7, invitee8] =
@@ -40,10 +42,10 @@ describe("InvitesV2", () => {
     invites = (await upgrades.deployProxy(InvitesV2, [nameService.address, 500, founder.address], {
       kind: "uups"
     })) as InvitesV2;
-
+    ubi = await upgrades.deployProxy(await ethers.getContractFactory("UBISchemeV2"), [nameService.address, 1000]);
+    await setDAOAddress("UBISCHEME", ubi.address);
     gd = (await ethers.getContractAt("IGoodDollar", gooddollar, founder)) as IGoodDollar;
     id = (await ethers.getContractAt("IdentityV3", identity, founder)) as IdentityV2;
-
     await gd["mint(address,uint256)"](invites.address, BN.from(5000));
     await loadFixture(initialState);
     // await gd.transfer(invites.address, BN.from(5000));
@@ -69,7 +71,7 @@ describe("InvitesV2", () => {
   it("should have version", async () => {
     expect(await invites.active()).to.be.true;
     const version = await invites.version();
-    expect(version).to.be.equal("2.3");
+    expect(version).to.be.equal("2.4");
   });
 
   it("should let anyone join", async () => {
@@ -410,4 +412,47 @@ describe("InvitesV2", () => {
     await invites.end();
     expect(await gd.balanceOf(invites.address).then(_ => _.toNumber())).to.be.eq(0);
   });
+
+  describe("minimums", () => {
+    it("should not allow bounty collection before minimum days", async () => {
+      await loadFixture(initialState);
+      await invites.setMinimums(0, 1);
+      await invites.setCampaignCode(ethers.utils.formatBytes32String("test"));
+
+      const tx = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.utils.formatBytes32String("test"));
+      const { events } = await tx.wait();
+      const bountyEvent = events.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent).undefined;
+
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      expect(await invites.canCollectBountyFor(invitee1.address)).to.be.false;
+      await time.increase(1 * 24 * 3600); // increase time by 2 days
+      expect(await invites.canCollectBountyFor(invitee1.address)).to.be.true;
+    });
+
+    it("should not allow bounty collection before minimum claims", async () => {
+      await loadFixture(initialState);
+      await invites.setMinimums(1, 0);
+      await invites.setCampaignCode(ethers.utils.formatBytes32String("test"));
+
+      const tx = await invites
+        .connect(invitee1)
+        .join(ethers.utils.hexZeroPad(invitee1.address, 32), ethers.utils.formatBytes32String("test"));
+      const { events } = await tx.wait();
+      const bountyEvent = events.find(_ => _.event === "InviterBounty");
+      expect(bountyEvent).undefined;
+
+      await id.addWhitelistedWithDID(invitee1.address, Math.random() + "").catch(e => e);
+
+      expect(await invites.canCollectBountyFor(invitee1.address)).to.be.false;
+      await ubi
+        .connect(invitee1)
+        .claim()
+        .then(_ => _.wait());
+      expect(await invites.canCollectBountyFor(invitee1.address)).to.be.true;
+    });
+  });
 });