Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- pragma solidity ^0.4.18;
- /**
- * @title SafeMath
- * @dev Math operations with safety checks that throw on error
- */
- library SafeMath {
- /**
- * @dev Multiplies two numbers, throws on overflow.
- */
- function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
- if (a == 0) {
- return 0;
- }
- c = a * b;
- assert(c / a == b);
- return c;
- }
- /**
- * @dev Integer division of two numbers, truncating the quotient.
- */
- function div(uint256 a, uint256 b) internal pure returns (uint256) {
- // assert(b > 0); // Solidity automatically throws when dividing by 0
- // uint256 c = a / b;
- // assert(a == b * c + a % b); // There is no case in which this doesn't hold
- return a / b;
- }
- /**
- * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
- */
- function sub(uint256 a, uint256 b) internal pure returns (uint256) {
- assert(b <= a);
- return a - b;
- }
- /**
- * @dev Adds two numbers, throws on overflow.
- */
- function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
- c = a + b;
- assert(c >= a);
- return c;
- }
- }
- contract ForeignToken {
- function balanceOf(address _owner) constant public returns (uint256);
- function transfer(address _to, uint256 _value) public returns (bool);
- }
- contract ERC20Basic {
- uint256 public totalSupply;
- function balanceOf(address who) public constant returns (uint256);
- function transfer(address to, uint256 value) public returns (bool);
- event Transfer(address indexed from, address indexed to, uint256 value);
- }
- contract ERC20 is ERC20Basic {
- function allowance(address owner, address spender) public constant returns (uint256);
- function transferFrom(address from, address to, uint256 value) public returns (bool);
- function approve(address spender, uint256 value) public returns (bool);
- event Approval(address indexed owner, address indexed spender, uint256 value);
- }
- contract Kingtoken is ERC20 {
- using SafeMath for uint256;
- address owner = msg.sender;
- mapping (address => uint256) balances;
- mapping (address => mapping (address => uint256)) allowed;
- string public constant name = "Kingtoken";
- string public constant symbol = "KING";
- uint public constant decimals = 8;
- uint256 public totalSupply = 20000000000e8;
- uint256 public totalDistributed = 4000000000e8;
- uint256 public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
- uint256 public tokensPerEth = 20000000e8;
- event Transfer(address indexed _from, address indexed _to, uint256 _value);
- event Approval(address indexed _owner, address indexed _spender, uint256 _value);
- event Distr(address indexed to, uint256 amount);
- event DistrFinished();
- event Airdrop(address indexed _owner, uint _amount, uint _balance);
- event TokensPerEthUpdated(uint _tokensPerEth);
- event Burn(address indexed burner, uint256 value);
- bool public distributionFinished = false;
- modifier canDistr() {
- require(!distributionFinished);
- _;
- }
- modifier onlyOwner() {
- require(msg.sender == owner);
- _;
- }
- function Kingtoken () public {
- owner = msg.sender;
- distr(owner, totalDistributed);
- }
- function transferOwnership(address newOwner) onlyOwner public {
- if (newOwner != address(0)) {
- owner = newOwner;
- }
- }
- function finishDistribution() onlyOwner canDistr public returns (bool) {
- distributionFinished = true;
- emit DistrFinished();
- return true;
- }
- function distr(address _to, uint256 _amount) canDistr private returns (bool) {
- totalDistributed = totalDistributed.add(_amount);
- balances[_to] = balances[_to].add(_amount);
- emit Distr(_to, _amount);
- emit Transfer(address(0), _to, _amount);
- return true;
- }
- function doAirdrop(address _participant, uint _amount) internal {
- require( _amount > 0 );
- require( totalDistributed < totalSupply );
- balances[_participant] = balances[_participant].add(_amount);
- totalDistributed = totalDistributed.add(_amount);
- if (totalDistributed >= totalSupply) {
- distributionFinished = true;
- }
- // log
- emit Airdrop(_participant, _amount, balances[_participant]);
- emit Transfer(address(0), _participant, _amount);
- }
- function adminClaimAirdrop(address _participant, uint _amount) external {
- doAirdrop(_participant, _amount);
- }
- function adminClaimAirdropMultiple(address[] _addresses, uint _amount) external {
- for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i], _amount);
- }
- function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
- tokensPerEth = _tokensPerEth;
- emit TokensPerEthUpdated(_tokensPerEth);
- }
- function () external payable {
- getTokens();
- }
- function getTokens() payable canDistr public {
- uint256 tokens = 0;
- // minimum contribution
- require( msg.value >= MIN_CONTRIBUTION );
- require( msg.value > 0 );
- // get baseline number of tokens
- tokens = tokensPerEth.mul(msg.value) / 1 ether;
- address investor = msg.sender;
- if (tokens > 0) {
- distr(investor, tokens);
- }
- if (totalDistributed >= totalSupply) {
- distributionFinished = true;
- }
- }
- function balanceOf(address _owner) constant public returns (uint256) {
- return balances[_owner];
- }
- // mitigates the ERC20 short address attack
- modifier onlyPayloadSize(uint size) {
- assert(msg.data.length >= size + 4);
- _;
- }
- function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
- require(_to != address(0));
- require(_amount <= balances[msg.sender]);
- balances[msg.sender] = balances[msg.sender].sub(_amount);
- balances[_to] = balances[_to].add(_amount);
- emit Transfer(msg.sender, _to, _amount);
- return true;
- }
- function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
- require(_to != address(0));
- require(_amount <= balances[_from]);
- require(_amount <= allowed[_from][msg.sender]);
- balances[_from] = balances[_from].sub(_amount);
- allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
- balances[_to] = balances[_to].add(_amount);
- emit Transfer(_from, _to, _amount);
- return true;
- }
- function approve(address _spender, uint256 _value) public returns (bool success) {
- // mitigates the ERC20 spend/approval race condition
- if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
- allowed[msg.sender][_spender] = _value;
- emit Approval(msg.sender, _spender, _value);
- return true;
- }
- function allowance(address _owner, address _spender) constant public returns (uint256) {
- return allowed[_owner][_spender];
- }
- function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
- ForeignToken t = ForeignToken(tokenAddress);
- uint bal = t.balanceOf(who);
- return bal;
- }
- function withdraw() onlyOwner public {
- address myAddress = this;
- uint256 etherBalance = myAddress.balance;
- owner.transfer(etherBalance);
- }
- function burn(uint256 _value) onlyOwner public {
- require(_value <= balances[msg.sender]);
- // no need to require value <= totalSupply, since that would imply the
- // sender's balance is greater than the totalSupply, which *should* be an assertion failure
- address burner = msg.sender;
- balances[burner] = balances[burner].sub(_value);
- totalSupply = totalSupply.sub(_value);
- totalDistributed = totalDistributed.sub(_value);
- emit Burn(burner, _value);
- }
- function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
- ForeignToken token = ForeignToken(_tokenContract);
- uint256 amount = token.balanceOf(address(this));
- return token.transfer(owner, amount);
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement