File 1 of 6 : DeliriumToken.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

import “@openzeppelin/contracts/token/ERC20/ERC20.sol”;
import “@openzeppelin/contracts/access/Ownable.sol”;

// DeliriumToken
contract DeliriumToken is ERC20, Ownable {

constructor()
ERC20(‘DELIRIUM’, ‘DELIRIUM’)
{}

/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}

File 2 of 6 : ERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import “./IERC20.sol”;
import “./extensions/IERC20Metadata.sol”;
import “../../utils/Context.sol”;

/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226%5BHow
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn’t required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;

mapping(address => mapping(address => uint256)) private _allowances;

uint256 private _totalSupply;

string private _name;
string private _symbol;

/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}

/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}

/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}

/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}

/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}

/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}

/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* – `recipient` cannot be the zero address.
* – the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}

/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}

/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* – `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}

/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* – `sender` and `recipient` cannot be the zero address.
* – `sender` must have a balance of at least `amount`.
* – the caller must have allowance for “sender“’s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);

uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, “ERC20: transfer amount exceeds allowance”);
unchecked {
_approve(sender, _msgSender(), currentAllowance – amount);
}

return true;
}

/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* – `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}

/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* – `spender` cannot be the zero address.
* – `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, “ERC20: decreased allowance below zero”);
unchecked {
_approve(_msgSender(), spender, currentAllowance – subtractedValue);
}

return true;
}

/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* – `sender` cannot be the zero address.
* – `recipient` cannot be the zero address.
* – `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), “ERC20: transfer from the zero address”);
require(recipient != address(0), “ERC20: transfer to the zero address”);

_beforeTokenTransfer(sender, recipient, amount);

uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, “ERC20: transfer amount exceeds balance”);
unchecked {
_balances[sender] = senderBalance – amount;
}
_balances[recipient] += amount;

emit Transfer(sender, recipient, amount);

_afterTokenTransfer(sender, recipient, amount);
}

/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* – `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), “ERC20: mint to the zero address”);

_beforeTokenTransfer(address(0), account, amount);

_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);

_afterTokenTransfer(address(0), account, amount);
}

/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* – `account` cannot be the zero address.
* – `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), “ERC20: burn from the zero address”);

_beforeTokenTransfer(account, address(0), amount);

uint256 accountBalance = _balances[account];
require(accountBalance >= amount, “ERC20: burn amount exceeds balance”);
unchecked {
_balances[account] = accountBalance – amount;
}
_totalSupply -= amount;

emit Transfer(account, address(0), amount);

_afterTokenTransfer(account, address(0), amount);
}

/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* – `owner` cannot be the zero address.
* – `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), “ERC20: approve from the zero address”);
require(spender != address(0), “ERC20: approve to the zero address”);

_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}

/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* – when `from` and `to` are both non-zero, `amount` of “from“’s tokens
* will be transferred to `to`.
* – when `from` is zero, `amount` tokens will be minted for `to`.
* – when `to` is zero, `amount` of “from“’s tokens will be burned.
* – `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}

