I have deployed an ERC20 smart contract to the Ethereum blockchain, it can be viewed here: https://etherscan.io/address/0x90c97591205aff8400dbe99f8b17c888e890d28d#readContract

I have been able to transfer tokens between two accounts back and forth

I was able to also send ETH into the ERC20 smart contract account.

I have attempted to call some of the other functions but getting really confused I need someone in simple english to say this function does this and should be called by X when you want to do Y. Here is the code,

contract Token {

/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}

/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant 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) 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) returns (bool success) {}

/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) 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) constant returns (uint256 remaining) {}

event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);

This implements ONLY the standard functions and NOTHING else.
For a token like you would want to deploy in something like Mist, see 

If you deploy this, you won't have anything useful.

Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20

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;

This Token Contract implements the standard token functionality 
(https://github.com/ethereum/EIPs/issues/20) as well as the following OPTIONAL extras intended for use by humans.

In other words. This is intended for deployment in something like a Token 
Factory or Mist wallet, and then used by humans.
Imagine coins, currencies, shares, voting weight, etc.
Machine-based, rapid creation of many tokens would not necessarily need these extra features or will be minted in other manners.

1) Initial Finite Supply (upon creation one specifies how much is minted).
2) In the absence of a token registry: Optional Decimal, Symbol & Name.
3) Optional approveAndCall() functionality to notify a contract if an 
approval() has occurred.


contract HumanStandardToken is StandardToken {

function () {
    //if ether is sent to this address, send it back.

/* Public variables of the token */

The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
string public name;                   //fancy name: eg Simon Bucks
uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
string public symbol;                 //An identifier: eg SBX
string public version = 'H0.1';       //human 0.1 standard. Just an arbitrary versioning scheme.

function HumanStandardToken(
    uint256 _initialAmount,
    string _tokenName,
    uint8 _decimalUnits,
    string _tokenSymbol
    ) {
    balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
    totalSupply = _initialAmount;                        // Update total supply
    name = _tokenName;                                   // Set the name for display purposes
    decimals = _decimalUnits;                            // Amount of decimals for display purposes
    symbol = _tokenSymbol;                               // Set the symbol for display purposes

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

    //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
    //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
    //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
    if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
    return true;

For this to work like most of the other ERC20 tokens out there being used in ICO's

  1. Does a user send ETH to the contract address ?
  2. If the user sends ETH to the contract address, does the contract owner then transfer an amount of tokens to that address based on the ETH value, do I call the transfer function by interacting with the contract from the account that created it. Transfer ethAddresstoSendTokens tokenAmt
  3. Should this be automated? I have read about ERC223 https://github.com/Dexaran/ERC23-tokens and automatically converting incoming ETH to Tokens
  4. What is the difference between Approve and Transfer ? If someone sends in ETH to the ERC20 token contract do I manually call Approve or Transfer.
  5. When ETH is sent to a ERC20 contract how can you transfer that ETH out to a wallet address
  6. Are there any good resources that will help me to automate or extend this contract since it has been published

At the moment with this ERC20 token I have two accounts holding the token and a value of 0.00005 Ether in the contract address.

  1. What is the relationship to the contract eth balance and the token holders? Does that 0.00005 Ether represent 100% of all tokens and as more ETH gets sent to the contract address it raises the value of the tokens
  2. If I have 1eth in my wallet account & 1 of my tokens in a contract account associated with that wallet does the value of the token add to the overall balance held in the wallet account

  3. When I interact with the contract as shown below what is preventing them from maliciously transferring tokens to who ever they way?

enter image description here

When I use tokenfactory to interact with the contract I see options such as

Approve Account

Approve account to withdraw multiple times up to the specified amount.

What is the purpose of this Approve account and what is stopping anyone from just approving their own account.

Similarity with

Transfer Allowance

Transfer between accounts a specified amount that you've been authorised to do so.

enter image description here

I am finding it hard to get simple answers to the questions I raised above. Any advice, recommendations and resources that will bring clarity and help me move forward is appreciated.

  • it is not a good idea to write a long post with many questions (9!!). i am proposing you to keep only the more important and open different posts.
    – Badr Bellaj
    Commented Aug 16, 2017 at 12:59
  • You are using a very old version of the solidity compiler, you should use a more recent one. For example the ether sent to it will get locked and nobody cannot retrieve it.
    – Ismael
    Commented Aug 16, 2017 at 19:57
  • 1
    There are many different designs to create a token sale. A common design is to have a "crowdsale" contract that will sell tokens in exchange of ether and allow refunds if the goal is not reached, and a separate "token" contract that has the ERC20/ERC223 functionality (github.com/OpenZeppelin/zeppelin-solidity has such design). You can have both functionalities in a single contract, for eample uetoken work that way etherscan.io/address/…
    – Ismael
    Commented Aug 16, 2017 at 20:08

1 Answer 1


There is a long list of questions here which generally makes it hard to answer them. I will start with the basics. The ERC20 Token that you created is stored on the blockchain and you can interact with it by calling different functions like getBalance, sendTransaction.

The way it works is that these tokens are used as a currency for different business models. This is the same concept as nowadays companies offer shares during Initial Public Offering(IPO). Same is the case here. This token is used as a tool to raise money. Companies who want to raise money through this generally publish there whitepapers listing in detail their business model and how they will create value for those who invest in their business

ICO (Initial Coin Offering) is used to distribute this tokens to the investors. For this another contract is written similar to the one used for deploying your ERC20 token, but is much more complex and detailed. This contract is linked to the ERC20 token address. and also contains a price in Ethers for these tokens. Anyone who wants to invest in the business would send Ethers to the ICO Address and would be rewarded tokens accordingly. E.g. 1 Ether = 1000 tokens.

Initially these tokens have zero value in the market. Once the company start their business, these tokens are listed in an crypto-currency exchange. From there tokens get market value.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.