TSF TOKEN GENERATOR

Contract : My Smart Bank

Deploy : My Smart Bank

Deployment Status:

Contract : Deafault TSF20 Token

pragma solidity >=0.6.0 <0.8.0;
      abstract contract Context {
          function _msgSender() internal view virtual returns (address payable) {
              return msg.sender;
          }
          function _msgData() internal view virtual returns (bytes memory) {
              this;
              return msg.data;
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      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);
      }
      
      pragma solidity >=0.6.0 <0.8.0;
      library SafeMath {
      
          function add(uint256 a, uint256 b) internal pure returns (uint256) {
              uint256 c = a + b;
              require(c >= a, "SafeMath: addition overflow");
      
              return c;
          }
          function sub(uint256 a, uint256 b) internal pure returns (uint256) {
              return sub(a, b, "SafeMath: subtraction overflow");
          }
          function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
              require(b <= a, errorMessage);
              uint256 c = a - b;
              return c;
          }
          function mul(uint256 a, uint256 b) internal pure returns (uint256) {
              if (a == 0) {
                  return 0;
              }
              uint256 c = a * b;
              require(c / a == b, "SafeMath: multiplication overflow");
              return c;
          }
          function div(uint256 a, uint256 b) internal pure returns (uint256) {
              return div(a, b, "SafeMath: division by zero");
          }
          function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
              require(b > 0, errorMessage);
              uint256 c = a / b;
              return c;
          }
          function mod(uint256 a, uint256 b) internal pure returns (uint256) {
              return mod(a, b, "SafeMath: modulo by zero");
          }
          function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
              require(b != 0, errorMessage);
              return a % b;
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      contract ERC20 is Context, IERC20 {
          using SafeMath for uint256;
          mapping (address => uint256) private _balances;
          mapping (address => mapping (address => uint256)) private _allowances;
          uint256 private _totalSupply;
          string private _name;
          string private _symbol;
          uint8 private _decimals;
          constructor (string memory name_, string memory symbol_) public {
              _name = name_;
              _symbol = symbol_;
              _decimals = 18;
          }
          function name() public view returns (string memory) {
              return _name;
          }
      
          function symbol() public view returns (string memory) {
              return _symbol;
          }
      
          function decimals() public view returns (uint8) {
              return _decimals;
          }
      
          function totalSupply() public view override returns (uint256) {
              return _totalSupply;
          }
          function balanceOf(address account) public view override returns (uint256) {
              return _balances[account];
          }
          function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
              _transfer(_msgSender(), recipient, amount);
              return true;
          }
          function allowance(address owner, address spender) public view virtual override returns (uint256) {
              return _allowances[owner][spender];
          }
          function approve(address spender, uint256 amount) public virtual override returns (bool) {
              _approve(_msgSender(), spender, amount);
              return true;
          }
          function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
              _transfer(sender, recipient, amount);
              _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
              return true;
          }
          function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
              _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
              return true;
          }
          function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
              _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
              return true;
          }
          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, amount);
              _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
              _balances[recipient] = _balances[recipient].add(amount);
              emit Transfer(sender, recipient, amount);
          }
          function _mint(address account, uint256 amount) internal virtual {
              require(account != address(0), "ERC20: mint to the zero address");
              _beforeTokenTransfer(address(0), account, amount);
              _totalSupply = _totalSupply.add(amount);
              _balances[account] = _balances[account].add(amount);
              emit Transfer(address(0), account, amount);
          }
          function _burn(address account, uint256 amount) internal virtual {
              require(account != address(0), "ERC20: burn from the zero address");
              _beforeTokenTransfer(account, address(0), amount);
              _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
              _totalSupply = _totalSupply.sub(amount);
              emit Transfer(account, address(0), amount);
          }
          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 _setupDecimals(uint8 decimals_) internal {
              _decimals = decimals_;
          }
          function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
      }
      pragma solidity 0.6.7;
      contract ERC20Base is ERC20 {
          constructor(string memory name, string memory symbol, uint256 totalSupply) public ERC20 (name, symbol) {
              _mint(_msgSender(), totalSupply);
          }
      }

Deploy TSF20 Default Token

Fill the following form and click CREATE TOKEN

Deployment Status:

