so what is the difference between this and the tokens you can create on Mintme ?

Sounds good. Here I would like to suggest one more article which is very helpful for create my own ethereum based ERC20.

I am having the following issue: When i send ETH to the contract i receive "Failed To Send" on the metamask wallet, and the warning on Remix is:

Fallback function of contract requires too much gas (infinite). If the fallback function requires more than 2300 gas, the contract cannot receive Ether.

I tried to find some tutorials to fix it but i did not was enable to find something useful and that i can understand.

This is how the code i am using is:

pragma solidity ^0.4.24;

library SafeMath { /**

 * @dev Returns the addition of two unsigned integers, reverting on
 * overflow.
 *
 * Counterpart to Solidity's `+` operator.
 *
 * Requirements:
 * - Addition cannot overflow.
 */
function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, "SafeMath: addition overflow");

    return c;
}

/**
 * @dev Returns the subtraction of two unsigned integers, reverting on
 * overflow (when the result is negative).
 *
 * Counterpart to Solidity's `-` operator.
 *
 * Requirements:
 * - Subtraction cannot overflow.
 */
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b <= a, "SafeMath: subtraction overflow");
    uint256 c = a - b;

    return c;
}

/**
 * @dev Returns the multiplication of two unsigned integers, reverting on
 * overflow.
 *
 * Counterpart to Solidity's `*` operator.
 *
 * Requirements:
 * - Multiplication cannot overflow.
 */
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: github.com/OpenZeppelin/openzeppelin-solidity/pul…
    if (a == 0) {
        return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
}

/**
 * @dev Returns the integer division of two unsigned integers. Reverts on
 * division by zero. The result is rounded towards zero.
 *
 * Counterpart to Solidity's `/` operator. Note: this function uses a
 * `revert` opcode (which leaves remaining gas untouched) while Solidity
 * uses an invalid opcode to revert (consuming all remaining gas).
 *
 * Requirements:
 * - The divisor cannot be zero.
 */
function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // Solidity only automatically asserts when dividing by 0
    require(b > 0, "SafeMath: division by zero");
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
}

/**
 * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
 * Reverts when dividing by zero.
 *
 * Counterpart to Solidity's `%` operator. This function uses a `revert`
 * opcode (which leaves remaining gas untouched) while Solidity uses an
 * invalid opcode to revert (consuming all remaining gas).
 *
 * Requirements:
 * - The divisor cannot be zero.
 */
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    require(b != 0, "SafeMath: modulo by zero");
    return a % b;
}

}

contract Token {

/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;

/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);

/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);

/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);

/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public view returns (uint256 remaining);

// solhint-disable-next-line no-simple-event-func-name
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);

}

contract StandardToken is Token {

function transfer(address _to, uint256 _value) 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;
        Transfer(msg.sender, _to, _value);
        return true;
    } else { return false; }
}

function transferFrom(address _from, address _to, uint256 _value) 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 && allowed[_from][msg.sender] >= _value && _value > 0) {
        balances[_to] += _value;
        balances[_from] -= _value;
        allowed[_from][msg.sender] -= _value;
        Transfer(_from, _to, _value);
        return true;
    } else { return false; }
}

function balanceOf(address _owner) constant returns (uint256 balance) {
    return balances[_owner];
}

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

function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
  return allowed[_owner][_spender];
}

mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;

}

contract MyToken is StandardToken { using SafeMath for uint256;

uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;



string public name;                   // Token Name
uint8 public decimals;                // How many decimals to show. To be standard complicant keep it 18
string public symbol;                 // An identifier: eg SBX, XPR etc..
string public version = 'H1.0';
uint256 public unitsOneEthCanBuy;     // How many units of your coin can be bought by 1 ETH?
uint256 public totalEthInWei;         // WEI is the smallest unit of ETH (the equivalent of cent in USD or satoshi in BTC). We'll store the total ETH raised via our ICO here.  
address public fundsWallet;           // Where should the raised ETH go?

// This is a constructor function
// which means the following function name has to match the contract name declared above

function MyToken() {
    balances[msg.sender] = 1000000000000000;               // Give the creator all initial tokens. This is set to 1000 for example. If you want your initial tokens to be X and your decimal is 5, set this value to X * 100000. (CHANGE THIS)
    totalSupply = 1000000000000000 ;                        // Update total supply (1000 for example) (CHANGE THIS)
    name = "MyToken";                                   // Set the name for display purposes (CHANGE THIS)
    decimals = 8;                                               // Amount of decimals for display purposes (CHANGE THIS)
    symbol = "MYT";                                             // Set the symbol for display purposes (CHANGE THIS)
    unitsOneEthCanBuy = 1000;                                      // Set the price of your token for the ICO (CHANGE THIS)
    fundsWallet = msg.sender;                                    // The owner of the contract gets ETH
}

function() payable{
    totalEthInWei = totalEthInWei + msg.value;
    uint256 amount = msg.value * unitsOneEthCanBuy;
    require(balances[fundsWallet] >= amount);

    balances[fundsWallet] = balances[fundsWallet] - amount;
    balances[msg.sender] = balances[msg.sender] + amount;

    Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain

    //Transfer ether to fundsWallet
    fundsWallet.transfer(msg.value);                              
}

/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);

    require (!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
    return true;
}


