@gooddollar/goodprotocol 1.0.29-beta.0 → 1.0.29-beta.2

package/contracts/staking/utils/StakingRewardsFixedAPY.sol

@@ -0,0 +1,336 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "./Math64X64.sol";
+import "hardhat/console.sol";
+
+/***
+ * @dev helper contract for calculating fixed per block compounding interest rate rewards.
+ */
+abstract contract StakingRewardsFixedAPY {
+	using Math64x64 for int128;
+
+	// precision constant for math
+	uint128 public constant PRECISION = 1e18;
+	uint128 public constant SHARE_PRECISION = 1e18;
+	uint128 public constant SHARE_DECIMALS = 1e4;
+
+	// the users stake information
+	struct StakerInfo {
+		uint128 lastSharePrice; // the share price that can be used to calculate earned rewards
+		uint128 rewardsPaid; // rewards that accounted already so should be substracted
+	}
+
+	struct Stats {
+		// last block this staking contract was updated and rewards were calculated
+		uint128 lastUpdateBlock;
+		// total supply of active stakes
+		uint128 totalStaked;
+		uint128 totalRewardsPaid;
+		uint256 savings; //total earning compounding interest;
+	}
+
+	Stats public stats;
+
+	// the user info sheet
+	mapping(address => StakerInfo) public stakersInfo;
+
+	// interest rate per one block in 1e18 precision.
+	//for example APY=5% then per block = nroot(1+0.05,numberOfBlocksPerYear)
+	//nroot(1.05,6000000) = 1.000000008131694
+	//in 1e18 = 1000000008131694000
+	int128 public interestRatePerBlockX64;
+
+	/**
+	 * @notice internal helper to convert unsigned interest rate per block in 1e18 precision to x64 format
+	 */
+	function _setAPY(uint128 _interestRatePerBlock) internal updateReward {
+		interestRatePerBlockX64 = Math64x64.divu(_interestRatePerBlock, 1e18); //convert to signed int x64
+	}
+
+	/**
+	 * @notice modifier to compound the APY on every state update
+	 */
+	modifier updateReward() {
+		_updateReward();
+		_;
+	}
+
+	/**
+	 * @dev the amount of shares of the savings _account holds
+	 * @param _account the address
+	 */
+	function sharesOf(address _account)
+		public
+		view
+		virtual
+		returns (uint256 shares);
+
+	/**
+	 * @dev the total outstanding shares
+	 */
+	function sharesSupply() public view virtual returns (uint256);
+
+	/**
+	 * @notice calculates the compounded savings based on passed blocks
+	 * @return compoundedSavings the new savings
+	 */
+	function _compound() internal 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 compound = interestRatePerBlockX64.pow(
+			block.number - stats.lastUpdateBlock
+		);
+		compoundedSavings = compound.mulu(stats.savings);
+	}
+
+	/**
+	 * @notice calculates the current share price (savings/totalShares)
+	 * @return price the current share price in SHARE_PRECISION
+	 */
+	function sharePrice() public view returns (uint256 price) {
+		uint256 compoundedSavings = _compound();
+
+		// console.log(
+		// 	"compoundedSavings %s, shares: %s, sharePrice: %s",
+		// 	compoundedSavings,
+		// 	stats.totalShares,
+		// 	(compoundedSavings * SHARE_PRECISION) / (stats.totalShares * PRECISION)
+		// );
+
+		return
+			sharesSupply() == 0
+				? 0
+				: (compoundedSavings * SHARE_PRECISION) / (sharesSupply() * PRECISION);
+	}
+
+	/**
+	 * @notice calculate how much user can withdraw
+	 * @return balance account compounded savings balance
+	 */
+	function getSavings(address _account)
+		external
+		view
+		returns (uint256 balance)
+	{
+		balance = (sharePrice() * sharesOf(_account)) / SHARE_PRECISION;
+	}
+
+	function ceil(uint256 amount, uint256 precision)
+		internal
+		pure
+		returns (uint256)
+	{
+		return ((amount + precision - 1) / precision);
+	}
+
+	/**
+	 * @dev helper to get _amount worth of shares
+	 */
+	function amountToShares(uint256 _amount)
+		public
+		view
+		returns (uint256 shares)
+	{
+		return
+			ceil(
+				(_amount * SHARE_PRECISION * SHARE_DECIMALS) / sharePrice(),
+				SHARE_DECIMALS
+			); //ceil ensures shares value >= amount
+	}
+
+	/**
+	 * @dev helper to get _account lastSharePrice, which is used to calculate accumulated rewards since lastSharePrice was updated
+	 */
+	function lastSharePrice(address _account)
+		public
+		view
+		returns (uint256 price)
+	{
+		return uint256(stakersInfo[_account].lastSharePrice);
+	}
+
+	/**
+	 * @dev get the principle of _account (ie estimated original deposit)
+	 */
+	function principle(address _account)
+		external
+		view
+		returns (uint256 deposited)
+	{
+		return (lastSharePrice(_account) * sharesOf(_account)) / SHARE_PRECISION;
+	}
+
+	/**
+	 * @notice The function allows anyone to calculate the exact amount of reward
+	 * earned.
+	 * @param _account A staker address
+	 * @return earnedRewards total rewards earned
+	 */
+	function earned(address _account)
+		public
+		view
+		returns (uint256 earnedRewards)
+	{
+		uint256 shares = sharesOf(_account);
+		uint256 curPrice = sharePrice();
+		uint256 lastPrice = lastSharePrice(_account);
+		lastPrice = lastPrice > curPrice ? curPrice : lastPrice; //it could be that share price is lower immediatly after staking
+
+		earnedRewards =
+			((curPrice * shares) - (lastPrice * shares)) /
+			SHARE_PRECISION;
+	}
+
+	/**
+	 * @notice calculate the interest earned and not yet paid for stats.totalStaked
+	 * @return debt the rewards(interest) not yet paid
+	 */
+	function getRewardsDebt() external view returns (uint256 debt) {
+		debt = _compound() - stats.totalStaked * PRECISION; //totalStaked is in G$ precision (ie 2 decimals)
+	}
+
+	/**
+	 * @notice compounds the global savings
+	 */
+	function _updateReward() internal virtual {
+		stats.savings = _compound();
+		stats.lastUpdateBlock = uint128(block.number);
+	}
+
+	/**
+	 * @notice perform state update when withdrawing
+	 * @param _from account address withdrawing
+	 * @param _shares amount to withdraw, if amount is max uint then it will withdraw available balance
+	 * @return depositComponent how much was withdrawn from user original stake. >0 only when _amount > interest (rewards) earned
+	 * @return rewardComponent how much was withdrawn from user earned rewards
+	 */
+	function _withdraw(address _from, uint256 _shares)
+		internal
+		virtual
+		updateReward
+		returns (uint256 depositComponent, uint256 rewardComponent)
+	{
+		uint256 sharesBalance = sharesOf(_from);
+
+		require(_shares > 0 && _shares <= sharesBalance, "no balance");
+
+		uint256 amount = (sharePrice() * _shares) / SHARE_PRECISION;
+
+		uint256 pendingRewards = earned(_from);
+
+		rewardComponent = pendingRewards >= amount ? amount : pendingRewards;
+
+		depositComponent = amount > rewardComponent ? amount - rewardComponent : 0;
+
+		//because of rounding down of rewardComponent after some operations this can cause the deposit component to be larger
+		//than it actually was
+		if (stats.totalStaked < depositComponent) {
+			uint256 diff = depositComponent - stats.totalStaked;
+			rewardComponent += diff;
+			depositComponent = stats.totalStaked;
+		}
+
+		require(amount > 0, "min shares withdraw value: 1 gd");
+
+		// console.log("withdraw: reducing principle by %s", _amount);
+
+		stats.savings -= amount * PRECISION;
+		stats.totalStaked -= uint128(depositComponent);
+		stats.totalRewardsPaid += uint128(rewardComponent);
+		stakersInfo[_from].rewardsPaid += uint128(rewardComponent);
+
+		uint256 newShareSupply = sharesSupply() - _shares;
+		uint256 newSharePrice = newShareSupply == 0
+			? 0
+			: (stats.savings * SHARE_PRECISION) / (newShareSupply * PRECISION);
+
+		if (
+			depositComponent > 0 ||
+			rewardComponent == pendingRewards ||
+			newShareSupply == 0
+		) //we have withdrawn all rewards so we reset lastSharePrice
+		{
+			// console.log("withdraw: reset shareprice to: %s", newSharePrice);
+			stakersInfo[_from].lastSharePrice = uint128(newSharePrice);
+		} else {
+			//we set the lastSharePrice to not include remaining rewards value
+			stakersInfo[_from].lastSharePrice = uint128(
+				newSharePrice -
+					((pendingRewards - rewardComponent) * SHARE_PRECISION) /
+					(sharesBalance - _shares)
+			);
+		}
+	}
+
+	/**
+	 * @notice perform state update when staking
+	 * @param _from account address staking
+	 * @param _amount amount to stake
+	 */
+	function _stake(address _from, uint256 _amount)
+		internal
+		virtual
+		updateReward
+		returns (uint256 shares)
+	{
+		require(_amount > 0, "Cannot stake 0");
+		shares = sharesSupply() > 0
+			? ((_amount * SHARE_PRECISION) / sharePrice()) //amount/sharePrice = new shares = amount/(savings/totalShares)
+			: (_amount * SHARE_DECIMALS); //principal/number of shares is shares price, so initially each share price will represent G%cent/SHARE_DECIMALS
+		require(shares > 0, "min stake 1 share price");
+
+		stakersInfo[_from].lastSharePrice = uint128(
+			sharesOf(_from) == 0
+				? (_amount * SHARE_PRECISION) / shares
+				: ((sharesOf(_from) * stakersInfo[_from].lastSharePrice) +
+					(shares * sharePrice())) / (sharesOf(_from) + shares)
+		);
+		stats.totalStaked += uint128(_amount);
+		stats.savings += _amount * PRECISION;
+	}
+
+	/**
+	 * @notice keep track of debt to user in case reward minting failed
+	 * @dev notice that this should not be called when _rewardsPaid are 0
+	 * @return shares added to cover rewards
+	 */
+	function _undoReward(address _to, uint256 _rewardsPaid)
+		internal
+		virtual
+		returns (uint256 shares)
+	{
+		//skip on invalid input
+		if (_rewardsPaid == 0) {
+			return 0;
+		}
+
+		//calculate this before udpating global savings
+		shares = sharesSupply() > 0
+			? ((_rewardsPaid * SHARE_PRECISION) / sharePrice())
+			: (_rewardsPaid * SHARE_DECIMALS); //staker previously withdrew all, so shares issued like on first stake
+
+		stats.totalRewardsPaid -= uint128(_rewardsPaid);
+		stats.savings += _rewardsPaid * PRECISION; //rewards are part of the compounding interest
+
+		stakersInfo[_to].rewardsPaid -= uint128(_rewardsPaid);
+
+		//remove rewards from the lastSharePrice
+		//we set the lastSharePrice to not include unwithdrawn rewards
+		//if lastSharePrice is 0 then nothing to do. it means all funds are rewards ie profit
+		if (stakersInfo[_to].lastSharePrice > 0) {
+			uint256 rewardsSharesPart = (_rewardsPaid * SHARE_PRECISION) /
+				(sharesOf(_to) + shares);
+
+			stakersInfo[_to].lastSharePrice = rewardsSharesPart >=
+				stakersInfo[_to].lastSharePrice
+				? 0
+				: uint128(stakersInfo[_to].lastSharePrice - rewardsSharesPart);
+		}
+	}
+}

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/contracts/utils/BulkProof.sol

@@ -32,14 +32,14 @@ contract BulkProof {
 		bytes32[] proof;
 	}
 
-	function bulkProof(Proof[] calldata proofs) external {
-		for (uint256 i = 0; i < proofs.length; i++) {
-			Proof memory proof = proofs[i];
-			GoodReserveCDai(0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0).claimGDX(
-				proof.account,
-				proof.balance,
-				proof.proof
-			);
-		}
-	}
+	// function bulkProof(Proof[] calldata proofs) external {
+	// 	for (uint256 i = 0; i < proofs.length; i++) {
+	// 		Proof memory proof = proofs[i];
+	// 		GoodReserveCDai(0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0).claimGDX(
+	// 			proof.account,
+	// 			proof.balance,
+	// 			proof.proof
+	// 		);
+	// 	}
+	// }
 }