pragma solidity ^0.4.12; | |
/** | |
* @title SafeMath | |
* @dev Math operations with safety checks that throw on error | |
*/ | |
library SafeMath { | |
function mul(uint256 a, uint256 b) internal constant returns (uint256) { | |
uint256 c = a * b; | |
assert(a == 0 || c / a == b); | |
return c; | |
} | |
function div(uint256 a, uint256 b) internal constant 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 c; | |
} | |
function sub(uint256 a, uint256 b) internal constant returns (uint256) { | |
assert(b <= a); | |
return a - b; | |
} | |
function add(uint256 a, uint256 b) internal constant returns (uint256) { | |
uint256 c = a + b; | |
assert(c >= a); | |
return c; | |
} | |
} | |
/** | |
* @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; | |
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); | |
/** | |
* @dev The Ownable constructor sets the original `owner` of the contract to the sender | |
* account. | |
*/ | |
function Ownable() { | |
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)); | |
OwnershipTransferred(owner, newOwner); | |
owner = newOwner; | |
} | |
} | |
/** | |
* @title ERC20Basic | |
* @dev Simpler version of ERC20 interface | |
* @dev see https://github.com/ethereum/EIPs/issues/179 | |
*/ | |
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); | |
} | |
/** | |
* @title Basic token | |
* @dev Basic version of StandardToken, with no allowances. | |
*/ | |
contract BasicToken is ERC20Basic { | |
using SafeMath for uint256; | |
mapping(address => uint256) balances; | |
/** | |
* @dev transfer token for a specified address | |
* @param _to The address to transfer to. | |
* @param _value The amount to be transferred. | |
*/ | |
function transfer(address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
// SafeMath.sub will throw if there is not enough balance. | |
balances[msg.sender] = balances[msg.sender].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
Transfer(msg.sender, _to, _value); | |
return true; | |
} | |
/** | |
* @dev Gets the balance of the specified address. | |
* @param _owner The address to query the the balance of. | |
* @return An uint256 representing the amount owned by the passed address. | |
*/ | |
function balanceOf(address _owner) public constant returns (uint256 balance) { | |
return balances[_owner]; | |
} | |
} | |
/** | |
* @title ERC20 interface | |
* @dev see https://github.com/ethereum/EIPs/issues/20 | |
*/ | |
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); | |
} | |
/** | |
* @title Standard ERC20 token | |
* | |
* @dev Implementation of the basic standard token. | |
* @dev https://github.com/ethereum/EIPs/issues/20 | |
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol | |
*/ | |
contract StandardToken is ERC20, BasicToken { | |
mapping (address => mapping (address => uint256)) allowed; | |
/** | |
* @dev Transfer tokens from one address to another | |
* @param _from address The address which you want to send tokens from | |
* @param _to address The address which you want to transfer to | |
* @param _value uint256 the amount of tokens to be transferred | |
*/ | |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
uint256 _allowance = allowed[_from][msg.sender]; | |
// Check is not needed because sub(_allowance, _value) will already throw if this condition is not met | |
// require (_value <= _allowance); | |
balances[_from] = balances[_from].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
allowed[_from][msg.sender] = _allowance.sub(_value); | |
Transfer(_from, _to, _value); | |
return true; | |
} | |
/** | |
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. | |
* | |
* Beware that changing an allowance with this method brings the risk that someone may use both the old | |
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this | |
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: | |
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 | |
* @param _spender The address which will spend the funds. | |
* @param _value The amount of tokens to be spent. | |
*/ | |
function approve(address _spender, uint256 _value) public returns (bool) { | |
allowed[msg.sender][_spender] = _value; | |
Approval(msg.sender, _spender, _value); | |
return true; | |
} | |
/** | |
* @dev Function to check the amount of tokens that an owner allowed to a spender. | |
* @param _owner address The address which owns the funds. | |
* @param _spender address The address which will spend the funds. | |
* @return A uint256 specifying the amount of tokens still available for the spender. | |
*/ | |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { | |
return allowed[_owner][_spender]; | |
} | |
/** | |
* approve should be called when allowed[_spender] == 0. To increment | |
* allowed value is better to use this function to avoid 2 calls (and wait until | |
* the first transaction is mined) | |
* From MonolithDAO Token.sol | |
*/ | |
function increaseApproval (address _spender, uint _addedValue) | |
returns (bool success) { | |
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); | |
Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
function decreaseApproval (address _spender, uint _subtractedValue) | |
returns (bool success) { | |
uint oldValue = allowed[msg.sender][_spender]; | |
if (_subtractedValue > oldValue) { | |
allowed[msg.sender][_spender] = 0; | |
} else { | |
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); | |
} | |
Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
} | |
/** | |
* @title Burnable Token | |
* @dev Token that can be irreversibly burned (destroyed). | |
*/ | |
contract BurnableToken is StandardToken { | |
event Burn(address indexed burner, uint256 value); | |
/** | |
* @dev Burns a specific amount of tokens. | |
* @param _value The amount of token to be burned. | |
*/ | |
function burn(uint256 _value) public { | |
require(_value > 0); | |
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); | |
Burn(burner, _value); | |
Transfer(burner, address(0), _value); | |
} | |
} | |
contract PCNCoin is BurnableToken, Ownable { | |
string public constant name = "PCN Coin"; | |
string public constant symbol = "PCNC"; | |
uint public constant decimals = 18; | |
// there is no problem in using * here instead of .mul() | |
uint256 public constant initialSupply = 900000000 * (10 ** uint256(decimals)); | |
// Constructors | |
function PCNCoin () { | |
totalSupply = initialSupply; | |
balances[msg.sender] = initialSupply; // Send all tokens to owner | |
} | |
} | |
/** | |
* @title Crowdsale | |
* @dev Crowdsale is a base contract for managing a token crowdsale. | |
* Crowdsales have a start and end timestamps, where investors can make | |
* token purchases and the crowdsale will assign them tokens based | |
* on a token per ETH rate. Funds collected are forwarded | |
to a wallet | |
* as they arrive. | |
*/ | |
contract token { function transfer(address receiver, uint amount){ } } | |
contract PCNCrowdsale is PCNCoin { | |
using SafeMath for uint256; | |
// uint256 durationInMinutes; | |
// address where funds are collected | |
// address public wallet; | |
// token address | |
// address public addressOfTokenUsedAsReward; | |
uint256 public price = 3000; | |
token tokenReward; | |
// mapping (address => uint) public contributions; | |
// start and end timestamps where investments are allowed (both inclusive) | |
// uint256 public startTime; | |
// uint256 public endTime; | |
// amount of raised money in wei | |
uint256 public weiRaised; | |
/** | |
* event for token purchase logging | |
* @param purchaser who paid for the tokens | |
* @param beneficiary who got the tokens | |
* @param value weis paid for purchase | |
* @param amount amount of tokens purchased | |
*/ | |
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); | |
function PCNCrowdsale () { | |
//You will change this to your wallet where you need the ETH | |
// wallet = 0x5daaAb630673a61f487965f90E13457a74F566D3; | |
// durationInMinutes = _durationInMinutes; | |
//Here will come the checksum address we got | |
// addressOfTokenUsedAsReward = 0x8aB10a31c97Af458Db24038Ed8b498590cf64d74; | |
tokenReward = token(address(this)); | |
} | |
bool public started = true; | |
function startSale() onlyOwner { | |
// if (msg.sender != wallet) throw; | |
started = true; | |
} | |
function stopSale() onlyOwner { | |
// if(msg.sender != wallet) throw; | |
started = false; | |
} | |
function setPrice(uint256 _price) onlyOwner { | |
// if(msg.sender != wallet) throw; | |
price = _price; | |
} | |
// fallback function can be used to buy tokens | |
function () payable { | |
buyTokens(msg.sender); | |
} | |
// low level token purchase function | |
function buyTokens(address beneficiary) payable { | |
require(beneficiary != 0x0); | |
require(validPurchase()); | |
uint256 weiAmount = msg.value; | |
// if(weiAmount < 10**16) throw; | |
// if(weiAmount > 50*10**18) throw; | |
// calculate token amount to be sent | |
uint256 tokens = (weiAmount) * price;//weiamount * price | |
// uint256 tokens = (weiAmount/10**(18-decimals)) * price;//weiamount * price | |
// update state | |
weiRaised = weiRaised.add(weiAmount); | |
// if(contributions[msg.sender].add(weiAmount)>10*10**18) throw; | |
// contributions[msg.sender] = contributions[msg.sender].add(weiAmount); | |
tokenReward.transfer(beneficiary, tokens); | |
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); | |
forwardFunds(); | |
} | |
// send ether to the fund collection wallet | |
// override to create custom fund forwarding mechanisms | |
function forwardFunds() internal { | |
// wallet.transfer(msg.value); | |
if (!owner.send(msg.value)) { | |
throw; | |
} | |
} | |
// @return true if the transaction can buy tokens | |
function validPurchase() internal constant returns (bool) { | |
bool withinPeriod = started; | |
bool nonZeroPurchase = msg.value != 0; | |
return withinPeriod && nonZeroPurchase; | |
} | |
function withdrawTokens(uint256 _amount) onlyOwner { | |
// if(msg.sender!=wallet) throw; | |
tokenReward.transfer(owner,_amount); | |
} | |
} |
This comment has been minimized.
This comment has been minimized.
good project |
This comment has been minimized.
This comment has been minimized.
Together we reach success in PCNCOIN |
This comment has been minimized.
This comment has been minimized.
ok đấy - rất tiềm năng |
This comment has been minimized.
This comment has been minimized.
Great project |
This comment has been minimized.
This comment has been minimized.
Best project |
This comment has been minimized.
This comment has been minimized.
Hello. |
This comment has been minimized.
This comment has been minimized.
iyi güzel proje |
This comment has been minimized.
This comment has been minimized.
Excelent project. congratulations!!! |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
This comment has been minimized.
https://www.pcncoin.com/referral/Tutam/