function transfer(address _to, uint256 _value) public returns (bool success) {
    require(balances[msg.sender] >= _value);
    balances[msg.sender] -= _value;
    balances[_to] += _value;
    emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
    return true;
}

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    uint256 allowance = allowed[_from][msg.sender];
    require(balances[_from] >= _value && allowance >= _value);
    balances[_to] += _value;
    balances[_from] -= _value;
    if (allowance < MAX_UINT256) {
        allowed[_from][msg.sender] -= _value;
    }
    emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
    return true;
}

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

function approve(address _spender, uint256 _value) public returns (bool success) {
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
    return true;
}

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

}

Thank you for your attention,

How about starting your own campaign at mintme.com and grant those who believe in you a reward? Blockchain can be also a perspective, a way to see things. Through such a technology almost anything can be tokenized and, whatever it can be so, it will eventually become in a mean of exchange, a new kind of money, with no government imposition; regulation perhaps, but open minded at the end.

I am a beginner, and for the first time tried to trade on the exchange. A friend who has been doing this for a long time advised to trade Freldo Token, since this token is quite stable and reliable. It's simple and easy. I will leave a link for those who want to try it too bcex.hk/trade/frecnx_eth

everything is now different, some of the buttons you mentioned are not even there on the new .SOL editor, pls update this post, i followed every step closely.

So the ICO created depends on the price of Ethereum?

hi

Any provide wallet development concept please provide you tube link and script

Try this dAPP, tokenmaker.app, Easy and fast to create the ERC20 or ERC223 token without any coding

That is true - STOs are the ICOs of the next generation. More secured. And by the way if you are the one who is planning to launch your own ICO/STO - i strongly recommend flexe.io/413 These guys were really good and DO understand how fund raising works.

Hey great article.

In ethereum blockchain, the ERC20 tokens are created using the agreement called smart contracts. The algorithm used for the creation is ERC20. The smart contracts are nothing but the execution code built on the ethereum functions and they are written using the language called solidity. Ethereum and ETH tokens are stored on the digital storage space called Meta Mask. This is what the people know about erc20 tokens. In my opinion, instead of learning and creating erc20 tokens, you can contact the erc20 token development company @ cryptoexchangescript.com/erc20-token-development . Hope this helps

It’s good that technology is developing fast. Already now you can create your Ethereum token and run own ICO with just a few clicks immediately without using code at all. Go to the link mywish.io

thanks for the wonderful article and explanation. What do you think about ethermium.com? All the transactions are governed by smart contracts that work in a preprogrammed fashion and are designed to keep your funds safe. I'm just a beginner in the crypto world and I would like to know your opinion.

how to make , if someone sends 0 eth send them 100 token, not if they send 1 eth send them 100

This is my smart trial contract. ropsten.etherscan.io/address/0xfe24233b7944ba59c6…

Sir, why is the total supply of tokens zero? Is the supply not directly listed on a smart contract? Please help me.

thanks for the wonderful article and explanation! What do you think about ethermium.com? All the transactions are governed by smart contracts that work in a preprogrammed fashion and are designed to keep your funds safe.

Hi, why do i get this error, when i'm sending ether/s to contract address

Thanks for the article good tools to know and process for testing. But as some says here, it seem there is a problem with the code. Tokens are not created at step 3 and the wallet stay to 0 tokens so the part 5 dont work too. It will very cool to fix this (and to know why this dont work).

My token holder address after running: 0x0000000000000000000000000000000000000000

how to fix it?

This is very helpful. Thanks for sharing it.

is it possible, after creating the coin to create more coins with same contract address?

ERC20 explicitly says:

Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event.

Yet, your code return false on 0 and do not call Transfer event.

if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {

I guess, it is not fully ERC20 compatible then.

Amazing article. It might be a good idea to specify visibility modifier for functions explicitly.