Contract : Mint/Burn TSF20 Token

pragma solidity >=0.6.0 <0.8.0;
      library EnumerableSet {
          struct Set {
              bytes32[] _values;
              mapping (bytes32 => uint256) _indexes;
          }
          function _add(Set storage set, bytes32 value) private returns (bool) {
              if (!_contains(set, value)) {
                  set._values.push(value);
                  set._indexes[value] = set._values.length;
                  return true;
              } else {
                  return false;
              }
          }
          function _remove(Set storage set, bytes32 value) private returns (bool) {
              uint256 valueIndex = set._indexes[value];
              if (valueIndex != 0) { 
                  uint256 toDeleteIndex = valueIndex - 1;
                  uint256 lastIndex = set._values.length - 1;
                  bytes32 lastvalue = set._values[lastIndex];
                  set._values[toDeleteIndex] = lastvalue;
                  set._indexes[lastvalue] = toDeleteIndex + 1; 
                  set._values.pop();
                  delete set._indexes[value];
                  return true;
              } else {
                  return false;
              }
          }
          function _contains(Set storage set, bytes32 value) private view returns (bool) {
              return set._indexes[value] != 0;
          }
          function _length(Set storage set) private view returns (uint256) {
              return set._values.length;
          }
          function _at(Set storage set, uint256 index) private view returns (bytes32) {
              require(set._values.length > index, "EnumerableSet: index out of bounds");
              return set._values[index];
          }
          struct Bytes32Set {
              Set _inner;
          }
          function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
              return _add(set._inner, value);
          }
          function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
              return _remove(set._inner, value);
          }
          function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
              return _contains(set._inner, value);
          }
          function length(Bytes32Set storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
              return _at(set._inner, index);
          }
          struct AddressSet {
              Set _inner;
          }
          function add(AddressSet storage set, address value) internal returns (bool) {
              return _add(set._inner, bytes32(uint256(value)));
          }
          function remove(AddressSet storage set, address value) internal returns (bool) {
              return _remove(set._inner, bytes32(uint256(value)));
          }
          function contains(AddressSet storage set, address value) internal view returns (bool) {
              return _contains(set._inner, bytes32(uint256(value)));
          }
          function length(AddressSet storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          function at(AddressSet storage set, uint256 index) internal view returns (address) {
              return address(uint256(_at(set._inner, index)));
          }
          struct UintSet {
              Set _inner;
          }
          function add(UintSet storage set, uint256 value) internal returns (bool) {
              return _add(set._inner, bytes32(value));
          }
          function remove(UintSet storage set, uint256 value) internal returns (bool) {
              return _remove(set._inner, bytes32(value));
          }
          function contains(UintSet storage set, uint256 value) internal view returns (bool) {
              return _contains(set._inner, bytes32(value));
          }
          function length(UintSet storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          function at(UintSet storage set, uint256 index) internal view returns (uint256) {
              return uint256(_at(set._inner, index));
          }
      }
      pragma solidity >=0.6.2 <0.8.0;
      library Address {
          function isContract(address account) internal view returns (bool) {
              uint256 size;
              // solhint-disable-next-line no-inline-assembly
              assembly { size := extcodesize(account) }
              return size > 0;
          }
          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");
              require(isContract(target), "Address: call to non-contract");
              (bool success, bytes memory returndata) = target.call{ value: value }(data);
              return _verifyCallResult(success, returndata, errorMessage);
          }
          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
              return functionStaticCall(target, data, "Address: low-level static call failed");
          }
          function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
              require(isContract(target), "Address: static call to non-contract");
              (bool success, bytes memory returndata) = target.staticcall(data);
              return _verifyCallResult(success, returndata, errorMessage);
          }
          function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
              if (success) {
                  return returndata;
              } else {
                  if (returndata.length > 0) {
                      assembly {
                          let returndata_size := mload(returndata)
                          revert(add(32, returndata), returndata_size)
                      }
                  } else {
                      revert(errorMessage);
                  }
              }
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      abstract contract Context {
          function _msgSender() internal view virtual returns (address payable) {
              return msg.sender;
          }
      
          function _msgData() internal view virtual returns (bytes memory) {
              this;
              return msg.data;
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      abstract contract AccessControl is Context {
          using EnumerableSet for EnumerableSet.AddressSet;
          using Address for address;
          struct RoleData {
              EnumerableSet.AddressSet members;
              bytes32 adminRole;
          }
          mapping (bytes32 => RoleData) private _roles;
          bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
          event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
          event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
          event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
          function hasRole(bytes32 role, address account) public view returns (bool) {
              return _roles[role].members.contains(account);
          }
          function getRoleMemberCount(bytes32 role) public view returns (uint256) {
              return _roles[role].members.length();
          }
          function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
              return _roles[role].members.at(index);
          }
          function getRoleAdmin(bytes32 role) public view returns (bytes32) {
              return _roles[role].adminRole;
          }
          function grantRole(bytes32 role, address account) public virtual {
              require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
      
              _grantRole(role, account);
          }
          function revokeRole(bytes32 role, address account) public virtual {
              require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
      
              _revokeRole(role, account);
          }
          function renounceRole(bytes32 role, address account) public virtual {
              require(account == _msgSender(), "AccessControl: can only renounce roles for self");
      
              _revokeRole(role, account);
          }
          function _setupRole(bytes32 role, address account) internal virtual {
              _grantRole(role, account);
          }
          function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
              emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
              _roles[role].adminRole = adminRole;
          }
      
          function _grantRole(bytes32 role, address account) private {
              if (_roles[role].members.add(account)) {
                  emit RoleGranted(role, account, _msgSender());
              }
          }
      
          function _revokeRole(bytes32 role, address account) private {
              if (_roles[role].members.remove(account)) {
                  emit RoleRevoked(role, account, _msgSender());
              }
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      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);
      }
      pragma solidity >=0.6.0 <0.8.0;
      library SafeMath {
          function add(uint256 a, uint256 b) internal pure returns (uint256) {
              uint256 c = a + b;
              require(c >= a, "SafeMath: addition overflow");
              return c;
          }
          function sub(uint256 a, uint256 b) internal pure returns (uint256) {
              return sub(a, b, "SafeMath: subtraction overflow");
          }
          function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
              require(b <= a, errorMessage);
              uint256 c = a - b;
              return c;
          }
          function mul(uint256 a, uint256 b) internal pure returns (uint256) {
              if (a == 0) {
                  return 0;
              }
              uint256 c = a * b;
              require(c / a == b, "SafeMath: multiplication overflow");
              return c;
          }
          function div(uint256 a, uint256 b) internal pure returns (uint256) {
              return div(a, b, "SafeMath: division by zero");
          }
          function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
              require(b > 0, errorMessage);
              uint256 c = a / b;
              return c;
          }
          function mod(uint256 a, uint256 b) internal pure returns (uint256) {
              return mod(a, b, "SafeMath: modulo by zero");
          }
          function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
              require(b != 0, errorMessage);
              return a % b;
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      contract ERC20 is Context, IERC20 {
          using SafeMath for uint256;
          mapping (address => uint256) private _balances;
          mapping (address => mapping (address => uint256)) private _allowances;
          uint256 private _totalSupply;
          string private _name;
          string private _symbol;
          uint8 private _decimals;
          constructor (string memory name_, string memory symbol_) public {
              _name = name_;
              _symbol = symbol_;
              _decimals = 18;
          }
          function name() public view returns (string memory) {
              return _name;
          }
          function symbol() public view returns (string memory) {
              return _symbol;
          }
          function decimals() public view returns (uint8) {
              return _decimals;
          }
          function totalSupply() public view override returns (uint256) {
              return _totalSupply;
          }
          function balanceOf(address account) public view override returns (uint256) {
              return _balances[account];
          }
          function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
              _transfer(_msgSender(), recipient, amount);
              return true;
          }
          function allowance(address owner, address spender) public view virtual override returns (uint256) {
              return _allowances[owner][spender];
          }
          function approve(address spender, uint256 amount) public virtual override returns (bool) {
              _approve(_msgSender(), spender, amount);
              return true;
          }
          function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
              _transfer(sender, recipient, amount);
              _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
              return true;
          }
          function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
              _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
              return true;
          }
          function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
              _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
              return true;
          }
          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, amount);
              _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
              _balances[recipient] = _balances[recipient].add(amount);
              emit Transfer(sender, recipient, amount);
          }
          function _mint(address account, uint256 amount) internal virtual {
              require(account != address(0), "ERC20: mint to the zero address");
              _beforeTokenTransfer(address(0), account, amount);
              _totalSupply = _totalSupply.add(amount);
              _balances[account] = _balances[account].add(amount);
              emit Transfer(address(0), account, amount);
          }
          function _burn(address account, uint256 amount) internal virtual {
              require(account != address(0), "ERC20: burn from the zero address");
              _beforeTokenTransfer(account, address(0), amount);
              _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
              _totalSupply = _totalSupply.sub(amount);
              emit Transfer(account, address(0), amount);
          }
          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 _setupDecimals(uint8 decimals_) internal {
              _decimals = decimals_;
          }
          function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
      }
      pragma solidity >=0.6.0 <0.8.0;
      abstract contract ERC20Burnable is Context, ERC20 {
          using SafeMath for uint256;
          function burn(uint256 amount) public virtual {
              _burn(_msgSender(), amount);
          }
          function burnFrom(address account, uint256 amount) public virtual {
              uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
              _approve(account, _msgSender(), decreasedAllowance);
              _burn(account, amount);
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      abstract contract Pausable is Context {
          event Paused(address account);
          event Unpaused(address account);
          bool private _paused;
          constructor () internal {
              _paused = false;
          }
          function paused() public view returns (bool) {
              return _paused;
          }
          modifier whenNotPaused() {
              require(!_paused, "Pausable: paused");
              _;
          }
          modifier whenPaused() {
              require(_paused, "Pausable: not paused");
              _;
          }
          function _pause() internal virtual whenNotPaused {
              _paused = true;
              emit Paused(_msgSender());
          }
          function _unpause() internal virtual whenPaused {
              _paused = false;
              emit Unpaused(_msgSender());
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      abstract contract ERC20Pausable is ERC20, Pausable {
          function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
              super._beforeTokenTransfer(from, to, amount);
              require(!paused(), "ERC20Pausable: token transfer while paused");
          }
      }
      pragma solidity >=0.6.0 <0.8.0;
      contract ERC20PresetMinterPauser is Context, AccessControl, ERC20Burnable, ERC20Pausable {
          bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
          bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
           * @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `PAUSER_ROLE` to the
       
          constructor(string memory name, string memory symbol) public ERC20(name, symbol) {
              _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
              _setupRole(MINTER_ROLE, _msgSender());
              _setupRole(PAUSER_ROLE, _msgSender());
          }
          function mint(address to, uint256 amount) public virtual {
              require(hasRole(MINTER_ROLE, _msgSender()), "ERC20PresetMinterPauser: must have minter role to mint");
              _mint(to, amount);
          }
          function pause() public virtual {
              require(hasRole(PAUSER_ROLE, _msgSender()), "ERC20PresetMinterPauser: must have pauser role to pause");
              _pause();
          }
          function unpause() public virtual {
              require(hasRole(PAUSER_ROLE, _msgSender()), "ERC20PresetMinterPauser: must have pauser role to unpause");
              _unpause();
          }
      
          function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20, ERC20Pausable) {
              super._beforeTokenTransfer(from, to, amount);
          }
      }
      pragma solidity 0.6.7;
      contract Token is ERC20PresetMinterPauser {
          constructor(string memory name, string memory symbol) public ERC20PresetMinterPauser (name, symbol) {
          }
      }

Deploy Mint/Burn TSF20 Token

Fill the following form and click CREATE TOKEN

Deployment Status:

PRIVATE KEY

METAMASK

Contract : My Smart Bank

Deploy : My Smart Bank

Contract Output :

Contract : Deafault TSF20 Token

Deploy TSF20 Default Token

Contract Output :

Contract : Mint/Burn TSF20 Token

Deploy Mint/Burn TSF20 Token

Contract Output :

Insert Private Key :

PRIVATE KEY

METAMASK

Contract : My Smart Bank

Deploy : My Smart Bank

Contract Output :

Contract : Deafault TSF20 Token

Deploy TSF20 Default Token

Contract Output :

Contract : Mint/Burn TSF20 Token

Deploy Mint/Burn TSF20 Token

Contract Output :