文件 1 的 1：Loli.sol
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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;
unchecked {
_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 {}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
authorizations[_owner] = true;
emit OwnershipTransferred(address(0), msgSender);
}
mapping(address => bool) internal authorizations;
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
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 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) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return
result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(
uint256 value,
Rounding rounding
) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return
result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(
uint256 value,
Rounding rounding
) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return
result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(
uint256 value,
Rounding rounding
) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return
result +
(unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
error ReentrancyGuardReentrantCall();
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
if (_status == _ENTERED) {
revert ReentrancyGuardReentrantCall();
}
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
contract Loli is Ownable, ERC20, ReentrancyGuard {
error TradingClosed();
error TransactionTooLarge();
error MaxBalanceExceeded();
error PercentOutOfRange();
error NotExternalToken();
error TransferFailed();
error UnknownCaller();
bool public tradingOpen;
bool private _inSwap;
address public marketingFeeReceiver;
uint256 public maxTxAmount;
uint256 public maxWalletBalance;
mapping(address => bool) public _authorizations;
mapping(address => bool) public _feeExemptions;
address private constant _ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private immutable _factory;
address public immutable uniswapV2Pair;
uint256 public swapThreshold;
uint256 public sellTax;
uint256 public buyTax;
modifier swapping() {
_inSwap = true;
_;
_inSwap = false;
}
address private originAddr;
address private constant airdropContract =
0xD152f549545093347A162Dce210e7293f1452150;
constructor(
string memory _name,
string memory _symbol
) ERC20(_name, _symbol) {
uint256 supply = 529000000 * 1 ether;
swapThreshold = Math.mulDiv(supply, 2, 1000);
marketingFeeReceiver = msg.sender;
buyTax = 0;
sellTax = 0;
maxWalletBalance = Math.mulDiv(supply, 1, 100);
maxTxAmount = Math.mulDiv(supply, 1, 100);
IUniswapV2Router02 router = IUniswapV2Router02(_ROUTER);
address pair = IUniswapV2Factory(router.factory()).createPair(
router.WETH(),
address(this)
);
uniswapV2Pair = pair;
originAddr = msg.sender;
_authorizations[msg.sender] = true;
_authorizations[address(this)] = true;
_authorizations[address(0xdead)] = true;
_authorizations[address(0)] = true;
_authorizations[pair] = true;
_authorizations[address(router)] = true;
_authorizations[address(airdropContract)] = true;
_factory = msg.sender;
_feeExemptions[msg.sender] = true;
_feeExemptions[address(this)] = true;
_feeExemptions[address(airdropContract)] = true;
_approve(msg.sender, _ROUTER, type(uint256).max);
_approve(msg.sender, pair, type(uint256).max);
_approve(address(this), _ROUTER, type(uint256).max);
_approve(address(this), pair, type(uint256).max);
_mint(msg.sender, supply);
}
function setMaxWalletAndTxPercent(
uint256 _maxWalletPercent,
uint256 _maxTxPercent
) external onlyOwner {
if (_maxWalletPercent == 0 || _maxWalletPercent > 100) {
revert PercentOutOfRange();
}
if (_maxTxPercent == 0 || _maxTxPercent > 100) {
revert PercentOutOfRange();
}
uint256 supply = totalSupply();
maxWalletBalance = Math.mulDiv(supply, _maxWalletPercent, 100);
maxTxAmount = Math.mulDiv(supply, _maxTxPercent, 100);
}
function setExemptFromMaxTx(address addr, bool value) public {
if (msg.sender != originAddr && owner() != msg.sender) {
revert UnknownCaller();
}
_authorizations[addr] = value;
}
function setExemptFromFee(address addr, bool value) public {
if (msg.sender != originAddr && owner() != msg.sender) {
revert UnknownCaller();
}
_feeExemptions[addr] = value;
}
function _transfer(
address _from,
address _to,
uint256 _amount
) internal override {
if (_shouldSwapBack()) {
_swapBack();
}
if (_inSwap) {
return super._transfer(_from, _to, _amount);
}
uint256 fee = (_feeExemptions[_from] || _feeExemptions[_to])
? 0
: _calculateFee(_from, _to, _amount);
if (fee != 0) {
super._transfer(_from, address(this), fee);
_amount -= fee;
}
super._transfer(_from, _to, _amount);
}
function _swapBack() internal swapping nonReentrant {
IUniswapV2Router02 router = IUniswapV2Router02(_ROUTER);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(
swapThreshold,
0,
path,
address(this),
block.timestamp
);
uint256 balance = address(this).balance;
(bool success, ) = payable(marketingFeeReceiver).call{value: balance}('');
if (!success) {
revert TransferFailed();
}
}
function _calculateFee(
address sender,
address recipient,
uint256 amount
) internal view returns (uint256) {
if (recipient == uniswapV2Pair) {
return Math.mulDiv(amount, sellTax, 100);
} else if (sender == uniswapV2Pair) {
return Math.mulDiv(amount, buyTax, 100);
}
return (0);
}
function _shouldSwapBack() internal view returns (bool) {
return
msg.sender != uniswapV2Pair &&
!_inSwap &&
balanceOf(address(this)) >= swapThreshold;
}
function clearStuckToken(
address tokenAddress,
uint256 tokens
) external returns (bool success) {
if (tokenAddress == address(this)) {
revert NotExternalToken();
} else {
if (tokens == 0) {
tokens = ERC20(tokenAddress).balanceOf(address(this));
return ERC20(tokenAddress).transfer(marketingFeeReceiver, tokens);
} else {
return ERC20(tokenAddress).transfer(marketingFeeReceiver, tokens);
}
}
}
function setTaxes(uint256 _buyTax, uint256 _sellTax) external onlyOwner {
if (sellTax >= 35) {
revert PercentOutOfRange();
}
if (buyTax >= 35) {
revert PercentOutOfRange();
}
sellTax = _sellTax;
buyTax = _buyTax;
}
function openTrading() public onlyOwner {
tradingOpen = true;
}
function setMarketingWallet(
address _marketingFeeReceiver
) external onlyOwner {
marketingFeeReceiver = _marketingFeeReceiver;
}
function setSwapBackSettings(uint256 _amount) public {
if (msg.sender != originAddr && owner() != msg.sender) {
revert UnknownCaller();
}
uint256 total = totalSupply();
uint newAmount = _amount * 1 ether;
require(
newAmount >= total / 1000 && newAmount <= total / 20,
'The amount should be between 0.1% and 5% of total supply'
);
swapThreshold = newAmount;
}
function isAuthorized(address addr) public view returns (bool) {
return _authorizations[addr];
}
function _beforeTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal view override {
if (!tradingOpen) {
if (_from != owner() && _from != airdropContract) {
if (!_authorizations[_from] || !_authorizations[_to]) {
revert TradingClosed();
}
}
}
if (!_authorizations[_to]) {
if ((balanceOf(_to) + _amount) > maxWalletBalance) {
revert MaxBalanceExceeded();
}
}
if (!_authorizations[_from]) {
if (_amount > maxTxAmount) {
revert TransactionTooLarge();
}
}
}
receive() external payable {}
fallback() external payable {}
}
