Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

CookingFirevsMasterChef

Created 3 years agoDiff never expires

92 removals

313 lines

106 additions

327 lines

contract MasterChef is Ownable, ReentrancyGuard {

contract CookingFire is Ownable, ReentrancyGuard {

using SafeMath for uint256;

using SafeBEP20 for IBEP20;

// 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.

// We do some fancy math here. Basically, any point in time, the amount of PANTHERs

// We do some fancy math here. Basically, any point in time, the amount of BLAZEs

// entitled to a user but is pending to be distributed is:

// pending reward = (user.amount * pool.accPantherPerShare) - user.rewardDebt

// pending reward = (user.amount * pool.accBlazePerShare) - user.rewardDebt

// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:

// 1. The pool's `accPantherPerShare` (and `lastRewardBlock`) gets updated.

// 1. The pool's `accBlazePerShare` (and `lastRewardBlock`) gets updated.

// 2. User receives the pending reward sent to his/her address.

// 3. User's `amount` gets updated.

// 4. User's `rewardDebt` gets updated.

}

// Info of each pool.

struct PoolInfo {

IBEP20 lpToken; // Address of LP token contract.

uint256 allocPoint; // How many allocation points assigned to this pool. PANTHERs to distribute per block.

uint256 allocPoint; // How many allocation points assigned to this pool. BLAZEs to distribute per block.

uint256 lastRewardBlock; // Last block number that PANTHERs distribution occurs.

uint256 lastRewardBlock; // Last block number that BLAZEs distribution occurs.

uint256 accPantherPerShare; // Accumulated PANTHERs per share, times 1e12. See below.

uint256 accBlazePerShare; // Accumulated BLAZEs per share, times 1e12. See below.

uint16 depositFeeBP; // Deposit fee in basis points

uint256 harvestInterval; // Harvest interval in seconds

}

// The PANTHER TOKEN!

// The BLAZE TOKEN!

PantherToken public panther;

BlazeToken public blaze;

// Dev address.

address public devAddress;

// Deposit Fee address

address public feeAddress;

// PANTHER tokens created per block.

// BLAZE tokens created per block.

uint256 public pantherPerBlock;

uint256 public blazePerBlock;

// Bonus muliplier for early panther makers.

// Bonus muliplier for early blaze makers.

uint256 public constant BONUS_MULTIPLIER = 1;

// Max harvest interval: 14 days.

uint256 public constant MAXIMUM_HARVEST_INTERVAL = 14 days;

// 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 block number when PANTHER mining starts.

// The block number when BLAZE mining starts.

uint256 public startBlock;

// Total locked up rewards

uint256 public totalLockedUpRewards;

// Panther referral contract address.

// Blaze referral contract address.

IPantherReferral public pantherReferral;

IBlazeReferral public blazeReferral;

// Referral commission rate in basis points.

uint16 public referralCommissionRate = 100;

// Max referral commission rate: 10%.

uint16 public constant MAXIMUM_REFERRAL_COMMISSION_RATE = 1000;

address private _operator;

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 previousAmount, uint256 newAmount);

event ReferralCommissionPaid(address indexed user, address indexed referrer, uint256 commissionAmount);

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

modifier onlyOperator() {

require(_operator == msg.sender, "operator: caller is not the operator");

}

constructor(

PantherToken _panther,

BlazeToken _blaze,

uint256 _startBlock,

uint256 _pantherPerBlock

uint256 _blazePerBlock

) public {

panther = _panther;

blaze = _blaze;

startBlock = _startBlock;

pantherPerBlock = _pantherPerBlock;

blazePerBlock = _blazePerBlock;

_operator = msg.sender;

devAddress = msg.sender;

feeAddress = msg.sender;

}

function poolLength() external view returns (uint256) {

return poolInfo.length;

}

function updateOperator(address _op) public onlyOperator {

_operator = _op;

}

