Contract Name:
TokenEmission
Contract Source Code:
File 1 of 1 : TokenEmission
pragma solidity ^0.4.4;
// Standard token interface (ERC 20)
// https://github.com/ethereum/EIPs/issues/20
contract ERC20
{
// Functions:
/// @return 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) constant returns (uint256);
/// @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);
/// @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);
/// @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);
/// @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);
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/**
* @title Contract for object that have an owner
*/
contract Owned {
/**
* Contract owner address
*/
address public owner;
/**
* @dev Delegate contract to another person
* @param _owner New owner address
*/
function setOwner(address _owner) onlyOwner
{ owner = _owner; }
/**
* @dev Owner check modifier
*/
modifier onlyOwner { if (msg.sender != owner) throw; _; }
}
/**
* @title Common pattern for destroyable contracts
*/
contract Destroyable {
address public hammer;
/**
* @dev Hammer setter
* @param _hammer New hammer address
*/
function setHammer(address _hammer) onlyHammer
{ hammer = _hammer; }
/**
* @dev Destroy contract and scrub a data
* @notice Only hammer can call it
*/
function destroy() onlyHammer
{ suicide(msg.sender); }
/**
* @dev Hammer check modifier
*/
modifier onlyHammer { if (msg.sender != hammer) throw; _; }
}
/**
* @title Generic owned destroyable contract
*/
contract Object is Owned, Destroyable {
function Object() {
owner = msg.sender;
hammer = msg.sender;
}
}
/**
* @title Token contract represents any asset in digital economy
*/
contract Token is Object, ERC20 {
/* Short description of token */
string public name;
string public symbol;
/* Total count of tokens exist */
uint public totalSupply;
/* Fixed point position */
uint8 public decimals;
/* Token approvement system */
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowances;
/**
* @dev Get balance of plain address
* @param _owner is a target address
* @return amount of tokens on balance
*/
function balanceOf(address _owner) constant returns (uint256)
{ return balances[_owner]; }
/**
* @dev Take allowed tokens
* @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)
{ return allowances[_owner][_spender]; }
/* Token constructor */
function Token(string _name, string _symbol, uint8 _decimals, uint _count) {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _count;
balances[msg.sender] = _count;
}
/**
* @dev Transfer self tokens to given address
* @param _to destination address
* @param _value amount of token values to send
* @notice `_value` tokens will be sended to `_to`
* @return `true` when transfer done
*/
function transfer(address _to, uint _value) returns (bool) {
if (balances[msg.sender] >= _value) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
return false;
}
/**
* @dev Transfer with approvement mechainsm
* @param _from source address, `_value` tokens shold be approved for `sender`
* @param _to destination address
* @param _value amount of token values to send
* @notice from `_from` will be sended `_value` tokens to `_to`
* @return `true` when transfer is done
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var avail = allowances[_from][msg.sender]
> balances[_from] ? balances[_from]
: allowances[_from][msg.sender];
if (avail >= _value) {
allowances[_from][msg.sender] -= _value;
balances[_from] -= _value;
balances[_to] += _value;
Transfer(_from, _to, _value);
return true;
}
return false;
}
/**
* @dev Give to target address ability for self token manipulation without sending
* @param _spender target address (future requester)
* @param _value amount of token values for approving
*/
function approve(address _spender, uint256 _value) returns (bool) {
allowances[msg.sender][_spender] += _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Reset count of tokens approved for given address
* @param _spender target address (future requester)
*/
function unapprove(address _spender)
{ allowances[msg.sender][_spender] = 0; }
}
contract TokenEmission is Token {
function TokenEmission(string _name, string _symbol, uint8 _decimals,
uint _start_count)
Token(_name, _symbol, _decimals, _start_count)
{}
/**
* @dev Token emission
* @param _value amount of token values to emit
* @notice owner balance will be increased by `_value`
*/
function emission(uint _value) onlyOwner {
// Overflow check
if (_value + totalSupply < totalSupply) throw;
totalSupply += _value;
balances[owner] += _value;
}
/**
* @dev Burn the token values from sender balance and from total
* @param _value amount of token values for burn
* @notice sender balance will be decreased by `_value`
*/
function burn(uint _value) {
if (balances[msg.sender] >= _value) {
balances[msg.sender] -= _value;
totalSupply -= _value;
}
}
}