文件 1 的 1：ChungaLungaCoin.sol
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
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 createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity >=0.5.0;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
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 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);
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, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
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 IUniswapV2Router02 is IUniswapV2Router01 {
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;
}
pragma solidity ^0.8.3;
interface ISafetyControl {
event APSStateChanged(
bool enabled,
uint256 txLimit,
uint256 thresh,
uint256 interval
);
function setAPS(bool enabled) external;
function setTCS(bool enabled) external;
function setAPSThreshPercent(uint256 thresh) external;
function setAPSThreshAmount(uint256 thresh) external;
function setAPSTxLimit(uint256 txLimit) external;
function setAPSInterval(uint256 interval) external;
function setPreSale(bool start) external;
function openTrading() external;
function addInitialLiquidity() external;
function setAccountShare(bool enabled) external;
}
pragma solidity ^0.8.3;
interface IFeeControl {
event ExcludeFromFees (
address indexed account,
bool isExcluded
);
event TakeFeeOnlyOnSwap (
bool enabled
);
event MinTokensBeforeSwapUpdated (
uint256 minTokensBeforeSwap
);
function feeControl(address account, bool exclude) external;
function isExcludedFromFee(address account) external view returns(bool);
function takeFeeOnlyOnSwap(bool onSwap) external;
function changeSwapThresh(uint256 thresh) external;
}
pragma solidity ^0.8.3;
interface IFee {
struct Fees {
uint256 marketingFee;
uint256 liquidityFee;
}
function changeMarketingWallet(address newWallet) external;
function setFees(uint256 liquidityFee, uint256 marketingFee, bool isBuy) external;
function setSwapOfFeeTokens(bool enable) external;
}
pragma solidity ^0.8.3;
interface IBlacklisting {
function setBlacklist(address account, bool add) external;
function setWhitelist(address account, bool add) external;
function isBlacklisted(address account) external view returns(bool);
function isWhitelisted(address account) external view returns(bool);
function setBlacklistFee(uint256 blacklistFee) external;
}
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
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);
}
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.3;
interface IChungaLungaCoin is IERC20, IERC20Metadata, IBlacklisting, ISafetyControl, IFee, IFeeControl {
event UpdateSwapV2Router (
address indexed newAddress
);
event SwapAndLiquifyEnabledUpdated (
bool enabled
);
event MarketingSwap (
uint256 tokensSwapped,
uint256 ethReceived,
bool success
);
event SwapAndLiquify (
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event TCSStateChanged(
bool enabled,
uint256 maxTxLimit,
uint256 holderLimit,
uint256 interval
);
function setAMMPair(address pair, bool value) external;
function setMaxTxPercent(uint256 maxTxPercent) external;
function setMaxTxAmount(uint256 maxTxAmount) external;
function maxTxControl(address account, bool exclude) external;
function isExcludedFromMaxTx(address account) external view returns(bool);
function setHolderLimit(uint256 limit) external;
function setSwapAndLiquifyEnabled(bool enabled) external;
function setHelperSaleAddress(address helperRouter, address presaleRouter) external;
function withdrawLocked(address payable recipient) external;
function withdrawFees() external;
function updateSwapV2Router(address newAddress) external;
function startWhitelistProcess(uint256 duration) external;
}
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.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;
library SafeERC20 {
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) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
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.8.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;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
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) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(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(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
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));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
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";
uint8 private constant _ADDRESS_LENGTH = 20;
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);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
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.0;
interface IAccessControlEnumerable is IAccessControl {
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
function getRoleMemberCount(bytes32 role) external view returns (uint256);
}
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, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(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 Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
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;
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);
_;
}
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) internal view virtual {
_checkRole(role, _msgSender());
}
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 AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
using EnumerableSet for EnumerableSet.AddressSet;
mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
}
function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
return _roleMembers[role].at(index);
}
function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
return _roleMembers[role].length();
}
function _grantRole(bytes32 role, address account) internal virtual override {
super._grantRole(role, account);
_roleMembers[role].add(account);
}
function _revokeRole(bytes32 role, address account) internal virtual override {
super._revokeRole(role, account);
_roleMembers[role].remove(account);
}
}
pragma solidity ^0.8.3;
contract ChungaLungaCoin is IChungaLungaCoin, ERC20, Ownable, AccessControlEnumerable {
using SafeMath for uint256;
using Address for address;
using SafeERC20 for IERC20;
event StateProgress (
bool liquidityAdded,
bool whitelistStarted,
bool tradeOpened
);
event WhitelistProcessStarted (
uint256 duration
);
struct TaxedValues{
uint256 amount;
uint256 tAmount;
uint256 tMarketing;
uint256 tLiquidity;
}
struct SwapValues{
uint256 tMarketing;
uint256 tLiquidity;
uint256 tHalfLiquidity;
uint256 tTotal;
uint256 swappedBalance;
}
uint256 private constant MAX = ~uint256(0);
uint8 private constant DECIMALS = 18;
uint256 private constant TOKENS_INITIAL = 10 * 10 ** 9;
uint256 private constant MIN_SWAP_THRESHOLD = 1 * 10 ** 3 * 10 ** uint256(DECIMALS);
uint256 private constant DECIMALS_FEES = 1000;
uint256 private constant LIMIT_FEES = 60;
uint256 private constant LIMIT_TOTAL_FEES = 100;
uint256 private constant TCS_TIME_INTERVAL = 2;
address private constant deadAddress = 0x000000000000000000000000000000000000dEaD;
bytes32 public constant CL_ADMIN_ROLE = keccak256("CL_ADMIN_ROLE");
bytes32 public constant CL_CTRL_ROLE = keccak256("CL_CTRL_ROLE");
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcludedFromMaxTx;
mapping(address => bool) private _blacklist;
mapping(address => bool) private _whitelist;
uint256 private _blacklistFee = 900;
address public marketingWalletAddress;
uint256 public tPendingMarketing;
uint256 public tPendingLiquidity;
uint256 private _tokensTotal = TOKENS_INITIAL * 10 ** uint256(DECIMALS);
Fees private _totalTakenFees = Fees(
{marketingFee: 0,
liquidityFee: 0
});
Fees private _buyFees = Fees(
{marketingFee: 30,
liquidityFee: 20
});
Fees private _previousBuyFees = Fees(
{marketingFee: _buyFees.marketingFee,
liquidityFee: _buyFees.liquidityFee
});
Fees private _sellFees = Fees(
{marketingFee: 30,
liquidityFee: 20
});
Fees private _previousSellFees = Fees(
{marketingFee: _sellFees.marketingFee,
liquidityFee: _sellFees.liquidityFee
});
bool private _inSwapAndLiquify;
bool private _swapAndLiquifyEnabled = true;
bool public apsEnabled = false;
bool public tcsEnabled = false;
bool private _whProcActive = false;
uint256 private _whStart = 0;
uint256 private _whDuration = 1;
bool private _accSharing = false;
uint256 private _apsThresh = 25 * 10 ** 6 * 10 ** uint256(DECIMALS);
uint256 private _apsLimit = 4;
uint256 private _apsInterval = 1440;
bool public liquidityAdded = false;
bool public tradingOpen = false;
bool private _swapMarketingTokens = true;
bool public feeOnlyOnSwap = false;
mapping (address => uint256) private _previousSale;
mapping (address => uint256) private _previousBuy;
uint256 private _maxTxAmount = 20 * 10 ** 6 * 10 ** uint256(DECIMALS);
uint256 private _maxHolderAmount = (_tokensTotal * 2) / 100;
uint256 private _swapThresh = 300 * 10 ** 3 * 10 ** uint256(DECIMALS);
IUniswapV2Router02 private _swapV2Router;
address private _swapV2Pair;
mapping (address => bool) public ammPairs;
constructor () ERC20("ChungaLungaCoin", "$CL") {
_changeMarketingWallet(address(0x0E7E45f0BE3c46907E6aF055AE1157E2Bb19aAf2));
_setupRole(CL_CTRL_ROLE, msg.sender);
_setupSwap(address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D));
_setupExclusions();
_setRoleAdmin(CL_ADMIN_ROLE, CL_ADMIN_ROLE);
_setRoleAdmin(CL_CTRL_ROLE, CL_ADMIN_ROLE);
_setupRole(CL_ADMIN_ROLE, msg.sender);
_setupRole(CL_ADMIN_ROLE, address(this));
_setupRole(CL_CTRL_ROLE, msg.sender);
_setupRole(CL_CTRL_ROLE, address(this));
_mint(msg.sender, _tokensTotal);
transferOwnership(msg.sender);
}
function addCTRLMember(address account) public virtual onlyRole(CL_ADMIN_ROLE) {
grantRole(CL_CTRL_ROLE, account);
}
function totalTakenFees() public view returns (uint256, uint256) {
return (_totalTakenFees.marketingFee, _totalTakenFees.liquidityFee);
}
function currentFees(bool isBuy) public view returns (uint256, uint256) {
if(isBuy){
return (_buyFees.marketingFee, _buyFees.liquidityFee);
} else {
return (_sellFees.marketingFee, _sellFees.liquidityFee);
}
}
function feeControl(address account, bool exclude) override external onlyRole(CL_CTRL_ROLE) {
_isExcludedFromFee[account] = exclude;
}
function isExcludedFromFee(address account) override external view returns(bool) {
return _isExcludedFromFee[account];
}
function maxTxControl(address account, bool exclude) external override onlyRole(CL_CTRL_ROLE) {
_isExcludedFromMaxTx[account] = exclude;
}
function isExcludedFromMaxTx(address account) public view override returns(bool) {
return _isExcludedFromMaxTx[account];
}
function setHolderLimit(uint256 limit) external override onlyRole(CL_CTRL_ROLE) {
require(limit > 0 && limit < TOKENS_INITIAL, "HOLDER_LIMIT1");
uint256 new_limit = limit * 10 ** uint256(DECIMALS);
require(new_limit > ((_tokensTotal * 5) / DECIMALS_FEES), "HOLDER_LIMIT2");
_maxHolderAmount = new_limit;
emit TCSStateChanged(tcsEnabled, _maxTxAmount, _maxHolderAmount, TCS_TIME_INTERVAL);
}
function setHelperSaleAddress(address helperRouter, address presaleRouter) external override onlyRole(CL_CTRL_ROLE) {
_excludeAccount(helperRouter, true);
_excludeAccount(presaleRouter, true);
}
function setTCS(bool enabled) override external onlyRole(CL_CTRL_ROLE) {
tcsEnabled = enabled;
emit TCSStateChanged(tcsEnabled, _maxTxAmount, _maxHolderAmount, TCS_TIME_INTERVAL);
}
function getTCSState() public view onlyRole(CL_CTRL_ROLE) returns(uint256, uint256, uint256) {
return (_maxTxAmount, _maxHolderAmount, TCS_TIME_INTERVAL);
}
function setAPS(bool enabled) override external onlyRole(CL_CTRL_ROLE) {
apsEnabled = enabled;
emit APSStateChanged(apsEnabled, _apsLimit, _apsThresh, _apsInterval);
}
function setAPSThreshPercent(uint256 thresh) override external onlyRole(CL_CTRL_ROLE) {
require(thresh < 50, "APS-THRESH-PERCENT");
_apsThresh = _tokensTotal.mul(thresh).div(DECIMALS_FEES);
emit APSStateChanged(apsEnabled, _apsLimit, _apsThresh, _apsInterval);
}
function setAPSThreshAmount(uint256 thresh) override external onlyRole(CL_CTRL_ROLE) {
require(thresh > 1000 && thresh < TOKENS_INITIAL, "APS-THRESH-AMOUNT");
_apsThresh = thresh * 10 ** uint256(DECIMALS);
emit APSStateChanged(apsEnabled, _apsLimit, _apsThresh, _apsInterval);
}
function setAPSTxLimit(uint256 txLimit) override external onlyRole(CL_CTRL_ROLE) {
require(txLimit < 20, "APS-TX-LIMIT");
_apsLimit = txLimit;
emit APSStateChanged(apsEnabled, _apsLimit, _apsThresh, _apsInterval);
}
function setAPSInterval(uint256 interval) override external onlyRole(CL_CTRL_ROLE) {
require(interval > 0, "APS-INTERVAL-0");
_apsInterval = interval;
emit APSStateChanged(apsEnabled, _apsLimit, _apsThresh, _apsInterval);
}
function getAPSState() public view onlyRole(CL_CTRL_ROLE) returns(uint256, uint256, uint256) {
return (_apsLimit, _apsThresh, _apsInterval);
}
function setAccountShare(bool enabled) override external onlyRole(CL_CTRL_ROLE) {
_accSharing = enabled;
}
function changeMarketingWallet(address account) override external onlyRole(CL_CTRL_ROLE) {
_changeMarketingWallet(account);
}
function setFees(uint256 liquidityFee, uint256 marketingFee, bool isBuy) external override onlyRole(CL_CTRL_ROLE) {
require(marketingFee + liquidityFee <= LIMIT_TOTAL_FEES, "FEE-MAX");
_setMarketingFeePercent(marketingFee, isBuy);
_setLiquidityFeePercent(liquidityFee, isBuy);
}
function setMaxTxPercent(uint256 maxTxPercent) override external onlyRole(CL_CTRL_ROLE) {
require(maxTxPercent > 0 && maxTxPercent < 100, "MAXTX_PERC_LIMIT");
_maxTxAmount = _tokensTotal.mul(maxTxPercent).div(DECIMALS_FEES);
emit TCSStateChanged(tcsEnabled, _maxTxAmount, _maxHolderAmount, TCS_TIME_INTERVAL);
}
function setMaxTxAmount(uint256 maxTxAmount) override external onlyRole(CL_CTRL_ROLE) {
require(maxTxAmount >= 1 && maxTxAmount < TOKENS_INITIAL, "MAXTX_AMNT_LIMIT");
_maxTxAmount = maxTxAmount * 10 ** uint256(DECIMALS);
emit TCSStateChanged(tcsEnabled, _maxTxAmount, _maxHolderAmount, TCS_TIME_INTERVAL);
}
function setSwapAndLiquifyEnabled(bool enabled) override external onlyRole(CL_CTRL_ROLE) {
_swapAndLiquifyEnabled = enabled;
emit SwapAndLiquifyEnabledUpdated(enabled);
}
function changeSwapThresh(uint256 thresh) override external onlyRole(CL_CTRL_ROLE){
uint256 newThresh = thresh * 10 ** uint256(DECIMALS);
require(newThresh > MIN_SWAP_THRESHOLD, "THRESH-LOW");
_swapThresh = newThresh;
}
function swapThresh() public view onlyRole(CL_CTRL_ROLE) returns(uint256) {
return _swapThresh;
}
function openTrading() override external onlyRole(CL_CTRL_ROLE) {
require(liquidityAdded, "LIQ-NONE");
_openTrading();
}
function _openTrading() internal {
tradingOpen = true;
emit StateProgress(true, true, true);
}
function startWhitelistProcess(uint256 duration) override external onlyRole(CL_CTRL_ROLE) {
require(duration > 1, "WHT-DUR-LOW");
_whProcActive = true;
_whDuration = duration;
_whStart = block.timestamp;
_maxTxAmount = 20 * 10 ** 6 * 10 ** uint256(DECIMALS);
tradingOpen = false;
emit StateProgress(true, true, false);
emit WhitelistProcessStarted(duration);
}
function setSwapOfFeeTokens(bool enabled) override external onlyRole(CL_CTRL_ROLE) {
_swapMarketingTokens = enabled;
}
function takeFeeOnlyOnSwap(bool onSwap) override external onlyRole(CL_CTRL_ROLE) {
feeOnlyOnSwap = onSwap;
emit TakeFeeOnlyOnSwap(feeOnlyOnSwap);
}
function defineLiquidityAdded() public onlyRole(CL_CTRL_ROLE) {
liquidityAdded = true;
emit StateProgress(true, false, false);
}
function addInitialLiquidity() override external onlyRole(CL_CTRL_ROLE) {
_approve(address(this), address(_swapV2Router), _tokensTotal);
_swapV2Router.addLiquidityETH{value: address(this).balance}
(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
defineLiquidityAdded();
IERC20(_swapV2Pair).approve(address(_swapV2Router),type(uint256).max);
}
function withdrawLocked(address payable recipient) external override onlyRole(CL_CTRL_ROLE) {
require(recipient != address(0), 'ADDR-0');
require(address(this).balance > 0, 'BAL-0');
uint256 amount = address(this).balance;
(bool success,) = payable(recipient).call{value: amount}('');
if(!success) {
revert();
}
}
function withdrawFees() external override onlyRole(CL_CTRL_ROLE) {
require(!_swapAndLiquifyEnabled, "WITHDRAW-SWAP");
super._transfer(address(this), marketingWalletAddress, balanceOf(address(this)));
tPendingMarketing = 0;
tPendingLiquidity = 0;
}
function isBlacklisted(address account) external view override returns(bool) {
return _blacklist[account];
}
function isWhitelisted(address account) external view override returns(bool) {
return _whitelist[account];
}
function setBlacklist(address account, bool add) external override onlyRole(CL_CTRL_ROLE) {
require(!add || !_whitelist[account], 'BLST-1');
_blacklist[account] = add;
}
function setWhitelist(address account, bool add) external override onlyRole(CL_CTRL_ROLE) {
require(!add || !_blacklist[account], 'BLST-2');
_whitelist[account] = add;
}
function setBlacklistFee(uint256 blacklistFee) external override onlyRole(CL_CTRL_ROLE) {
_blacklistFee = blacklistFee;
}
function bulkWhitelist(address[] calldata addrs) external onlyRole(CL_CTRL_ROLE) {
for (uint i=0; i<addrs.length; i++){
_whitelist[addrs[i]] = true;
}
}
function setPreSale(bool start) external override onlyRole(CL_CTRL_ROLE) {
if(start) {
_removeAllFee(true);
_removeAllFee(false);
} else {
_restoreAllFee(true);
_restoreAllFee(false);
}
}
function updateSwapV2Router(address newAddress) external override onlyRole(CL_CTRL_ROLE) {
require(newAddress != address(0), "R2-1");
_setupSwap(newAddress);
}
receive() external payable {}
function _setupSwap(address routerAddress) private {
_swapV2Router = IUniswapV2Router02(routerAddress);
_swapV2Pair = IUniswapV2Factory(_swapV2Router.factory()).createPair(address(this), _swapV2Router.WETH());
_setAMMPair(address(_swapV2Pair), true);
_isExcludedFromMaxTx[address(_swapV2Router)] = true;
_approve(owner(), address(_swapV2Router), type(uint256).max);
ERC20(address(_swapV2Router.WETH())).approve(address(_swapV2Router), type(uint256).max);
ERC20(address(_swapV2Router.WETH())).approve(address(this), type(uint256).max);
emit UpdateSwapV2Router(routerAddress);
}
function setAMMPair(address pair, bool value) external override onlyRole(CL_CTRL_ROLE) {
_setAMMPair(pair, value);
}
function _setAMMPair(address pair, bool value) private {
ammPairs[pair] = value;
_isExcludedFromMaxTx[pair] = value;
}
function _excludeAccount(address addr, bool ex) private {
_isExcludedFromFee[addr] = ex;
_isExcludedFromMaxTx[addr] = ex;
}
function _setupExclusions() private {
_excludeAccount(msg.sender, true);
_excludeAccount(address(this), true);
_excludeAccount(owner(), true);
_excludeAccount(deadAddress, true);
_excludeAccount(marketingWalletAddress, true);
}
function _changeMarketingWallet(address addr) internal {
require(addr != address(0), "ADDR-0");
_excludeAccount(marketingWalletAddress, false);
marketingWalletAddress = addr;
_excludeAccount(addr, true);
}
function _isBuy(address from) internal view returns(bool) {
return ammPairs[from];
}
function _isSell(address to) internal view returns(bool) {
return ammPairs[to];
}
function _checkTxLimit(address from, address to, uint256 amount) internal view {
if (_isBuy(from)) {
require(amount <= _maxTxAmount || _isExcludedFromMaxTx[to], "TX-LIMIT-BUY");
} else if (_isSell(to)) {
require(amount <= _maxTxAmount || _isExcludedFromMaxTx[from], "TX-LIMIT-SELL");
} else {
require(amount <= _maxTxAmount || (_isExcludedFromMaxTx[from] && _isExcludedFromMaxTx[to]), "TX-LIMIT");
}
}
function _setMarketingFeePercent(uint256 fee, bool isBuy) internal {
require(fee <= LIMIT_FEES, "FEE-LIMIT-M");
if(isBuy){
_previousBuyFees.marketingFee = _buyFees.marketingFee;
_buyFees.marketingFee = fee;
} else {
_previousSellFees.marketingFee = _sellFees.marketingFee;
_sellFees.marketingFee = fee;
}
}
function _setLiquidityFeePercent(uint256 liquidityFee, bool isBuy) internal {
require(liquidityFee <= LIMIT_FEES, "FEE-LIMIT-L");
if(isBuy){
_previousBuyFees.liquidityFee = _buyFees.liquidityFee;
_buyFees.liquidityFee = liquidityFee;
} else {
_previousSellFees.liquidityFee = _sellFees.liquidityFee;
_sellFees.liquidityFee = liquidityFee;
}
}
function _getValues(uint256 amount, bool isBuy) private view returns (TaxedValues memory totalValues) {
totalValues.amount = amount;
totalValues.tMarketing = _calculateMarketingFee(amount, isBuy);
totalValues.tLiquidity = _calculateLiquidityFee(amount, isBuy);
totalValues.tAmount = amount.sub(totalValues.tMarketing).sub(totalValues.tLiquidity);
return totalValues;
}
function _calculateMarketingFee(uint256 amount, bool isBuy) private view returns (uint256) {
if(isBuy){
return _buyFees.marketingFee > 0 ?
amount.mul(_buyFees.marketingFee).div(DECIMALS_FEES) : 0;
} else {
return _sellFees.marketingFee > 0 ?
amount.mul(_sellFees.marketingFee).div(DECIMALS_FEES) : 0;
}
}
function _calculateLiquidityFee(uint256 amount, bool isBuy) private view returns (uint256) {
if(isBuy){
return _buyFees.liquidityFee > 0 ?
amount.mul(_buyFees.liquidityFee).div(DECIMALS_FEES) : 0;
} else {
return _sellFees.liquidityFee > 0 ?
amount.mul(_sellFees.liquidityFee).div(DECIMALS_FEES) : 0;
}
}
function _removeAllFee(bool isBuy) private {
if(isBuy){
_previousBuyFees = _buyFees;
_buyFees.liquidityFee = 0;
_buyFees.marketingFee = 0;
} else {
_previousSellFees = _sellFees;
_sellFees.liquidityFee = 0;
_sellFees.marketingFee = 0;
}
}
function _restoreAllFee(bool isBuy) private {
if(isBuy){
_buyFees = _previousBuyFees;
} else {
_sellFees = _previousSellFees;
}
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "FROM-ADDR-0");
require(to != address(0), "TO-ADDR-0");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if(_blacklist[from] || _blacklist[to]) {
_blacklistDefense(from, to, amount);
return;
}
if (!_inSwapAndLiquify) {
_whitelistProcessCheck();
_tcsCheck(from, to, amount);
_apsCheck(from, to, amount);
_delayedProvision(from, to);
}
bool takeFee = !_inSwapAndLiquify;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to] ) {
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
}
function _blacklistDefense(address from, address to, uint256 amount) private {
uint256 tFee = amount * _blacklistFee / DECIMALS_FEES;
uint256 tRest = amount - tFee;
super._transfer(from, address(this), tFee);
super._transfer(from, to, tRest);
uint256 totalFeeP = 0;
uint256 mFee = 0;
uint256 lFee = 0;
if (_isBuy(from)) {
totalFeeP = _buyFees.liquidityFee + _buyFees.marketingFee;
if (totalFeeP > 0) {
lFee = _buyFees.liquidityFee > 0 ? tFee * _buyFees.liquidityFee / totalFeeP : 0;
mFee = tFee - lFee;
}
} else {
totalFeeP = _sellFees.liquidityFee + _sellFees.marketingFee;
if (totalFeeP > 0) {
lFee = _sellFees.liquidityFee > 0 ? tFee * _sellFees.liquidityFee / totalFeeP : 0;
mFee = tFee - lFee;
}
}
if (totalFeeP > 0) {
tPendingMarketing += mFee;
tPendingLiquidity += lFee;
_totalTakenFees.marketingFee += mFee;
_totalTakenFees.liquidityFee += lFee;
}
}
function _whitelistProcessCheck() private {
if (_whProcActive) {
if (_whStart + (_whDuration * 1 minutes) < block.timestamp) {
_whProcActive = false;
_maxTxAmount = 30 * 10 ** 6 * 10 ** uint256(DECIMALS);
_openTrading();
}
}
}
function _tcsCheck(address from, address to, uint256 amount) view private {
if (tcsEnabled) {
_checkTxLimit(from, to, amount);
if (!_whProcActive || (!_whitelist[from] && !_whitelist[to])) {
require(tradingOpen, "TCS-TRADE");
require(_accSharing || _isBuy(from) || _isSell(to), "TCS-ACC-SHARE");
}
if (_isBuy(from)) {
require(amount + balanceOf(to) <= _maxHolderAmount, "TCS-HOLDER-LIMIT");
} else if(!_isSell(to)) {
require(amount + balanceOf(to) <= _maxHolderAmount, "TCS-HOLDER-LIMIT");
}
if (_isSell(to)) {
require( (_previousSale[from] + (TCS_TIME_INTERVAL * 1 minutes)) < block.timestamp, "TCS-TIME");
} else if (_isBuy(from)) {
require( (_previousBuy[to] + (TCS_TIME_INTERVAL * 1 minutes)) < block.timestamp, "TCS-TIME");
} else {
require( (_previousSale[from] + (TCS_TIME_INTERVAL * 1 minutes)) < block.timestamp, "TCS-TIME");
require( (_previousBuy[to] + (TCS_TIME_INTERVAL * 1 minutes)) < block.timestamp, "TCS-TIME");
}
}
}
function _apsCheck(address from, address to, uint256 amount) view private {
if (apsEnabled) {
require(amount < (totalSupply() * _apsLimit / DECIMALS_FEES), "APS-SUPPLY");
if(_isSell(to)) {
uint256 fromBalance = balanceOf(from);
if(fromBalance >= _apsThresh) {
require(amount < (fromBalance / (5)), "APS-BALANCE");
}
require( (_previousSale[from] + (_apsInterval * 1 minutes)) < block.timestamp, "APS-TIME");
}
}
}
function _swapAndLiquifyAllFees() private {
uint256 contractBalance = balanceOf(address(this));
uint256 tTotal = tPendingLiquidity + tPendingMarketing;
if(contractBalance == 0 || tTotal == 0 || tTotal < _swapThresh) {return;}
uint256 tLiqHalf = contractBalance * tPendingLiquidity / tTotal / 2;
uint256 amountToSwapForETH = contractBalance.sub(tLiqHalf);
uint256 initialBalance = address(this).balance;
_swapTokensForEth(amountToSwapForETH, address(this));
uint256 swappedBalance = address(this).balance.sub(initialBalance);
uint256 cMarketing = swappedBalance.mul(tPendingMarketing).div(tTotal);
uint256 cLiq = swappedBalance - cMarketing;
if(tPendingLiquidity > 0 && cLiq > 0){
_addLiquidity(tLiqHalf, cLiq);
emit SwapAndLiquify(tLiqHalf, cLiq, tPendingLiquidity.sub(tLiqHalf));
}
(bool sent,) = address(marketingWalletAddress).call{value: cMarketing}("");
emit MarketingSwap(tPendingMarketing, cMarketing, sent);
tPendingLiquidity = 0;
tPendingMarketing = 0;
}
function _delayedProvision(address from, address to) private {
if (
!_inSwapAndLiquify &&
!_isBuy(from) &&
_swapAndLiquifyEnabled &&
!_isExcludedFromFee[from] &&
!_isExcludedFromFee[to]
) {
_inSwapAndLiquify = true;
_swapAndLiquifyAllFees();
_inSwapAndLiquify = false;
}
}
function _swapTokensForEth(uint256 tokenAmount, address account) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = _swapV2Router.WETH();
_approve(address(this), address(_swapV2Router), tokenAmount);
_swapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
account,
block.timestamp
);
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(_swapV2Router), tokenAmount);
_swapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0,
0,
deadAddress,
block.timestamp
);
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
bool isBuy = _isBuy(sender);
uint256 fees = 0;
if (takeFee) {
TaxedValues memory totalValues = _getValues(amount, isBuy);
fees = totalValues.tMarketing + totalValues.tLiquidity;
if(fees > 0) {
tPendingMarketing += totalValues.tMarketing;
tPendingLiquidity += totalValues.tLiquidity;
_totalTakenFees.marketingFee += totalValues.tMarketing;
_totalTakenFees.liquidityFee += totalValues.tLiquidity;
super._transfer(sender, address(this), fees);
amount -= fees;
}
}
if (isBuy) {
_previousBuy[recipient] = block.timestamp;
} else if(_isSell(recipient)) {
_previousSale[sender] = block.timestamp;
} else {
_previousBuy[recipient] = block.timestamp;
_previousSale[sender] = block.timestamp;
}
super._transfer(sender, recipient, amount);
}
}
