文件 1 的 1：Wujing.sol
pragma solidity ^0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
_owner = msg.sender;
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_owner = address(0);
}
}
library SafeERC20 {
function safeTransfer(address token, address to, uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: INTERNAL TRANSFER_FAILED');
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
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(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external;
function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract Wujing is Ownable {
string private constant _name = unicode"Wujing";
string private constant _symbol = unicode"WUJING";
uint256 private constant _totalSupply = 420_000_000_000 * 1e18;
uint256 public maxTransactionAmount = (_totalSupply * 1) / 1000;
uint256 public maxWallet = (_totalSupply * 1) / 100;
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 1000;
address private TeamWallet = 0xA62301B473B4B14807AFb1381EA1874aC6748a17;
address private revWallet = 0x0096aaE42b21619AaDa5356D3d44C963b7FB2C3C;
address private DexmarketingWallet = 0xd6746F1E5cBEAdd00904f5B83339586798DdE265;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 0;
uint8 public sellTotalFees = 0;
uint8 public revFee = 50;
uint8 public treasuryFee = 25;
uint8 public teamFee = 25;
bool private swapping;
bool public limitsInEffect;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(uint256 tokensSwapped, uint256 teamETH, uint256 revETH, uint256 TreasuryETH);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
IUniswapV2Router02 public constant uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
setExcludedFromFees(address(0xdead), true);
setExcludedFromFees(revWallet, true);
setExcludedFromMaxTransaction(address(uniswapV2Router), true);
setExcludedFromMaxTransaction(address(0xdead), true);
setExcludedFromMaxTransaction(revWallet, true);
setExcludedFromFees(DexmarketingWallet, true);
setExcludedFromMaxTransaction(DexmarketingWallet, true);
_balances[DexmarketingWallet] = (_totalSupply * 10) / 100;
emit Transfer(address(0), DexmarketingWallet, _balances[DexmarketingWallet]);
setExcludedFromFees(TeamWallet, true);
setExcludedFromMaxTransaction(TeamWallet, true);
_balances[TeamWallet] = (_totalSupply * 10) / 100;
emit Transfer(address(0), TeamWallet, _balances[TeamWallet]);
setExcludedFromFees(owner(), true);
setExcludedFromMaxTransaction(owner(), true);
_balances[owner()] = (_totalSupply * 80) / 100;
emit Transfer(address(0), owner(), _balances[owner()]);
}
receive() external payable {}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return 18;
}
function totalSupply() public pure returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
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 transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
uint256 currentAllowance = _allowances[sender][msg.sender];
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, msg.sender, currentAllowance - amount);
}
}
_transfer(sender, recipient, amount);
return true;
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (!launched && (from != owner() && from != address(this) && to != owner())) {
revert("Trading not enabled");
}
if (limitsInEffect) {
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) {
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTx");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
} else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount,"Sell transfer amount exceeds the maxTx");
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
}
bool canSwap = balanceOf(address(this)) >= swapTokensAtAmount;
if (canSwap && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 senderBalance = _balances[from];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
} else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
}
if (fees > 0) {
unchecked {
amount = amount - fees;
_balances[from] -= fees;
_balances[address(this)] += fees;
}
emit Transfer(from, address(this), fees);
}
}
unchecked {
_balances[from] -= amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
}
function removeLimits() external onlyOwner {
limitsInEffect = false;
}
function setDistributionFees(uint8 _RevFee, uint8 _TreasuryFee, uint8 _teamFee) external onlyOwner {
revFee = _RevFee;
treasuryFee = _TreasuryFee;
teamFee = _teamFee;
require((revFee + treasuryFee + teamFee) == 100, "Distribution have to be equal to 100%");
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees) external onlyOwner {
require(_buyTotalFees <= 100, "Buy fees must be less than or equal to 100%");
require(_sellTotalFees <= 100, "Sell fees must be less than or equal to 100%");
buyTotalFees = _buyTotalFees;
sellTotalFees = _sellTotalFees;
}
function setExcludedFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
}
function setExcludedFromMaxTransaction(address account, bool excluded) public onlyOwner {
_isExcludedMaxTransactionAmount[account] = excluded;
}
function airdropWallets(address[] memory addresses, uint256[] memory amounts) external onlyOwner {
require(!launched, "Already launched");
for (uint256 i = 0; i < addresses.length; i++) {
require(_balances[msg.sender] >= amounts[i], "ERC20: transfer amount exceeds balance");
_balances[addresses[i]] += amounts[i];
_balances[msg.sender] -= amounts[i];
emit Transfer(msg.sender, addresses[i], amounts[i]);
}
}
function openTrade(address uniswapV2Pair_) external onlyOwner {
require(!launched, "Already launched");
automatedMarketMakerPairs[uniswapV2Pair_] = true;
setExcludedFromMaxTransaction(address(uniswapV2Pair_), true);
launched = true;
}
function itsTime() external payable onlyOwner {
require(!launched, "Already launched");
uniswapV2Router.addLiquidityETH{value: msg.value}(
address(this),
_balances[address(this)],
0,
0,
TeamWallet,
block.timestamp
);
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
automatedMarketMakerPairs[pair] = value;
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
require(newSwapAmount >= (totalSupply() * 1) / 100000, "Swap amount cannot be lower than 0.001% of the supply");
require(newSwapAmount <= (totalSupply() * 5) / 1000, "Swap amount cannot be higher than 0.5% of the supply");
swapTokensAtAmount = newSwapAmount;
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
require(newMaxTx >= ((totalSupply() * 1) / 1000) / 1e18, "Cannot set max transaction lower than 0.1%");
maxTransactionAmount = newMaxTx * (10**18);
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
require(newMaxWallet >= ((totalSupply() * 1) / 1000) / 1e18, "Cannot set max wallet lower than 0.1%");
maxWallet = newMaxWallet * (10**18);
}
function updateRevWallet(address newAddress) external onlyOwner {
require(newAddress != address(0), "Address cannot be zero");
revWallet = newAddress;
}
function updateTreasuryWallet(address newAddress) external onlyOwner {
require(newAddress != address(0), "Address cannot be zero");
DexmarketingWallet = newAddress;
}
function updateTeamWallet(address newAddress) external onlyOwner {
require(newAddress != address(0), "Address cannot be zero");
TeamWallet = newAddress;
}
function excludedFromFee(address account) public view returns (bool) {
return _isExcludedFromFees[account];
}
function withdrawStuckToken(address token, address to) external onlyOwner {
uint256 _contractBalance = IERC20(token).balanceOf(address(this));
SafeERC20.safeTransfer(token, to, _contractBalance);
}
function withdrawStuckETH(address addr) external onlyOwner {
require(addr != address(0), "Invalid address");
(bool success, ) = addr.call{value: address(this).balance}("");
require(success, "Withdrawal failed");
}
function swapBack() private {
uint256 swapThreshold = swapTokensAtAmount;
if (balanceOf(address(this)) > swapTokensAtAmount * 20) {
swapThreshold = swapTokensAtAmount * 20;
}
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = WETH;
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
uint256 ethForRev = (ethBalance * revFee) / 100;
uint256 ethForTeam = (ethBalance * teamFee) / 100;
uint256 ethForTreasury = ethBalance - ethForRev - ethForTeam;
emit SwapAndLiquify(swapThreshold, ethForTeam, ethForRev, ethForTreasury);
}
}
}
