Смарт-контракт

pragma solidity ^0.4.16;

/**
* @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;
}

}

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) public; }

contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;

// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);

// This notifies clients about the amount burnt
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 = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}

/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
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 {
_transfer(msg.sender, _to, _value);
}

/**
* 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]); // Check allowance
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); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
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); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
}

/******************************************/
/* ADVANCED TOKEN STARTS HERE */
/******************************************/

contract PalCoin is owned, TokenERC20 {

uint256 public sellPrice;
uint256 public buyPrice;

string public name = 'PalCoin';
string public symbol = 'PLC';
uint256 public coinsupply = 30000000;

mapping (address => bool) public frozenAccount;

/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);

/* Initializes contract with initial supply tokens to the creator of the contract */
function PalCoin() TokenERC20(30000000, "PalCoin", "PLC") public {}

/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
}

/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}

/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}

/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}

/// @notice Buy tokens from contract by sending ether
function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}

/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}

interface token {
function transfer(address receiver, uint amount);
}

contract Crowdsale is owned {

using SafeMath for uint256;

address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public torenRaised;
uint public deadlinePre;
uint public mainprice;
uint public price;
uint public etap; // start;

uint256 public coinsupply = 30000000;
uint256 public limitPre = 10;
uint256 public limitICO = 50;

uint public point01 = 1521936000; // 25.03 etap = 1;
uint public point02 = 1522195200; // 28.03 etap = 2;
uint public point03 = 1522540800; // 01.04 etap = 3;
uint public point04 = 1527724800; // 31.05 etap = 4;
uint public point05 = 1530403200; // 01.07 etap = 5;
uint public point06 = 1534291200; // 15.08 etap = 6;
uint public point07 = 1538265600; // 30.09 etap = 7;

uint public partrefund = 100; // refund;

uint public bonus1 = 50 finney;
uint public bonus2 = 500 finney;
uint public bonus3 = 1000 finney;

uint public bonus4 = 10000 finney;
uint public bonus5 = 50000 finney;
uint public bonus6 = 100000 finney;

uint adbonus;

token public tokenReward;
mapping(address => uint256) public balancePre;
mapping(address => uint256) public bunusesICO;
mapping(address => uint256) public balanceICO;
bool fundingPreReached = false;
bool fundingReached = false;
bool crowdsaleClosed = false;
bool icoClosed = true;

event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);

/**
* Constrctor function
*
* Setup the owner
*/

address ifSuccessfulSendTo = 0x16DBCFac3b8F69C29CbD76f0201a5DC8e6c8b7F2;
uint fundingGoalInEthers = 200;
uint inputdeadline = 1521763200;
uint etherCostOfEachToken = 200000000000000;

PalCoin public tokent = new PalCoin();

function setPoin(uint npoint04, uint npoint05, uint npoint06, uint npoint07) onlyOwner public {
point04 = npoint04;
point05 = npoint05;
point06 = npoint06;
point07 = npoint07;
}


function Crowdsale (
) {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadlinePre = inputdeadline;
mainprice = etherCostOfEachToken;
tokenReward = token(tokent);
}

