README.md

Code

Contract Source Code contract owned { address public owner;

function owned() public {
    owner = msg.sender;
}

modifier onlyOwner {
    require(msg.sender == owner);
    _;
}

function transferOwnership(address newOwner) onlyOwner public {
    owner = newOwner;
}

}

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }

contract TOURISTOKEN { string public name; string public symbol; uint8 public decimals = 18; uint256 public totalSupply;

mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

event Transfer(address indexed from, address indexed to, uint256 value);

event Burn(address indexed from, uint256 value);

/**
 * Constrctor function
 *
 * Initializes contract with initial supply tokens to the creator of the contract
 */
function TokenERC20(
    uint256 initialSupply,
    string tokenName,
    string tokenSymbol
) public {
    totalSupply =;  
    balanceOf[msg.sender] = totalSupply;               
    name = "TOURISTOKEN";                                   
    symbol = "TOU";                               
}

/**
 * Internal transfer, only can be called by this contract
 */
function _transfer(address _from, address _to, uint _value) internal {
    require(_to != 0x0);
    require(balanceOf[_from] >= _value);
    require(balanceOf[_to] + _value > balanceOf[_to]);
    uint previousBalances = balanceOf[_from] + balanceOf[_to];
    balanceOf[_from] -= _value;
    balanceOf[_to] += _value;
    emit Transfer(_from, _to, _value);
    assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}

/**
 * Transfer tokens
 *
 * Send `_value` tokens to `_to` from your account
 *
 * @param _to The address of the recipient
 * @param _value the amount to send
 */
function transfer(address _to, uint256 _value) public returns (bool success) {
    _transfer(msg.sender, _to, _value);
    return true;
}

/**
 * Transfer tokens from other address
 *
 * Send `_value` tokens to `_to` in behalf of `_from`
 *
 * @param _from The address of the sender
 * @param _to The address of the recipient
 * @param _value the amount to send
 */
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    require(_value <= allowance[_from][msg.sender]);    
    allowance[_from][msg.sender] -= _value;
    _transfer(_from, _to, _value);
    return true;
}

/**
 * Set allowance for other address
 *
 * Allows `_spender` to spend no more than `_value` tokens in your behalf
 *
 * @param _spender The address authorized to spend
 * @param _value the max amount they can spend
 */
function approve(address _spender, uint256 _value) public
    returns (bool success) {
    allowance[msg.sender][_spender] = _value;
    return true;
}

/**
 * Set allowance for other address and notify
 *
 * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
 *
 * @param _spender The address authorized to spend
 * @param _value the max amount they can spend
 * @param _extraData some extra information to send to the approved contract
 */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
    public
    returns (bool success) {
    tokenRecipient spender = tokenRecipient(_spender);
    if (approve(_spender, _value)) {
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }
}

/**
 * Destroy tokens
 *
 * Remove `_value` tokens from the system irreversibly
 *
 * @param _value the amount of money to burn
 */
function burn(uint256 _value) public returns (bool success) {
    require(balanceOf[msg.sender] >= _value);   
    balanceOf[msg.sender] -= _value;            
    totalSupply -= _value;                      
    emit Burn(msg.sender, _value);
    return true;
}

/**
 * Destroy tokens from other account
 *
 * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
 *
 * @param _from the address of the sender
 * @param _value the amount of money to burn
 */
function burnFrom(address _from, uint256 _value) public returns (bool success) {
    require(balanceOf[_from] >= _value);                
    require(_value <= allowance[_from][msg.sender]);    
    balanceOf[_from] -= _value;                         
    allowance[_from][msg.sender] -= _value;             
    totalSupply -= _value;                              
    emit Burn(_from, _value);
    return true;
}

}

contract MyAdvancedToken is owned, TOURISTOKEN {

uint256 public sellPrice;
uint256 public buyPrice;

mapping (address => bool) public frozenAccount;

event FrozenFunds(address target, bool frozen);

function MyAdvancedToken(
    uint256 initialSupply,
    string tokenName,
    string tokenSymbol
 )MyAdvancedToken(initialSupply, tokenName, tokenSymbol) public {}

function _transfer(address _from, address _to, uint _value) internal {
    require (_to != 0x0);                               
    require (balanceOf[_from] >= _value);              
    require (balanceOf[_to] + _value >= balanceOf[_to]); 
    require(!frozenAccount[_from]);                     
    require(!frozenAccount[_to]);                       
    balanceOf[_from] -= _value;                         
    balanceOf[_to] += _value;                           
    emit Transfer(_from, _to, _value);
}

function mint(address target, uint256 mintedAmount) onlyOwner public {
    balanceOf[target] += mintedAmount;
    totalSupply += mintedAmount;
    emit Transfer(0, this, mintedAmount);
    emit Transfer(this, target, mintedAmount);
}


function freezeAccount(address target, bool freeze) onlyOwner public {
    frozenAccount[target] = freeze;
    emit FrozenFunds(target, freeze);
}


function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
    sellPrice = newSellPrice;
    buyPrice = newBuyPrice;
}


function buy() payable public {
    uint amount = msg.value /buyPrice ;              
    _transfer(this, msg.sender, amount);              
}


function sell(uint256 amount) public {
    address myAddress = this;
    require(myAddress.balance >= amount * sellPrice);      
    _transfer(msg.sender, this, amount);              
    msg.sender.transfer(amount * sellPrice);          
}

}

/**

• @title SafeMath
• @dev Math operations with safety checks that throw on error */ 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; } } /**

• Constrctor function function totalSupply() public constant returns (uint256 supply);

function balanceOf(address _owner) public constant returns (uint256 balance);

function transfer(address _to, uint256 _value) public returns (bool success);

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

function approve(address _spender, uint256 _value) public returns (bool success);

function allowance(address _owner, address _spender) public constant returns (uint256 remaining);

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

uint public decimals; string public name; }

/**

• @title Ownable
• @dev The Ownable contract has an owner address, and provides basic authorization control
• functions, this simplifies the implementation of "user permissions". */ contract Ownable {

address public owner;

/**

• @dev The Ownable constructor sets the original owner of the contract to the sender
• account. */ constructor() public { owner = msg.sender; }

/**

• @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(msg.sender == owner); _; }

/**

• @dev Allows the current owner to transfer control of the contract to a newOwner.
• @param newOwner The address to transfer ownership to. */ function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0));
  owner = newOwner; }

}