/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* – when `from` and `to` are both non-zero, `amount` of “from“’s tokens
* has been transferred to `to`.
* – when `from` is zero, `amount` tokens have been minted for `to`.
* – when `to` is zero, `amount` of “from“’s tokens have been burned.
* – `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}

File 3 of 6 : Ownable.sol

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

File 4 of 6 : IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);

/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);

/**
* @dev Moves `amount` tokens from the caller’s account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);

/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);

/**
* @dev Sets `amount` as the allowance of `spender` over the caller’s tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender’s allowance to 0 and set the
* desired value afterwards:
* github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);

/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller’s
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);

/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);

/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}

File 5 of 6 : IERC20Metadata.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import “../IERC20.sol”;

/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);

/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);

/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}

File 6 of 6 : Context.sol

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

import “@openzeppelin/contracts/token/ERC20/IERC20.sol”;
import “@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol”;
import “@openzeppelin/contracts/security/ReentrancyGuard.sol”;

import “./DeliriumToken.sol”;

// MasterChef is the master of Delirium. He can make Delirium 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 DELIRIUM is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it’s bug-free. God bless.
contract MasterChefV2 is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;

// 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 DELIRIUMs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accDeliriumPerShare) – user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here’s what happens:
// 1. The pool’s `accDeliriumPerShare` (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 {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. DELIRIUMs to distribute per block.
uint256 lastRewardBlock; // Last block number that DELIRIUMs distribution occurs.
uint256 accDeliriumPerShare; // Accumulated DELIRIUMs per share, times 1e12. See below.
uint16 depositFeeBP; // Deposit fee in basis points
uint256 lpSupply;
}

uint256 public deliriumMaximumSupply = 500 * (10 ** 3) * (10 ** 18); // 500,000 delirium

// The DELIRIUM TOKEN!
DeliriumToken public immutable delirium;
// DELIRIUM tokens created per block.
uint256 public deliriumPerBlock;
// 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 DELIRIUM mining starts.
uint256 public startBlock;
// The block number when DELIRIUM mining ends.
uint256 public emmissionEndBlock = type(uint256).max;

event addPool(uint256 indexed pid, address lpToken, uint256 allocPoint, uint256 depositFeeBP);
event setPool(uint256 indexed pid, address lpToken, uint256 allocPoint, uint256 depositFeeBP);
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 SetEmissionRate(address indexed caller, uint256 previousAmount, uint256 newAmount);
event SetFeeAddress(address indexed user, address indexed newAddress);
event SetStartBlock(uint256 newStartBlock);
event SetDeliriumMaximumSupply(uint256 newMaxSupply);

constructor(
DeliriumToken _delirium,
address _feeAddress,
uint256 _deliriumPerBlock,
uint256 _startBlock
) {
require(_feeAddress != address(0), “!nonzero”);

delirium = _delirium;
feeAddress = _feeAddress;
deliriumPerBlock = _deliriumPerBlock;
startBlock = _startBlock;
}

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

mapping(IERC20 => bool) public poolExistence;
modifier nonDuplicated(IERC20 _lpToken) {
require(poolExistence[_lpToken] == false, “nonDuplicated: duplicated”);
_;
}

// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP, bool _withUpdate) external onlyOwner nonDuplicated(_lpToken) {
// Make sure the provided token is ERC20
_lpToken.balanceOf(address(this));

require(_depositFeeBP <= 401, “add: invalid deposit fee basis points”);
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint + _allocPoint;
poolExistence[_lpToken] = true;

poolInfo.push(PoolInfo({
lpToken : _lpToken,
allocPoint : _allocPoint,
lastRewardBlock : lastRewardBlock,
accDeliriumPerShare : 0,
depositFeeBP : _depositFeeBP,
lpSupply: 0
}));

emit addPool(poolInfo.length – 1, address(_lpToken), _allocPoint, _depositFeeBP);
}

// Update the given pool’s DELIRIUM allocation point and deposit fee. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, bool _withUpdate) external onlyOwner {
require(_depositFeeBP <= 401, “set: invalid deposit fee basis points”);
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint – poolInfo[_pid].allocPoint + _allocPoint;
poolInfo[_pid].allocPoint = _allocPoint;
poolInfo[_pid].depositFeeBP = _depositFeeBP;

emit setPool(_pid, address(poolInfo[_pid].lpToken), _allocPoint, _depositFeeBP);
}

// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
// As we set the multiplier to 0 here after emmissionEndBlock
// deposits aren’t blocked after farming ends.
if (_from > emmissionEndBlock)
return 0;
if (_to > emmissionEndBlock)
return emmissionEndBlock – _from;
else
return _to – _from;
}

// View function to see pending DELIRIUMs on frontend.
function pendingDelirium(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accDeliriumPerShare = pool.accDeliriumPerShare;
if (block.number > pool.lastRewardBlock && pool.lpSupply != 0 && totalAllocPoint > 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 deliriumReward = (multiplier * deliriumPerBlock * pool.allocPoint) / totalAllocPoint;
accDeliriumPerShare = accDeliriumPerShare + ((deliriumReward * 1e12) / pool.lpSupply);
}

return ((user.amount * accDeliriumPerShare) / 1e12) – 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;
}

if (pool.lpSupply == 0 || pool.allocPoint == 0) {
pool.lastRewardBlock = block.number;
return;
}

uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 deliriumReward = (multiplier * deliriumPerBlock * pool.allocPoint) / totalAllocPoint;

// This shouldn’t happen, but just in case we stop rewards.
if (delirium.totalSupply() > deliriumMaximumSupply)
deliriumReward = 0;
else if ((delirium.totalSupply() + deliriumReward) > deliriumMaximumSupply)
deliriumReward = deliriumMaximumSupply – delirium.totalSupply();

if (deliriumReward > 0)
delirium.mint(address(this), deliriumReward);

// The first time we reach Delirium max supply we solidify the end of farming.
if (delirium.totalSupply() >= deliriumMaximumSupply && emmissionEndBlock == type(uint256).max)
emmissionEndBlock = block.number;

pool.accDeliriumPerShare = pool.accDeliriumPerShare + ((deliriumReward * 1e12) / pool.lpSupply);
pool.lastRewardBlock = block.number;
}

// Deposit LP tokens to MasterChef for DELIRIUM allocation.
function deposit(uint256 _pid, uint256 _amount) external nonReentrant {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = ((user.amount * pool.accDeliriumPerShare) / 1e12) – user.rewardDebt;
if (pending > 0) {
safeDeliriumTransfer(msg.sender, pending);
}
}
if (_amount > 0) {
uint256 balanceBefore = pool.lpToken.balanceOf(address(this));
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
_amount = pool.lpToken.balanceOf(address(this)) – balanceBefore;
require(_amount > 0, “we dont accept deposits of 0 size”);

if (pool.depositFeeBP > 0) {
uint256 depositFee = (_amount * pool.depositFeeBP) / 10000;
pool.lpToken.safeTransfer(feeAddress, depositFee);
user.amount = user.amount + _amount – depositFee;
pool.lpSupply = pool.lpSupply + _amount – depositFee;
} else {
user.amount = user.amount + _amount;
pool.lpSupply = pool.lpSupply + _amount;
}
}
user.rewardDebt = (user.amount * pool.accDeliriumPerShare) / 1e12;

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

// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _pid, uint256 _amount) external nonReentrant {
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 * pool.accDeliriumPerShare) / 1e12) – user.rewardDebt;
if (pending > 0) {
safeDeliriumTransfer(msg.sender, pending);
}
if (_amount > 0) {
user.amount = user.amount – _amount;
pool.lpToken.safeTransfer(address(msg.sender), _amount);
pool.lpSupply = pool.lpSupply – _amount;
}
user.rewardDebt = (user.amount * pool.accDeliriumPerShare) / 1e12;
emit Withdraw(msg.sender, _pid, _amount);
}

// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) external nonReentrant {
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);

// In the case of an accounting error, we choose to let the user emergency withdraw anyway
if (pool.lpSupply >= amount)
pool.lpSupply = pool.lpSupply – amount;
else
pool.lpSupply = 0;

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

// Safe delirium transfer function, just in case if rounding error causes pool to not have enough DELIRIUMs.
function safeDeliriumTransfer(address _to, uint256 _amount) internal {
uint256 deliriumBal = delirium.balanceOf(address(this));
bool transferSuccess = false;
if (_amount > deliriumBal) {
transferSuccess = delirium.transfer(_to, deliriumBal);
} else {
transferSuccess = delirium.transfer(_to, _amount);
}
require(transferSuccess, “safeDeliriumTransfer: transfer failed”);
}

function setFeeAddress(address _feeAddress) external onlyOwner {
require(_feeAddress != address(0), “!nonzero”);
feeAddress = _feeAddress;
emit SetFeeAddress(msg.sender, _feeAddress);
}

function setStartBlock(uint256 _newStartBlock) external onlyOwner {
require(block.number < startBlock, “cannot change start block if sale has already commenced”);
require(block.number < _newStartBlock, “cannot set start block in the past”);
startBlock = _newStartBlock;

emit SetStartBlock(startBlock);
}

function setEmissionRate(uint256 _deliriumPerBlock) public onlyOwner {
require(_deliriumPerBlock > 0);

massUpdatePools();
deliriumPerBlock = _deliriumPerBlock;

emit SetEmissionRate(msg.sender, deliriumPerBlock, _deliriumPerBlock);
}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Timelock {

event NewAdmin(address indexed newAdmin);
event NewPendingAdmin(address indexed newPendingAdmin);
event NewDelay(uint indexed newDelay);
event CancelTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);
event ExecuteTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);
event QueueTransaction(bytes32 indexed txHash, address indexed target, uint value, string signature, bytes data, uint eta);

uint public constant GRACE_PERIOD = 14 days;
uint public constant MINIMUM_DELAY = 6 hours;
uint public constant MAXIMUM_DELAY = 30 days;

address public admin;
address public pendingAdmin;
uint public delay;
bool public admin_initialized;

mapping (bytes32 => bool) public queuedTransactions;

constructor(address admin_, uint delay_) {
require(delay_ >= MINIMUM_DELAY, “Timelock::constructor: Delay must exceed minimum delay.”);
require(delay_ <= MAXIMUM_DELAY, “Timelock::constructor: Delay must not exceed maximum delay.”);

admin = admin_;
delay = delay_;
admin_initialized = false;
}

// XXX: function() external payable { }
receive() external payable { }

function setDelay(uint delay_) public {
require(msg.sender == address(this), “Timelock::setDelay: Call must come from Timelock.”);
require(delay_ >= MINIMUM_DELAY, “Timelock::setDelay: Delay must exceed minimum delay.”);
require(delay_ <= MAXIMUM_DELAY, “Timelock::setDelay: Delay must not exceed maximum delay.”);
delay = delay_;

emit NewDelay(delay);
}

function acceptAdmin() public {
require(msg.sender == pendingAdmin, “Timelock::acceptAdmin: Call must come from pendingAdmin.”);
admin = msg.sender;
pendingAdmin = address(0);

emit NewAdmin(admin);
}

function setPendingAdmin(address pendingAdmin_) public {
// allows one time setting of admin for deployment purposes
if (admin_initialized) {
require(msg.sender == address(this), “Timelock::setPendingAdmin: Call must come from Timelock.”);
} else {
require(msg.sender == admin, “Timelock::setPendingAdmin: First call must come from admin.”);
admin_initialized = true;
}
pendingAdmin = pendingAdmin_;

emit NewPendingAdmin(pendingAdmin);
}

function queueTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public returns (bytes32) {
require(msg.sender == admin, “Timelock::queueTransaction: Call must come from admin.”);
require(eta >= getBlockTimestamp() + delay, “Timelock::queueTransaction: Estimated execution block must satisfy delay.”);

bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
queuedTransactions[txHash] = true;

emit QueueTransaction(txHash, target, value, signature, data, eta);
return txHash;
}

function cancelTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public {
require(msg.sender == admin, “Timelock::cancelTransaction: Call must come from admin.”);

bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
queuedTransactions[txHash] = false;

emit CancelTransaction(txHash, target, value, signature, data, eta);
}

function executeTransaction(address target, uint value, string memory signature, bytes memory data, uint eta) public payable returns (bytes memory) {
require(msg.sender == admin, “Timelock::executeTransaction: Call must come from admin.”);

bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
require(queuedTransactions[txHash], “Timelock::executeTransaction: Transaction hasn’t been queued.”);
require(getBlockTimestamp() >= eta, “Timelock::executeTransaction: Transaction hasn’t surpassed time lock.”);
require(getBlockTimestamp() <= eta + GRACE_PERIOD, “Timelock::executeTransaction: Transaction is stale.”);

queuedTransactions[txHash] = false;

bytes memory callData;

if (bytes(signature).length == 0) {
callData = data;
} else {
callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
}

// solium-disable-next-line security/no-call-value
(bool success, bytes memory returnData) = target.call{value: value}(callData);
require(success, “Timelock::executeTransaction: Transaction execution reverted.”);

emit ExecuteTransaction(txHash, target, value, signature, data, eta);

return returnData;
}

function getBlockTimestamp() internal view returns (uint) {
// solium-disable-next-line security/no-block-members
return block.timestamp;
}
}