文件 1 的 1：APPLE.sol
pragma solidity >=0.4.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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.8.0;
interface IPYESwapRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
pragma solidity >=0.6.2;
interface IPYESwapRouter is IPYESwapRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function pairFeeAddress(address pair) external view returns (address);
function adminFee() external view returns (uint256);
function feeAddressGet() external view returns (address);
}
pragma solidity >=0.5.0;
interface IPYESwapPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function baseToken() external view returns (address);
function getTotalFee() external view returns (uint);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function updateTotalFee(uint totalFee) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast, address _baseToken);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, uint amount0Fee, uint amount1Fee, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
function setBaseToken(address _baseToken) external;
}
pragma solidity >=0.5.0;
interface IPYESwapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function pairExist(address pair) external view returns (bool);
function createPair(address tokenA, address tokenB, bool supportsTokenFee) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function routerInitialize(address) external;
function routerAddress() external view returns (address);
}
pragma solidity >=0.5.0;
interface IWETH {
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
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.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
pragma solidity ^0.8.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 & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b + (a % b == 0 ? 0 : 1);
}
}
pragma solidity ^0.8.0;
library Arrays {
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (array.length == 0) {
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
if (array[mid] > element) {
high = mid;
} else {
low = mid + 1;
}
}
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
pragma solidity ^0.8.0;
interface IAccessControl {
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) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
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.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
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;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, _allowances[owner][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = _allowances[owner][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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 += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(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);
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);
}
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 _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)
)
);
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
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 {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
pragma solidity >=0.4.0;
contract BEP20 is Context, IBEP20, Ownable {
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_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override virtual returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override virtual returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance')
);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(
_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero')
);
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(
account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance')
);
}
}
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
contract APPLE is Context, Ownable, AccessControl, ERC20 {
using SafeMath for uint256;
using Address for address;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant FEE_SETTER_ROLE = keccak256("FEE_SETTER_ROLE");
struct Staked {
uint256 amount;
}
address[] holders;
mapping (address => uint256) holderIndexes;
uint256 public totalStaked;
struct Fees {
uint256 developmentFee;
uint256 buybackFee;
uint256 burnFee;
address developmentAddress;
}
struct FeeValues {
uint256 transferAmount;
uint256 development;
uint256 buyback;
uint256 burn;
}
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => Staked) public staked;
mapping (address => bool) isBlacklisted;
mapping (address => bool) isStakingContract;
uint256 private _tTotal;
struct Settings {
bool autoBuybackEnabled;
uint256 autoBuybackCap;
uint256 autoBuybackAccumulator;
uint256 autoBuybackAmount;
uint256 autoBuybackBlockPeriod;
uint256 autoBuybackBlockLast;
uint256 minimumBuyBackThreshold;
}
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _includeSwapFee;
mapping (uint256 => address) private pairs;
mapping (uint256 => address) private tokens;
uint256 private pairsLength;
mapping (address => bool) public _isPairAddress;
string constant _name = "ApplePYE";
string constant _symbol = "APPLEPYE";
uint8 constant _decimals = 18;
Fees public _defaultFees;
Fees public _defaultSellFees;
Fees private _previousFees;
Fees private _emptyFees;
Fees private _sellFees;
Fees private _outsideBuyFees;
Fees private _outsideSellFees;
Settings public _buyback;
IPYESwapRouter public pyeSwapRouter;
address public pyeSwapPair;
address public WETH;
address public constant _burnAddress = 0x000000000000000000000000000000000000dEaD;
bool public swapEnabled = true;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
modifier onlyExchange() {
bool isPair = false;
for(uint i = 0; i < pairsLength; i++) {
if(pairs[i] == msg.sender) isPair = true;
}
require(
msg.sender == address(pyeSwapRouter)
|| isPair
, "PYE: NOT_ALLOWED"
);
_;
}
mapping (address => address) public 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);
constructor (address _router, address _development, uint256 _developmentFee, uint256 _buybackFee, uint256 _burnFee) ERC20("","") {
_setupRole(MINTER_ROLE, msg.sender);
_setupRole(BURNER_ROLE, msg.sender);
_setupRole(FEE_SETTER_ROLE, msg.sender);
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
pyeSwapRouter = IPYESwapRouter(_router);
WETH = pyeSwapRouter.WETH();
pyeSwapPair = IPYESwapFactory(pyeSwapRouter.factory())
.createPair(address(this), WETH, true);
tokens[pairsLength] = WETH;
pairs[pairsLength] = pyeSwapPair;
pairsLength += 1;
_isPairAddress[pyeSwapPair] = true;
_isExcludedFromFee[_msgSender()] = true;
_isExcludedFromFee[pyeSwapPair] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_burnAddress] = true;
_defaultFees = Fees(
_developmentFee,
_buybackFee,
0,
_development
);
_defaultSellFees = Fees(
_developmentFee,
_buybackFee,
_burnFee,
_development
);
_sellFees = Fees(
0,
0,
_burnFee,
_development
);
_outsideBuyFees = Fees(
_developmentFee.add(_buybackFee),
0,
0,
_development
);
_outsideSellFees = Fees(
_developmentFee.add(_buybackFee),
0,
_burnFee,
_development
);
IPYESwapPair(pyeSwapPair).updateTotalFee(400);
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure override returns (string memory) {
return _name;
}
function symbol() public pure override returns (string memory) {
return _symbol;
}
function decimals() public pure override returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual override returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual override returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function excludeFromFee(address account) public {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_isExcludedFromFee[account] = false;
}
function addOutsideSwapPair(address account) public {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_includeSwapFee[account] = true;
}
function removeOutsideSwapPair(address account) public {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_includeSwapFee[account] = false;
}
function _updatePairsFee() internal {
for (uint j = 0; j < pairsLength; j++) {
IPYESwapPair(pairs[j]).updateTotalFee(getTotalFee());
}
}
function setBuybackPercent(uint256 _buybackFee) external {
require(hasRole(FEE_SETTER_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
require(_defaultSellFees.developmentFee.add(_defaultSellFees.burnFee).add(_buybackFee) <= 2500, "Fees exceed max limit.");
_defaultFees.buybackFee = _buybackFee;
_defaultSellFees.buybackFee = _buybackFee;
_outsideBuyFees.developmentFee = _outsideBuyFees.developmentFee.add(_buybackFee);
_outsideSellFees.developmentFee = _outsideSellFees.developmentFee.add(_buybackFee);
_updatePairsFee();
}
function setDevelopmentPercent(uint256 _developmentFee) external {
require(hasRole(FEE_SETTER_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
require(_defaultSellFees.buybackFee.add(_defaultSellFees.burnFee).add(_developmentFee) <= 2500, "Fees exceed max limit.");
_defaultFees.developmentFee = _developmentFee;
_defaultSellFees.developmentFee = _developmentFee;
_outsideBuyFees.developmentFee = _outsideBuyFees.buybackFee.add(_developmentFee);
_outsideSellFees.developmentFee = _outsideSellFees.buybackFee.add(_developmentFee);
_updatePairsFee();
}
function setdevelopmentAddress(address _development) external {
require(hasRole(FEE_SETTER_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
require(_development != address(0), "PYE: Address Zero is not allowed");
_defaultFees.developmentAddress = _development;
_defaultSellFees.developmentAddress = _development;
_outsideBuyFees.developmentAddress = _development;
_outsideSellFees.developmentAddress = _development;
}
function setSellBurnFee(uint256 _burnFee) external {
require(hasRole(FEE_SETTER_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
require(_defaultSellFees.buybackFee.add(_defaultSellFees.developmentFee).add(_burnFee) <= 2500, "Fees exceed max limit.");
_sellFees.burnFee = _burnFee;
_defaultSellFees.burnFee = _burnFee;
_outsideSellFees.burnFee = _burnFee;
}
function updateRouterAndPair(address _router, address _pair) public {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_isExcludedFromFee[pyeSwapPair] = false;
pyeSwapRouter = IPYESwapRouter(_router);
pyeSwapPair = _pair;
WETH = pyeSwapRouter.WETH();
_isPairAddress[pyeSwapPair] = true;
_isExcludedFromFee[pyeSwapPair] = true;
pairs[0] = pyeSwapPair;
tokens[0] = WETH;
IPYESwapPair(pyeSwapPair).updateTotalFee(getTotalFee());
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (FeeValues memory) {
FeeValues memory values = FeeValues(
0,
calculateFee(tAmount, _defaultFees.developmentFee),
calculateFee(tAmount, _defaultFees.buybackFee),
calculateFee(tAmount, _defaultFees.burnFee)
);
values.transferAmount = tAmount.sub(values.development).sub(values.buyback).sub(values.burn);
return values;
}
function calculateFee(uint256 _amount, uint256 _fee) private pure returns (uint256) {
if(_fee == 0) return 0;
return _amount.mul(_fee).div(
10**4
);
}
function removeAllFee() private {
_previousFees = _defaultFees;
_defaultFees = _emptyFees;
}
function setSellFee() private {
_previousFees = _defaultFees;
_defaultFees = _sellFees;
}
function setOutsideBuyFee() private {
_previousFees = _defaultFees;
_defaultFees = _outsideBuyFees;
}
function setOutsideSellFee() private {
_previousFees = _defaultFees;
_defaultFees = _outsideSellFees;
}
function restoreAllFee() private {
_defaultFees = _previousFees;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function _approve(
address owner,
address spender,
uint256 amount
) internal override {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function getBalance(address keeper) public view returns (uint256){
return _balances[keeper];
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "BEP20: transfer from the zero address");
require(to != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isBlacklisted[to]);
_beforeTokenTransfer(from, to, amount);
if(shouldAutoBuyback(amount)){ triggerAutoBuyback(); }
if(isStakingContract[to]) {
uint256 newAmountAdd = staked[from].amount.add(amount);
setStaked(from, newAmountAdd);
}
if(isStakingContract[from]) {
uint256 newAmountSub = staked[to].amount.sub(amount);
setStaked(to, newAmountSub);
}
uint8 takeFee = 0;
if(_isPairAddress[to] && from != address(pyeSwapRouter) && !isExcludedFromFee(from)) {
takeFee = 1;
} else if(_includeSwapFee[from]) {
takeFee = 2;
} else if(_includeSwapFee[to]) {
takeFee = 3;
}
_tokenTransfer(from, to, amount, takeFee);
}
function getCirculatingSupply() public view returns (uint256) {
return _tTotal.sub(balanceOf(_burnAddress)).sub(balanceOf(address(0)));
}
function getTotalFee() public view returns (uint256) {
return _defaultFees.developmentFee
.add(_defaultFees.buybackFee)
.add(_defaultFees.burnFee);
}
function _tokenTransfer(address sender, address recipient, uint256 amount, uint8 takeFee) private {
if(takeFee == 0) {
removeAllFee();
} else if(takeFee == 1) {
setSellFee();
} else if(takeFee == 2) {
setOutsideBuyFee();
} else if(takeFee == 3) {
setOutsideSellFee();
}
FeeValues memory _values = _getValues(amount);
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(_values.transferAmount);
_takeFees(_values);
emit Transfer(sender, recipient, _values.transferAmount);
if(delegates[sender] == address(0)) {
delegates[sender] = sender;
}
if(delegates[recipient] == address(0)) {
delegates[recipient] = recipient;
}
if(amount == _values.transferAmount) {
_moveDelegates(delegates[sender], delegates[recipient], amount);
} else {
_moveDelegates(delegates[sender], delegates[recipient], _values.transferAmount);
_moveDelegates(delegates[sender], delegates[_defaultFees.developmentAddress], _values.development);
_moveDelegates(delegates[sender], address(0), _values.burn);
}
if(takeFee == 0 || takeFee == 1) {
restoreAllFee();
} else if(takeFee == 2 || takeFee == 3) {
restoreAllFee();
emit Transfer(sender, _defaultFees.developmentAddress, _values.development);
}
}
function _takeFees(FeeValues memory values) private {
_takeFee(values.development, _defaultFees.developmentAddress);
_takeBurnFee(values.burn);
}
function _takeFee(uint256 tAmount, address recipient) private {
if(recipient == address(0)) return;
if(tAmount == 0) return;
_balances[recipient] = _balances[recipient].add(tAmount);
}
function _takeBurnFee(uint256 amount) private {
if(amount == 0) return;
_balances[address(this)] = _balances[address(this)].add(amount);
_burn(address(this), amount);
}
function depositLPFee(uint256 amount, address token) public onlyExchange {
uint256 tokenIndex = _getTokenIndex(token);
if(tokenIndex < pairsLength) {
uint256 allowanceT = IERC20(token).allowance(msg.sender, address(this));
if(allowanceT >= amount) {
IERC20(token).transferFrom(msg.sender, address(this), amount);
if(token != WETH) {
uint256 balanceBefore = IERC20(address(WETH)).balanceOf(address(this));
swapToWETH(amount, token);
uint256 fAmount = IERC20(address(WETH)).balanceOf(address(this)).sub(balanceBefore);
uint256 totalFee = getTotalFee();
uint256 developmentFeeAmount = fAmount.mul(_defaultFees.developmentFee).div(totalFee);
IERC20(WETH).transfer(_defaultFees.developmentAddress, developmentFeeAmount);
} else {
uint256 totalFee = getTotalFee();
uint256 developmentFeeAmount = amount.mul(_defaultFees.developmentFee).div(totalFee);
IERC20(token).transfer(_defaultFees.developmentAddress, developmentFeeAmount);
}
}
}
}
function swapToWETH(uint256 amount, address token) internal {
address[] memory path = new address[](2);
path[0] = token;
path[1] = WETH;
IERC20(token).approve(address(pyeSwapRouter), amount);
pyeSwapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
amount,
0,
path,
address(this),
block.timestamp
);
}
function shouldAutoBuyback(uint256 amount) internal view returns (bool) {
return msg.sender != pyeSwapPair
&& !inSwap
&& _buyback.autoBuybackEnabled
&& _buyback.autoBuybackBlockLast + _buyback.autoBuybackBlockPeriod <= block.number
&& IERC20(address(WETH)).balanceOf(address(this)) >= _buyback.autoBuybackAmount
&& amount >= _buyback.minimumBuyBackThreshold;
}
function triggerAutoBuyback() internal {
buyTokens(_buyback.autoBuybackAmount, _burnAddress);
_buyback.autoBuybackBlockLast = block.number;
_buyback.autoBuybackAccumulator = _buyback.autoBuybackAccumulator.add(_buyback.autoBuybackAmount);
if(_buyback.autoBuybackAccumulator > _buyback.autoBuybackCap){ _buyback.autoBuybackEnabled = false; }
}
function buyTokens(uint256 amount, address to) internal swapping {
address[] memory path = new address[](2);
path[0] = WETH;
path[1] = address(this);
IERC20(WETH).approve(address(pyeSwapRouter), amount);
pyeSwapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(
amount,
0,
path,
to,
block.timestamp
);
}
function setAutoBuybackSettings(bool _enabled, uint256 _cap, uint256 _amount, uint256 _period, uint256 _minimumThreshold) external {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_buyback.autoBuybackEnabled = _enabled;
_buyback.autoBuybackCap = _cap;
_buyback.autoBuybackAccumulator = 0;
_buyback.autoBuybackAmount = _amount;
_buyback.autoBuybackBlockPeriod = _period;
_buyback.autoBuybackBlockLast = block.number;
_buyback.minimumBuyBackThreshold = _minimumThreshold;
}
function _getTokenIndex(address _token) internal view returns (uint256) {
uint256 index = pairsLength + 1;
for(uint256 i = 0; i < pairsLength; i++) {
if(tokens[i] == _token) index = i;
}
return index;
}
function addPair(address _pair, address _token) public {
address factory = pyeSwapRouter.factory();
require(
msg.sender == factory
|| msg.sender == address(pyeSwapRouter)
|| msg.sender == address(this)
, "PYE: NOT_ALLOWED"
);
if(!_checkPairRegistered(_pair)) {
_isExcludedFromFee[_pair] = true;
_isPairAddress[_pair] = true;
pairs[pairsLength] = _pair;
tokens[pairsLength] = _token;
pairsLength += 1;
IPYESwapPair(_pair).updateTotalFee(getTotalFee());
}
}
function _checkPairRegistered(address _pair) internal view returns (bool) {
bool isPair = false;
for(uint i = 0; i < pairsLength; i++) {
if(pairs[i] == _pair) isPair = true;
}
return isPair;
}
function rescueETH(uint256 amount, address to) external {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
payable(to).transfer(amount);
}
function rescueToken(IERC20 token, uint256 amount, address to) external {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
if( token.balanceOf(address(this)) < amount ) {
amount = token.balanceOf(address(this));
}
token.transfer(to, amount);
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal override virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _mint(address account, uint256 amount) override internal {
require(account != address(0), 'BEP20: mint to the zero address');
_tTotal = _tTotal.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) override internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_tTotal = _tTotal.sub(amount);
emit Transfer(account, address(0), amount);
}
function burnFrom(address _from, uint256 _amount) public {
require(hasRole(BURNER_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_spendAllowance(_from, msg.sender, _amount);
_beforeTokenTransfer(_from, address(0), _amount);
_burn(_from, _amount);
if(delegates[_from] == address(0)) {
delegates[_from] = _from;
}
_moveDelegates(delegates[_from], address(0), _amount);
}
function mint(address _to, uint256 _amount) public {
require(hasRole(MINTER_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_beforeTokenTransfer(address(0), _to, _amount);
_mint(_to, _amount);
if(delegates[_to] == address(0)) {
delegates[_to] = _to;
}
_moveDelegates(address(0), delegates[_to], _amount);
}
function burn(uint256 _amount) public {
require(hasRole(BURNER_ROLE, msg.sender), "APPLE: NOT_ALLOWED");
_beforeTokenTransfer(msg.sender, address(0), _amount);
_burn(msg.sender, _amount);
if(delegates[msg.sender] == address(0)) {
delegates[msg.sender] = msg.sender;
}
_moveDelegates(delegates[msg.sender], address(0), _amount);
}
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), "APPLE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "APPLE::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "APPLE::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, "APPLE::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, "APPLE::_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 view returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
function getOwnedBalance(address account) external view returns (uint256){
return staked[account].amount.add(_balances[account]);
}
function setStaked(address holder, uint256 amount) internal {
if(amount > 0 && staked[holder].amount == 0){
addHolder(holder);
}else if(amount == 0 && staked[holder].amount > 0){
removeHolder(holder);
}
totalStaked = totalStaked.sub(staked[holder].amount).add(amount);
staked[holder].amount = amount;
}
function addHolder(address holder) internal {
holderIndexes[holder] = holders.length;
holders.push(holder);
}
function removeHolder(address holder) internal {
holders[holderIndexes[holder]] = holders[holders.length-1];
holderIndexes[holders[holders.length-1]] = holderIndexes[holder];
holders.pop();
}
function setIsStakingContract(address account, bool set) external {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "FUEL: NOT_ALLOWED");
isStakingContract[account] = set;
}
function blacklistAddress(address addressToBlacklist) external {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "FUEL: NOT_ALLOWED");
require(!isBlacklisted[addressToBlacklist] , "Address is already blacklisted!");
isBlacklisted[addressToBlacklist] = true;
}
function removeFromBlacklist(address addressToRemove) external {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "FUEL: NOT_ALLOWED");
require(isBlacklisted[addressToRemove] , "Address has not been blacklisted! Enter an address that is on the blacklist.");
isBlacklisted[addressToRemove] = false;
}
using Arrays for uint256[];
using Counters for Counters.Counter;
Counters.Counter private _currentSnapshotId;
struct Snapshots {
uint256[] ids;
uint256[] values;
}
mapping(address => Snapshots) private _accountBalanceSnapshots;
Snapshots private _totalSupplySnapshots;
event Snapshot(uint256 id);
function snapshot() public onlyOwner {
_snapshot();
}
function _snapshot() internal virtual returns (uint256) {
_currentSnapshotId.increment();
uint256 currentId = _getCurrentSnapshotId();
emit Snapshot(currentId);
return currentId;
}
function _getCurrentSnapshotId() internal view virtual returns (uint256) {
return _currentSnapshotId.current();
}
function getCurrentSnapshotID() public view onlyOwner returns (uint256) {
return _getCurrentSnapshotId();
}
function totalBalanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);
return snapshotted ? value : (balanceOf(account).add(staked[account].amount));
}
function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);
return snapshotted ? value : totalSupply();
}
function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) {
require(snapshotId > 0, "ERC20Snapshot: id is 0");
require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id");
uint256 index = snapshots.ids.findUpperBound(snapshotId);
if (index == snapshots.ids.length) {
return (false, 0);
} else {
return (true, snapshots.values[index]);
}
}
function _updateAccountSnapshot(address account) private {
_updateSnapshot(_accountBalanceSnapshots[account], (balanceOf(account).add(staked[account].amount)));
}
function _updateTotalSupplySnapshot() private {
_updateSnapshot(_totalSupplySnapshots, totalSupply());
}
function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
uint256 currentId = _getCurrentSnapshotId();
if (_lastSnapshotId(snapshots.ids) < currentId) {
snapshots.ids.push(currentId);
snapshots.values.push(currentValue);
}
}
function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
if (ids.length == 0) {
return 0;
} else {
return ids[ids.length - 1];
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {
_updateAccountSnapshot(to);
_updateTotalSupplySnapshot();
} else if (to == address(0)) {
_updateAccountSnapshot(from);
_updateTotalSupplySnapshot();
} else {
_updateAccountSnapshot(from);
_updateAccountSnapshot(to);
}
}
}
