@gooddollar/goodprotocol 1.0.29-beta.1 → 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/ubi/UBIScheme.sol

@@ -71,7 +71,8 @@ contract UBIScheme is DAOUpgradeableContract {
 	//dont use first claim, and give ubi as usual
 	bool public useFirstClaimPool;
 
-	uint256 public defaultDailyUbi;
+	//minimum amount of users to divide the pool for, renamed from defaultDailyUbi
+	uint256 public minActiveUsers;
 
 	// A pool of GD to give to activated users,
 	// since they will enter the UBI pool
@@ -99,14 +100,14 @@ contract UBIScheme is DAOUpgradeableContract {
 	// Total claims per user stat
 	mapping(address => uint256) public totalClaimsPerUser;
 
+	bool public paused;
+
 	// Emits when a withdraw has been succeded
 	event WithdrawFromDao(uint256 prevBalance, uint256 newBalance);
 
 	// Emits when a user is activated
 	event ActivatedUser(address indexed account);
 
-	bool public paused;
-
 	// Emits when a fish has been succeded
 	event InactiveUserFished(
 		address indexed caller,
@@ -157,8 +158,8 @@ contract UBIScheme is DAOUpgradeableContract {
 		iterationGasLimit = 150000;
 		periodStart = (block.timestamp / (1 days)) * 1 days + 12 hours; //set start time to GMT noon
 		startOfCycle = periodStart;
-		useFirstClaimPool = true;
-		defaultDailyUbi = 5000;
+		useFirstClaimPool = address(_firstClaimPool) != address(0);
+		minActiveUsers = 1000;
 	}
 
 	function setUseFirstClaimPool(bool _use) public {
@@ -285,17 +286,20 @@ contract UBIScheme is DAOUpgradeableContract {
 			Funds storage funds = dailyUBIHistory[currentDay];
 			funds.hasWithdrawn = shouldWithdrawFromDAO;
 			funds.openAmount = currentBalance;
-			if (activeUsersCount > 0) {
-				dailyUbi = dailyCyclePool / activeUsersCount;
-			} else if (useFirstClaimPool == false) {
-				dailyUbi = defaultDailyUbi;
-			}
+			dailyUbi = dailyCyclePool / max(activeUsersCount, minActiveUsers);
+			//update minActiveUsers as claimers grow
+			minActiveUsers = max(activeUsersCount / 2, minActiveUsers);
+
 			emit UBICalculated(currentDay, dailyUbi, block.number);
 		}
 
 		return dailyUbi;
 	}
 
+	function max(uint256 a, uint256 b) private pure returns (uint256) {
+		return a >= b ? a : b;
+	}
+
 	/**
 	 *@dev Sets the currentDay variable to amount of days
 	 * since start of contract.
@@ -356,12 +360,14 @@ contract UBIScheme is DAOUpgradeableContract {
 	 * and emits an event in case of claimed.
 	 * In case that `isFirstTime` is true, it awards the user.
 	 * @param _account the account which recieves the funds
+	 * @param _target the recipient of funds
 	 * @param _amount the amount to transfer
 	 * @param _isClaimed true for claimed
 	 * @param _isFirstTime true for new user or fished user
 	 */
 	function _transferTokens(
 		address _account,
+		address _target,
 		uint256 _amount,
 		bool _isClaimed,
 		bool _isFirstTime
@@ -377,7 +383,7 @@ contract UBIScheme is DAOUpgradeableContract {
 
 		// awards a new user or a fished user
 		if (_isFirstTime) {
-			uint256 awardAmount = firstClaimPool.awardUser(_account);
+			uint256 awardAmount = firstClaimPool.awardUser(_target);
 			claimDay[currentDay].claimAmount += awardAmount;
 			emit UBIClaimed(_account, awardAmount);
 		} else {
@@ -386,7 +392,7 @@ contract UBIScheme is DAOUpgradeableContract {
 				emit UBIClaimed(_account, _amount);
 			}
 			IGoodDollar token = nativeToken();
-			require(token.transfer(_account, _amount), "claim transfer failed");
+			require(token.transfer(_target, _amount), "claim transfer failed");
 		}
 	}
 
@@ -403,11 +409,9 @@ contract UBIScheme is DAOUpgradeableContract {
 		{
 			_dailyCyclePool = currentBalance / cycleLength;
 		}
-		if (activeUsersCount > 0) {
-			_dailyUbi = _dailyCyclePool / activeUsersCount;
-		} else if (useFirstClaimPool == false) {
-			_dailyUbi = defaultDailyUbi;
-		}
+
+		_dailyUbi = _dailyCyclePool / max(activeUsersCount, minActiveUsers);
+
 		return _dailyUbi;
 	}
 
@@ -447,9 +451,10 @@ contract UBIScheme is DAOUpgradeableContract {
 	 * calculats the amount the account can claims, and transfers the amount to the account.
 	 * Emits the address of account and amount claimed.
 	 * @param _account The claimer account
+	 * @param _target recipient of funds
 	 * @return A bool indicating if UBI was claimed
 	 */
-	function _claim(address _account) internal returns (bool) {
+	function _claim(address _account, address _target) internal returns (bool) {
 		// calculats the formula up today ie on day 0 there are no active users, on day 1 any user
 		// (new or active) will trigger the calculation with the active users count of the day before
 		// and so on. the new or inactive users that will become active today, will not take into account
@@ -462,16 +467,16 @@ contract UBIScheme is DAOUpgradeableContract {
 			!fishedUsersAddresses[_account] &&
 			!hasClaimed(_account)
 		) {
-			_transferTokens(_account, newDistribution, true, false);
+			_transferTokens(_account, _target, newDistribution, true, false);
 			return true;
 		} else if (!isNotNewUser(_account) || fishedUsersAddresses[_account]) {
 			// a unregistered or fished user
 			activeUsersCount += 1;
 			fishedUsersAddresses[_account] = false;
 			if (useFirstClaimPool) {
-				_transferTokens(_account, 0, false, true);
+				_transferTokens(_account, _target, 0, false, true);
 			} else {
-				_transferTokens(_account, newDistribution, true, false);
+				_transferTokens(_account, _target, newDistribution, true, false);
 			}
 			emit ActivatedUser(_account);
 			return true;
@@ -486,14 +491,13 @@ contract UBIScheme is DAOUpgradeableContract {
 	 * @return A bool indicating if UBI was claimed
 	 */
 	function claim() public requireStarted returns (bool) {
-		require(
-			IIdentity(nameService.getAddress("IDENTITY")).isWhitelisted(msg.sender),
-			"UBIScheme: not whitelisted"
-		);
-		bool didClaim = _claim(msg.sender);
+		address whitelistedRoot = IIdentityV2(nameService.getAddress("IDENTITY"))
+			.getWhitelistedRoot(msg.sender);
+		require(whitelistedRoot != address(0), "UBIScheme: not whitelisted");
+		bool didClaim = _claim(whitelistedRoot, msg.sender);
 		address claimerDistribution = nameService.getAddress("GDAO_CLAIMERS");
 		if (didClaim && claimerDistribution != address(0)) {
-			ClaimersDistribution(claimerDistribution).updateClaim(msg.sender);
+			ClaimersDistribution(claimerDistribution).updateClaim(whitelistedRoot);
 		}
 		return didClaim;
 	}
@@ -524,7 +528,7 @@ contract UBIScheme is DAOUpgradeableContract {
 		if (activeUsersCount > 0) {
 			activeUsersCount -= 1;
 		}
-		_transferTokens(msg.sender, newDistribution, false, false);
+		_transferTokens(msg.sender, msg.sender, newDistribution, false, false);
 		emit InactiveUserFished(msg.sender, _account, newDistribution);
 		return true;
 	}
@@ -572,18 +576,19 @@ contract UBIScheme is DAOUpgradeableContract {
 		paused = _pause;
 	}
 
-	function upgrade() public {
-		_onlyAvatar();
-		paused = true;
-		activeUsersCount = 50000; //estimated
-		dailyUbi = 0; //required so distributionformula will trigger
-		cycleLength = 30;
-		currentCycleLength = 0; //this will trigger a new cycle calculation in distribution formula
-		startOfCycle = block.timestamp - 91 days; //this will trigger a new calculation in distributionFormula
-		periodStart = 1646136000;
-		distributionFormula();
-		emit CycleLengthSet(cycleLength);
-	}
+	// function upgrade() public {
+	// 	_onlyAvatar();
+	// 	paused = true;
+	// 	activeUsersCount = 50000; //estimated
+	// 	dailyUbi = 0; //required so distributionformula will trigger
+	// 	cycleLength = 30;
+	// 	currentCycleLength = 0; //this will trigger a new cycle calculation in distribution formula
+	// 	startOfCycle = block.timestamp - 91 days; //this will trigger a new calculation in distributionFormula
+	// 	periodStart = 1646136000;
+	// 	maxDailyUBI = 50000;
+	// 	distributionFormula();
+	// 	emit CycleLengthSet(cycleLength);
+	// }
 
 	function setActiveUserCount(uint256 _activeUserCount) public {
 		_onlyAvatar();

package/contracts/utils/AdminWallet.sol

@@ -4,10 +4,10 @@ pragma solidity >=0.8.0;
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 
 import "../Interfaces.sol";
+import "../utils/NameService.sol";
 
 /* @title Admin wallet contract allowing whitelisting and topping up of
  * addresses
@@ -15,7 +15,6 @@ import "../Interfaces.sol";
 contract AdminWallet is
 	Initializable,
 	UUPSUpgradeable,
-	OwnableUpgradeable,
 	AccessControlUpgradeable
 {
 	bytes32 public constant WALLET_ADMIN_ROLE = keccak256("WALLET_ADMIN_ROLE");
@@ -28,10 +27,13 @@ contract AdminWallet is
 	uint256 public toppingTimes;
 	uint256 public gasPrice;
 
-	IIdentity public identity;
+	NameService public nameService;
 
 	mapping(uint256 => mapping(address => uint256)) toppings;
 
+	uint64 public maxDailyNewWallets;
+	uint64 public day;
+
 	event AdminsAdded(address payable[] indexed admins);
 	event AdminsRemoved(address[] indexed admins);
 	event WalletTopped(address indexed user, uint256 amount);
@@ -47,17 +49,29 @@ contract AdminWallet is
 	 */
 	function initialize(
 		address payable[] memory _admins,
+		NameService _ns,
 		address _owner,
-		IIdentity _identity
+		uint256 _gasPrice
 	) public initializer {
 		__AccessControl_init_unchained();
-		__Ownable_init_unchained();
 		_setupRole(DEFAULT_ADMIN_ROLE, _owner);
-		_setDefaults(600000, 9e6, 3, 1e10);
-		identity = _identity;
+		_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+
+		_setDefaults(600000, 9e6, 3, _gasPrice);
+		nameService = _ns;
 		if (_admins.length > 0) {
 			addAdmins(_admins);
 		}
+		if (msg.sender != _owner) revokeRole(DEFAULT_ADMIN_ROLE, msg.sender);
+	}
+
+	modifier onlyOwner() {
+		require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not owner");
+		_;
+	}
+
+	function getIdentity() public view returns (IIdentityV2) {
+		return IIdentityV2(nameService.getAddress("IDENTITY"));
 	}
 
 	function setDefaults(
@@ -171,28 +185,45 @@ contract AdminWallet is
 		onlyAdmin
 		reimburseGas
 	{
-		identity.addWhitelistedWithDID(_user, _did);
+		getIdentity().addWhitelistedWithDID(_user, _did);
+	}
+
+	/* @dev Function to add given address to whitelist of identity contract
+	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
+	 */
+	function whitelist(
+		address _user,
+		string memory _did,
+		uint256 orgChain,
+		uint256 dateAuthenticated
+	) public onlyAdmin reimburseGas {
+		getIdentity().addWhitelistedWithDIDAndChain(
+			_user,
+			_did,
+			orgChain,
+			dateAuthenticated
+		);
 	}
 
 	/* @dev Function to remove given address from whitelist of identity contract
 	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
 	 */
 	function removeWhitelist(address _user) public onlyAdmin reimburseGas {
-		identity.removeWhitelisted(_user);
+		getIdentity().removeWhitelisted(_user);
 	}
 
 	/* @dev Function to add given address to blacklist of identity contract
 	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
 	 */
 	function blacklist(address _user) public onlyAdmin reimburseGas {
-		identity.addBlacklisted(_user);
+		getIdentity().addBlacklisted(_user);
 	}
 
 	/* @dev Function to remove given address from blacklist of identity contract
 	 * can only be done by admins of wallet and if wallet is an IdentityAdmin
 	 */
 	function removeBlacklist(address _user) public onlyAdmin reimburseGas {
-		identity.removeBlacklisted(_user);
+		getIdentity().removeBlacklisted(_user);
 	}
 
 	/* @dev Function to top given address with amount of G$ given in constructor

package/hardhat.config.ts

@@ -60,8 +60,8 @@ const hhconfig: HardhatUserConfig = {
         network: "celo",
         chainId: 42220,
         urls: {
-          apiURL: "https://api.celoscan.io",
-          browserURL: "https://celoscan.io"
+          apiURL: "https://api.celoscan.io/api",
+          browserURL: "https://celoscan.io/"
         }
       }
     ]
@@ -193,6 +193,20 @@ const hhconfig: HardhatUserConfig = {
       gas: 3000000,
       gasPrice: 500000000,
       chainId: 42220
+    },
+    "staging-celo": {
+      accounts: { mnemonic },
+      url: "https://forno.celo.org",
+      gas: 3000000,
+      gasPrice: 150000000,
+      chainId: 42220
+    },
+    "development-celo": {
+      accounts: { mnemonic },
+      url: "https://forno.celo.org",
+      gas: 3000000,
+      gasPrice: 150000000,
+      chainId: 42220
     }
   },
   mocha: {

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "1.0.29-beta.1",
+  "version": "1.0.29-beta.2",
   "description": "GoodDollar Protocol",
   "scripts": {
+    "prepack": "npm run minimize",
     "build": "scripts/build.sh deploy",
     "coverage:report": "export COVERALLS_REPO_TOKEN='qiXNelh1HXMAsoPah9yRD2yG2WlqrDfLh' && cat ../coverage/lcov.info coverage/lcov.info | coveralls",
     "coverage": "export CODE_COVERAGE=true; hardhat --max-memory 6096 coverage",
@@ -55,7 +56,7 @@
   },
   "homepage": "https://gooddollar.org",
   "dependencies": {
-    "@gooddollar/goodcontracts": "^2.6.2",
+    "@gooddollar/goodcontracts": "^2.6.4",
     "@jsier/retrier": "^1.2.4",
     "@openzeppelin/contracts": "^4.5.0",
     "@openzeppelin/contracts-upgradeable": "^4.3.2",