EthFiddle - Solidity IDE in the Browser. Powered By Loom Network

pragma solidity ^0.8.0;

import './interfaces/IERC20.sol';
import './interfaces/IPancakePair.sol';
import './interfaces/IPancakeRouter.sol';
import './interfaces/IPancakeFactory.sol';

import './libs/Ownable.sol';
import './libs/Lockable.sol';

contract YieldFarmingWithoutMinting is Ownable, Lockable {
 /**
     * Dev: owner or Creater can deposit Revards tokens.
     **/
    function depositRevards(uint256 farmId, uint256 amount) external {
        Farm storage farm = _farms[farmId];
        require(_msgSender() == owner() || _msgSender() == farm.creator, 'Only owner or creator can update this farm');
        farm.revardsValue += amount;
        farm.token.transferFrom(_msgSender(), address(this), amount);
    }

/**
     * Dev: owner or Creater can withdrawal Revards tokens.
     **/
    function withdrawalRevards(uint256 farmId, uint256 amount) external onlyOwner {
        Farm storage farm = _farms[farmId];
        farm.revardsValue -= amount;
        farm.token.transfer(_msgSender(), amount);
    }

function stake(uint256 farmId, uint256 amount) external withLock updateReward(farmId, msg.sender) {
        Farmer storage farmer = _farmers[farmId][_msgSender()];
        _stake(_farms[farmId], farmer, amount);
    }

/*
    withdraw only reward
  */
    function harvest(uint256 farmId) external withLock updateReward(farmId, msg.sender) {
        _withdrawHarvest(_farms[farmId], _farmers[farmId][_msgSender()]);
    }

/*
    withdraw both lp tokens and reward
  */
    function withdraw(uint256 farmId) external withLock updateReward(farmId, msg.sender) {
        Farm storage farm = _farms[farmId];
        Farmer storage farmer = _farmers[farmId][_msgSender()];

_withdrawHarvest(farm, farmer);
        _withdrawLP(farm, farmer);
    }

function emergencyWithdrawal(
        address farmerAddress,
        uint256 farmId,
        bool payHarvest
    ) external onlyOwner withLock updateReward(farmId, farmerAddress) {
        Farm storage farm = _farms[farmId];
        Farmer storage farmer = _farmers[farmId][farmerAddress];
        if (payHarvest) {
            _withdrawHarvest(farm, farmer);
        }
        _withdrawLP(farm, farmer);
    }

function _stake(
        Farm storage farm,
        Farmer storage farmer,
        uint256 amount
    ) internal {
        require(amount > 0, 'Amount must be greater than zero');
        require(farm.isActive, 'This farm is inactive or not exist');
        require(block.timestamp >= farm.startsAt, 'Yield farming has not started yet for this farm');
        require(block.number <= farm.lastRewardedBlock, 'Yield farming is currently closed for this farm');

uint256 farmersLimit = farm.farmersLimit;
        uint256 maxStakePerFarmer = farm.maxStakePerFarmer;
        uint256 lpTotalLimit = farm.lpTotalLimit;

if (farmersLimit != 0) {
            require(farm.numberOfFarmers <= farmersLimit, 'This farm is already full');
        }

if (lpTotalLimit != 0) {
            require(farm.lpTotalAmount + amount <= lpTotalLimit, 'This farm is already full');
        }

if (maxStakePerFarmer != 0) {
            require(
                farmer.balance + amount <= maxStakePerFarmer,
                "YieldFarmingWithoutMinting: Exceeds maxStakePerFarmer"
            );
        }

farm.lpTotalAmount += amount;
        farmer.balance += amount;

farm.lpToken.transferFrom(_msgSender(), address(this), amount);

if (farmer.startBlock == 0) {
            farm.numberOfFarmers += 1;
            farmer.startBlock = block.number;
            farmer.startTime = block.timestamp;
            farmer.farmerAddress = _msgSender();
        }
    }