@gooddollar/goodcollective-contracts 1.0.5-beta.7a2c704 → 1.1.0

package/contracts/DirectPayments/DirectPaymentsFactory.sol

@@ -15,6 +15,7 @@ import "hardhat/console.sol";
 
 contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
     error NOT_PROJECT_OWNER();
+    error NOT_POOL();
 
     event PoolCreated(
         address indexed pool,
@@ -45,6 +46,9 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
     address public feeRecipient;
     uint32 public feeBps;
 
+    mapping(address => address[]) public memberPools;
+    address[] public pools;
+
     modifier onlyProjectOwnerOrNon(string memory projectId) {
         DirectPaymentsPool controlPool = projectIdToControlPool[keccak256(bytes(projectId))];
         // console.log("result %s", controlPool.hasRole(controlPool.DEFAULT_ADMIN_ROLE(), msg.sender));
@@ -56,16 +60,21 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         _;
     }
 
-    modifier onlyProjectOwnerByPool(DirectPaymentsPool pool) {
-        string memory projectId = registry[address(pool)].projectId;
-        DirectPaymentsPool controlPool = projectIdToControlPool[keccak256(bytes(projectId))];
-        if (controlPool.hasRole(controlPool.DEFAULT_ADMIN_ROLE(), msg.sender) == false) {
+    modifier onlyPoolOwner(DirectPaymentsPool pool) {
+        if (pool.hasRole(pool.DEFAULT_ADMIN_ROLE(), msg.sender) == false) {
             revert NOT_PROJECT_OWNER();
         }
 
         _;
     }
 
+    modifier onlyPool() {
+        if (bytes(registry[msg.sender].projectId).length == 0) {
+            revert NOT_POOL();
+        }
+        _;
+    }
+
     function _authorizeUpgrade(address _impl) internal virtual override onlyRole(DEFAULT_ADMIN_ROLE) {}
 
     function initialize(
@@ -138,12 +147,14 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         registry[address(pool)].projectId = _projectId;
 
         pool.renounceRole(DEFAULT_ADMIN_ROLE, address(this));
+        pools.push(address(pool));
+
         emit PoolCreated(address(pool), _projectId, _ipfs, nextNftType, _settings, _limits);
 
         nextNftType++;
     }
 
-    function changePoolDetails(DirectPaymentsPool _pool, string memory _ipfs) external onlyProjectOwnerByPool(_pool) {
+    function changePoolDetails(DirectPaymentsPool _pool, string memory _ipfs) external onlyPoolOwner(_pool) {
         registry[address(_pool)].ipfs = _ipfs;
         emit PoolDetailsChanged(address(_pool), _ipfs);
     }
@@ -162,4 +173,8 @@ contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
         feeBps = _feeBps;
         feeRecipient = _feeRecipient;
     }
+
+    function addMember(address account) external onlyPool {
+        memberPools[account].push(msg.sender);
+    }
 }

package/contracts/DirectPayments/DirectPaymentsPool.sol

@@ -21,7 +21,7 @@ interface IMembersValidator {
 }
 
 interface IIdentityV2 {
-    function getWhitelistedRoot(address member) external returns (address);
+    function getWhitelistedRoot(address member) external view returns (address);
 }
 
 /**
@@ -112,7 +112,7 @@ contract DirectPaymentsPool is
     DirectPaymentsFactory public registry;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
-    constructor(ISuperfluid _host, ISwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
+    constructor(ISuperfluid _host, IV3SwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
 
     /**
      * @dev Authorizes an upgrade for the implementation contract.
@@ -120,8 +120,8 @@ contract DirectPaymentsPool is
      */
     function _authorizeUpgrade(address impl) internal virtual override onlyRole(DEFAULT_ADMIN_ROLE) {}
 
-    function getRegistry() public view override returns (DirectPaymentsFactory) {
-        return DirectPaymentsFactory(registry);
+    function getRegistry() public view override returns (IRegistry) {
+        return IRegistry(address(registry));
     }
 
     /**
@@ -341,10 +341,17 @@ contract DirectPaymentsPool is
             }
         }
 
-        _setupRole(MEMBER_ROLE, member);
+        _grantRole(MEMBER_ROLE, member);
         return true;
     }
 
+    function _grantRole(bytes32 role, address account) internal virtual override {
+        if (role == MEMBER_ROLE) {
+            registry.addMember(account);
+        }
+        super._grantRole(role, account);
+    }
+
     function mintNFT(address _to, ProvableNFT.NFTData memory _nftData, bool withClaim) external onlyRole(MINTER_ROLE) {
         uint nftId = nft.mintPermissioned(_to, _nftData, true, "");
         if (withClaim) {

package/contracts/GoodCollective/GoodCollectiveSuperApp.sol

@@ -9,13 +9,19 @@ import { SuperTokenV1Library } from "@superfluid-finance/ethereum-contracts/cont
 import { CFAv1Library, IConstantFlowAgreementV1 } from "@superfluid-finance/ethereum-contracts/contracts/apps/CFAv1Library.sol";
 
 import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
-import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
+import "@uniswap/swap-router-contracts/contracts/interfaces/IV3SwapRouter.sol";
 
 import "../DirectPayments/DirectPaymentsFactory.sol";
 import "../utils/HelperLibrary.sol";
 
 // import "hardhat/console.sol";
 
+interface IRegistry {
+    function feeRecipient() external view returns (address);
+
+    function feeBps() external view returns (uint32);
+}
+
 abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     int96 public constant MIN_FLOW_RATE = 386e9;
 
@@ -51,7 +57,7 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     // ask about "receiver" can it be different then app?
 
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-    ISwapRouter public immutable swapRouter;
+    IV3SwapRouter public immutable swapRouter;
 
     struct SupporterData {
         uint256 contribution;
@@ -71,12 +77,12 @@ abstract contract GoodCollectiveSuperApp is SuperAppBaseFlow {
     uint256[48] private _reserved;
 
     /// @custom:oz-upgrades-unsafe-allow constructor
-    constructor(ISuperfluid _host, ISwapRouter _swapRouter) SuperAppBaseFlow(_host) {
+    constructor(ISuperfluid _host, IV3SwapRouter _swapRouter) SuperAppBaseFlow(_host) {
         if (address(_host) == address(0)) revert ZERO_ADDRESS();
         swapRouter = _swapRouter;
     }
 
-    function getRegistry() public view virtual returns (DirectPaymentsFactory);
+    function getRegistry() public view virtual returns (IRegistry);
 
     /**
      * @dev Sets the address of the super token and registers the app with the host

package/contracts/UBI/MultiClaimModule.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+
+// Interface for ERC-7579 IModule (minimal implementation)
+interface IModule {
+    /**
+     * @dev This function is called by the smart account during installation of the module
+     * @param data arbitrary data that may be required on the module during `onInstall` initialization
+     *
+     * MUST revert on error (i.e. if module is already enabled)
+     */
+    function onInstall(bytes calldata data) external;
+
+    /**
+     * @dev This function is called by the smart account during uninstallation of the module
+     * @param data arbitrary data that may be required on the module during `onUninstall` de-initialization
+     *
+     * MUST revert on error
+     */
+    function onUninstall(bytes calldata data) external;
+
+    /**
+     * @dev Returns boolean value if module is a certain type
+     * @param typeID the module type ID according the ERC-7579 spec
+     *
+     * MUST return true if the module is of the given type and false otherwise
+     */
+    function isModuleType(uint256 typeID) external view returns (bool);
+
+    /**
+     * @dev Returns bit-encoded integer of the different typeIds of the module
+     *
+     * MUST return all the bit-encoded typeIds of the module
+     */
+    function getModuleTypes() external view returns (uint256);
+}
+
+interface IClaimable {
+    function claim() external;
+}
+
+contract MultiClaimModule is IModule {
+    // Function to claim tokens from multiple contracts
+    function multiClaim(
+        address[] calldata contracts,
+        IERC20Upgradeable token,
+        address recipient
+    ) external returns (bool[] memory success) {
+        // Loop through each contract address
+        uint256 tokenBalance = token.balanceOf(address(this));
+        success = new bool[](contracts.length);
+        for (uint i = 0; i < contracts.length; i++) {
+            try IClaimable(contracts[i]).claim() {
+                success[i] = true;
+            } catch {}
+        }
+
+        // Transfer any token balance after claims to recipient
+        uint256 tokenBalanceDiff = token.balanceOf(address(this)) - tokenBalance;
+        if (tokenBalanceDiff > 0) {
+            token.transfer(recipient, tokenBalanceDiff);
+        }
+    }
+
+    function onInstall(bytes calldata data) external override {}
+
+    function onUninstall(bytes calldata data) external override {}
+
+    function isModuleType(uint256 typeID) external view override returns (bool) {
+        return true;
+    }
+
+    function getModuleTypes() public view override returns (uint256) {
+        return 2;
+    }
+}

package/contracts/UBI/UBIPool.sol

@@ -0,0 +1,388 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8;
+import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import { IERC721Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
+
+import "../GoodCollective/GoodCollectiveSuperApp.sol";
+import "./UBIPoolFactory.sol";
+
+interface IMembersValidator {
+    function isMemberValid(
+        address pool,
+        address operator,
+        address member,
+        bytes memory extraData
+    ) external returns (bool);
+}
+
+interface IIdentityV2 {
+    function getWhitelistedRoot(address member) external view returns (address);
+}
+
+contract UBIPool is AccessControlUpgradeable, GoodCollectiveSuperApp, UUPSUpgradeable {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    error CLAIMFOR_DISABLED();
+    error NOT_MEMBER(address claimer);
+    error NOT_WHITELISTED(address claimer);
+    error ALREADY_CLAIMED(address claimer);
+    error INVALID_0_VALUE();
+    error EMPTY_MANAGER();
+    error MAX_MEMBERS_REACHED();
+
+    bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
+    bytes32 public constant MEMBER_ROLE = keccak256("MEMBER_ROLE");
+
+    event PoolSettingsChanged(PoolSettings settings);
+    event UBISettingsChanged(UBISettings settings);
+    // Emits when daily ubi is calculated
+    event UBICalculated(
+        uint256 day,
+        uint256 dailyUbi,
+        uint256 blockNumber,
+        uint256 periodClaimers,
+        uint256 periodDistributed
+    );
+
+    //Emits whenever a new multi day cycle starts
+    event UBICycleCalculated(uint256 day, uint256 pool, uint256 cycleLength, uint256 dailyUBIPool);
+
+    event UBIClaimed(address indexed whitelistedRoot, address indexed claimer, uint256 amount);
+    // Define functions
+    struct PoolSettings {
+        address manager;
+        IMembersValidator membersValidator;
+        IIdentityV2 uniquenessValidator;
+        IERC20Upgradeable rewardToken;
+    }
+
+    struct UBISettings {
+        //number of days of each UBI pool cycle
+        uint32 cycleLengthDays;
+        //how often can someone claim their UBI
+        uint32 claimPeriodDays;
+        //minimum amount of users to divide the pool for, renamed from defaultDailyUbi
+        uint32 minActiveUsers;
+        // can you trigger claim for someone else
+        bool claimForEnabled;
+        uint maxClaimAmount;
+        uint32 maxMembers;
+    }
+
+    struct PoolStatus {
+        //current day of distribution
+        uint256 currentDay;
+        // Result of distribution formula
+        // calculated each day
+        uint256 dailyUbi;
+        //the amount of G$ UBI pool for each day in the cycle to be divided by active users
+        uint256 dailyCyclePool;
+        //timestamp of current cycle start
+        uint256 startOfCycle;
+        //should be 0 for starters so distributionFormula detects new cycle on first day claim
+        uint256 currentCycleLength;
+        uint256 periodClaimers;
+        uint256 periodDistributed;
+        mapping(address => uint256) lastClaimed;
+        uint32 membersCount;
+    }
+
+    PoolSettings public settings;
+    UBISettings public ubiSettings;
+    PoolStatus public status;
+
+    UBIPoolFactory public registry;
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(ISuperfluid _host, IV3SwapRouter _swapRouter) GoodCollectiveSuperApp(_host, _swapRouter) {}
+
+    /**
+     * @dev Authorizes an upgrade for the implementation contract.
+     * @param impl The address of the new implementation contract.
+     */
+    function _authorizeUpgrade(address impl) internal virtual override onlyRole(DEFAULT_ADMIN_ROLE) {}
+
+    function getRegistry() public view override returns (IRegistry) {
+        return IRegistry(address(registry));
+    }
+
+    /**
+     * @dev Initializes the contract with the given settings and limits.
+     * @param _settings The PoolSettings struct containing pool settings.
+     * @param _ubiSettings The UBISettings struct containing safety limits.
+     */
+    function initialize(
+        PoolSettings memory _settings,
+        UBISettings memory _ubiSettings,
+        UBIPoolFactory _registry
+    ) external initializer {
+        registry = _registry;
+        settings = _settings;
+        ubiSettings = _ubiSettings;
+        _verifyUBISettings(_ubiSettings);
+        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        _setupRole(MANAGER_ROLE, _settings.manager);
+        setSuperToken(ISuperToken(address(settings.rewardToken)));
+    }
+
+    function upgradeToLatest(bytes memory data) external payable virtual {
+        address impl = address(UBIPoolFactory(address(registry)).impl());
+        _authorizeUpgrade(impl);
+        _upgradeToAndCallUUPS(impl, data, false);
+    }
+
+    function getCurrentDay() public view returns (uint256) {
+        return (block.timestamp - 12 hours) / (1 days); //make day start at 12:00pm
+    }
+
+    /**
+     * @dev The claim calculation formula. Divide the daily pool with
+     * the sum of the active users.
+     * the daily balance is determined by dividing current pool by the cycle length
+     * @return The amount of GoodDollar the user can claim
+     */
+    function distributionFormula() internal returns (uint256) {
+        // once every claim cycle
+        uint256 currentDay = getCurrentDay();
+        if (currentDay > status.currentDay + ubiSettings.claimPeriodDays) {
+            status.currentDay = currentDay;
+            uint32 cycleLength = ubiSettings.cycleLengthDays;
+            uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
+            //start early cycle if daily pool size is +%5 previous pool or not enough until end of cycle
+            uint256 nextDailyPool = currentBalance / cycleLength;
+            bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
+                currentBalance < (status.dailyCyclePool * (cycleLength - currentDayInCycle()));
+
+            if (
+                currentDayInCycle() >= status.currentCycleLength || shouldStartEarlyCycle
+            ) //start of cycle or first time
+            {
+                status.dailyCyclePool = nextDailyPool;
+                status.currentCycleLength = cycleLength;
+                status.startOfCycle = currentDay;
+                emit UBICycleCalculated(currentDay, currentBalance, cycleLength, nextDailyPool);
+            }
+
+            uint256 prevPeriodClaimers = status.periodClaimers;
+            status.dailyUbi = min(
+                ubiSettings.maxClaimAmount,
+                status.dailyCyclePool / max((prevPeriodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
+            );
+            //update minActiveUsers as claimers grow
+            ubiSettings.minActiveUsers = uint32(max(prevPeriodClaimers / 2, ubiSettings.minActiveUsers));
+
+            emit UBICalculated(
+                currentDay,
+                status.dailyUbi,
+                block.number,
+                status.periodClaimers,
+                status.periodDistributed
+            );
+            status.periodClaimers = 0;
+            status.periodDistributed = 0;
+        }
+
+        return status.dailyUbi;
+    }
+
+    /**
+     * @dev returns the day count since start of current cycle
+     */
+    function currentDayInCycle() public view returns (uint256) {
+        return getCurrentDay() - status.startOfCycle;
+    }
+
+    function max(uint256 a, uint256 b) private pure returns (uint256) {
+        return a >= b ? a : b;
+    }
+
+    function min(uint256 a, uint256 b) private pure returns (uint256) {
+        return a < b ? a : b;
+    }
+
+    /**
+     * @dev Claims UBI
+     */
+    function claim() external {
+        _claim(msg.sender, true);
+    }
+
+    function claimFor(address claimer, bool sendToWhitelistedRoot) external {
+        if (!ubiSettings.claimForEnabled) revert CLAIMFOR_DISABLED();
+
+        _claim(claimer, sendToWhitelistedRoot);
+    }
+
+    /**
+     * @dev Claims UBI
+     * @param claimer the address of the claimer.
+     */
+
+    function _claim(address claimer, bool sendToWhitelistedRoot) internal {
+        address whitelistedRoot = IIdentityV2(settings.uniquenessValidator).getWhitelistedRoot(claimer);
+        if (whitelistedRoot == address(0)) revert NOT_WHITELISTED(claimer);
+        if (address(settings.membersValidator) != address(0) && hasRole(MEMBER_ROLE, claimer) == false)
+            revert NOT_MEMBER(claimer);
+
+        // 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
+        // within the calculation.
+        uint256 dailyUbi = distributionFormula();
+
+        // active user which has not claimed today yet, ie user last claimed < today
+        if (status.lastClaimed[whitelistedRoot] == status.currentDay) revert ALREADY_CLAIMED(whitelistedRoot);
+
+        status.lastClaimed[whitelistedRoot] = status.currentDay;
+        status.periodClaimers += 1;
+        status.periodDistributed += dailyUbi;
+
+        settings.rewardToken.safeTransfer(sendToWhitelistedRoot ? whitelistedRoot : claimer, dailyUbi);
+
+        emit UBIClaimed(whitelistedRoot, claimer, dailyUbi);
+    }
+
+    function addMemberByManager(address member) external onlyRole(MANAGER_ROLE) returns (bool) {
+        if (hasRole(MEMBER_ROLE, member)) return true;
+
+        if (address(settings.uniquenessValidator) != address(0)) {
+            address rootAddress = settings.uniquenessValidator.getWhitelistedRoot(member);
+            if (rootAddress == address(0)) revert NOT_WHITELISTED(member);
+        }
+
+        _grantRole(MEMBER_ROLE, member);
+        return true;
+    }
+
+    /**
+     * @dev Adds a member to the contract.
+     * @param member The address of the member to add.
+     * @param extraData Additional data to validate the member.
+     */
+
+    function addMember(address member, bytes memory extraData) external returns (bool isMember) {
+        if (hasRole(MEMBER_ROLE, member)) return true;
+
+        if (address(settings.uniquenessValidator) != address(0)) {
+            address rootAddress = settings.uniquenessValidator.getWhitelistedRoot(member);
+            if (rootAddress == address(0)) revert NOT_WHITELISTED(member);
+        }
+
+        // if no members validator then anyone can join the pool
+        if (address(settings.membersValidator) != address(0)) {
+            if (settings.membersValidator.isMemberValid(address(this), msg.sender, member, extraData) == false) {
+                return false;
+            }
+        }
+
+        _grantRole(MEMBER_ROLE, member);
+        return true;
+    }
+
+    function _grantRole(bytes32 role, address account) internal virtual override {
+        if (role == MEMBER_ROLE) {
+            registry.addMember(account);
+            if (ubiSettings.maxMembers > 0 && status.membersCount > ubiSettings.maxMembers)
+                revert MAX_MEMBERS_REACHED();
+            status.membersCount += 1;
+        }
+        super._grantRole(role, account);
+    }
+
+    function _revokeRole(bytes32 role, address account) internal virtual override {
+        if (role == MEMBER_ROLE) {
+            status.membersCount -= 1;
+        }
+        super._revokeRole(role, account);
+    }
+
+    /**
+     * @dev Sets the safety limits for the pool.
+     * @param _ubiSettings The new safety limits.
+     */
+    function setUBISettings(UBISettings memory _ubiSettings) public onlyRole(MANAGER_ROLE) {
+        _verifyUBISettings(_ubiSettings);
+        ubiSettings = _ubiSettings;
+        emit UBISettingsChanged(_ubiSettings);
+    }
+
+    function _verifyUBISettings(UBISettings memory _ubiSettings) internal pure {
+        if (
+            _ubiSettings.claimPeriodDays == 0 ||
+            _ubiSettings.cycleLengthDays == 0 ||
+            _ubiSettings.minActiveUsers == 0 ||
+            _ubiSettings.maxClaimAmount == 0
+        ) revert INVALID_0_VALUE();
+    }
+
+    /**
+     * @dev Sets the settings for the pool.
+     * @param _settings The new pool settings.
+     */
+    function setPoolSettings(PoolSettings memory _settings) public onlyRole(MANAGER_ROLE) {
+        if (_settings.manager == address(0)) revert EMPTY_MANAGER();
+
+        if (_settings.manager != settings.manager) {
+            _revokeRole(MANAGER_ROLE, settings.manager);
+            _setupRole(MANAGER_ROLE, _settings.manager);
+        }
+        settings = _settings;
+        emit PoolSettingsChanged(_settings);
+    }
+
+    function estimateNextDailyUBI() public view returns (uint256) {
+        uint256 currentBalance = settings.rewardToken.balanceOf(address(this));
+        //start early cycle if we can increase the daily UBI pool
+        uint256 nextDailyPool = currentBalance / ubiSettings.cycleLengthDays;
+        bool shouldStartEarlyCycle = nextDailyPool > (status.dailyCyclePool * 105) / 100 ||
+            currentBalance < (status.dailyCyclePool * (status.currentCycleLength - currentDayInCycle()));
+
+        uint256 _dailyCyclePool = status.dailyCyclePool;
+        uint256 _dailyUbi;
+        if (
+            (currentDayInCycle() + 1) >= status.currentCycleLength || shouldStartEarlyCycle
+        ) //start of cycle or first time
+        {
+            _dailyCyclePool = currentBalance / ubiSettings.cycleLengthDays;
+        }
+
+        _dailyUbi = min(
+            ubiSettings.maxClaimAmount,
+            _dailyCyclePool / max((status.periodClaimers * 10500) / 10000, ubiSettings.minActiveUsers)
+        );
+        return _dailyUbi;
+    }
+
+    function checkEntitlement() public view returns (uint256) {
+        return checkEntitlement(msg.sender);
+    }
+
+    /**
+     * @dev Checks the amount which the sender address is eligible to claim for,
+     * regardless if they have been whitelisted or not. In case the user is
+     * active, then the current day must be equal to the actual day, i.e. claim
+     * or fish has already been executed today.
+     * @return The amount of GD tokens the address can claim.
+     */
+    function checkEntitlement(address _member) public view returns (uint256) {
+        // current day has already been updated which means
+        // that the dailyUbi has been updated
+        if (status.currentDay == getCurrentDay() && status.dailyUbi > 0) {
+            return hasClaimed(_member) ? 0 : status.dailyUbi;
+        }
+        return estimateNextDailyUBI();
+    }
+
+    function hasClaimed(address _member) public view returns (bool) {
+        address whitelistedRoot = IIdentityV2(settings.uniquenessValidator).getWhitelistedRoot(_member);
+        return status.lastClaimed[whitelistedRoot] == status.currentDay;
+    }
+
+    function nextClaimTime() public view returns (uint256) {
+        return getCurrentDay() * (1 days) - (12 hours);
+    }
+}