Comparar texto

Encontre a diferença entre dois arquivos de texto

Editor live

Recolher inalteradas

Sem quebra de linha

Layout

Nível de detalhe

Realce de sintaxe

Diffchecker Desktop A maneira mais segura de usar o Diffchecker. Obtenha o aplicativo Diffchecker Desktop: seus diffs nunca saem do seu computador!Obter Desktop

LYPTUS Masterchef vs EGG Masterchef

Criado há 5 anosO diff nunca expira

79 remoções

Linhas
Total
Removido

Caracteres
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

258 linhas

68 adições

Linhas
Total
Adicionado

Caracteres
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

246 linhas

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

// .----------------. .----------------. .----------------. .----------------. .----------------.

import "@openzeppelin/contracts/math/SafeMath.sol";

// | .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |

import "./libs/IBEP20.sol";

// | | ___ ____ | || | ____ | || | __ | || | _____ | || | __ | |

import "./libs/SafeBEP20.sol";

// | | |_ ||_ _| | || | .' `. | || | / \ | || | |_ _| | || | / \ | |

import "@openzeppelin/contracts/access/Ownable.sol";

// | | | |_/ / | || | / .--. \ | || | / /\ \ | || | | | | || | / /\ \ | |

// | | | __'. | || | | | | | | || | / ____ \ | || | | | _ | || | / ____ \ | |

// | | _| | \ \_ | || | \ `--' / | || | _/ / \ \_ | || | _| |__/ | | || | _/ / \ \_ | |

// | | |____||____| | || | `.____.' | || ||____| |____|| || | |________| | || ||____| |____|| |

// | | | || | | || | | || | | || | | |

// | '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |

// '----------------' '----------------' '----------------' '----------------' '----------------'

import "./SafeMath.sol";

import "./IBEP20.sol";

import "./SafeBEP20.sol";

import "./Ownable.sol";

import "./LYPTUSToken.sol";

import "./EggToken.sol";

// MasterChef is the master of Lyptus. He can make Lyptus and he is a fair guy.

// MasterChef is the master of Egg. He can make Egg and he is a fair guy.

// Note that it's ownable and the owner wields tremendous power. The ownership

// will be transferred to a governance smart contract once LYPTUS is sufficiently

// will be transferred to a governance smart contract once EGG is sufficiently

// distributed and the community can show to govern itself.

// Have fun reading it. Hopefully it's bug-free. God bless.

contract MasterChef is Ownable {

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.

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

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

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

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

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

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

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

// 1. The pool's `accEggPerShare` (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. LYPTUSs to distribute per block.

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

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

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

uint256 accLyptusPerShare; // Accumulated LYPTUSs per share, times 1e12. See below.

uint256 accEggPerShare; // Accumulated EGGs per share, times 1e12. See below.

uint16 depositFeeBP; // Deposit fee in basis points

}

// The LYPTUS TOKEN!

// The EGG TOKEN!

LyptusToken public lyptus;

EggToken public egg;

// Dev address.

address public devaddr;

// LYPTUS tokens created per block.

// EGG tokens created per block.

uint256 public lyptusPerBlock;

uint256 public eggPerBlock;

// Bonus muliplier for early lyptus makers.

// Bonus muliplier for early egg makers.

uint256 public constant BONUS_MULTIPLIER = 1;

// Deposit Fee address

address public feeAddress;

// 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 LYPTUS mining starts.

// The block number when EGG mining starts.

uint256 public startBlock;

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);

constructor(

LyptusToken _lyptus,

EggToken _egg,

address _devaddr,

address _feeAddress,

uint256 _lyptusPerBlock,

uint256 _eggPerBlock,

uint256 _startBlock

) public {

lyptus = _lyptus;

egg = _egg;

devaddr = _devaddr;

feeAddress = _feeAddress;

lyptusPerBlock = _lyptusPerBlock;

eggPerBlock = _eggPerBlock;

startBlock = _startBlock;

}

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, bool _withUpdate) public onlyOwner {

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

if (_withUpdate) {

massUpdatePools();

}

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

totalAllocPoint = totalAllocPoint.add(_allocPoint);

poolInfo.push(PoolInfo({

lpToken: _lpToken,

allocPoint: _allocPoint,

lastRewardBlock: lastRewardBlock,

accLyptusPerShare: 0,

accEggPerShare: 0,

depositFeeBP: _depositFeeBP

}));

}

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

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

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

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

if (_withUpdate) {

massUpdatePools();

}

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

poolInfo[_pid].allocPoint = _allocPoint;

poolInfo[_pid].depositFeeBP = _depositFeeBP;

}

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

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

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

}

// View function to see pending LYPTUSs on frontend.

// View function to see pending EGGs on frontend.

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

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

PoolInfo storage pool = poolInfo[_pid];

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

uint256 accLyptusPerShare = pool.accLyptusPerShare;

uint256 accEggPerShare = pool.accEggPerShare;

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

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

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

uint256 lyptusReward = multiplier.mul(lyptusPerBlock).mul(pool.allocPoint).div(totalAllocPoint);

