文件 1 的 1：FryCook.sol
pragma solidity ^0.6.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
pragma solidity ^0.6.2;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.6.0;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity ^0.6.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1;
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
pragma solidity ^0.6.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
pragma solidity ^0.6.0;
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
pragma solidity ^0.6.0;
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
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);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
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);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
pragma solidity ^0.6.0;
abstract contract ERC20Capped is ERC20 {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {
require(totalSupply().add(amount) <= _cap, "ERC20Capped: cap exceeded");
}
}
}
pragma solidity ^0.6.0;
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity 0.6.12;
contract ChickenToken is ERC20Capped, Ownable {
constructor() public ERC20("ChickenToken", "CHKN") ERC20Capped(580000000000000000000000000) { }
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
mapping (address => address) internal _delegates;
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
mapping (address => uint32) public numCheckpoints;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping (address => uint) public nonces;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(
address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s
)
external
{
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)
)
);
bytes32 structHash = keccak256(
abi.encode(
DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry
)
);
bytes32 digest = keccak256(
abi.encodePacked(
"\x19\x01",
domainSeparator,
structHash
)
);
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CHKN::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CHKN::delegateBySig: invalid nonce");
require(now <= expiry, "CHKN::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "CHKN::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2;
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
)
internal
{
uint32 blockNumber = safe32(block.number, "CHKN::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
pragma solidity 0.6.12;
interface ICookMigrator {
function migrate(IERC20 token) external returns (IERC20);
}
contract FryCook is AccessControl {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct PoolInfo {
IERC20 lpToken;
uint256 allocPoint;
uint256 lastRewardBlock;
uint256 totalScore;
uint256 accChickenPerScore;
uint256 earlyBirdMinShares;
uint256 earlyBirdExtra;
uint256 earlyBirdGraceEndBlock;
uint256 earlyBirdHalvingBlocks;
}
struct UserInfo {
uint256 amount;
uint256 score;
uint256 earlyBirdMult;
bool earlyBird;
uint256 rewardDebt;
}
bytes32 public constant EXECUTIVE_ROLE = keccak256("EXECUTIVE_ROLE");
bytes32 public constant HEAD_CHEF_ROLE = keccak256("HEAD_CHEF_ROLE");
bytes32 public constant SOUS_CHEF_ROLE = keccak256("SOUS_CHEF_ROLE");
bytes32 public constant WAITSTAFF_ROLE = keccak256("WAITSTAFF_ROLE");
ChickenToken public chicken;
uint256 public chickenCap;
address public devaddr;
uint256 public bonusStage2Block;
uint256 public bonusStage3Block;
uint256 public bonusStage4Block;
uint256 public bonusEndBlock;
uint256 public chickenPerBlock;
uint256 public constant BONUS_MULTIPLIER_STAGE_1 = 20;
uint256 public constant BONUS_MULTIPLIER_STAGE_2 = 15;
uint256 public constant BONUS_MULTIPLIER_STAGE_3 = 10;
uint256 public constant BONUS_MULTIPLIER_STAGE_4 = 5;
uint256 public devBonusStage2Block;
uint256 public devBonusStage3Block;
uint256 public devBonusStage4Block;
uint256 public devBonusEndBlock;
uint256 public constant DEV_DIV_STAGE_1 = 10;
uint256 public constant DEV_DIV_STAGE_2 = 12;
uint256 public constant DEV_DIV_STAGE_3 = 16;
uint256 public constant DEV_DIV_STAGE_4 = 25;
uint256 public constant DEV_DIV = 50;
uint256 public constant EARLY_BIRD_PRECISION = 1e12;
uint256 public constant ACC_CHICKEN_PRECISION = 1e12;
ICookMigrator public migrator;
PoolInfo[] public poolInfo;
mapping (address => uint256) public tokenPid;
mapping (address => bool) public hasToken;
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
uint256 public totalAllocPoint = 0;
uint256 public startBlock;
event Deposit(address indexed staker, address indexed funder, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed staker, address indexed agent, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(
ChickenToken _chicken,
address _devaddr,
uint256 _chickenPerBlock,
uint256 _startBlock,
uint256 _bonusEndBlock,
uint256 _devBonusEndBlock
) public {
chicken = _chicken;
devaddr = _devaddr;
chickenPerBlock = _chickenPerBlock;
bonusEndBlock = _bonusEndBlock;
startBlock = _startBlock;
devBonusEndBlock = _devBonusEndBlock;
uint256 bonusStep = bonusEndBlock.sub(startBlock).div(4);
bonusStage2Block = bonusStep.add(startBlock);
bonusStage3Block = bonusStep.mul(2).add(startBlock);
bonusStage4Block = bonusStep.mul(3).add(startBlock);
uint256 devBonusStep = devBonusEndBlock.sub(startBlock).div(4);
devBonusStage2Block = devBonusStep.add(startBlock);
devBonusStage3Block = devBonusStep.mul(2).add(startBlock);
devBonusStage4Block = devBonusStep.mul(3).add(startBlock);
_setupRole(EXECUTIVE_ROLE, msg.sender);
_setupRole(HEAD_CHEF_ROLE, msg.sender);
_setRoleAdmin(EXECUTIVE_ROLE, EXECUTIVE_ROLE);
_setRoleAdmin(HEAD_CHEF_ROLE, EXECUTIVE_ROLE);
_setRoleAdmin(SOUS_CHEF_ROLE, EXECUTIVE_ROLE);
_setRoleAdmin(WAITSTAFF_ROLE, EXECUTIVE_ROLE);
chickenCap = chicken.cap();
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function add(
uint256 _allocPoint,
IERC20 _lpToken,
uint256 _earlyBirdMinShares,
uint256 _earlyBirdInitialBonus,
uint256 _earlyBirdGraceEndBlock,
uint256 _earlyBirdHalvingBlocks,
bool _withUpdate
) public {
require(hasRole(HEAD_CHEF_ROLE, msg.sender), "FryCook::add: not authorized");
require(!hasToken[address(_lpToken)], "FryCook::add: lpToken already added");
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
hasToken[address(_lpToken)] = true;
tokenPid[address(_lpToken)] = poolInfo.length;
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
earlyBirdMinShares: _earlyBirdMinShares,
earlyBirdExtra: _earlyBirdInitialBonus.sub(1),
earlyBirdGraceEndBlock: _earlyBirdGraceEndBlock,
earlyBirdHalvingBlocks: _earlyBirdHalvingBlocks,
lastRewardBlock: lastRewardBlock,
totalScore: 0,
accChickenPerScore: 0
}));
}
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public {
require(hasRole(HEAD_CHEF_ROLE, msg.sender) || hasRole(SOUS_CHEF_ROLE, msg.sender), "FryCook::set: not authorized");
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
poolInfo[_pid].allocPoint = _allocPoint;
}
function setMigrator(ICookMigrator _migrator) public {
require(hasRole(EXECUTIVE_ROLE, msg.sender), "FryCook::setMigrator: not authorized");
migrator = _migrator;
}
function migrate(uint256 _pid) public {
require(address(migrator) != address(0), "FryCook::migrate: no migrator");
PoolInfo storage pool = poolInfo[_pid];
IERC20 lpToken = pool.lpToken;
uint256 bal = lpToken.balanceOf(address(this));
lpToken.safeApprove(address(migrator), bal);
IERC20 newLpToken = migrator.migrate(lpToken);
require(bal == newLpToken.balanceOf(address(this)), "FryCook::migrate: bad");
pool.lpToken = newLpToken;
tokenPid[address(newLpToken)] = _pid;
hasToken[address(newLpToken)] = true;
tokenPid[address(lpToken)] = 0;
hasToken[address(lpToken)] = false;
}
function getIntersection(uint256 _from, uint256 _to, uint256 _from2, uint256 _to2) public pure returns (uint256) {
if (_to <= _from2) {
return 0;
} else if (_to2 <= _from) {
return 0;
} else {
return Math.min(_to, _to2).sub(Math.max(_from, _from2));
}
}
function getMintMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
if (_from >= bonusEndBlock) {
return _to.sub(_from);
} else {
uint256 mult = 0;
mult = mult.add(getIntersection(_from, _to, 0, bonusStage2Block).mul(BONUS_MULTIPLIER_STAGE_1));
mult = mult.add(getIntersection(_from, _to, bonusStage2Block, bonusStage3Block).mul(BONUS_MULTIPLIER_STAGE_2));
mult = mult.add(getIntersection(_from, _to, bonusStage3Block, bonusStage4Block).mul(BONUS_MULTIPLIER_STAGE_3));
mult = mult.add(getIntersection(_from, _to, bonusStage4Block, bonusEndBlock).mul(BONUS_MULTIPLIER_STAGE_4));
mult = mult.add(Math.max(_to, bonusEndBlock).sub(bonusEndBlock));
return mult;
}
}
function getDevDivisor(uint256 _block) public view returns (uint256) {
if (_block >= devBonusEndBlock) {
return DEV_DIV;
} else if (_block >= devBonusStage4Block) {
return DEV_DIV_STAGE_4;
} else if (_block >= devBonusStage3Block) {
return DEV_DIV_STAGE_3;
} else if (_block >= devBonusStage2Block) {
return DEV_DIV_STAGE_2;
} else {
return DEV_DIV_STAGE_1;
}
}
function getEarlyBirdMultiplier(uint256 _block, uint256 _pid) public view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
uint256 decliningPortion = pool.earlyBirdExtra.mul(EARLY_BIRD_PRECISION);
if (_block <= pool.earlyBirdGraceEndBlock) {
return decliningPortion.add(EARLY_BIRD_PRECISION);
}
uint256 distance = _block.sub(pool.earlyBirdGraceEndBlock);
uint256 halvings = distance.div(pool.earlyBirdHalvingBlocks);
if (halvings >= 120) {
return EARLY_BIRD_PRECISION;
}
uint256 progress = distance.sub(halvings.mul(pool.earlyBirdHalvingBlocks));
uint256 divisor = (2 ** halvings).mul(1e8);
uint256 nextDivisor = (2 ** (halvings.add(1))).mul(1e8);
uint256 diff = nextDivisor.sub(divisor);
uint256 alpha = progress.mul(1e8).div(pool.earlyBirdHalvingBlocks);
divisor = divisor.add(diff.mul(alpha).div(1e8));
return decliningPortion.mul(1e8).div(divisor).add(EARLY_BIRD_PRECISION);
}
function pendingChicken(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accChickenPerScore = pool.accChickenPerScore;
uint256 totalScore = pool.totalScore;
if (block.number > pool.lastRewardBlock && totalScore != 0) {
uint256 multiplier = getMintMultiplier(pool.lastRewardBlock, block.number);
uint256 chickenReward = multiplier.mul(chickenPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accChickenPerScore = accChickenPerScore.add(chickenReward.mul(ACC_CHICKEN_PRECISION).div(totalScore));
}
return user.score.mul(accChickenPerScore).div(ACC_CHICKEN_PRECISION).sub(user.rewardDebt);
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 totalScore = pool.totalScore;
if (totalScore == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMintMultiplier(pool.lastRewardBlock, block.number);
uint256 chickenReward = multiplier.mul(chickenPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
uint256 devReward = chickenReward.div(getDevDivisor(block.number));
uint256 supply = chicken.totalSupply();
if (supply.add(chickenReward).add(devReward) > chickenCap) {
chickenReward = chickenCap.sub(supply);
devReward = 0;
}
chicken.mint(address(this), chickenReward);
chicken.mint(devaddr, devReward);
pool.accChickenPerScore = pool.accChickenPerScore.add(chickenReward.mul(ACC_CHICKEN_PRECISION).div(totalScore));
pool.lastRewardBlock = block.number;
}
function deposit(uint256 _pid, uint256 _amount) public {
_deposit(_pid, _amount, msg.sender, msg.sender);
}
function depositTo(uint256 _pid, uint256 _amount, address _staker) public {
require(hasRole(WAITSTAFF_ROLE, msg.sender), "FryCook::depositTo: not authorized");
_deposit(_pid, _amount, _staker, msg.sender);
}
function _deposit(uint256 _pid, uint256 _amount, address _staker, address _funder) internal {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_staker];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.score.mul(pool.accChickenPerScore).div(ACC_CHICKEN_PRECISION).sub(user.rewardDebt);
if (pending > 0) {
safeChickenTransfer(_staker, pending);
}
} else {
user.earlyBirdMult = EARLY_BIRD_PRECISION;
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(_funder, address(this), _amount);
uint256 oldScore = user.score;
user.amount = user.amount.add(_amount);
if (!user.earlyBird && user.amount >= pool.earlyBirdMinShares) {
user.earlyBird = true;
user.earlyBirdMult = getEarlyBirdMultiplier(block.number, _pid);
}
user.score = user.amount.mul(user.earlyBirdMult).div(EARLY_BIRD_PRECISION);
pool.totalScore = pool.totalScore.add(user.score).sub(oldScore);
}
user.rewardDebt = user.score.mul(pool.accChickenPerScore).div(ACC_CHICKEN_PRECISION);
emit Deposit(_staker, _funder, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public {
_withdraw(_pid, _amount, address(msg.sender), address(msg.sender));
}
function withdrawFrom(uint256 _pid, uint256 _amount, address _staker) public {
require(hasRole(WAITSTAFF_ROLE, msg.sender), "FryCook::withdrawFrom: not authorized");
_withdraw(_pid, _amount, _staker, address(msg.sender));
}
function _withdraw(uint256 _pid, uint256 _amount, address _staker, address _agent) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_staker];
require(user.amount >= _amount, "FryCook::withdraw: not good");
updatePool(_pid);
uint256 pending = user.score.mul(pool.accChickenPerScore).div(ACC_CHICKEN_PRECISION).sub(user.rewardDebt);
if (pending > 0) {
safeChickenTransfer(_staker, pending);
}
if (_amount > 0) {
uint256 oldScore = user.score;
user.amount = user.amount.sub(_amount);
if (user.earlyBird && user.amount < pool.earlyBirdMinShares) {
user.earlyBird = false;
user.earlyBirdMult = EARLY_BIRD_PRECISION;
}
user.score = user.amount.mul(user.earlyBirdMult).div(EARLY_BIRD_PRECISION);
pool.lpToken.safeTransfer(_agent, _amount);
pool.totalScore = pool.totalScore.add(user.score).sub(oldScore);
}
user.rewardDebt = user.score.mul(pool.accChickenPerScore).div(ACC_CHICKEN_PRECISION);
emit Withdraw(_staker, _agent, _pid, _amount);
}
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
pool.totalScore = pool.totalScore.sub(user.score);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.earlyBird = false;
user.earlyBirdMult = EARLY_BIRD_PRECISION;
user.score = 0;
user.rewardDebt = 0;
}
function safeChickenTransfer(address _to, uint256 _amount) internal {
uint256 chickenBal = chicken.balanceOf(address(this));
if (_amount > chickenBal) {
chicken.transfer(_to, chickenBal);
} else {
chicken.transfer(_to, _amount);
}
}
function dev(address _devaddr) public {
require(msg.sender == devaddr, "FryCook::dev: wut?");
devaddr = _devaddr;
}
}
