Affiliates.sol

/**
 * Copyright 2017-2020, Sovryn, All Rights Reserved.
 * Licensed under the Apache License, Version 2.0.
 */

pragma solidity 0.5.17;
pragma experimental ABIEncoderV2;

import "../core/State.sol";
import "../mixins/EnumerableBytes32Set.sol";
import "../openzeppelin/SafeERC20.sol";
import "../events/AffiliatesEvents.sol";
import "../feeds/IPriceFeeds.sol";
import "../locked/ILockedSOV.sol";
import "../mixins/ModuleCommonFunctionalities.sol";

/**
 * @title Affiliates contract.
 * @notice Track referrals and reward referrers (affiliates) with tokens.
 *   In-detail specifications are found at https://wiki.sovryn.app/en/community/Affiliates
 * @dev Module: Affiliates upgradable
 *   Storage: from State, functions called from Protocol by delegatecall
 */
contract Affiliates is State, AffiliatesEvents, ModuleCommonFunctionalities {
    using SafeERC20 for IERC20;

    /**
     * @notice Void constructor.
     */
    // solhint-disable-next-line no-empty-blocks
    constructor() public {}

    /**
     * @notice Avoid calls to this contract except for those explicitly declared.
     */
    function() external {
        revert("Affiliates - fallback not allowed");
    }

    /**
     * @notice Set delegate callable functions by proxy contract.
     * @dev This contract is designed as a module, this way logic can be
     *   expanded and upgraded w/o losing storage that is kept in the protocol (State.sol)
     *   initialize() is used to register in the proxy external (module) functions
     *   to be called via the proxy.
     * @param target The address of a new logic implementation.
     */
    function initialize(address target) external onlyOwner {
        address prevModuleContractAddress = logicTargets[this.setAffiliatesReferrer.selector];
        _setTarget(this.setAffiliatesReferrer.selector, target);
        _setTarget(this.getUserNotFirstTradeFlag.selector, target);
        _setTarget(this.getReferralsList.selector, target);
        _setTarget(this.setUserNotFirstTradeFlag.selector, target);
        _setTarget(this.payTradingFeeToAffiliatesReferrer.selector, target);
        _setTarget(this.getAffiliatesReferrerBalances.selector, target);
        _setTarget(this.getAffiliatesReferrerTokenBalance.selector, target);
        _setTarget(this.getAffiliatesReferrerTokensList.selector, target);
        _setTarget(this.withdrawAffiliatesReferrerTokenFees.selector, target);
        _setTarget(this.withdrawAllAffiliatesReferrerTokenFees.selector, target);
        _setTarget(this.getMinReferralsToPayout.selector, target);
        _setTarget(this.getAffiliatesUserReferrer.selector, target);
        _setTarget(this.getAffiliateRewardsHeld.selector, target);
        _setTarget(this.getAffiliateTradingTokenFeePercent.selector, target);
        _setTarget(this.getAffiliatesTokenRewardsValueInRbtc.selector, target);
        emit ProtocolModuleContractReplaced(prevModuleContractAddress, target, "Affiliates");
    }

    /**
     * @notice Function modifier to avoid any other calls not coming from loan pools.
     */
    modifier onlyCallableByLoanPools() {
        require(loanPoolToUnderlying[msg.sender] != address(0), "Affiliates: not authorized");
        _;
    }

    /**
     * @notice Function modifier to avoid any other calls not coming from within protocol functions.
     */
    modifier onlyCallableInternal() {
        require(msg.sender == protocolAddress, "Affiliates: not authorized");
        _;
    }

    /**
     * @notice Data structure comprised of 3 flags to compute the result of setting a referrer.
     */
    struct SetAffiliatesReferrerResult {
        bool success;
        bool alreadySet;
        bool userNotFirstTradeFlag;
    }

    /**
     * @notice Loan pool calls this function to tell affiliates
     *   a user coming from a referrer is trading and should be registered if not yet.
     *   Taking into account some user status flags may lead to the user and referrer
     *   become added or not to the affiliates record.
     *
     * @param user The address of the user that is trading on loan pools.
     * @param referrer The address of the referrer the user is coming from.
     */
    function setAffiliatesReferrer(
        address user,
        address referrer
    ) external onlyCallableByLoanPools whenNotPaused {
        SetAffiliatesReferrerResult memory result;

        result.userNotFirstTradeFlag = getUserNotFirstTradeFlag(user);
        result.alreadySet = affiliatesUserReferrer[user] != address(0);
        result.success = !(result.userNotFirstTradeFlag || result.alreadySet || user == referrer);
        if (result.success) {
            affiliatesUserReferrer[user] = referrer;
            referralsList[referrer].add(user);
            emit SetAffiliatesReferrer(user, referrer);
        } else {
            emit SetAffiliatesReferrerFail(
                user,
                referrer,
                result.alreadySet,
                result.userNotFirstTradeFlag
            );
        }
    }

    /**
     * @notice Getter to query the referrals coming from a referrer.
     * @param referrer The address of a given referrer.
     * @return The referralsList mapping value by referrer.
     */
    function getReferralsList(address referrer) external view returns (address[] memory refList) {
        refList = referralsList[referrer].enumerate();
        return refList;
    }

    /**
     * @notice Getter to query the not-first-trade flag of a user.
     * @param user The address of a given user.
     * @return The userNotFirstTradeFlag mapping value by user.
     */
    function getUserNotFirstTradeFlag(address user) public view returns (bool) {
        return userNotFirstTradeFlag[user];
    }

    /**
     * @notice Setter to toggle on the not-first-trade flag of a user.
     * @param user The address of a given user.
     */
    function setUserNotFirstTradeFlag(
        address user
    ) external onlyCallableByLoanPools whenNotPaused {
        if (!userNotFirstTradeFlag[user]) {
            userNotFirstTradeFlag[user] = true;
            emit SetUserNotFirstTradeFlag(user);
        }
    }

    /**
     * @notice Internal getter to query the fee share for affiliate program.
     * @dev It returns a value defined at protocol storage (State.sol)
     * @return The percentage of fee share w/ 18 decimals.
     */
    function _getAffiliatesTradingFeePercentForSOV() internal view returns (uint256) {
        return affiliateFeePercent;
    }

    /**
     * @notice Internal to calculate the affiliates trading token fee amount.
     *   Affiliates program has 2 kind of rewards:
     *     1. x% based on the fee of the token that is traded (in form of the token itself).
     *     2. x% based on the fee of the token that is traded (in form of SOV).
     *   This _getReferrerTradingFeeForToken calculates the first one
     *   by applying a custom percentage multiplier.
     * @param feeTokenAmount The trading token fee amount.
     * @return The affiliates share of the trading token fee amount.
     */
    function _getReferrerTradingFeeForToken(
        uint256 feeTokenAmount
    ) internal view returns (uint256) {
        return feeTokenAmount.mul(getAffiliateTradingTokenFeePercent()).div(10 ** 20);
    }

    /**
     * @notice Getter to query the fee share of trading token fee for affiliate program.
     * @dev It returns a value defined at protocol storage (State.sol)
     * @return The percentage of fee share w/ 18 decimals.
     */
    function getAffiliateTradingTokenFeePercent() public view returns (uint256) {
        return affiliateTradingTokenFeePercent;
    }

    /**
     * @notice Getter to query referral threshold for paying out to the referrer.
     * @dev It returns a value defined at protocol storage (State.sol)
     * @return The minimum number of referrals set by Protocol.
     */
    function getMinReferralsToPayout() public view returns (uint256) {
        return minReferralsToPayout;
    }

    /**
     * @notice Get the sovToken reward of a trade.
     * @dev The reward is worth x% of the trading fee.
     * @param feeToken The address of the token in which the trading/borrowing fee was paid.
     * @param feeAmount The height of the fee.
     * @return The reward amount.
     * */
    function _getSovBonusAmount(
        address feeToken,
        uint256 feeAmount
    ) internal view returns (uint256) {
        uint256 rewardAmount;
        address _priceFeeds = priceFeeds;

        /// @dev Calculate the reward amount, querying the price feed.
        (bool success, bytes memory data) = _priceFeeds.staticcall(
            abi.encodeWithSelector(
                IPriceFeeds(_priceFeeds).queryReturn.selector,
                feeToken,
                sovTokenAddress, /// dest token = SOV
                feeAmount.mul(_getAffiliatesTradingFeePercentForSOV()).div(1e20)
            )
        );
        // solhint-disable-next-line no-inline-assembly
        assembly {
            if eq(success, 1) {
                rewardAmount := mload(add(data, 32))
            }
        }

        return rewardAmount;
    }

    /**
     * @notice Protocol calls this function to pay the affiliates rewards to a user (referrer).
     *
     * @dev Affiliates program has 2 kind of rewards:
     *     1. x% based on the fee of the token that is traded (in form of the token itself).
     *     2. x% based on the fee of the token that is traded (in form of SOV).
     *   Both are paid in this function.
     *
     * @dev Actually they are not paid, but just holded by protocol until user claims them by
     *   actively calling withdrawAffiliatesReferrerTokenFees() function,
     *   and/or when unvesting lockedSOV.
     *
     * @dev To be precise, what this function does is updating the registers of the rewards
     *   for the referrer including the assignment of the SOV tokens as rewards to the
     *   referrer's vesting contract.
     *
     * @param referrer The address of the referrer.
     * @param trader The address of the trader.
     * @param token The address of the token in which the trading/borrowing fee was paid.
     * @param tradingFeeTokenBaseAmount Total trading fee amount, the base for calculating referrer's fees.
     *
     * @return referrerBonusSovAmount The amount of SOV tokens paid to the referrer (through a vesting contract, lockedSOV).
     * @return referrerBonusTokenAmount The amount of trading tokens paid directly to the referrer.
     */
    function payTradingFeeToAffiliatesReferrer(
        address referrer,
        address trader,
        address token,
        uint256 tradingFeeTokenBaseAmount
    )
        external
        onlyCallableInternal
        whenNotPaused
        returns (uint256 referrerBonusSovAmount, uint256 referrerBonusTokenAmount)
    {
        bool isHeld = referralsList[referrer].length() < getMinReferralsToPayout();
        bool bonusPaymentIsSuccess = true;
        uint256 paidReferrerBonusSovAmount;

        /// Process token fee rewards first.
        referrerBonusTokenAmount = _getReferrerTradingFeeForToken(tradingFeeTokenBaseAmount);
        if (!affiliatesReferrerTokensList[referrer].contains(token))
            affiliatesReferrerTokensList[referrer].add(token);
        affiliatesReferrerBalances[referrer][token] = affiliatesReferrerBalances[referrer][token]
            .add(referrerBonusTokenAmount);

        /// Then process SOV rewards.
        referrerBonusSovAmount = _getSovBonusAmount(token, tradingFeeTokenBaseAmount);
        uint256 rewardsHeldByProtocol = affiliateRewardsHeld[referrer];

        if (isHeld) {
            /// If referrals less than minimum, temp the rewards SOV to the storage
            affiliateRewardsHeld[referrer] = rewardsHeldByProtocol.add(referrerBonusSovAmount);
        } else {
            /// If referrals >= minimum, directly send all of the remain rewards to locked sov
            /// Call depositSOV() in LockedSov contract
            /// Set the affiliaterewardsheld = 0
            if (affiliateRewardsHeld[referrer] > 0) {
                affiliateRewardsHeld[referrer] = 0;
            }

            paidReferrerBonusSovAmount = referrerBonusSovAmount.add(rewardsHeldByProtocol);
            IERC20(sovTokenAddress).approve(lockedSOVAddress, paidReferrerBonusSovAmount);

            (bool success, ) = lockedSOVAddress.call(
                abi.encodeWithSignature(
                    "depositSOV(address,uint256)",
                    referrer,
                    paidReferrerBonusSovAmount
                )
            );

            if (!success) {
                bonusPaymentIsSuccess = false;
            }
        }

        if (bonusPaymentIsSuccess) {
            emit PayTradingFeeToAffiliate(
                referrer,
                trader, // trader
                token,
                isHeld,
                tradingFeeTokenBaseAmount,
                referrerBonusTokenAmount,
                referrerBonusSovAmount,
                paidReferrerBonusSovAmount
            );
        } else {
            emit PayTradingFeeToAffiliateFail(
                referrer,
                trader, // trader
                token,
                tradingFeeTokenBaseAmount,
                referrerBonusTokenAmount,
                referrerBonusSovAmount,
                paidReferrerBonusSovAmount
            );
        }

        return (referrerBonusSovAmount, referrerBonusTokenAmount);
    }

    /**
     * @notice Referrer calls this function to receive its reward in a given token.
     *   It will send the other (non-SOV) reward tokens from trading protocol fees,
     *   to the referrer’s wallet.
     * @dev Rewards are held by protocol in different tokens coming from trading fees.
     *   Referrer has to claim them one by one for every token with accumulated balance.
     * @param token The address of the token to withdraw.
     * @param receiver The address of the withdrawal beneficiary.
     * @param amount The amount of tokens to claim. If greater than balance, just sends balance.
     */
    function withdrawAffiliatesReferrerTokenFees(
        address token,
        address receiver,
        uint256 amount
    ) public whenNotPaused {
        require(receiver != address(0), "Affiliates: cannot withdraw to zero address");
        address referrer = msg.sender;
        uint256 referrerTokenBalance = affiliatesReferrerBalances[referrer][token];
        uint256 withdrawAmount = referrerTokenBalance > amount ? amount : referrerTokenBalance;

        require(withdrawAmount > 0, "Affiliates: cannot withdraw zero amount");

        require(
            referralsList[referrer].length() >= getMinReferralsToPayout(),
            "Your referrals has not reached the minimum request"
        );

        uint256 newReferrerTokenBalance = referrerTokenBalance.sub(withdrawAmount);

        if (newReferrerTokenBalance == 0) {
            _removeAffiliatesReferrerToken(referrer, token);
        } else {
            affiliatesReferrerBalances[referrer][token] = newReferrerTokenBalance;
        }

        IERC20(token).safeTransfer(receiver, withdrawAmount);

        emit WithdrawAffiliatesReferrerTokenFees(referrer, receiver, token, withdrawAmount);
    }

    /**
     * @notice Withdraw to msg.sender all token fees for a referrer.
     * @dev It's done by looping through its available tokens.
     * @param receiver The address of the withdrawal beneficiary.
     */
    function withdrawAllAffiliatesReferrerTokenFees(address receiver) external whenNotPaused {
        require(receiver != address(0), "Affiliates: cannot withdraw to zero address");
        address referrer = msg.sender;

        require(
            referralsList[referrer].length() >= getMinReferralsToPayout(),
            "Your referrals has not reached the minimum request"
        );

        (
            address[] memory tokenAddresses,
            uint256[] memory tokenBalances
        ) = getAffiliatesReferrerBalances(referrer);
        for (uint256 i; i < tokenAddresses.length; i++) {
            withdrawAffiliatesReferrerTokenFees(tokenAddresses[i], receiver, tokenBalances[i]);
        }
    }

    /**
     * @notice Internal function to delete a referrer's token balance.
     * @param referrer The address of the referrer.
     * @param token The address of the token specifying the balance to remove.
     */
    function _removeAffiliatesReferrerToken(address referrer, address token) internal {
        delete affiliatesReferrerBalances[referrer][token];
        affiliatesReferrerTokensList[referrer].remove(token);
    }

    /**
     * @notice Get all token balances of a referrer.
     * @param referrer The address of the referrer.
     * @return referrerTokensList The array of available tokens (keys).
     * @return referrerTokensBalances The array of token balances (values).
     */
    function getAffiliatesReferrerBalances(
        address referrer
    )
        public
        view
        returns (address[] memory referrerTokensList, uint256[] memory referrerTokensBalances)
    {
        referrerTokensList = getAffiliatesReferrerTokensList(referrer);
        referrerTokensBalances = new uint256[](referrerTokensList.length);
        for (uint256 i; i < referrerTokensList.length; i++) {
            referrerTokensBalances[i] = getAffiliatesReferrerTokenBalance(
                referrer,
                referrerTokensList[i]
            );
        }
        return (referrerTokensList, referrerTokensBalances);
    }

    /**
     * @dev Get all token rewards estimation value in rbtc.
     *
     * @param referrer Address of referrer.
     *
     * @return The value estimation in rbtc.
     */
    function getAffiliatesTokenRewardsValueInRbtc(
        address referrer
    ) external view returns (uint256 rbtcTotalAmount) {
        address[] memory tokensList = getAffiliatesReferrerTokensList(referrer);
        address _priceFeeds = priceFeeds;

        for (uint256 i; i < tokensList.length; i++) {
            // Get the value of each token in rbtc

            (bool success, bytes memory data) = _priceFeeds.staticcall(
                abi.encodeWithSelector(
                    IPriceFeeds(_priceFeeds).queryReturn.selector,
                    tokensList[i], // source token
                    address(wrbtcToken), // dest token = SOV
                    affiliatesReferrerBalances[referrer][tokensList[i]] // total token rewards
                )
            );

            assembly {
                if eq(success, 1) {
                    rbtcTotalAmount := add(rbtcTotalAmount, mload(add(data, 32)))
                }
            }
        }
    }

    /**
     * @notice Get all available tokens at the affiliates program for a given referrer.
     * @param referrer The address of a given referrer.
     * @return tokensList The list of available tokens.
     */
    function getAffiliatesReferrerTokensList(
        address referrer
    ) public view returns (address[] memory tokensList) {
        tokensList = affiliatesReferrerTokensList[referrer].enumerate();
        return tokensList;
    }

    /**
     * @notice Getter to query the affiliate balance for a given referrer and token.
     * @param referrer The address of the referrer.
     * @param token The address of the token to get balance for.
     * @return The affiliatesReferrerBalances mapping value by referrer and token keys.
     */
    function getAffiliatesReferrerTokenBalance(
        address referrer,
        address token
    ) public view returns (uint256) {
        return affiliatesReferrerBalances[referrer][token];
    }

    /**
     * @notice Getter to query the address of referrer for a given user.
     * @param user The address of the user.
     * @return The address on affiliatesUserReferrer mapping value by user key.
     */
    function getAffiliatesUserReferrer(address user) public view returns (address) {
        return affiliatesUserReferrer[user];
    }

    /**
     * @notice Getter to query the reward amount held for a given referrer.
     * @param referrer The address of the referrer.
     * @return The affiliateRewardsHeld mapping value by referrer key.
     */
    function getAffiliateRewardsHeld(address referrer) public view returns (uint256) {
        return affiliateRewardsHeld[referrer];
    }
}