/**
* Fallback function
*
* The function without name is the default function that is called whenever anyone sends funds to a contract
*/
function () payable {
price = mainprice;
require(!crowdsaleClosed || !icoClosed);
uint amount = msg.value;

if (now < point05) { // preICO
uint tokenLimit = limitPre * coinsupply / 100;
if (amount >= bonus3) {
price = price.mul(35).div(100);
bunusesICO[msg.sender] = 4;
}
else if (amount >= bonus2) {
price = price.mul(40).div(100);
bunusesICO[msg.sender] = 3;
}
else if (amount >= bonus1) {
price = price.mul(45).div(100);
bunusesICO[msg.sender] = 2;
}
} else { // ICO
tokenLimit = limitICO * coinsupply / 100;
if (amount >= bonus6) {
price = price.mul(50).div(100);
adbonus = bunusesICO[msg.sender];
if (adbonus > 0) {
adbonus = adbonus + 2;
adbonus = adbonus.div(100) + 1;
price = price.mul(adbonus);
}
}
else if (amount >= bonus5) {
price = price.mul(50).div(100);
adbonus = bunusesICO[msg.sender];
if (adbonus > 0) {
adbonus = adbonus + 1;
adbonus = adbonus.div(100) + 1;
price = price.mul(adbonus);
}
}
else if (amount >= bonus4) {
price = price.mul(55).div(100);
adbonus = bunusesICO[msg.sender];
if (adbonus > 0) {
adbonus = adbonus.div(100) + 1;
price = price.mul(adbonus);
}
} else {
price = price.mul(60).div(100);
}
}
uint tokenAmount = amount / price;
require ((torenRaised + tokenAmount) <= tokenLimit);
if (now < point04) { // preICO
balancePre[msg.sender] += amount;
} else { // ICO
balanceICO[msg.sender] += amount;
}
amountRaised += amount;
tokenReward.transfer(msg.sender, tokenAmount * 1 ether);
torenRaised += tokenAmount;
FundTransfer(msg.sender, amount, true);
}

/**
* Set point
*
* Set current point of roadmap
*/
function setPoint(uint inetap) onlyOwner public {
etap = inetap;
}

modifier afterDeadlinePre() { if (now >= deadlinePre) _; }

/**
* Check if goal was reached
*
* Checks if the goal or time limit has been reached and ends the campaign
*/
function checkPreReached() onlyOwner afterDeadlinePre public {
if (now >= point07) {
icoClosed = true;
fundingReached = true;
GoalReached(beneficiary, amountRaised);
}
else if (now >= point06 && etap < 6){
partrefund = 20;
icoClosed = true;
}
else if (now >= point05 && etap > 5){ // start ICO
icoClosed = false;
}
else if (now >= point04) { // end of PreICO
partrefund = 20;
fundingPreReached = true;
if (etap < 4){
fundingPreReached = false;
} else {
fundingPreReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
else if (now >= point03){
partrefund = 40;
fundingPreReached = true;
if (etap < 3) {
fundingPreReached = false;
}
}
else if (now >= point02){
partrefund = 60;
fundingPreReached = true;
if (etap < 2) {
fundingPreReached = false;
}
}
else if (now >= point01 && etap < 1){
partrefund = 100;
fundingPreReached = false;
} else {
fundingPreReached = true;
}
crowdsaleClosed = true;
}

/**
* Withdraw the funds
*
* Checks to see if goal or time limit has been reached, and if so, and the funding goal was reached,
* sends the entire amount to the beneficiary. If goal was not reached, each contributor can withdraw
* the amount they contributed.
*/
function safeWithdrawal() afterDeadlinePre {
if (!fundingReached) {
if (now > point06 && icoClosed) { // ICO ended
amount = balanceICO[msg.sender];
balanceICO[msg.sender] = 0;
amount = amount * partrefund / 100; // refund by point
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceICO[msg.sender] = amount;
}
}
} else { // preICO
if (crowdsaleClosed && !fundingPreReached) {
uint amount = balancePre[msg.sender];
balancePre[msg.sender] = 0;
amount = amount * partrefund / 100; // refund by point
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balancePre[msg.sender] = amount;
}
}
}
}
if (beneficiary == msg.sender) { // take away all
if ((now > point04 && now < point05) || (now > point07)) {
if (beneficiary.send(this.balance)) {
FundTransfer(beneficiary, amountRaised, false);
if (now > point07) {
tokenReward.transfer(beneficiary, (coinsupply - torenRaised) * 1 ether);
}
} else {
//If we fail to send the funds to beneficiary, unlock funders balance
fundingPreReached = false;
}
}
}
} else { // compensation
if (beneficiary == msg.sender) {
if (partrefund < 100) {
uint compensation = amountRaised * (100 - partrefund - 2);
if ((compensation - amountRaised * 2 / 100) > (amountRaised - this.balance)) {
if (beneficiary.send(compensation)) {
FundTransfer(beneficiary, amountRaised, false);
}
}
}
}
}
}
}