README.md

If you want to create your own token, simply follow the below code, and importantly do the following: In the Constructor Arguments section: Input

Arg [0] : name (string): YourTokenName

Arg [1] : symbol (string): YourAbbreviatedSymbolName

Arg [2] : decimals (uint8): Input2HereForStandard

Arg [3] : initialSupply (uint256): InputDesiredNumberOfTokens

buttonmaker.xyz

Ropsten Testnet Deploy

https://ropsten.etherscan.io/address/0x4923fc1a88bd2d1fd206e30533f2049e61534db6#code

Solidity code

/** *Submitted for verification at Etherscan.io on 2021-01-30 */

pragma solidity ^0.5.0;

/**

• @dev Interface of the ERC20 standard as defined in the EIP. Does not include

• the optional functions; to access them see {ERC20Detailed}. / interface ERC20Interface { /*

  • @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256);

  /**

  • @dev Returns the amount of tokens owned by account. */ function balanceOf(address account) external view returns (uint256);

  /**

  • @dev Moves amount tokens from the caller's account to recipient.
  • Returns a boolean value indicating whether the operation succeeded.
  • Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool);

  /**

  • @dev Returns the remaining number of tokens that spender will be
  • allowed to spend on behalf of owner through {transferFrom}. This is
  • zero by default.
  • This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256);

  /**

  • @dev Sets amount as the allowance of spender over the caller's tokens.
  • Returns a boolean value indicating whether the operation succeeded.
  • IMPORTANT: Beware that changing an allowance with this method brings the risk
  • that someone may use both the old and the new allowance by unfortunate
  • transaction ordering. One possible solution to mitigate this race
  • condition is to first reduce the spender's allowance to 0 and set the
  • desired value afterwards:
  • ethereum/EIPs#20 (comment)
  • Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool);

  /**

  • @dev Moves amount tokens from sender to recipient using the
  • allowance mechanism. amount is then deducted from the caller's
  • allowance.
  • Returns a boolean value indicating whether the operation succeeded.
  • Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

  /**

  • @dev Emitted when value tokens are moved from one account (from) to
  • another (to).
  • Note that value may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value);

  /**

  • @dev Emitted when the allowance of a spender for an owner is set by
  • a call to {approve}. value is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }

contract ERC20Base is ERC20Interface { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. // constructor () internal { } // solhint-disable-previous-line no-empty-blocks

mapping (address => uint256) public _balances;
mapping (address => mapping (address => uint256)) public _allowances;
uint256 public _totalSupply;

function transfer(address _to, uint256 _value) public returns (bool success) {
    //Default assumes totalSupply can't be over max (2^256 - 1).
    //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
    //Replace the if with this one instead.
    //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
    if (_balances[msg.sender] >= _value && _value > 0) {
        _balances[msg.sender] -= _value;
        _balances[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    } else { 
        return false;
    }
}

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    //same as above. Replace this line with the following if you want to protect against wrapping uints.
    //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
    if (_balances[_from] >= _value && _allowances[_from][msg.sender] >= _value && _value > 0) {
        _balances[_to] += _value;
        _balances[_from] -= _value;
        _allowances[_from][msg.sender] -= _value;
        emit Transfer(_from, _to, _value);
        return true;
    } else {
        return false;
    }
}

function balanceOf(address _owner) public view returns (uint256 balance) {
    return _balances[_owner];
}

function approve(address _spender, uint256 _value) public returns (bool success) {
    _allowances[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
}

function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
  return _allowances[_owner][_spender];
}

function totalSupply() public view returns (uint256 total) {
    return _totalSupply;
}

}

contract Token is ERC20Base {

string private _name;
string private _symbol;
uint8 private _decimals;

constructor (string memory name, string memory symbol, uint8 decimals, uint256 initialSupply) public payable {
    _name = name;
    _symbol = symbol;
    _decimals = decimals;
    _totalSupply = initialSupply;
    _balances[msg.sender] = initialSupply;
}

/**
 * @dev Returns the name of the token.
 */
function name() public view returns (string memory) {
    return _name;
}

/**
 * @dev Returns the symbol of the token, usually a shorter version of the
 * name.
 */
function symbol() public view returns (string memory) {
    return _symbol;
}

/**
 * @dev Returns the number of decimals used to get its user representation.
 * For example, if `decimals` equals `2`, a balance of `505` tokens should
 * be displayed to a user as `5,05` (`505 / 10 ** 2`).
 *
 * Tokens usually opt for a value of 18, imitating the relationship between
 * Ether and Wei.
 *
 * NOTE: This information is only used for _display_ purposes: it in
 * no way affects any of the arithmetic of the contract, including
 * {IERC20-balanceOf} and {IERC20-transfer}.
 */
function decimals() public view returns (uint8) {
    return _decimals;
}

}