uint256 eggReward = multiplier.mul(eggPerBlock).mul(pool.allocPoint).div(totalAllocPoint);

accLyptusPerShare = accLyptusPerShare.add(lyptusReward.mul(1e12).div(lpSupply));

accEggPerShare = accEggPerShare.add(eggReward.mul(1e12).div(lpSupply));

}

return user.amount.mul(accLyptusPerShare).div(1e12).sub(user.rewardDebt);

return user.amount.mul(accEggPerShare).div(1e12).sub(user.rewardDebt);

}

// 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 lyptusReward = multiplier.mul(lyptusPerBlock).mul(pool.allocPoint).div(totalAllocPoint);

uint256 eggReward = multiplier.mul(eggPerBlock).mul(pool.allocPoint).div(totalAllocPoint);

lyptus.mint(devaddr, lyptusReward.div(10));

egg.mint(devaddr, eggReward.div(10));

lyptus.mint(address(this), lyptusReward);

egg.mint(address(this), eggReward);

pool.accLyptusPerShare = pool.accLyptusPerShare.add(lyptusReward.mul(1e12).div(lpSupply));

pool.accEggPerShare = pool.accEggPerShare.add(eggReward.mul(1e12).div(lpSupply));

pool.lastRewardBlock = block.number;

}

// Deposit LP tokens to MasterChef for LYPTUS allocation.

// Deposit LP tokens to MasterChef for EGG allocation.

function deposit(uint256 _pid, uint256 _amount) public {

PoolInfo storage pool = poolInfo[_pid];

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

updatePool(_pid);

if (user.amount > 0) {

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

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

if(pending > 0) {

safeLyptusTransfer(msg.sender, pending);

safeEggTransfer(msg.sender, pending);

}

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.accLyptusPerShare).div(1e12);

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

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

}

// Withdraw LP tokens from MasterChef.

function withdraw(uint256 _pid, uint256 _amount) public {

PoolInfo storage pool = poolInfo[_pid];

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

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

updatePool(_pid);

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

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

if(pending > 0) {

safeLyptusTransfer(msg.sender, pending);

safeEggTransfer(msg.sender, pending);

}

if(_amount > 0) {

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

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

}

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

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

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

}

// Withdraw without caring about rewards. EMERGENCY ONLY.

function emergencyWithdraw(uint256 _pid) public {

PoolInfo storage pool = poolInfo[_pid];

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

uint256 amount = user.amount;

user.amount = 0;

user.rewardDebt = 0;

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

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

}

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

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

function safeLyptusTransfer(address _to, uint256 _amount) internal {

function safeEggTransfer(address _to, uint256 _amount) internal {

uint256 lyptusBal = lyptus.balanceOf(address(this));

uint256 eggBal = egg.balanceOf(address(this));

if (_amount > lyptusBal) {

if (_amount > eggBal) {

lyptus.transfer(_to, lyptusBal);

egg.transfer(_to, eggBal);

} else {

lyptus.transfer(_to, _amount);

egg.transfer(_to, _amount);

}

// Update dev address by the previous dev.

function dev(address _devaddr) public {

require(msg.sender == devaddr, "dev: wut?");

devaddr = _devaddr;

}

function setFeeAddress(address _feeAddress) public{

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

feeAddress = _feeAddress;

}

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

function updateEmissionRate(uint256 _lyptusPerBlock) public onlyOwner {

function updateEmissionRate(uint256 _eggPerBlock) public onlyOwner {

massUpdatePools();

lyptusPerBlock = _lyptusPerBlock;

eggPerBlock = _eggPerBlock;

}

Diferenças salvas

Texto original

Abrir arquivo

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

//  .----------------.  .----------------.  .----------------.  .----------------.  .----------------. 
// | .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
// | |  ___  ____   | || |     ____     | || |      __      | || |   _____      | || |      __      | |
// | | |_  ||_  _|  | || |   .'    `.   | || |     /  \     | || |  |_   _|     | || |     /  \     | |
// | |   | |_/ /    | || |  /  .--.  \  | || |    / /\ \    | || |    | |       | || |    / /\ \    | |
// | |   |  __'.    | || |  | |    | |  | || |   / ____ \   | || |    | |   _   | || |   / ____ \   | |
// | |  _| |  \ \_  | || |  \  `--'  /  | || | _/ /    \ \_ | || |   _| |__/ |  | || | _/ /    \ \_ | |
// | | |____||____| | || |   `.____.'   | || ||____|  |____|| || |  |________|  | || ||____|  |____|| |
// | |              | || |              | || |              | || |              | || |              | |
// | '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
// '----------------'  '----------------'  '----------------'  '----------------'  '----------------'

import "./SafeMath.sol";
import "./IBEP20.sol";
import "./SafeBEP20.sol";
import "./Ownable.sol";

import "./LYPTUSToken.sol";

// MasterChef is the master of Lyptus. He can make Lyptus and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once LYPTUS is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable {
    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.
        //
        // We do some fancy math here. Basically, any point in time, the amount of LYPTUSs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accLyptusPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accLyptusPerShare` (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. LYPTUSs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that LYPTUSs distribution occurs.
        uint256 accLyptusPerShare;   // Accumulated LYPTUSs per share, times 1e12. See below.
        uint16 depositFeeBP;      // Deposit fee in basis points
    }

// The LYPTUS TOKEN!
    LyptusToken public lyptus;
    // Dev address.
    address public devaddr;
    // LYPTUS tokens created per block.
    uint256 public lyptusPerBlock;
    // Bonus muliplier for early lyptus makers.
    uint256 public constant BONUS_MULTIPLIER = 1;
    // Deposit Fee address
    address public feeAddress;

// 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 LYPTUS mining starts.
    uint256 public startBlock;

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);

constructor(
        LyptusToken _lyptus,
        address _devaddr,
        address _feeAddress,
        uint256 _lyptusPerBlock,
        uint256 _startBlock
    ) public {
        lyptus = _lyptus;
        devaddr = _devaddr;
        feeAddress = _feeAddress;
        lyptusPerBlock = _lyptusPerBlock;
        startBlock = _startBlock;
    }

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, bool _withUpdate) public onlyOwner {
        require(_depositFeeBP <= 10000, "add: invalid deposit fee basis points");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accLyptusPerShare: 0,
            depositFeeBP: _depositFeeBP
        }));
    }

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

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

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