function updateStartBlock(uint256 _startBlock) public onlyOperator {

require(block.number > startBlock, "updateStartBlock: farming already initiated");

startBlock = _startBlock;

}

// Add a new lp to the pool. Can only be called by the owner.

// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.

function add(uint256 _allocPoint, IBEP20 _lpToken, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOwner {

function add(uint256 _allocPoint, IBEP20 _lpToken, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOperator {

require(_depositFeeBP <= 10000, "add: invalid deposit fee basis points");

require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "add: invalid harvest interval");

if (_withUpdate) {

massUpdatePools();

}

uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;

totalAllocPoint = totalAllocPoint.add(_allocPoint);

poolInfo.push(PoolInfo({

lpToken: _lpToken,

allocPoint: _allocPoint,

lastRewardBlock: lastRewardBlock,

accPantherPerShare: 0,

accBlazePerShare: 0,

depositFeeBP: _depositFeeBP,

harvestInterval: _harvestInterval

}));

}

// Update the given pool's PANTHER allocation point and deposit fee. Can only be called by the owner.

// Update the given pool's BLAZE allocation point and deposit fee. Can only be called by the owner.

function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOwner {

function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOperator {

require(_depositFeeBP <= 10000, "set: invalid deposit fee basis points");

require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "set: invalid harvest interval");

if (_withUpdate) {

massUpdatePools();

}

totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);

poolInfo[_pid].allocPoint = _allocPoint;

poolInfo[_pid].depositFeeBP = _depositFeeBP;

poolInfo[_pid].harvestInterval = _harvestInterval;

}

// Return reward multiplier over the given _from to _to block.

function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {

return _to.sub(_from).mul(BONUS_MULTIPLIER);

}

// View function to see pending PANTHERs on frontend.

// View function to see pending BLAZEs on frontend.

function pendingPanther(uint256 _pid, address _user) external view returns (uint256) {

function pendingBlaze(uint256 _pid, address _user) external view returns (uint256) {

PoolInfo storage pool = poolInfo[_pid];

UserInfo storage user = userInfo[_pid][_user];

uint256 accPantherPerShare = pool.accPantherPerShare;

uint256 accBlazePerShare = pool.accBlazePerShare;

uint256 lpSupply = pool.lpToken.balanceOf(address(this));

if (block.number > pool.lastRewardBlock && lpSupply != 0) {

uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);

uint256 pantherReward = multiplier.mul(pantherPerBlock).mul(pool.allocPoint).div(totalAllocPoint);

uint256 blazeReward = multiplier.mul(blazePerBlock).mul(pool.allocPoint).div(totalAllocPoint);

accPantherPerShare = accPantherPerShare.add(pantherReward.mul(1e12).div(lpSupply));

accBlazePerShare = accBlazePerShare.add(blazeReward.mul(1e12).div(lpSupply));

}

uint256 pending = user.amount.mul(accPantherPerShare).div(1e12).sub(user.rewardDebt);

uint256 pending = user.amount.mul(accBlazePerShare).div(1e12).sub(user.rewardDebt);

return pending.add(user.rewardLockedUp);

}

// View function to see if user can harvest PANTHERs.

// View function to see if user can harvest BLAZEs.

function canHarvest(uint256 _pid, address _user) public view returns (bool) {

UserInfo storage user = userInfo[_pid][_user];

return block.timestamp >= user.nextHarvestUntil;

}

// Update reward variables for all pools. Be careful of gas spending!

function massUpdatePools() public {

uint256 length = poolInfo.length;

for (uint256 pid = 0; pid < length; ++pid) {

updatePool(pid);

}

// Update reward variables of the given pool to be up-to-date.

function updatePool(uint256 _pid) public {

PoolInfo storage pool = poolInfo[_pid];

if (block.number <= pool.lastRewardBlock) {

return;

}

uint256 lpSupply = pool.lpToken.balanceOf(address(this));

if (lpSupply == 0 || pool.allocPoint == 0) {

pool.lastRewardBlock = block.number;

return;

}

uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);

uint256 pantherReward = multiplier.mul(pantherPerBlock).mul(pool.allocPoint).div(totalAllocPoint);

uint256 blazeReward = multiplier.mul(blazePerBlock).mul(pool.allocPoint).div(totalAllocPoint);

panther.mint(devAddress, pantherReward.div(10));

blaze.mint(devAddress, blazeReward.div(10));

panther.mint(address(this), pantherReward);

blaze.mint(address(this), blazeReward);

pool.accPantherPerShare = pool.accPantherPerShare.add(pantherReward.mul(1e12).div(lpSupply));

pool.accBlazePerShare = pool.accBlazePerShare.add(blazeReward.mul(1e12).div(lpSupply));

pool.lastRewardBlock = block.number;

}

// Deposit LP tokens to MasterChef for PANTHER allocation.

// Deposit LP tokens to CookingFire for BLAZE allocation.

function deposit(uint256 _pid, uint256 _amount, address _referrer) public nonReentrant {

PoolInfo storage pool = poolInfo[_pid];

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

updatePool(_pid);

if (_amount > 0 && address(pantherReferral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {

if (_amount > 0 && address(blazeReferral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {

pantherReferral.recordReferral(msg.sender, _referrer);

blazeReferral.recordReferral(msg.sender, _referrer);

}

payOrLockupPendingPanther(_pid);

payOrLockupPendingBlaze(_pid);

if (_amount > 0) {

pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);

if (address(pool.lpToken) == address(panther)) {

uint256 transferTax = _amount.mul(panther.transferTaxRate()).div(10000);

_amount = _amount.sub(transferTax);

}

if (pool.depositFeeBP > 0) {

uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);

pool.lpToken.safeTransfer(feeAddress, depositFee);

user.amount = user.amount.add(_amount).sub(depositFee);

} else {

user.amount = user.amount.add(_amount);

}

user.rewardDebt = user.amount.mul(pool.accPantherPerShare).div(1e12);

user.rewardDebt = user.amount.mul(pool.accBlazePerShare).div(1e12);

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

}

// Withdraw LP tokens from MasterChef.

// Withdraw LP tokens from CookingFire.

function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {

PoolInfo storage pool = poolInfo[_pid];

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

require(user.amount >= _amount, "withdraw: not good");

updatePool(_pid);

payOrLockupPendingPanther(_pid);

payOrLockupPendingBlaze(_pid);

if (_amount > 0) {

user.amount = user.amount.sub(_amount);

pool.lpToken.safeTransfer(address(msg.sender), _amount);

}

user.rewardDebt = user.amount.mul(pool.accPantherPerShare).div(1e12);

user.rewardDebt = user.amount.mul(pool.accBlazePerShare).div(1e12);

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;

user.amount = 0;

user.rewardDebt = 0;

user.rewardLockedUp = 0;

user.nextHarvestUntil = 0;

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

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

}

// Pay or lockup pending PANTHERs.

// Pay or lockup pending BLAZEs.

function payOrLockupPendingPanther(uint256 _pid) internal {

function payOrLockupPendingBlaze(uint256 _pid) internal {

PoolInfo storage pool = poolInfo[_pid];

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

if (user.nextHarvestUntil == 0) {

user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);

}

uint256 pending = user.amount.mul(pool.accPantherPerShare).div(1e12).sub(user.rewardDebt);

uint256 pending = user.amount.mul(pool.accBlazePerShare).div(1e12).sub(user.rewardDebt);

if (canHarvest(_pid, msg.sender)) {

if (pending > 0 || user.rewardLockedUp > 0) {

uint256 totalRewards = pending.add(user.rewardLockedUp);

// reset lockup

totalLockedUpRewards = totalLockedUpRewards.sub(user.rewardLockedUp);

user.rewardLockedUp = 0;

user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);

// send rewards

safePantherTransfer(msg.sender, totalRewards);

safeBlazeTransfer(msg.sender, totalRewards);

payReferralCommission(msg.sender, totalRewards);

}

} else if (pending > 0) {

user.rewardLockedUp = user.rewardLockedUp.add(pending);

totalLockedUpRewards = totalLockedUpRewards.add(pending);

emit RewardLockedUp(msg.sender, _pid, pending);

}

// Safe panther transfer function, just in case if rounding error causes pool to not have enough PANTHERs.

// Safe blaze transfer function, just in case if rounding error causes pool to not have enough BLAZEs.

function safePantherTransfer(address _to, uint256 _amount) internal {

function safeBlazeTransfer(address _to, uint256 _amount) internal {

uint256 pantherBal = panther.balanceOf(address(this));

uint256 blazeBal = blaze.balanceOf(address(this));

if (_amount > pantherBal) {

if (_amount > blazeBal) {

panther.transfer(_to, pantherBal);

blaze.transfer(_to, blazeBal);

} else {

panther.transfer(_to, _amount);

blaze.transfer(_to, _amount);

}

// Update dev address by the previous dev.

function setOperator(address _op) public onlyOperator {

_operator = _op;

}

function setDevAddress(address _devAddress) public {

require(msg.sender == devAddress, "setDevAddress: FORBIDDEN");

require(_devAddress != address(0), "setDevAddress: ZERO");

devAddress = _devAddress;

}

function setFeeAddress(address _feeAddress) public {

require(msg.sender == feeAddress, "setFeeAddress: FORBIDDEN");

require(_feeAddress != address(0), "setFeeAddress: ZERO");

feeAddress = _feeAddress;

}

// Pancake has to add hidden dummy pools in order to alter the emission, here we make it simple and transparent to all.

function updateEmissionRate(uint256 _pantherPerBlock) public onlyOwner {

function updateEmissionRate(uint256 _blazePerBlock) public onlyOperator {

massUpdatePools();

emit EmissionRateUpdated(msg.sender, pantherPerBlock, _pantherPerBlock);

emit EmissionRateUpdated(msg.sender, blazePerBlock, _blazePerBlock);

pantherPerBlock = _pantherPerBlock;

blazePerBlock = _blazePerBlock;

}

// Update the panther referral contract address by the owner

// Update the blaze referral contract address by the owner

function setPantherReferral(IPantherReferral _pantherReferral) public onlyOwner {

function setBlazeReferral(IBlazeReferral _blazeReferral) public onlyOwner {

pantherReferral = _pantherReferral;

blazeReferral = _blazeReferral;

}

// Update referral commission rate by the owner

function setReferralCommissionRate(uint16 _referralCommissionRate) public onlyOwner {

require(_referralCommissionRate <= MAXIMUM_REFERRAL_COMMISSION_RATE, "setReferralCommissionRate: invalid referral commission rate basis points");

referralCommissionRate = _referralCommissionRate;

}

// Pay referral commission to the referrer who referred this user.

function payReferralCommission(address _user, uint256 _pending) internal {

if (address(pantherReferral) != address(0) && referralCommissionRate > 0) {

if (address(blazeReferral) != address(0) && referralCommissionRate > 0) {

address referrer = pantherReferral.getReferrer(_user);

address referrer = blazeReferral.getReferrer(_user);

uint256 commissionAmount = _pending.mul(referralCommissionRate).div(10000);

if (referrer != address(0) && commissionAmount > 0) {

panther.mint(referrer, commissionAmount);

blaze.mint(referrer, commissionAmount);

pantherReferral.recordReferralCommission(referrer, commissionAmount);

blazeReferral.recordReferralCommission(referrer, commissionAmount);

emit ReferralCommissionPaid(_user, referrer, commissionAmount);

}

Saved diffs

Original text

Open file

contract MasterChef is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeBEP20 for IBEP20;

    // 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.
        //
        // We do some fancy math here. Basically, any point in time, the amount of PANTHERs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accPantherPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accPantherPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IBEP20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. PANTHERs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that PANTHERs distribution occurs.
        uint256 accPantherPerShare;   // Accumulated PANTHERs per share, times 1e12. See below.
        uint16 depositFeeBP;      // Deposit fee in basis points
        uint256 harvestInterval;  // Harvest interval in seconds
    }

    // The PANTHER TOKEN!
    PantherToken public panther;
    // Dev address.
    address public devAddress;
    // Deposit Fee address
    address public feeAddress;
    // PANTHER tokens created per block.
    uint256 public pantherPerBlock;
    // Bonus muliplier for early panther makers.
    uint256 public constant BONUS_MULTIPLIER = 1;
    // Max harvest interval: 14 days.
    uint256 public constant MAXIMUM_HARVEST_INTERVAL = 14 days;

    // 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 block number when PANTHER mining starts.
    uint256 public startBlock;
    // Total locked up rewards
    uint256 public totalLockedUpRewards;

    // Panther referral contract address.
    IPantherReferral public pantherReferral;
    // Referral commission rate in basis points.
    uint16 public referralCommissionRate = 100;
    // Max referral commission rate: 10%.
    uint16 public constant MAXIMUM_REFERRAL_COMMISSION_RATE = 1000;

    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 previousAmount, uint256 newAmount);
    event ReferralCommissionPaid(address indexed user, address indexed referrer, uint256 commissionAmount);
    event RewardLockedUp(address indexed user, uint256 indexed pid, uint256 amountLockedUp);

    constructor(
        PantherToken _panther,
        uint256 _startBlock,
        uint256 _pantherPerBlock
    ) public {
        panther = _panther;
        startBlock = _startBlock;
        pantherPerBlock = _pantherPerBlock;

        devAddress = msg.sender;
        feeAddress = msg.sender;
    }

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

    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    function add(uint256 _allocPoint, IBEP20 _lpToken, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOwner {
        require(_depositFeeBP <= 10000, "add: invalid deposit fee basis points");
        require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "add: invalid harvest interval");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accPantherPerShare: 0,
            depositFeeBP: _depositFeeBP,
            harvestInterval: _harvestInterval
        }));
    }

    // Update the given pool's PANTHER allocation point and deposit fee. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOwner {
        require(_depositFeeBP <= 10000, "set: invalid deposit fee basis points");
        require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "set: invalid harvest interval");
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
        poolInfo[_pid].harvestInterval = _harvestInterval;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
        return _to.sub(_from).mul(BONUS_MULTIPLIER);
    }

    // View function to see pending PANTHERs on frontend.
    function pendingPanther(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accPantherPerShare = pool.accPantherPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 pantherReward = multiplier.mul(pantherPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accPantherPerShare = accPantherPerShare.add(pantherReward.mul(1e12).div(lpSupply));
        }
        uint256 pending = user.amount.mul(accPantherPerShare).div(1e12).sub(user.rewardDebt);
        return pending.add(user.rewardLockedUp);
    }

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

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 pantherReward = multiplier.mul(pantherPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        panther.mint(devAddress, pantherReward.div(10));
        panther.mint(address(this), pantherReward);
        pool.accPantherPerShare = pool.accPantherPerShare.add(pantherReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to MasterChef for PANTHER allocation.
    function deposit(uint256 _pid, uint256 _amount, address _referrer) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (_amount > 0 && address(pantherReferral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {
            pantherReferral.recordReferral(msg.sender, _referrer);
        }
        payOrLockupPendingPanther(_pid);
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            if (address(pool.lpToken) == address(panther)) {
                uint256 transferTax = _amount.mul(panther.transferTaxRate()).div(10000);
                _amount = _amount.sub(transferTax);
            }
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(feeAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
            } else {
                user.amount = user.amount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accPantherPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        payOrLockupPendingPanther(_pid);
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accPantherPerShare).div(1e12);
        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;
        user.amount = 0;
        user.rewardDebt = 0;
        user.rewardLockedUp = 0;
        user.nextHarvestUntil = 0;
        pool.lpToken.safeTransfer(address(msg.sender), amount);
        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }

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

        if (user.nextHarvestUntil == 0) {
            user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);
        }

        uint256 pending = user.amount.mul(pool.accPantherPerShare).div(1e12).sub(user.rewardDebt);
        if (canHarvest(_pid, msg.sender)) {
            if (pending > 0 || user.rewardLockedUp > 0) {
                uint256 totalRewards = pending.add(user.rewardLockedUp);

                // reset lockup
                totalLockedUpRewards = totalLockedUpRewards.sub(user.rewardLockedUp);
                user.rewardLockedUp = 0;
                user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);

                // send rewards
                safePantherTransfer(msg.sender, totalRewards);
                payReferralCommission(msg.sender, totalRewards);
            }
        } else if (pending > 0) {
            user.rewardLockedUp = user.rewardLockedUp.add(pending);
            totalLockedUpRewards = totalLockedUpRewards.add(pending);
            emit RewardLockedUp(msg.sender, _pid, pending);
        }
    }

    // Safe panther transfer function, just in case if rounding error causes pool to not have enough PANTHERs.
    function safePantherTransfer(address _to, uint256 _amount) internal {
        uint256 pantherBal = panther.balanceOf(address(this));
        if (_amount > pantherBal) {
            panther.transfer(_to, pantherBal);
        } else {
            panther.transfer(_to, _amount);
        }
    }

    // Update dev address by the previous dev.
    function setDevAddress(address _devAddress) public {
        require(msg.sender == devAddress, "setDevAddress: FORBIDDEN");
        require(_devAddress != address(0), "setDevAddress: ZERO");
        devAddress = _devAddress;
    }

    function setFeeAddress(address _feeAddress) public {
        require(msg.sender == feeAddress, "setFeeAddress: FORBIDDEN");
        require(_feeAddress != address(0), "setFeeAddress: ZERO");
        feeAddress = _feeAddress;
    }

    // Pancake has to add hidden dummy pools in order to alter the emission, here we make it simple and transparent to all.
    function updateEmissionRate(uint256 _pantherPerBlock) public onlyOwner {
        massUpdatePools();
        emit EmissionRateUpdated(msg.sender, pantherPerBlock, _pantherPerBlock);
        pantherPerBlock = _pantherPerBlock;
    }

    // Update the panther referral contract address by the owner
    function setPantherReferral(IPantherReferral _pantherReferral) public onlyOwner {
        pantherReferral = _pantherReferral;
    }

    // Update referral commission rate by the owner
    function setReferralCommissionRate(uint16 _referralCommissionRate) public onlyOwner {
        require(_referralCommissionRate <= MAXIMUM_REFERRAL_COMMISSION_RATE, "setReferralCommissionRate: invalid referral commission rate basis points");
        referralCommissionRate = _referralCommissionRate;
    }

    // Pay referral commission to the referrer who referred this user.
    function payReferralCommission(address _user, uint256 _pending) internal {
        if (address(pantherReferral) != address(0) && referralCommissionRate > 0) {
            address referrer = pantherReferral.getReferrer(_user);
            uint256 commissionAmount = _pending.mul(referralCommissionRate).div(10000);

            if (referrer != address(0) && commissionAmount > 0) {
                panther.mint(referrer, commissionAmount);
                pantherReferral.recordReferralCommission(referrer, commissionAmount);
                emit ReferralCommissionPaid(_user, referrer, commissionAmount);
            }
        }
    }
}

Changed text

Open file

contract CookingFire is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeBEP20 for IBEP20;

    // 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.
        //
        // We do some fancy math here. Basically, any point in time, the amount of BLAZEs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accBlazePerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accBlazePerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IBEP20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. BLAZEs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that BLAZEs distribution occurs.
        uint256 accBlazePerShare;   // Accumulated BLAZEs per share, times 1e12. See below.
        uint16 depositFeeBP;      // Deposit fee in basis points
        uint256 harvestInterval;  // Harvest interval in seconds
    }

    // The BLAZE TOKEN!
    BlazeToken public blaze;
    // Dev address.
    address public devAddress;
    // Deposit Fee address
    address public feeAddress;
    // BLAZE tokens created per block.
    uint256 public blazePerBlock;
    // Bonus muliplier for early blaze makers.
    uint256 public constant BONUS_MULTIPLIER = 1;
    // Max harvest interval: 14 days.
    uint256 public constant MAXIMUM_HARVEST_INTERVAL = 14 days;

    // 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 block number when BLAZE mining starts.
    uint256 public startBlock;
    // Total locked up rewards
    uint256 public totalLockedUpRewards;

    // Blaze referral contract address.
    IBlazeReferral public blazeReferral;
    // Referral commission rate in basis points.
    uint16 public referralCommissionRate = 100;
    // Max referral commission rate: 10%.
    uint16 public constant MAXIMUM_REFERRAL_COMMISSION_RATE = 1000;
    
    address private _operator;

    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 previousAmount, uint256 newAmount);
    event ReferralCommissionPaid(address indexed user, address indexed referrer, uint256 commissionAmount);
    event RewardLockedUp(address indexed user, uint256 indexed pid, uint256 amountLockedUp);
    modifier onlyOperator() {
        require(_operator == msg.sender, "operator: caller is not the operator");
        _;
    }   

    
    constructor(
        BlazeToken _blaze,
        uint256 _startBlock,
        uint256 _blazePerBlock
    ) public {
        blaze = _blaze;
        startBlock = _startBlock;
        blazePerBlock = _blazePerBlock;
        
        _operator = msg.sender;
        devAddress = msg.sender;
        feeAddress = msg.sender;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }
    function updateOperator(address _op) public onlyOperator {
        _operator = _op;
    }
    function updateStartBlock(uint256 _startBlock) public onlyOperator {
        require(block.number > startBlock, "updateStartBlock: farming already initiated");
        startBlock = _startBlock;
    }
    // Add a new lp to the pool. Can only be called by the owner.
    // XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    function add(uint256 _allocPoint, IBEP20 _lpToken, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOperator {
        require(_depositFeeBP <= 10000, "add: invalid deposit fee basis points");
        require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "add: invalid harvest interval");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accBlazePerShare: 0,
            depositFeeBP: _depositFeeBP,
            harvestInterval: _harvestInterval
        }));
    }

    // Update the given pool's BLAZE allocation point and deposit fee. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOperator {
        require(_depositFeeBP <= 10000, "set: invalid deposit fee basis points");
        require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "set: invalid harvest interval");
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
        poolInfo[_pid].harvestInterval = _harvestInterval;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
        return _to.sub(_from).mul(BONUS_MULTIPLIER);
    }

    // View function to see pending BLAZEs on frontend.
    function pendingBlaze(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accBlazePerShare = pool.accBlazePerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 blazeReward = multiplier.mul(blazePerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accBlazePerShare = accBlazePerShare.add(blazeReward.mul(1e12).div(lpSupply));
        }
        uint256 pending = user.amount.mul(accBlazePerShare).div(1e12).sub(user.rewardDebt);
        return pending.add(user.rewardLockedUp);
    }

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

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 blazeReward = multiplier.mul(blazePerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        blaze.mint(devAddress, blazeReward.div(10));
        blaze.mint(address(this), blazeReward);
        pool.accBlazePerShare = pool.accBlazePerShare.add(blazeReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to CookingFire for BLAZE allocation.
    function deposit(uint256 _pid, uint256 _amount, address _referrer) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (_amount > 0 && address(blazeReferral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {
            blazeReferral.recordReferral(msg.sender, _referrer);
        }
        payOrLockupPendingBlaze(_pid);
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(feeAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
            } else {
                user.amount = user.amount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accBlazePerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from CookingFire.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        payOrLockupPendingBlaze(_pid);
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accBlazePerShare).div(1e12);
        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;
        user.amount = 0;
        user.rewardDebt = 0;
        user.rewardLockedUp = 0;
        user.nextHarvestUntil = 0;
        pool.lpToken.safeTransfer(address(msg.sender), amount);
        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }

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

        if (user.nextHarvestUntil == 0) {
            user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);
        }

        uint256 pending = user.amount.mul(pool.accBlazePerShare).div(1e12).sub(user.rewardDebt);
        if (canHarvest(_pid, msg.sender)) {
            if (pending > 0 || user.rewardLockedUp > 0) {
                uint256 totalRewards = pending.add(user.rewardLockedUp);

                // reset lockup
                totalLockedUpRewards = totalLockedUpRewards.sub(user.rewardLockedUp);
                user.rewardLockedUp = 0;
                user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);

                // send rewards
                safeBlazeTransfer(msg.sender, totalRewards);
                payReferralCommission(msg.sender, totalRewards);
            }
        } else if (pending > 0) {
            user.rewardLockedUp = user.rewardLockedUp.add(pending);
            totalLockedUpRewards = totalLockedUpRewards.add(pending);
            emit RewardLockedUp(msg.sender, _pid, pending);
        }
    }

    // Safe blaze transfer function, just in case if rounding error causes pool to not have enough BLAZEs.
    function safeBlazeTransfer(address _to, uint256 _amount) internal {
        uint256 blazeBal = blaze.balanceOf(address(this));
        if (_amount > blazeBal) {
            blaze.transfer(_to, blazeBal);
        } else {
            blaze.transfer(_to, _amount);
        }
    }

    // Update dev address by the previous dev.
    function setOperator(address _op) public onlyOperator {
        _operator = _op;
    }
    function setDevAddress(address _devAddress) public {
        require(msg.sender == devAddress, "setDevAddress: FORBIDDEN");
        require(_devAddress != address(0), "setDevAddress: ZERO");
        devAddress = _devAddress;
    }

    function setFeeAddress(address _feeAddress) public {
        require(msg.sender == feeAddress, "setFeeAddress: FORBIDDEN");
        require(_feeAddress != address(0), "setFeeAddress: ZERO");
        feeAddress = _feeAddress;
    }

    // Pancake has to add hidden dummy pools in order to alter the emission, here we make it simple and transparent to all.
    function updateEmissionRate(uint256 _blazePerBlock) public onlyOperator {
        massUpdatePools();
        emit EmissionRateUpdated(msg.sender, blazePerBlock, _blazePerBlock);
        blazePerBlock = _blazePerBlock;
    }

    // Update the blaze referral contract address by the owner
    function setBlazeReferral(IBlazeReferral _blazeReferral) public onlyOwner {
        blazeReferral = _blazeReferral;
    }

    // Update referral commission rate by the owner
    function setReferralCommissionRate(uint16 _referralCommissionRate) public onlyOwner {
        require(_referralCommissionRate <= MAXIMUM_REFERRAL_COMMISSION_RATE, "setReferralCommissionRate: invalid referral commission rate basis points");
        referralCommissionRate = _referralCommissionRate;
    }

    // Pay referral commission to the referrer who referred this user.
    function payReferralCommission(address _user, uint256 _pending) internal {
        if (address(blazeReferral) != address(0) && referralCommissionRate > 0) {
            address referrer = blazeReferral.getReferrer(_user);
            uint256 commissionAmount = _pending.mul(referralCommissionRate).div(10000);

            if (referrer != address(0) && commissionAmount > 0) {
                blaze.mint(referrer, commissionAmount);
                blazeReferral.recordReferralCommission(referrer, commissionAmount);
                emit ReferralCommissionPaid(_user, referrer, commissionAmount);
            }
        }
    }
}