Contract 0xf3a5454496e26ac57da879bf3285fa85debf0388 5

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./rewarders/IComplexRewarder.sol";
import "./libraries/BoringERC20.sol";
import "./IStellaPair.sol";

contract StellaDistributorV2 is Ownable, ReentrancyGuard {
    using BoringERC20 for IBoringERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 rewardLockedUp; // Reward locked up.
        uint256 nextHarvestUntil; // When can the user harvest again.
    }

    // Info of each pool.
    struct PoolInfo {
        IBoringERC20 lpToken; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. Stella to distribute per block.
        uint256 lastRewardTimestamp; // Last block number that Stella distribution occurs.
        uint256 accStellaPerShare; // Accumulated Stella per share, times 1e18. See below.
        uint16 depositFeeBP; // Deposit fee in basis points
        uint256 harvestInterval; // Harvest interval in seconds
        uint256 totalLp; // Total token in Pool
        IComplexRewarder[] rewarders; // Array of rewarder contract for pools with incentives
    }

    IBoringERC20 public stella;

    // Stella tokens created per second
    uint256 public stellaPerSec;

    // Max harvest interval: 14 days
    uint256 public constant MAXIMUM_HARVEST_INTERVAL = 14 days;

    // Maximum deposit fee rate: 10%
    uint16 public constant MAXIMUM_DEPOSIT_FEE_RATE = 1000;

    // Info of each pool
    PoolInfo[] public poolInfo;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    // The timestamp when Stella mining starts.
    uint256 public startTimestamp;

    // Total locked up rewards
    uint256 public totalLockedUpRewards;

    // Total Stella in Stella Pools (can be multiple pools)
    uint256 public totalStellaInPools = 0;

    // Team address.
    address public teamAddress;

    // Treasury address.
    address public treasuryAddress;

    // Investor address.
    address public investorAddress;

    // Percentage of pool rewards that goto the team.
    uint256 public teamPercent;

    // Percentage of pool rewards that goes to the treasury.
    uint256 public treasuryPercent;

    // Percentage of pool rewards that goes to the investor.
    uint256 public investorPercent;

    // The precision factor
    uint256 private immutable ACC_TOKEN_PRECISION = 1e12;

    modifier validatePoolByPid(uint256 _pid) {
        require(_pid < poolInfo.length, "Pool does not exist");
        _;
    }

    event Add(
        uint256 indexed pid,
        uint256 allocPoint,
        IBoringERC20 indexed lpToken,
        uint16 depositFeeBP,
        uint256 harvestInterval,
        IComplexRewarder[] indexed rewarders
    );

    event Set(
        uint256 indexed pid,
        uint256 allocPoint,
        uint16 depositFeeBP,
        uint256 harvestInterval,
        IComplexRewarder[] indexed rewarders
    );

    event UpdatePool(
        uint256 indexed pid,
        uint256 lastRewardTimestamp,
        uint256 lpSupply,
        uint256 accStellaPerShare
    );

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);

    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);

    event EmergencyWithdraw(
        address indexed user,
        uint256 indexed pid,
        uint256 amount
    );

    event EmissionRateUpdated(
        address indexed caller,
        uint256 previousValue,
        uint256 newValue
    );

    event RewardLockedUp(
        address indexed user,
        uint256 indexed pid,
        uint256 amountLockedUp
    );

    event AllocPointsUpdated(
        address indexed caller,
        uint256 previousAmount,
        uint256 newAmount
    );

    event SetTeamAddress(
        address indexed oldAddress,
        address indexed newAddress
    );

    event SetTreasuryAddress(
        address indexed oldAddress,
        address indexed newAddress
    );

    event SetInvestorAddress(
        address indexed oldAddress,
        address indexed newAddress
    );

    event SetTeamPercent(uint256 oldPercent, uint256 newPercent);

    event SetTreasuryPercent(uint256 oldPercent, uint256 newPercent);

    event SetInvestorPercent(uint256 oldPercent, uint256 newPercent);

    constructor(
        IBoringERC20 _stella,
        uint256 _stellaPerSec,
        address _teamAddress,
        address _treasuryAddress,
        address _investorAddress,
        uint256 _teamPercent,
        uint256 _treasuryPercent,
        uint256 _investorPercent
    ) {
        require(
            _teamPercent <= 1000,
            "constructor: invalid team percent value"
        );
        require(
            _treasuryPercent <= 1000,
            "constructor: invalid treasury percent value"
        );
        require(
            _investorPercent <= 1000,
            "constructor: invalid investor percent value"
        );
        require(
            _teamPercent + _treasuryPercent + _investorPercent <= 1000,
            "constructor: total percent over max"
        );

        //StartBlock always many years later from contract const ruct, will be set later in StartFarming function
        startTimestamp = block.timestamp + (60 * 60 * 24 * 365);

        stella = _stella;
        stellaPerSec = _stellaPerSec;

        teamAddress = _teamAddress;
        treasuryAddress = _treasuryAddress;
        investorAddress = _investorAddress;

        teamPercent = _teamPercent;
        treasuryPercent = _treasuryPercent;
        investorPercent = _investorPercent;
    }

    // Set farming start, can call only once
    function startFarming() public onlyOwner {
        require(
            block.timestamp < startTimestamp,
            "start farming: farm started already"
        );

        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            PoolInfo storage pool = poolInfo[pid];
            pool.lastRewardTimestamp = block.timestamp;
        }

        startTimestamp = block.timestamp;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    // Can add multiple pool with same lp token without messing up rewards, because each pool's balance is tracked using its own totalLp
    function add(
        uint256 _allocPoint,
        IBoringERC20 _lpToken,
        uint16 _depositFeeBP,
        uint256 _harvestInterval,
        IComplexRewarder[] calldata _rewarders
    ) public onlyOwner {
        require(_rewarders.length <= 10, "add: too many rewarders");
        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "add: deposit fee too high"
        );
        require(
            _harvestInterval <= MAXIMUM_HARVEST_INTERVAL,
            "add: invalid harvest interval"
        );
        require(
            Address.isContract(address(_lpToken)),
            "add: LP token must be a valid contract"
        );

        for (
            uint256 rewarderId = 0;
            rewarderId < _rewarders.length;
            ++rewarderId
        ) {
            require(
                Address.isContract(address(_rewarders[rewarderId])),
                "add: rewarder must be contract"
            );
        }

        _massUpdatePools();

        uint256 lastRewardTimestamp = block.timestamp > startTimestamp
            ? block.timestamp
            : startTimestamp;

        totalAllocPoint += _allocPoint;

        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardTimestamp: lastRewardTimestamp,
                accStellaPerShare: 0,
                depositFeeBP: _depositFeeBP,
                harvestInterval: _harvestInterval,
                totalLp: 0,
                rewarders: _rewarders
            })
        );

        emit Add(
            poolInfo.length - 1,
            _allocPoint,
            _lpToken,
            _depositFeeBP,
            _harvestInterval,
            _rewarders
        );
    }

    // Update the given pool's Stella allocation point and deposit fee. Can only be called by the owner.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        uint16 _depositFeeBP,
        uint256 _harvestInterval,
        IComplexRewarder[] calldata _rewarders
    ) public onlyOwner validatePoolByPid(_pid) {
        require(_rewarders.length <= 10, "set: too many rewarders");

        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "set: deposit fee too high"
        );
        require(
            _harvestInterval <= MAXIMUM_HARVEST_INTERVAL,
            "set: invalid harvest interval"
        );

        for (
            uint256 rewarderId = 0;
            rewarderId < _rewarders.length;
            ++rewarderId
        ) {
            require(
                Address.isContract(address(_rewarders[rewarderId])),
                "set: rewarder must be contract"
            );
        }

        _massUpdatePools();

        totalAllocPoint =
            totalAllocPoint -
            poolInfo[_pid].allocPoint +
            _allocPoint;

        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
        poolInfo[_pid].harvestInterval = _harvestInterval;
        poolInfo[_pid].rewarders = _rewarders;

        emit Set(
            _pid,
            _allocPoint,
            _depositFeeBP,
            _harvestInterval,
            _rewarders
        );
    }

    // View function to see pending rewards on frontend.
    function pendingTokens(uint256 _pid, address _user)
        external
        view
        validatePoolByPid(_pid)
        returns (
            address[] memory addresses,
            string[] memory symbols,
            uint256[] memory decimals,
            uint256[] memory amounts
        )
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accStellaPerShare = pool.accStellaPerShare;
        uint256 lpSupply = pool.totalLp;

        if (block.timestamp > pool.lastRewardTimestamp && lpSupply != 0) {
            uint256 multiplier = block.timestamp - pool.lastRewardTimestamp;
            uint256 total = 1000;
            uint256 lpPercent = total -
                teamPercent -
                treasuryPercent -
                investorPercent;

            uint256 stellaReward = (multiplier *
                stellaPerSec *
                pool.allocPoint *
                lpPercent) /
                totalAllocPoint /
                total;

            accStellaPerShare += (
                ((stellaReward * ACC_TOKEN_PRECISION) / lpSupply)
            );
        }

        uint256 pendingStella = (((user.amount * accStellaPerShare) /
            ACC_TOKEN_PRECISION) - user.rewardDebt) + user.rewardLockedUp;

        addresses = new address[](pool.rewarders.length + 1);
        symbols = new string[](pool.rewarders.length + 1);
        amounts = new uint256[](pool.rewarders.length + 1);
        decimals = new uint256[](pool.rewarders.length + 1);

        addresses[0] = address(stella);
        symbols[0] = IBoringERC20(stella).safeSymbol();
        decimals[0] = IBoringERC20(stella).safeDecimals();
        amounts[0] = pendingStella;

        for (
            uint256 rewarderId = 0;
            rewarderId < pool.rewarders.length;
            ++rewarderId
        ) {
            addresses[rewarderId + 1] = address(
                pool.rewarders[rewarderId].rewardToken()
            );

            symbols[rewarderId + 1] = IBoringERC20(
                pool.rewarders[rewarderId].rewardToken()
            ).safeSymbol();

            decimals[rewarderId + 1] = IBoringERC20(
                pool.rewarders[rewarderId].rewardToken()
            ).safeDecimals();

            amounts[rewarderId + 1] = pool.rewarders[rewarderId].pendingTokens(
                _pid,
                _user
            );
        }
    }

    /// @notice View function to see pool rewards per sec
    function poolRewardsPerSec(uint256 _pid)
        external
        view
        validatePoolByPid(_pid)
        returns (
            address[] memory addresses,
            string[] memory symbols,
            uint256[] memory decimals,
            uint256[] memory rewardsPerSec
        )
    {
        PoolInfo storage pool = poolInfo[_pid];

        addresses = new address[](pool.rewarders.length + 1);
        symbols = new string[](pool.rewarders.length + 1);
        decimals = new uint256[](pool.rewarders.length + 1);
        rewardsPerSec = new uint256[](pool.rewarders.length + 1);

        addresses[0] = address(stella);
        symbols[0] = IBoringERC20(stella).safeSymbol();
        decimals[0] = IBoringERC20(stella).safeDecimals();

        uint256 total = 1000;
        uint256 lpPercent = total -
            teamPercent -
            treasuryPercent -
            investorPercent;

        rewardsPerSec[0] =
            (pool.allocPoint * stellaPerSec * lpPercent) /
            totalAllocPoint /
            total;

        for (
            uint256 rewarderId = 0;
            rewarderId < pool.rewarders.length;
            ++rewarderId
        ) {
            addresses[rewarderId + 1] = address(
                pool.rewarders[rewarderId].rewardToken()
            );

            symbols[rewarderId + 1] = IBoringERC20(
                pool.rewarders[rewarderId].rewardToken()
            ).safeSymbol();

            decimals[rewarderId + 1] = IBoringERC20(
                pool.rewarders[rewarderId].rewardToken()
            ).safeDecimals();

            rewardsPerSec[rewarderId + 1] = pool
                .rewarders[rewarderId]
                .poolRewardsPerSec(_pid);
        }
    }

    // View function to see rewarders for a pool
    function poolRewarders(uint256 _pid)
        external
        view
        validatePoolByPid(_pid)
        returns (address[] memory rewarders)
    {
        PoolInfo storage pool = poolInfo[_pid];
        rewarders = new address[](pool.rewarders.length);
        for (
            uint256 rewarderId = 0;
            rewarderId < pool.rewarders.length;
            ++rewarderId
        ) {
            rewarders[rewarderId] = address(pool.rewarders[rewarderId]);
        }
    }

    // View function to see if user can harvest Stella.
    function canHarvest(uint256 _pid, address _user)
        public
        view
        validatePoolByPid(_pid)
        returns (bool)
    {
        UserInfo storage user = userInfo[_pid][_user];
        return
            block.timestamp >= startTimestamp &&
            block.timestamp >= user.nextHarvestUntil;
    }

    // Update reward vairables for all pools. Be careful of gas spending!
    function massUpdatePools() external nonReentrant {
        _massUpdatePools();
    }

    // Internal method for massUpdatePools
    function _massUpdatePools() internal {
        for (uint256 pid = 0; pid < poolInfo.length; ++pid) {
            _updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) external nonReentrant {
        _updatePool(_pid);
    }

    // Internal method for _updatePool
    function _updatePool(uint256 _pid) internal validatePoolByPid(_pid) {
        PoolInfo storage pool = poolInfo[_pid];

        if (block.timestamp <= pool.lastRewardTimestamp) {
            return;
        }

        uint256 lpSupply = pool.totalLp;

        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardTimestamp = block.timestamp;
            return;
        }

        uint256 multiplier = block.timestamp - pool.lastRewardTimestamp;

        uint256 stellaReward = ((multiplier * stellaPerSec) * pool.allocPoint) /
            totalAllocPoint;

        uint256 total = 1000;
        uint256 lpPercent = total -
            teamPercent -
            treasuryPercent -
            investorPercent;

        stella.mint(teamAddress, (stellaReward * teamPercent) / total);
        stella.mint(treasuryAddress, (stellaReward * treasuryPercent) / total);
        stella.mint(investorAddress, (stellaReward * investorPercent) / total);
        stella.mint(address(this), (stellaReward * lpPercent) / total);

        pool.accStellaPerShare +=
            (stellaReward * ACC_TOKEN_PRECISION * lpPercent) /
            pool.totalLp /
            total;

        pool.lastRewardTimestamp = block.timestamp;

        emit UpdatePool(
            _pid,
            pool.lastRewardTimestamp,
            lpSupply,
            pool.accStellaPerShare
        );
    }

    function depositWithPermit(
        uint256 pid,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public nonReentrant validatePoolByPid(pid) {
        PoolInfo storage pool = poolInfo[pid];
        IStellaPair pair = IStellaPair(address(pool.lpToken));
        pair.permit(msg.sender, address(this), amount, deadline, v, r, s);
        _deposit(pid, amount);
    }

    // Deposit tokens for Stella allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        _deposit(_pid, _amount);
    }

    // Deposit tokens for Stella allocation.
    function _deposit(uint256 _pid, uint256 _amount)
        internal
        validatePoolByPid(_pid)
    {
        require(
            block.timestamp >= startTimestamp,
            "deposit: farming not started"
        );

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        _updatePool(_pid);

        payOrLockupPendingStella(_pid);

        if (_amount > 0) {
            uint256 beforeDeposit = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(msg.sender, address(this), _amount);
            uint256 afterDeposit = pool.lpToken.balanceOf(address(this));

            _amount = afterDeposit - beforeDeposit;

            if (pool.depositFeeBP > 0) {
                uint256 depositFee = (_amount * pool.depositFeeBP) / 10000;
                pool.lpToken.safeTransfer(treasuryAddress, depositFee);

                _amount = _amount - depositFee;
            }

            user.amount += _amount;

            if (address(pool.lpToken) == address(stella)) {
                totalStellaInPools += _amount;
            }
        }
        user.rewardDebt =
            (user.amount * pool.accStellaPerShare) /
            ACC_TOKEN_PRECISION;

        for (
            uint256 rewarderId = 0;
            rewarderId < pool.rewarders.length;
            ++rewarderId
        ) {
            pool.rewarders[rewarderId].onStellaReward(
                _pid,
                msg.sender,
                user.amount
            );
        }

        if (_amount > 0) {
            pool.totalLp += _amount;
        }

        emit Deposit(msg.sender, _pid, _amount);
    }

    //withdraw tokens
    function withdraw(uint256 _pid, uint256 _amount)
        public
        nonReentrant
        validatePoolByPid(_pid)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        //this will make sure that user can only withdraw from his pool
        require(user.amount >= _amount, "withdraw: user amount not enough");

        //cannot withdraw more than pool's balance
        require(pool.totalLp >= _amount, "withdraw: pool total not enough");

        _updatePool(_pid);

        payOrLockupPendingStella(_pid);

        if (_amount > 0) {
            user.amount -= _amount;
            if (address(pool.lpToken) == address(stella)) {
                totalStellaInPools -= _amount;
            }
            pool.lpToken.safeTransfer(msg.sender, _amount);
        }

        user.rewardDebt =
            (user.amount * pool.accStellaPerShare) /
            ACC_TOKEN_PRECISION;

        for (
            uint256 rewarderId = 0;
            rewarderId < pool.rewarders.length;
            ++rewarderId
        ) {
            pool.rewarders[rewarderId].onStellaReward(
                _pid,
                msg.sender,
                user.amount
            );
        }

        if (_amount > 0) {
            pool.totalLp -= _amount;
        }

        emit Withdraw(msg.sender, _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 amount = user.amount;

        //Cannot withdraw more than pool's balance
        require(
            pool.totalLp >= amount,
            "emergency withdraw: pool total not enough"
        );

        user.amount = 0;
        user.rewardDebt = 0;
        user.rewardLockedUp = 0;
        user.nextHarvestUntil = 0;
        pool.totalLp -= amount;

        for (
            uint256 rewarderId = 0;
            rewarderId < pool.rewarders.length;
            ++rewarderId
        ) {
            pool.rewarders[rewarderId].onStellaReward(_pid, msg.sender, 0);
        }

        if (address(pool.lpToken) == address(stella)) {
            totalStellaInPools -= amount;
        }

        pool.lpToken.safeTransfer(msg.sender, amount);

        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }

    // Pay or lockup pending Stella.
    function payOrLockupPendingStella(uint256 _pid) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        if (user.nextHarvestUntil == 0 && block.timestamp >= startTimestamp) {
            user.nextHarvestUntil = block.timestamp + pool.harvestInterval;
        }

        uint256 pending = ((user.amount * pool.accStellaPerShare) /
            ACC_TOKEN_PRECISION) - user.rewardDebt;

        if (canHarvest(_pid, msg.sender)) {
            if (pending > 0 || user.rewardLockedUp > 0) {
                uint256 pendingRewards = pending + user.rewardLockedUp;

                // reset lockup
                totalLockedUpRewards -= user.rewardLockedUp;
                user.rewardLockedUp = 0;
                user.nextHarvestUntil = block.timestamp + pool.harvestInterval;

                // send rewards
                safeStellaTransfer(msg.sender, pendingRewards);
            }
        } else if (pending > 0) {
            totalLockedUpRewards += pending;
            user.rewardLockedUp += pending;
            emit RewardLockedUp(msg.sender, _pid, pending);
        }
    }

    // Safe Stella transfer function, just in case if rounding error causes pool do not have enough Stella.
    function safeStellaTransfer(address _to, uint256 _amount) internal {
        if (stella.balanceOf(address(this)) > totalStellaInPools) {
            //stellaBal = total Stella in StellaDistributor - total Stella in Stella pools, this will make sure that StellaDistributor never transfer rewards from deposited Stella pools
            uint256 stellaBal = stella.balanceOf(address(this)) -
                totalStellaInPools;
            if (_amount >= stellaBal) {
                stella.safeTransfer(_to, stellaBal);
            } else if (_amount > 0) {
                stella.safeTransfer(_to, _amount);
            }
        }
    }

    function updateEmissionRate(uint256 _stellaPerSec) public onlyOwner {
        _massUpdatePools();

        emit EmissionRateUpdated(msg.sender, stellaPerSec, _stellaPerSec);

        stellaPerSec = _stellaPerSec;
    }

    function updateAllocPoint(uint256 _pid, uint256 _allocPoint)
        public
        onlyOwner
    {
        _massUpdatePools();

        emit AllocPointsUpdated(
            msg.sender,
            poolInfo[_pid].allocPoint,
            _allocPoint
        );

        totalAllocPoint =
            totalAllocPoint -
            poolInfo[_pid].allocPoint +
            _allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    function poolTotalLp(uint256 pid) external view returns (uint256) {
        return poolInfo[pid].totalLp;
    }

    // Function to harvest many pools in a single transaction
    function harvestMany(uint256[] calldata _pids) public nonReentrant {
        require(_pids.length <= 30, "harvest many: too many pool ids");
        for (uint256 index = 0; index < _pids.length; ++index) {
            _deposit(_pids[index], 0);
        }
    }

    // Update team address by the previous team address.
    function setTeamAddress(address _teamAddress) public {
        require(
            msg.sender == teamAddress,
            "set team address: only previous team address can call this method"
        );
        require(
            _teamAddress != address(0),
            "set team address: invalid new team address"
        );
        teamAddress = _teamAddress;
        emit SetTeamAddress(msg.sender, _teamAddress);
    }

    function setTeamPercent(uint256 _newTeamPercent) public onlyOwner {
        require(
            _newTeamPercent <= 1000,
            "set team percent: invalid percent value"
        );
        require(
            treasuryPercent + _newTeamPercent + investorPercent <= 1000,
            "set team percent: total percent over max"
        );
        emit SetTeamPercent(teamPercent, _newTeamPercent);
        teamPercent = _newTeamPercent;
    }

    // Update treasury address by the previous treasury.
    function setTreasuryAddress(address _treasuryAddress) public {
        require(
            msg.sender == treasuryAddress,
            "set treasury address: only previous treasury address can call this method"
        );
        require(
            _treasuryAddress != address(0),
            "set treasury address: invalid new treasury address"
        );
        treasuryAddress = _treasuryAddress;
        emit SetTreasuryAddress(msg.sender, _treasuryAddress);
    }

    function setTreasuryPercent(uint256 _newTreasuryPercent) public onlyOwner {
        require(
            _newTreasuryPercent <= 1000,
            "set treasury percent: invalid percent value"
        );
        require(
            teamPercent + _newTreasuryPercent + investorPercent <= 1000,
            "set treasury percent: total percent over max"
        );
        emit SetTreasuryPercent(treasuryPercent, _newTreasuryPercent);
        treasuryPercent = _newTreasuryPercent;
    }

    // Update the investor address by the previous investor.
    function setInvestorAddress(address _investorAddress) public {
        require(
            msg.sender == investorAddress,
            "set investor address: only previous investor can call this method"
        );
        require(
            _investorAddress != address(0),
            "set investor address: invalid new investor address"
        );
        investorAddress = _investorAddress;
        emit SetInvestorAddress(msg.sender, _investorAddress);
    }

    function setInvestorPercent(uint256 _newInvestorPercent) public onlyOwner {
        require(
            _newInvestorPercent <= 1000,
            "set investor percent: invalid percent value"
        );
        require(
            teamPercent + _newInvestorPercent + treasuryPercent <= 1000,
            "set investor percent: total percent over max"
        );
        emit SetInvestorPercent(investorPercent, _newInvestorPercent);
        investorPercent = _newInvestorPercent;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

import "../libraries/IBoringERC20.sol";

interface IComplexRewarder {
    function onStellaReward(
        uint256 pid,
        address user,
        uint256 newLpAmount
    ) external;

    function pendingTokens(uint256 pid, address user)
        external
        view
        returns (uint256 pending);

    function rewardToken() external view returns (IBoringERC20);

    function poolRewardsPerSec(uint256 pid) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

// solhint-disable avoid-low-level-calls
import "./IBoringERC20.sol";
library BoringERC20 {
    bytes4 private constant SIG_SYMBOL = 0x95d89b41; // symbol()
    bytes4 private constant SIG_NAME = 0x06fdde03; // name()
    bytes4 private constant SIG_DECIMALS = 0x313ce567; // decimals()
    bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
    bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256)

    function returnDataToString(bytes memory data)
        internal
        pure
        returns (string memory)
    {
        if (data.length >= 64) {
            return abi.decode(data, (string));
        } else if (data.length == 32) {
            uint8 i = 0;
            while (i < 32 && data[i] != 0) {
                i++;
            }
            bytes memory bytesArray = new bytes(i);
            for (i = 0; i < 32 && data[i] != 0; i++) {
                bytesArray[i] = data[i];
            }
            return string(bytesArray);
        } else {
            return "???";
        }
    }

    /// @notice Provides a safe ERC20.symbol version which returns '???' as fallback string.
    /// @param token The address of the ERC-20 token contract.
    /// @return (string) Token symbol.
    function safeSymbol(IBoringERC20 token)
        internal
        view
        returns (string memory)
    {
        (bool success, bytes memory data) = address(token).staticcall(
            abi.encodeWithSelector(SIG_SYMBOL)
        );
        return success ? returnDataToString(data) : "???";
    }

    /// @notice Provides a safe ERC20.name version which returns '???' as fallback string.
    /// @param token The address of the ERC-20 token contract.
    /// @return (string) Token name.
    function safeName(IBoringERC20 token)
        internal
        view
        returns (string memory)
    {
        (bool success, bytes memory data) = address(token).staticcall(
            abi.encodeWithSelector(SIG_NAME)
        );
        return success ? returnDataToString(data) : "???";
    }

    /// @notice Provides a safe ERC20.decimals version which returns '18' as fallback value.
    /// @param token The address of the ERC-20 token contract.
    /// @return (uint8) Token decimals.
    function safeDecimals(IBoringERC20 token) internal view returns (uint8) {
        (bool success, bytes memory data) = address(token).staticcall(
            abi.encodeWithSelector(SIG_DECIMALS)
        );
        return success && data.length == 32 ? abi.decode(data, (uint8)) : 18;
    }

    /// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
    /// Reverts on a failed transfer.
    /// @param token The address of the ERC-20 token.
    /// @param to Transfer tokens to.
    /// @param amount The token amount.
    function safeTransfer(
        IBoringERC20 token,
        address to,
        uint256 amount
    ) internal {
        (bool success, bytes memory data) = address(token).call(
            abi.encodeWithSelector(SIG_TRANSFER, to, amount)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "BoringERC20: Transfer failed"
        );
    }

    /// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
    /// Reverts on a failed transfer.
    /// @param token The address of the ERC-20 token.
    /// @param from Transfer tokens from.
    /// @param to Transfer tokens to.
    /// @param amount The token amount.
    function safeTransferFrom(
        IBoringERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        (bool success, bytes memory data) = address(token).call(
            abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "BoringERC20: TransferFrom failed"
        );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

interface IStellaPair {
    function initialize(address, address) external;

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

interface IBoringERC20 {
    function mint(address to, uint256 amount) external;

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    /// @notice EIP 2612
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

[{"inputs":[{"internalType":"contract IBoringERC20","name":"_stella","type":"address"},{"internalType":"uint256","name":"_stellaPerSec","type":"uint256"},{"internalType":"address","name":"_teamAddress","type":"address"},{"internalType":"address","name":"_treasuryAddress","type":"address"},{"internalType":"address","name":"_investorAddress","type":"address"},{"internalType":"uint256","name":"_teamPercent","type":"uint256"},{"internalType":"uint256","name":"_treasuryPercent","type":"uint256"},{"internalType":"uint256","name":"_investorPercent","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":true,"internalType":"contract IBoringERC20","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"indexed":false,"internalType":"uint256","name":"harvestInterval","type":"uint256"},{"indexed":true,"internalType":"contract IComplexRewarder[]","name":"rewarders","type":"address[]"}],"name":"Add","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"AllocPointsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"EmissionRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLockedUp","type":"uint256"}],"name":"RewardLockedUp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"indexed":false,"internalType":"uint256","name":"harvestInterval","type":"uint256"},{"indexed":true,"internalType":"contract IComplexRewarder[]","name":"rewarders","type":"address[]"}],"name":"Set","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetInvestorAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPercent","type":"uint256"}],"name":"SetInvestorPercent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetTeamAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPercent","type":"uint256"}],"name":"SetTeamPercent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetTreasuryAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPercent","type":"uint256"}],"name":"SetTreasuryPercent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accStellaPerShare","type":"uint256"}],"name":"UpdatePool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MAXIMUM_DEPOSIT_FEE_RATE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_HARVEST_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IBoringERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"contract IComplexRewarder[]","name":"_rewarders","type":"address[]"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"canHarvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"depositWithPermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_pids","type":"uint256[]"}],"name":"harvestMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"investorAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"investorPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingTokens","outputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"string[]","name":"symbols","type":"string[]"},{"internalType":"uint256[]","name":"decimals","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IBoringERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"internalType":"uint256","name":"accStellaPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"harvestInterval","type":"uint256"},{"internalType":"uint256","name":"totalLp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"poolRewarders","outputs":[{"internalType":"address[]","name":"rewarders","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"poolRewardsPerSec","outputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"string[]","name":"symbols","type":"string[]"},{"internalType":"uint256[]","name":"decimals","type":"uint256[]"},{"internalType":"uint256[]","name":"rewardsPerSec","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"poolTotalLp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"contract IComplexRewarder[]","name":"_rewarders","type":"address[]"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_investorAddress","type":"address"}],"name":"setInvestorAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newInvestorPercent","type":"uint256"}],"name":"setInvestorPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_teamAddress","type":"address"}],"name":"setTeamAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTeamPercent","type":"uint256"}],"name":"setTeamPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasuryAddress","type":"address"}],"name":"setTreasuryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTreasuryPercent","type":"uint256"}],"name":"setTreasuryPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startFarming","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stella","outputs":[{"internalType":"contract IBoringERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stellaPerSec","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLockedUpRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStellaInPools","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"treasuryPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"updateAllocPoint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stellaPerSec","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"rewardLockedUp","type":"uint256"},{"internalType":"uint256","name":"nextHarvestUntil","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000e358838ce72d5e61e0018a2ffac4bec5f4c88d200000000000000000000000000000000000000000000000000893720a7058d800000000000000000000000008401b6068e61fc252e1a9959ab764ef5da0ca541000000000000000000000000ce86f05a3568fc973c51c3cf76850df456391f14000000000000000000000000d3252671f1eaa4dcd28eb12d64cdd762511ea32c000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000000640000000000000000000000000000000000000000000000000000000000000064

-----Decoded View---------------
Arg [0] : _stella (address): 0x0e358838ce72d5e61e0018a2ffac4bec5f4c88d2
Arg [1] : _stellaPerSec (uint256): 38622685190000000
Arg [2] : _teamAddress (address): 0x8401b6068e61fc252e1a9959ab764ef5da0ca541
Arg [3] : _treasuryAddress (address): 0xce86f05a3568fc973c51c3cf76850df456391f14
Arg [4] : _investorAddress (address): 0xd3252671f1eaa4dcd28eb12d64cdd762511ea32c
Arg [5] : _teamPercent (uint256): 100
Arg [6] : _treasuryPercent (uint256): 100
Arg [7] : _investorPercent (uint256): 100

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000e358838ce72d5e61e0018a2ffac4bec5f4c88d2
Arg [1] : 00000000000000000000000000000000000000000000000000893720a7058d80
Arg [2] : 0000000000000000000000008401b6068e61fc252e1a9959ab764ef5da0ca541
Arg [3] : 000000000000000000000000ce86f05a3568fc973c51c3cf76850df456391f14
Arg [4] : 000000000000000000000000d3252671f1eaa4dcd28eb12d64cdd762511ea32c
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000064
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000064
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000064