// 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 lyptusReward = multiplier.mul(lyptusPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        lyptus.mint(devaddr, lyptusReward.div(10));
        lyptus.mint(address(this), lyptusReward);
        pool.accLyptusPerShare = pool.accLyptusPerShare.add(lyptusReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

// Deposit LP tokens to MasterChef for LYPTUS allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accLyptusPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeLyptusTransfer(msg.sender, pending);
            }
        }
        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.accLyptusPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

// Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accLyptusPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeLyptusTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accLyptusPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }

// Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        pool.lpToken.safeTransfer(address(msg.sender), amount);
        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }

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

// Update dev address by the previous dev.
    function dev(address _devaddr) public {
        require(msg.sender == devaddr, "dev: wut?");
        devaddr = _devaddr;
    }

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

//Pancake has to add hidden dummy pools inorder to alter the emission, here we make it simple and transparent to all.
    function updateEmissionRate(uint256 _lyptusPerBlock) public onlyOwner {
        massUpdatePools();
        lyptusPerBlock = _lyptusPerBlock;
    }
}

Texto alterado

Abrir arquivo

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

import "@openzeppelin/contracts/math/SafeMath.sol";
import "./libs/IBEP20.sol";
import "./libs/SafeBEP20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

import "./EggToken.sol";

// MasterChef is the master of Egg. He can make Egg and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once EGG is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable {
    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.
        //
        // We do some fancy math here. Basically, any point in time, the amount of EGGs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accEggPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accEggPerShare` (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. EGGs to distribute per block.
        uint256 lastRewardBlock;  // Last block number that EGGs distribution occurs.
        uint256 accEggPerShare;   // Accumulated EGGs per share, times 1e12. See below.
        uint16 depositFeeBP;      // Deposit fee in basis points
    }

// The EGG TOKEN!
    EggToken public egg;
    // Dev address.
    address public devaddr;
    // EGG tokens created per block.
    uint256 public eggPerBlock;
    // Bonus muliplier for early egg makers.
    uint256 public constant BONUS_MULTIPLIER = 1;
    // Deposit Fee address
    address public feeAddress;

constructor(
        EggToken _egg,
        address _devaddr,
        address _feeAddress,
        uint256 _eggPerBlock,
        uint256 _startBlock
    ) public {
        egg = _egg;
        devaddr = _devaddr;
        feeAddress = _feeAddress;
        eggPerBlock = _eggPerBlock;
        startBlock = _startBlock;
    }

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, bool _withUpdate) public onlyOwner {
        require(_depositFeeBP <= 10000, "add: invalid deposit fee basis points");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accEggPerShare: 0,
            depositFeeBP: _depositFeeBP
        }));
    }

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

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

// 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 eggReward = multiplier.mul(eggPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        egg.mint(devaddr, eggReward.div(10));
        egg.mint(address(this), eggReward);
        pool.accEggPerShare = pool.accEggPerShare.add(eggReward.mul(1e12).div(lpSupply));
        pool.lastRewardBlock = block.number;
    }

// Deposit LP tokens to MasterChef for EGG allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accEggPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeEggTransfer(msg.sender, pending);
            }
        }
        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.accEggPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

// Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accEggPerShare).div(1e12).sub(user.rewardDebt);
        if(pending > 0) {
            safeEggTransfer(msg.sender, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accEggPerShare).div(1e12);
        emit Withdraw(msg.sender, _pid, _amount);
    }

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

// Update dev address by the previous dev.
    function dev(address _devaddr) public {
        require(msg.sender == devaddr, "dev: wut?");
        devaddr = _devaddr;
    }

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

//Pancake has to add hidden dummy pools inorder to alter the emission, here we make it simple and transparent to all.
    function updateEmissionRate(uint256 _eggPerBlock) public onlyOwner {
        massUpdatePools();
        eggPerBlock = _eggPerBlock;
    }
}