Valor Prime Non-Fungible Tokens

0xff4635874e544f25c79ac416c695153f1835c732

hasRole keyboard_arrow_up

    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

getRoleMemberCount keyboard_arrow_up

    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

getRoleMember keyboard_arrow_up

    function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
        return _roles[role].members.at(index);
    }

getRoleAdmin keyboard_arrow_up

    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

grantRole keyboard_arrow_up

    function grantRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");

        _grantRole(role, account);
    }

revokeRole keyboard_arrow_up

    function revokeRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");

        _revokeRole(role, account);
    }

renounceRole keyboard_arrow_up

    function renounceRole(bytes32 role, address account) public virtual {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

initialize keyboard_arrow_up

    function initialize(
        address _manager,
        address _migrator
    ) public initializer {
        _setupRole(MANAGER_ROLE, _manager);
        _setupRole(MIGRATOR_ROLE, _migrator);
        init_ = false;
    }

init keyboard_arrow_up

    function init(
        address _mainTokenAddress,
        address _auctionAddress,
        address _subBalancesAddress,
        address _foreignSwapAddress,
        address _stakingV1Address,
        uint256 _stepTimestamp
    ) external onlyMigrator {
        require(!init_, "Staking: init is active");
        init_ = true;
        /** Setup */
        _setupRole(EXTERNAL_STAKER_ROLE, _foreignSwapAddress);
        _setupRole(EXTERNAL_STAKER_ROLE, _auctionAddress);

        addresses = Addresses({
            mainToken: _mainTokenAddress,
            auction: _auctionAddress,
            subBalances: _subBalancesAddress
        });

        stakingV1 = IStakingV1(_stakingV1Address);

        stepTimestamp = _stepTimestamp;

        if (startContract == 0) {
            startContract = now;
            nextPayoutCall = startContract.add(_stepTimestamp);
        }

        if (shareRate == 0) {
            shareRate = 1e18;
        }
    }

sessionsOf_ keyboard_arrow_up

    function sessionsOf_(address account)
        external
        view
        returns (uint256[] memory)
    {
        return sessionsOf[account];
    }

stake keyboard_arrow_up

    function stake(uint256 amount, uint256 stakingDays) external {
        if (now >= nextPayoutCall) makePayout();

        // Staking days must be greater then 0 and less then or equal to 5555.
        require(stakingDays != 0, "stakingDays < 1");
        require(stakingDays <= 5555, "stakingDays > 5555");

        uint256 start = now;
        uint256 end = now.add(stakingDays.mul(stepTimestamp));

        IToken(addresses.mainToken).burn(msg.sender, amount);
        lastSessionId = lastSessionId.add(1);
        uint256 sessionId = lastSessionId;
        uint256 shares = _getStakersSharesAmount(amount, start, end);
        sharesTotalSupply = sharesTotalSupply.add(shares);

        sessionDataOf[msg.sender][sessionId] = Session({
            amount: amount,
            start: start,
            end: end,
            shares: shares,
            firstPayout: payouts.length,
            lastPayout: payouts.length + stakingDays,
            withdrawn: false,
            payout: 0
        });

        sessionsOf[msg.sender].push(sessionId);

        ISubBalances(addresses.subBalances).callIncomeStakerTrigger(
            msg.sender,
            sessionId,
            start,
            end,
            shares
        );

        emit Stake(msg.sender, sessionId, amount, start, end, shares);
    }

externalStake keyboard_arrow_up

    function externalStake(
        uint256 amount,
        uint256 stakingDays,
        address staker
    ) external override onlyExternalStaker {
        if (now >= nextPayoutCall) makePayout();

        require(stakingDays != 0, "stakingDays < 1");
        require(stakingDays <= 5555, "stakingDays > 5555");

        uint256 start = now;
        uint256 end = now.add(stakingDays.mul(stepTimestamp));

        lastSessionId = lastSessionId.add(1);
        uint256 sessionId = lastSessionId;
        uint256 shares = _getStakersSharesAmount(amount, start, end);
        sharesTotalSupply = sharesTotalSupply.add(shares);

        sessionDataOf[staker][sessionId] = Session({
            amount: amount,
            start: start,
            end: end,
            shares: shares,
            firstPayout: payouts.length,
            lastPayout: payouts.length + stakingDays,
            withdrawn: false,
            payout: 0
        });

        sessionsOf[staker].push(sessionId);

        ISubBalances(addresses.subBalances).callIncomeStakerTrigger(
            staker,
            sessionId,
            start,
            end,
            shares
        );

        emit Stake(staker, sessionId, amount, start, end, shares);
    }

calculateStakingInterest keyboard_arrow_up

    function calculateStakingInterest(
        uint256 firstPayout,
        uint256 lastPayout,
        uint256 shares
    ) public view returns (uint256) {
        uint256 stakingInterest;
        uint256 lastIndex = MathUpgradeable.min(
            payouts.length,
            lastPayout
        );

        for (
            uint256 i = firstPayout;
            i < lastIndex;
            i++
        ) {
            uint256 payout = payouts[i].payout.mul(shares).div(
                payouts[i].sharesTotalSupply
            );

            stakingInterest = stakingInterest.add(payout);
        }

        return stakingInterest;
    }

unstake keyboard_arrow_up

    function unstake(uint256 sessionId) external {
        if (now >= nextPayoutCall) makePayout();

        Session storage session = sessionDataOf[msg.sender][sessionId];

        require(
            session.shares != 0
                && session.withdrawn == false,
            "Staking: Stake withdrawn/invalid"
        );

        uint256 actualEnd = now;
        uint256 amountOut = unstakeInternal(
            sessionId,
            session.amount,
            session.start,
            session.end,
            actualEnd,
            session.shares,
            session.firstPayout,
            session.lastPayout
        );

        ISubBalances(addresses.subBalances).callOutcomeStakerTrigger(
            sessionId,
            session.start,
            session.end,
            actualEnd,
            session.shares
        );

        session.end = actualEnd;
        session.withdrawn = true;
        session.payout = amountOut;
    }

unstakeV1 keyboard_arrow_up

    function unstakeV1(uint256 sessionId) external {
        if (now >= nextPayoutCall) makePayout();

        require(sessionId <= lastSessionIdV1, "Staking: Invalid sessionId");

        Session storage session = sessionDataOf[msg.sender][sessionId];

        // Unstaked already
        require(
            session.shares == 0 && session.withdrawn == false,
            "Staking: Stake withdrawn"
        );

        (uint256 amount, uint256 start, uint256 end, uint256 shares, uint256 firstPayout)
            = stakingV1.sessionDataOf(msg.sender, sessionId);

        // Unstaked in v1 / doesn't exist
        require(
            shares > 0,
            "Staking: Stake withdrawn"
        );

        uint256 lastPayout = (end - start) / stepTimestamp + firstPayout;

        uint256 actualEnd = now;
        uint256 amountOut = unstakeInternal(
            sessionId,
            amount,
            start,
            end,
            actualEnd,
            shares,
            firstPayout,
            lastPayout
        );

        ISubBalances(addresses.subBalances).callOutcomeStakerTriggerV1(
            msg.sender,
            sessionId,
            start,
            end,
            actualEnd,
            shares
        );

        sessionDataOf[msg.sender][sessionId] = Session({
            amount: amount,
            start: start,
            end: actualEnd,
            shares: shares,
            firstPayout: firstPayout,
            lastPayout: lastPayout,
            withdrawn: true,
            payout: amountOut
        });

        sessionsOf[msg.sender].push(sessionId);
    }

getAmountOutAndPenalty keyboard_arrow_up

    function getAmountOutAndPenalty(uint256 amount, uint256 start, uint256 end, uint256 stakingInterest)
        public
        view
        returns (uint256, uint256)
    {
        uint256 stakingSeconds = end.sub(start);
        uint256 stakingDays = stakingSeconds.div(stepTimestamp);
        uint256 secondsStaked = now.sub(start);
        uint256 daysStaked = secondsStaked.div(stepTimestamp);
        uint256 amountAndInterest = amount.add(stakingInterest);

        // Early
        if (stakingDays > daysStaked) {
            uint256 payOutAmount = amountAndInterest.mul(secondsStaked).div(
                stakingSeconds
            );

            uint256 earlyUnstakePenalty = amountAndInterest.sub(payOutAmount);

            return (payOutAmount, earlyUnstakePenalty);
            // In time
        } else if (
            daysStaked < stakingDays.add(14)
        ) {
            return (amountAndInterest, 0);
            // Late
        } else if (
            daysStaked < stakingDays.add(714)
        ) {
            uint256 daysAfterStaking = daysStaked - stakingDays;

            uint256 payOutAmount = amountAndInterest
                .mul(uint256(714).sub(daysAfterStaking))
                .div(700);

            uint256 lateUnstakePenalty = amountAndInterest.sub(payOutAmount);

            return (payOutAmount, lateUnstakePenalty);
            // Nothing
        } else {
            return (0, amountAndInterest);
        }
    }

makePayout keyboard_arrow_up

    function makePayout() public {
        require(now >= nextPayoutCall, "Staking: Wrong payout time");

        uint256 payout = _getPayout();

        payouts.push(
            Payout({payout: payout, sharesTotalSupply: sharesTotalSupply})
        );

        nextPayoutCall = nextPayoutCall.add(stepTimestamp);

        emit MakePayout(payout, sharesTotalSupply, now);
    }

readPayout keyboard_arrow_up

    function readPayout() external view returns (uint256) {
        uint256 amountTokenInDay = IERC20Upgradeable(addresses.mainToken).balanceOf(address(this));

        uint256 currentTokenTotalSupply = (IERC20Upgradeable(addresses.mainToken).totalSupply()).add(
            globalPayin
        );

        uint256 inflation = uint256(8)
            .mul(currentTokenTotalSupply.add(sharesTotalSupply))
            .div(36500);

        return amountTokenInDay.add(inflation);
    }

setupRole keyboard_arrow_up

    function setupRole(bytes32 role, address account) external onlyManager {
        _setupRole(role, account);
    }